wp-typia 0.20.5 → 0.22.0

package/dist-bunli/{cli-j1tyw390.js → cli-1w5vkye4.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   getPackageVersions
-} from "./cli-tesygdnr.js";
+} from "./cli-39er8888.js";
 import {
   seedProjectMigrations
-} from "./cli-2rev5hqm.js";
+} from "./cli-e623rs7g.js";
 import {
   ensureMigrationDirectories,
   isPlainObject,
@@ -59,10 +59,14 @@ import {
   toTitleCase,
   validateBlockSlug,
   validateNamespace
-} from "./cli-3w3qxq9w.js";
+} from "./cli-j180bk07.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
+import {
+  CLI_DIAGNOSTIC_CODES,
+  createCliDiagnosticCodeError
+} from "./cli-p95wr1q8.js";
 import {
   __commonJS,
   __require,
@@ -5274,6 +5278,17 @@ function buildInteractivityTypesSource(variables, attributes) {
           { name: "maxClicks", typeExpression: "number" }
         ],
         name: `${variables.pascalCase}Context`
+      },
+      {
+        members: [
+          { name: "clicks", typeExpression: "number" },
+          { name: "isAnimating", typeExpression: "boolean" },
+          { name: "isVisible", typeExpression: "boolean" },
+          { name: "progress", typeExpression: "number" },
+          { name: "clampedClicks", typeExpression: "number" },
+          { name: "isComplete", typeExpression: "boolean" }
+        ],
+        name: `${variables.pascalCase}State`
       }
     ],
     typeAliases: [
@@ -5803,13 +5818,13 @@ function resolveLocalCliPathOption(options) {
   }
   const resolvedPath = path5.resolve(options.cwd, normalizedValue);
   if (!fs3.existsSync(resolvedPath)) {
-    throw new Error(`\`${options.label}\` path does not exist: ${resolvedPath}. Check the path relative to ${options.cwd}.`);
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`${options.label}\` path does not exist: ${resolvedPath}. Check the path relative to ${options.cwd}.`);
   }
   return resolvedPath;
 }
 function assertExternalLayerCompositionOptions(options) {
   if (options.externalLayerId && !options.externalLayerSource) {
-    throw new Error("externalLayerId requires externalLayerSource when composing built-in template layers.");
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "externalLayerId requires externalLayerSource when composing built-in template layers.");
   }
 }
 function createBuiltInVariantErrorMessage(options) {
@@ -5819,7 +5834,7 @@ function assertBuiltInTemplateVariantAllowed(options) {
   if (!options.variant) {
     return;
   }
-  throw new Error(createBuiltInVariantErrorMessage({
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, createBuiltInVariantErrorMessage({
     templateId: options.templateId,
     variant: options.variant
   }));
@@ -6036,7 +6051,7 @@ function normalizeQueryPostType(value) {
   }
   const validationResult = validateQueryPostType(value);
   if (validationResult !== true) {
-    throw new Error(validationResult);
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, validationResult);
   }
   return value.trim().toLowerCase();
 }
@@ -6108,7 +6123,7 @@ async function resolveTemplateId({
   if (templateId) {
     const normalizedTemplateId = normalizeTemplateSelection(templateId);
     if (isRemovedBuiltInTemplateId(templateId)) {
-      throw new Error(getRemovedBuiltInTemplateMessage(templateId));
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getRemovedBuiltInTemplateMessage(templateId));
     }
     if (normalizedTemplateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
       return normalizedTemplateId;
@@ -6118,10 +6133,10 @@ async function resolveTemplateId({
     }
     const mistypedBuiltInTemplateMessage = getMistypedBuiltInTemplateMessage(templateId);
     if (mistypedBuiltInTemplateMessage) {
-      throw new Error(mistypedBuiltInTemplateMessage);
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, mistypedBuiltInTemplateMessage);
     }
     if (!looksLikeExplicitExternalTemplateLocator(normalizedTemplateId)) {
-      throw new Error(getUnknownTemplateMessage(templateId));
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getUnknownTemplateMessage(templateId));
     }
     return normalizedTemplateId;
   }
@@ -6129,7 +6144,7 @@ async function resolveTemplateId({
     return "basic";
   }
   if (!isInteractive || !selectTemplate) {
-    throw new Error(`Template is required in non-interactive mode. Use ${TEMPLATE_SELECTION_HINT}.`);
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Template is required in non-interactive mode. Use ${TEMPLATE_SELECTION_HINT}.`);
   }
   return normalizeTemplateSelection(await selectTemplate());
 }
@@ -6146,7 +6161,7 @@ async function resolvePackageManagerId({
     return "npm";
   }
   if (!isInteractive || !selectPackageManager) {
-    throw new Error(`Package manager is required in non-interactive mode. Use --package-manager <${PACKAGE_MANAGER_IDS.join("|")}>.`);
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Package manager is required in non-interactive mode. Use --package-manager <${PACKAGE_MANAGER_IDS.join("|")}>.`);
   }
   return selectPackageManager();
 }
@@ -6204,9 +6219,9 @@ async function collectScaffoldAnswers({
 }
 
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
-import fs14 from "fs";
-import { promises as fsp10 } from "fs";
-import path17 from "path";
+import fs15 from "fs";
+import { promises as fsp11 } from "fs";
+import path18 from "path";
 
 // ../wp-typia-project-tools/src/runtime/scaffold-apply-utils.ts
 import fs6 from "fs";
@@ -6692,7 +6707,6 @@ async function defaultInstallDependencies({
     stdio: "inherit"
   });
 }
-
 // ../wp-typia-project-tools/src/runtime/scaffold-repository-reference.ts
 import fs5 from "fs";
 import { createRequire } from "module";
@@ -7961,10 +7975,10 @@ async function detectTemplateSourceFormat(sourceDir) {
 
 // ../wp-typia-project-tools/src/runtime/template-source-seeds.ts
 var import_semver = __toESM(require_semver2(), 1);
-import fs13 from "fs";
-import { promises as fsp9 } from "fs";
+import fs14 from "fs";
+import { promises as fsp10 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import path16 from "path";
+import path17 from "path";
 import { spawnSync } from "child_process";
 
 // ../../node_modules/.bun/tar@7.5.13/node_modules/tar/dist/esm/index.min.js
@@ -11114,11 +11128,342 @@ var So = (s3) => {
   s3.mtimeCache || (s3.mtimeCache = new Map), s3.filter = t ? (e, i) => t(e, i) && !((s3.mtimeCache?.get(e) ?? i.mtime ?? 0) > (i.mtime ?? 0)) : (e, i) => !((s3.mtimeCache?.get(e) ?? i.mtime ?? 0) > (i.mtime ?? 0));
 };
 
+// ../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 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 CACHE_MARKER_FILE = "wp-typia-template-cache.json";
+var PRIVATE_CACHE_DIRECTORY_MODE = 448;
+var REDACTED_CACHE_METADATA_VALUE = "[redacted]";
+var DISABLED_CACHE_VALUES = new Set(["0", "false", "no", "off"]);
+var CACHE_PUBLISH_RACE_ERROR_CODES = new Set(["EEXIST", "ENOTEMPTY"]);
+var CACHE_UNAVAILABLE_ERROR_CODES = new Set([
+  "EACCES",
+  "ENOSPC",
+  "ENOTDIR",
+  "EPERM",
+  "EROFS"
+]);
+var URL_LIKE_METADATA_KEY = /(url|uri|registry|tarball)/iu;
+var SAFE_CACHE_NAMESPACE_SEGMENT = /^[A-Za-z0-9_.-]+$/u;
+function isExternalTemplateCacheEnabled(env = process.env) {
+  const rawValue2 = env[EXTERNAL_TEMPLATE_CACHE_ENV];
+  if (rawValue2 === undefined) {
+    return true;
+  }
+  return !DISABLED_CACHE_VALUES.has(rawValue2.trim().toLowerCase());
+}
+function getExternalTemplateCacheRoot(env = process.env) {
+  const configuredCacheDir = env[EXTERNAL_TEMPLATE_CACHE_DIR_ENV]?.trim();
+  if (configuredCacheDir) {
+    return path16.resolve(configuredCacheDir);
+  }
+  return path16.join(os2.tmpdir(), `wp-typia-template-source-cache-${getCurrentUserCacheSegment()}`);
+}
+function createExternalTemplateCacheKey(keyParts) {
+  return createHash("sha256").update(JSON.stringify(keyParts)).digest("hex");
+}
+async function pathExists(filePath) {
+  try {
+    await fsp9.access(filePath, fs13.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectoryPath(directory) {
+  try {
+    const stats = await fsp9.lstat(directory);
+    return stats.isDirectory() && !stats.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function getNodeErrorCode(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 });
+  } catch {}
+}
+function getCurrentUserCacheSegment() {
+  if (typeof process.getuid === "function") {
+    return String(process.getuid());
+  }
+  try {
+    const safeUsername = os2.userInfo().username.trim().replace(/[^A-Za-z0-9._-]+/gu, "-");
+    return safeUsername.length > 0 ? safeUsername : "user";
+  } catch {
+    return "user";
+  }
+}
+function getCurrentUid() {
+  return typeof process.getuid === "function" ? process.getuid() : null;
+}
+async function isPrivateCacheDirectory(directory) {
+  try {
+    const stats = await fsp9.lstat(directory);
+    if (!stats.isDirectory() || stats.isSymbolicLink()) {
+      return false;
+    }
+    const currentUid = getCurrentUid();
+    if (currentUid !== null && stats.uid !== currentUid) {
+      return false;
+    }
+    if (process.platform !== "win32" && (stats.mode & 63) !== 0) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensurePrivateCacheDirectory(directory) {
+  try {
+    await fsp9.mkdir(directory, {
+      mode: PRIVATE_CACHE_DIRECTORY_MODE,
+      recursive: true
+    });
+    const stats = await fsp9.lstat(directory);
+    if (!stats.isDirectory() || stats.isSymbolicLink()) {
+      return false;
+    }
+    const currentUid = getCurrentUid();
+    if (currentUid !== null && stats.uid !== currentUid) {
+      return false;
+    }
+    if (process.platform !== "win32") {
+      if ((stats.mode & 63) !== 0) {
+        await fsp9.chmod(directory, PRIVATE_CACHE_DIRECTORY_MODE);
+      }
+    }
+    return isPrivateCacheDirectory(directory);
+  } catch {
+    return false;
+  }
+}
+function sanitizeCacheMetadataValue(key, value) {
+  if (!URL_LIKE_METADATA_KEY.test(key)) {
+    return value;
+  }
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return REDACTED_CACHE_METADATA_VALUE;
+  }
+}
+function sanitizeCacheMetadata(metadata) {
+  return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [
+    key,
+    value === null ? null : sanitizeCacheMetadataValue(key, value)
+  ]));
+}
+function resolveCacheNamespaceDir(cacheRoot, namespace) {
+  if (namespace === "." || namespace === ".." || !SAFE_CACHE_NAMESPACE_SEGMENT.test(namespace)) {
+    return null;
+  }
+  const namespaceDir = path16.join(cacheRoot, namespace);
+  const relativeNamespaceDir = path16.relative(cacheRoot, namespaceDir);
+  if (relativeNamespaceDir.length === 0 || relativeNamespaceDir.startsWith("..") || path16.isAbsolute(relativeNamespaceDir)) {
+    return null;
+  }
+  return namespaceDir;
+}
+function getCacheEntryPaths(descriptor) {
+  const cacheKey = createExternalTemplateCacheKey(descriptor.keyParts);
+  const cacheRoot = getExternalTemplateCacheRoot();
+  const namespaceDir = resolveCacheNamespaceDir(cacheRoot, descriptor.namespace);
+  if (!namespaceDir) {
+    return null;
+  }
+  const entryDir = path16.join(namespaceDir, cacheKey);
+  return {
+    cacheKey,
+    cacheRoot,
+    entryDir,
+    markerPath: path16.join(entryDir, CACHE_MARKER_FILE),
+    namespaceDir,
+    sourceDir: path16.join(entryDir, "source")
+  };
+}
+async function isReusableCacheEntry(entryDir, markerPath, sourceDir) {
+  return await isPrivateCacheDirectory(entryDir) && await pathExists(markerPath) && await isDirectoryPath(sourceDir);
+}
+function parseCacheMarkerMetadata(markerText) {
+  let marker;
+  try {
+    marker = JSON.parse(markerText);
+  } catch {
+    return null;
+  }
+  if (typeof marker !== "object" || marker === null || Array.isArray(marker)) {
+    return null;
+  }
+  const rawMetadata = marker.metadata;
+  if (typeof rawMetadata !== "object" || rawMetadata === null || Array.isArray(rawMetadata)) {
+    return null;
+  }
+  const metadata = {};
+  for (const [key, value] of Object.entries(rawMetadata)) {
+    if (typeof value !== "string" && value !== null) {
+      return null;
+    }
+    metadata[key] = value;
+  }
+  const rawCreatedAt = marker.createdAt;
+  const createdAtMs = typeof rawCreatedAt === "string" ? Date.parse(rawCreatedAt) : 0;
+  return {
+    createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : 0,
+    metadata
+  };
+}
+function cacheMetadataMatches(actual, expected) {
+  return Object.entries(expected).every(([key, value]) => actual[key] === value);
+}
+async function findReusableExternalTemplateSourceCache(descriptor) {
+  if (!isExternalTemplateCacheEnabled()) {
+    return null;
+  }
+  const cacheRoot = getExternalTemplateCacheRoot();
+  const namespaceDir = resolveCacheNamespaceDir(cacheRoot, descriptor.namespace);
+  if (!namespaceDir) {
+    return null;
+  }
+  if (!await isPrivateCacheDirectory(cacheRoot) || !await isPrivateCacheDirectory(namespaceDir)) {
+    return null;
+  }
+  let entries;
+  try {
+    entries = await fsp9.readdir(namespaceDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  let bestEntry = null;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    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)) {
+      continue;
+    }
+    if (!bestEntry || marker.createdAtMs > bestEntry.createdAtMs) {
+      bestEntry = {
+        createdAtMs: marker.createdAtMs,
+        sourceDir
+      };
+    }
+  }
+  return bestEntry ? {
+    cacheHit: true,
+    sourceDir: bestEntry.sourceDir
+  } : null;
+}
+async function resolveExternalTemplateSourceCache(descriptor, populateSourceDir) {
+  if (!isExternalTemplateCacheEnabled()) {
+    return null;
+  }
+  const cacheEntryPaths = getCacheEntryPaths(descriptor);
+  if (!cacheEntryPaths) {
+    return null;
+  }
+  const { cacheKey, cacheRoot, entryDir, markerPath, namespaceDir, sourceDir } = cacheEntryPaths;
+  if (!await ensurePrivateCacheDirectory(cacheRoot) || !await ensurePrivateCacheDirectory(namespaceDir)) {
+    return null;
+  }
+  if (await isReusableCacheEntry(entryDir, markerPath, sourceDir)) {
+    return {
+      cacheHit: true,
+      sourceDir
+    };
+  }
+  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, {
+      mode: PRIVATE_CACHE_DIRECTORY_MODE,
+      recursive: true
+    });
+    if (process.platform !== "win32") {
+      await fsp9.chmod(temporaryEntryDir, PRIVATE_CACHE_DIRECTORY_MODE);
+    }
+    try {
+      await populateSourceDir(temporarySourceDir);
+    } catch (error) {
+      populateFailed = true;
+      throw error;
+    }
+    await fsp9.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);
+    return {
+      cacheHit: false,
+      sourceDir
+    };
+  } catch (error) {
+    await removeTemporaryCacheEntry(temporaryEntryDir);
+    if (populateFailed) {
+      if (CACHE_UNAVAILABLE_ERROR_CODES.has(getNodeErrorCode(error))) {
+        return null;
+      }
+      throw error;
+    }
+    const errorCode = getNodeErrorCode(error);
+    if (CACHE_PUBLISH_RACE_ERROR_CODES.has(errorCode) && await isReusableCacheEntry(entryDir, markerPath, sourceDir)) {
+      return {
+        cacheHit: true,
+        sourceDir
+      };
+    }
+    if (CACHE_PUBLISH_RACE_ERROR_CODES.has(errorCode) || CACHE_UNAVAILABLE_ERROR_CODES.has(errorCode)) {
+      return null;
+    }
+    throw error;
+  }
+}
+
 // ../wp-typia-project-tools/src/runtime/template-source-seeds.ts
 var USER_FACING_TEMPLATE_IDS2 = [
   ...TEMPLATE_IDS,
   OFFICIAL_WORKSPACE_TEMPLATE_ALIAS
 ];
+var GITHUB_TEMPLATE_CACHE_REVISION_RACE_CODE = "github-template-cache-revision-race";
+function createGitHubTemplateCacheRevisionRaceError(message) {
+  const error = new Error(message);
+  error.code = GITHUB_TEMPLATE_CACHE_REVISION_RACE_CODE;
+  return error;
+}
+function isGitHubTemplateCacheRevisionRaceError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === GITHUB_TEMPLATE_CACHE_REVISION_RACE_CODE;
+}
 function getUnknownNpmTemplateMessage(templateId) {
   return [
     `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS2.join(", ")}.`,
@@ -11126,6 +11471,43 @@ function getUnknownNpmTemplateMessage(templateId) {
     "If you meant an npm template package, verify the package name and configured npm registry."
   ].join(" ");
 }
+function readOptionalDistString(dist, key) {
+  const value = dist[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function normalizeNpmRegistryCacheKey(registryBase) {
+  try {
+    const url = new URL(registryBase);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/u, "");
+  } catch {
+    return registryBase;
+  }
+}
+async function downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl, unpackDir) {
+  const tarballResponse = await fetchWithExternalTemplateTimeout(tarballUrl, {
+    label: `downloading npm template tarball for ${locator.raw}@${resolvedVersion}`
+  });
+  if (!tarballResponse.ok) {
+    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, {
+    label: `npm template tarball for ${locator.raw}@${resolvedVersion}`,
+    maxBytes: getExternalTemplateTarballMaxBytes()
+  }));
+  await co({
+    cwd: unpackDir,
+    file: tarballPath,
+    strip: 1
+  });
+  await fsp10.rm(tarballPath, { force: true });
+  await assertNoSymlinks2(unpackDir);
+}
 function selectRegistryVersion(metadata, locator) {
   const distTags = isPlainObject(metadata["dist-tags"]) ? metadata["dist-tags"] : {};
   const versions = isPlainObject(metadata.versions) ? metadata.versions : {};
@@ -11165,7 +11547,7 @@ async function fetchNpmTemplateSource(locator) {
   });
   if (!metadataResponse.ok) {
     if (metadataResponse.status === 404) {
-      throw new Error(getUnknownNpmTemplateMessage(locator.raw));
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, getUnknownNpmTemplateMessage(locator.raw));
     }
     throw new Error(`Failed to fetch npm template metadata for ${locator.raw}: ${metadataResponse.status}`);
   }
@@ -11183,27 +11565,43 @@ async function fetchNpmTemplateSource(locator) {
   if (typeof tarballUrl !== "string" || tarballUrl.length === 0) {
     throw new Error(`npm template metadata is missing tarball URL for ${locator.raw}@${resolvedVersion}.`);
   }
+  const tarballIntegrity = readOptionalDistString(versionMetadata.dist, "integrity");
+  const tarballShasum = readOptionalDistString(versionMetadata.dist, "shasum");
+  if (tarballIntegrity || tarballShasum) {
+    const registryCacheKey = normalizeNpmRegistryCacheKey(registryBase);
+    const cachedSource = await resolveExternalTemplateSourceCache({
+      keyParts: [
+        "npm",
+        registryCacheKey,
+        locator.name,
+        locator.raw,
+        resolvedVersion,
+        tarballIntegrity ?? "",
+        tarballShasum ?? ""
+      ],
+      metadata: {
+        integrity: tarballIntegrity,
+        package: locator.name,
+        raw: locator.raw,
+        registry: registryBase,
+        shasum: tarballShasum,
+        tarball: tarballUrl,
+        version: resolvedVersion
+      },
+      namespace: "npm"
+    }, (unpackDir) => downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl, unpackDir));
+    if (cachedSource) {
+      await assertNoSymlinks2(cachedSource.sourceDir);
+      return {
+        blockDir: cachedSource.sourceDir,
+        rootDir: cachedSource.sourceDir
+      };
+    }
+  }
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
   try {
-    const tarballResponse = await fetchWithExternalTemplateTimeout(tarballUrl, {
-      label: `downloading npm template tarball for ${locator.raw}@${resolvedVersion}`
-    });
-    if (!tarballResponse.ok) {
-      throw new Error(`Failed to download npm template tarball for ${locator.raw}: ${tarballResponse.status}`);
-    }
-    const tarballPath = path16.join(tempRoot, "template.tgz");
-    const unpackDir = path16.join(tempRoot, "source");
-    await fsp9.mkdir(unpackDir, { recursive: true });
-    await fsp9.writeFile(tarballPath, await readBufferResponseWithLimit(tarballResponse, {
-      label: `npm template tarball for ${locator.raw}@${resolvedVersion}`,
-      maxBytes: getExternalTemplateTarballMaxBytes()
-    }));
-    await co({
-      cwd: unpackDir,
-      file: tarballPath,
-      strip: 1
-    });
-    await assertNoSymlinks2(unpackDir);
+    const unpackDir = path17.join(tempRoot, "source");
+    await downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl, unpackDir);
     return {
       blockDir: unpackDir,
       cleanup,
@@ -11218,20 +11616,20 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
   if (locator.rawSpec !== "" && locator.rawSpec !== "*") {
     return null;
   }
-  const workspacePackagesRoot = path16.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..");
-  if (fs13.existsSync(workspacePackagesRoot)) {
-    for (const entry of fs13.readdirSync(workspacePackagesRoot, {
+  const workspacePackagesRoot = path17.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..");
+  if (fs14.existsSync(workspacePackagesRoot)) {
+    for (const entry of fs14.readdirSync(workspacePackagesRoot, {
       withFileTypes: true
     })) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const packageDir = path16.join(workspacePackagesRoot, entry.name);
-      const packageJsonPath = path16.join(packageDir, "package.json");
-      if (!fs13.existsSync(packageJsonPath)) {
+      const packageDir = path17.join(workspacePackagesRoot, entry.name);
+      const packageJsonPath = path17.join(packageDir, "package.json");
+      if (!fs14.existsSync(packageJsonPath)) {
         continue;
       }
-      const manifest = JSON.parse(fs13.readFileSync(packageJsonPath, "utf8"));
+      const manifest = JSON.parse(fs14.readFileSync(packageJsonPath, "utf8"));
       if (manifest.name === locator.name) {
         return {
           blockDir: packageDir,
@@ -11240,10 +11638,10 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
       }
     }
   }
-  const workspaceRequire = createRequire2(path16.join(path16.resolve(cwd), "__wp_typia_template_resolver__.cjs"));
+  const workspaceRequire = createRequire2(path17.join(path17.resolve(cwd), "__wp_typia_template_resolver__.cjs"));
   try {
-    const packageJsonPath = fs13.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
-    const sourceDir = path16.dirname(packageJsonPath);
+    const packageJsonPath = fs14.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
+    const sourceDir = path17.dirname(packageJsonPath);
     return {
       blockDir: sourceDir,
       rootDir: sourceDir
@@ -11252,11 +11650,11 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
     const errorCode = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
     if (errorCode === "MODULE_NOT_FOUND" || errorCode === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
       for (const basePath of workspaceRequire.resolve.paths(locator.name) ?? []) {
-        const packageJsonPath = path16.join(basePath, locator.name, "package.json");
-        if (!fs13.existsSync(packageJsonPath)) {
+        const packageJsonPath = path17.join(basePath, locator.name, "package.json");
+        if (!fs14.existsSync(packageJsonPath)) {
           continue;
         }
-        const sourceDir = path16.dirname(fs13.realpathSync(packageJsonPath));
+        const sourceDir = path17.dirname(fs14.realpathSync(packageJsonPath));
         return {
           blockDir: sourceDir,
           rootDir: sourceDir
@@ -11268,64 +11666,250 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
   }
 }
 function isOfficialWorkspaceTemplateSeed(seed) {
-  const packageJsonPath = path16.join(seed.rootDir, "package.json");
-  if (!fs13.existsSync(packageJsonPath)) {
+  const packageJsonPath = path17.join(seed.rootDir, "package.json");
+  if (!fs14.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson = JSON.parse(fs13.readFileSync(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(fs14.readFileSync(packageJsonPath, "utf8"));
     return packageJson.name === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE;
   } catch {
     return false;
   }
 }
 async function assertNoSymlinks2(sourceDir) {
-  const stats = await fsp9.lstat(sourceDir);
+  const stats = await fsp10.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 fsp9.readdir(sourceDir)) {
-    await assertNoSymlinks2(path16.join(sourceDir, entry));
+  for (const entry of await fsp10.readdir(sourceDir)) {
+    await assertNoSymlinks2(path17.join(sourceDir, entry));
   }
 }
-async function resolveGitHubTemplateSource(locator) {
-  const { path: remoteRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
-  const checkoutDir = path16.join(remoteRoot, "source");
-  try {
-    const args = ["clone", "--depth", "1"];
-    if (locator.ref) {
-      args.push("--branch", locator.ref);
-    }
-    args.push(`https://github.com/${locator.owner}/${locator.repo}.git`, checkoutDir);
-    const cloneTimeoutMs = getExternalTemplateTimeoutMs();
-    const cloneResult = spawnSync("git", args, {
-      stdio: "ignore",
-      timeout: cloneTimeoutMs
-    });
-    if (cloneResult.error) {
-      const errorCode = typeof cloneResult.error === "object" && cloneResult.error !== null && "code" in cloneResult.error ? String(cloneResult.error.code) : "";
-      if (errorCode === "ETIMEDOUT") {
-        throw createExternalTemplateTimeoutError(`cloning GitHub template ${locator.owner}/${locator.repo}`, cloneTimeoutMs);
-      }
-      throw cloneResult.error;
+function runGitTemplateCommand(args, label, options = {}) {
+  const timeoutMs = getExternalTemplateTimeoutMs();
+  const result = options.captureOutput ? spawnSync("git", args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs
+  }) : spawnSync("git", args, {
+    stdio: "ignore",
+    timeout: timeoutMs
+  });
+  if (result.error) {
+    const errorCode = typeof result.error === "object" && result.error !== null && "code" in result.error ? String(result.error.code) : "";
+    if (errorCode === "ETIMEDOUT") {
+      throw createExternalTemplateTimeoutError(label, timeoutMs);
+    }
+    throw result.error;
+  }
+  if (result.signal === "SIGTERM" || result.signal === "SIGKILL") {
+    throw createExternalTemplateTimeoutError(label, timeoutMs);
+  }
+  return result;
+}
+function getGitHubTemplateRepositoryUrl(locator) {
+  return `https://github.com/${locator.owner}/${locator.repo}.git`;
+}
+function resolveGitHubTemplateDirectory(checkoutDir, locator) {
+  const sourceDir = path17.resolve(checkoutDir, locator.sourcePath);
+  const relativeSourceDir = path17.relative(checkoutDir, sourceDir);
+  if (relativeSourceDir.startsWith("..") || path17.isAbsolute(relativeSourceDir)) {
+    throw new Error("GitHub template path must stay within the cloned repository.");
+  }
+  if (!fs14.existsSync(sourceDir)) {
+    throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
+  }
+  return sourceDir;
+}
+function cloneGitHubTemplateSource(locator, checkoutDir) {
+  const args = ["clone", "--depth", "1"];
+  if (locator.ref) {
+    args.push("--branch", locator.ref);
+  }
+  args.push(getGitHubTemplateRepositoryUrl(locator), checkoutDir);
+  const cloneResult = runGitTemplateCommand(args, `cloning GitHub template ${locator.owner}/${locator.repo}`);
+  if (cloneResult.status !== 0) {
+    throw new Error(`Failed to clone GitHub template source ${locator.owner}/${locator.repo}.`);
+  }
+}
+function readGitHubTemplateHeadRevision(checkoutDir) {
+  const result = runGitTemplateCommand(["-C", checkoutDir, "rev-parse", "HEAD"], "reading GitHub template checkout revision", { captureOutput: true });
+  if (result.status !== 0 || typeof result.stdout !== "string") {
+    return null;
+  }
+  const revision = result.stdout.trim().split(/\s+/u)[0];
+  return /^[0-9a-f]{40}$/iu.test(revision) ? revision.toLowerCase() : null;
+}
+function pinGitHubTemplateCacheRevision(locator, checkoutDir, cacheRevision) {
+  const normalizedCacheRevision = cacheRevision.toLowerCase();
+  if (readGitHubTemplateHeadRevision(checkoutDir) === normalizedCacheRevision) {
+    return;
+  }
+  const fetchResult = runGitTemplateCommand(["-C", checkoutDir, "fetch", "--depth", "1", "origin", cacheRevision], `fetching GitHub template revision ${locator.owner}/${locator.repo}`);
+  if (fetchResult.status !== 0) {
+    throw createGitHubTemplateCacheRevisionRaceError(`Failed to fetch GitHub template revision ${cacheRevision} for ${locator.owner}/${locator.repo}.`);
+  }
+  const checkoutResult = runGitTemplateCommand(["-C", checkoutDir, "checkout", "--detach", cacheRevision], `checking out GitHub template revision ${locator.owner}/${locator.repo}`);
+  if (checkoutResult.status !== 0) {
+    throw createGitHubTemplateCacheRevisionRaceError(`Failed to check out GitHub template revision ${cacheRevision} for ${locator.owner}/${locator.repo}.`);
+  }
+  if (readGitHubTemplateHeadRevision(checkoutDir) !== normalizedCacheRevision) {
+    throw createGitHubTemplateCacheRevisionRaceError(`GitHub template checkout did not match resolved revision ${cacheRevision} for ${locator.owner}/${locator.repo}.`);
+  }
+}
+function getGitHubTemplateRevisionPatterns(locator) {
+  const ref = locator.ref ?? "HEAD";
+  if (!locator.ref) {
+    return [ref];
+  }
+  if (ref.startsWith("refs/")) {
+    return [ref, `${ref}^{}`];
+  }
+  return [ref, `refs/heads/${ref}`, `refs/tags/${ref}`, `refs/tags/${ref}^{}`];
+}
+function pickGitHubTemplateCacheRevision(locator, revisions) {
+  const ref = locator.ref ?? "HEAD";
+  if (!locator.ref) {
+    return revisions[0]?.revision ?? null;
+  }
+  if (!ref.startsWith("refs/")) {
+    const branchRevision = revisions.find((entry) => entry.resolvedRef === `refs/heads/${ref}`);
+    if (branchRevision) {
+      return branchRevision.revision;
+    }
+    const peeledTagRevision = revisions.find((entry) => entry.resolvedRef === `refs/tags/${ref}^{}`);
+    if (peeledTagRevision) {
+      return peeledTagRevision.revision;
     }
-    if (cloneResult.signal === "SIGTERM" || cloneResult.signal === "SIGKILL") {
-      throw createExternalTemplateTimeoutError(`cloning GitHub template ${locator.owner}/${locator.repo}`, cloneTimeoutMs);
+    const tagRevision = revisions.find((entry) => entry.resolvedRef === `refs/tags/${ref}`);
+    if (tagRevision) {
+      return tagRevision.revision;
+    }
+  }
+  if (ref.startsWith("refs/tags/")) {
+    const peeledRevision = revisions.find((entry) => entry.resolvedRef === `${ref}^{}`);
+    if (peeledRevision) {
+      return peeledRevision.revision;
+    }
+  }
+  const exactRevision = revisions.find((entry) => entry.resolvedRef === ref);
+  return (exactRevision ?? revisions[0])?.revision ?? null;
+}
+function resolveGitHubTemplateCacheRevision(locator) {
+  const result = runGitTemplateCommand([
+    "ls-remote",
+    getGitHubTemplateRepositoryUrl(locator),
+    ...getGitHubTemplateRevisionPatterns(locator)
+  ], `checking GitHub template revision ${locator.owner}/${locator.repo}`, { captureOutput: true });
+  if (result.status !== 0 || typeof result.stdout !== "string") {
+    return {
+      lookupUnavailable: true,
+      revision: null
+    };
+  }
+  const revisions = result.stdout.split(`
+`).map((line) => {
+    const [revision, resolvedRef] = line.trim().split(/\s+/u);
+    if (!/^[0-9a-f]{40}$/iu.test(revision) || !resolvedRef) {
+      return null;
     }
-    if (cloneResult.status !== 0) {
-      throw new Error(`Failed to clone GitHub template source ${locator.owner}/${locator.repo}.`);
+    return {
+      resolvedRef,
+      revision: revision.toLowerCase()
+    };
+  }).filter((entry) => entry !== null);
+  return {
+    lookupUnavailable: false,
+    revision: pickGitHubTemplateCacheRevision(locator, revisions)
+  };
+}
+function getGitHubTemplateCacheMetadata(locator, revision) {
+  return {
+    ...revision ? { revision } : {},
+    owner: locator.owner,
+    ref: locator.ref,
+    repo: locator.repo,
+    sourcePath: locator.sourcePath
+  };
+}
+async function reuseGitHubTemplateCacheByMetadata(locator) {
+  const cachedSource = await findReusableExternalTemplateSourceCache({
+    metadata: getGitHubTemplateCacheMetadata(locator),
+    namespace: "github"
+  });
+  if (!cachedSource) {
+    return null;
+  }
+  const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+  await assertNoSymlinks2(sourceDir);
+  return {
+    blockDir: sourceDir,
+    rootDir: sourceDir
+  };
+}
+async function resolveGitHubTemplateSource(locator) {
+  const cacheEnabled = isExternalTemplateCacheEnabled();
+  let cacheRevisionLookupUnavailable = false;
+  let cacheRevision = null;
+  if (cacheEnabled) {
+    try {
+      const resolvedRevision = resolveGitHubTemplateCacheRevision(locator);
+      cacheRevision = resolvedRevision.revision;
+      cacheRevisionLookupUnavailable = resolvedRevision.lookupUnavailable;
+    } catch {
+      cacheRevision = null;
+      cacheRevisionLookupUnavailable = true;
     }
-    const sourceDir = path16.resolve(checkoutDir, locator.sourcePath);
-    const relativeSourceDir = path16.relative(checkoutDir, sourceDir);
-    if (relativeSourceDir.startsWith("..") || path16.isAbsolute(relativeSourceDir)) {
-      throw new Error("GitHub template path must stay within the cloned repository.");
+  }
+  if (cacheEnabled && !cacheRevision && cacheRevisionLookupUnavailable) {
+    const cachedSource = await reuseGitHubTemplateCacheByMetadata(locator);
+    if (cachedSource) {
+      return cachedSource;
     }
-    if (!fs13.existsSync(sourceDir)) {
-      throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
+  }
+  if (cacheRevision) {
+    const resolvedCacheRevision = cacheRevision;
+    try {
+      const cachedSource = await resolveExternalTemplateSourceCache({
+        keyParts: [
+          "github",
+          locator.owner,
+          locator.repo,
+          locator.sourcePath,
+          locator.ref ?? "",
+          resolvedCacheRevision
+        ],
+        metadata: getGitHubTemplateCacheMetadata(locator, resolvedCacheRevision),
+        namespace: "github"
+      }, async (checkoutDir2) => {
+        cloneGitHubTemplateSource(locator, checkoutDir2);
+        const sourceDir = resolveGitHubTemplateDirectory(checkoutDir2, locator);
+        await assertNoSymlinks2(sourceDir);
+        pinGitHubTemplateCacheRevision(locator, checkoutDir2, resolvedCacheRevision);
+      });
+      if (cachedSource) {
+        const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+        await assertNoSymlinks2(sourceDir);
+        return {
+          blockDir: sourceDir,
+          rootDir: sourceDir
+        };
+      }
+    } catch (error) {
+      if (!isGitHubTemplateCacheRevisionRaceError(error)) {
+        throw error;
+      }
     }
+  }
+  const { path: remoteRoot, cleanup } = await createManagedTempRoot("wp-typia-template-source-");
+  const checkoutDir = path17.join(remoteRoot, "source");
+  try {
+    cloneGitHubTemplateSource(locator, checkoutDir);
+    const sourceDir = resolveGitHubTemplateDirectory(checkoutDir, locator);
     await assertNoSymlinks2(sourceDir);
     return {
       blockDir: sourceDir,
@@ -11339,8 +11923,8 @@ async function resolveGitHubTemplateSource(locator) {
 }
 async function resolveTemplateSeed(locator, cwd) {
   if (locator.kind === "path") {
-    const sourceDir = path16.resolve(cwd, locator.templatePath);
-    if (!fs13.existsSync(sourceDir)) {
+    const sourceDir = path17.resolve(cwd, locator.templatePath);
+    if (!fs14.existsSync(sourceDir)) {
       throw new Error(`Template path does not exist: ${sourceDir}`);
     }
     await assertNoSymlinks2(sourceDir);
@@ -11464,6 +12048,41 @@ async function resolveTemplateSource(templateId, cwd, variables, variant) {
   }
 }
 
+// ../wp-typia-project-tools/src/runtime/version-floor.ts
+function parseVersionFloorParts(value) {
+  return value.split(".").map((part, index) => {
+    if (!/^\d+$/u.test(part)) {
+      throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
+    }
+    return Number.parseInt(part, 10);
+  });
+}
+function compareVersionFloors(left, right) {
+  const leftParts = parseVersionFloorParts(left);
+  const rightParts = parseVersionFloorParts(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0;index < length; index += 1) {
+    const leftValue = leftParts[index] ?? 0;
+    const rightValue = rightParts[index] ?? 0;
+    if (leftValue > rightValue) {
+      return 1;
+    }
+    if (leftValue < rightValue) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function pickHigherVersionFloor(current, candidate) {
+  if (!candidate) {
+    return current;
+  }
+  if (!current) {
+    return candidate;
+  }
+  return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
+}
+
 // ../wp-typia-project-tools/src/runtime/ai-feature-capability.ts
 var AI_FEATURE_DEFINITIONS = {
   wordpressAiClient: {
@@ -11528,39 +12147,6 @@ var DEFAULT_AI_FEATURE_REGISTRY = Object.values(AI_FEATURE_DEFINITIONS).reduce((
   accumulator[definition.id] = definition;
   return accumulator;
 }, {});
-function parseVersionFloorParts(value) {
-  return value.split(".").map((part, index) => {
-    if (!/^\d+$/.test(part)) {
-      throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
-    }
-    return Number.parseInt(part, 10);
-  });
-}
-function compareVersionFloors(left, right) {
-  const leftParts = parseVersionFloorParts(left);
-  const rightParts = parseVersionFloorParts(right);
-  const length = Math.max(leftParts.length, rightParts.length);
-  for (let index = 0;index < length; index += 1) {
-    const leftValue = leftParts[index] ?? 0;
-    const rightValue = rightParts[index] ?? 0;
-    if (leftValue > rightValue) {
-      return 1;
-    }
-    if (leftValue < rightValue) {
-      return -1;
-    }
-  }
-  return 0;
-}
-function pickHigherVersionFloor(current, candidate) {
-  if (!candidate) {
-    return current;
-  }
-  if (!current) {
-    return candidate;
-  }
-  return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
-}
 function normalizeSelections(selections) {
   const normalized = new Map;
   for (const selection of selections) {
@@ -11625,35 +12211,8 @@ var REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY = [
     mode: "required"
   }
 ];
-function parseVersionFloorParts2(value) {
-  return value.split(".").map((part, index) => {
-    if (!/^\d+$/u.test(part)) {
-      throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
-    }
-    return Number.parseInt(part, 10);
-  });
-}
-function compareVersionFloors2(left, right) {
-  const leftParts = parseVersionFloorParts2(left);
-  const rightParts = parseVersionFloorParts2(right);
-  const length = Math.max(leftParts.length, rightParts.length);
-  for (let index = 0;index < length; index += 1) {
-    const leftValue = leftParts[index] ?? 0;
-    const rightValue = rightParts[index] ?? 0;
-    if (leftValue > rightValue) {
-      return 1;
-    }
-    if (leftValue < rightValue) {
-      return -1;
-    }
-  }
-  return 0;
-}
-function pickHigherVersionFloor2(current, candidate) {
-  if (!candidate) {
-    return current;
-  }
-  return compareVersionFloors2(current, candidate) >= 0 ? current : candidate;
+function pickHigherScaffoldVersionFloor(current, candidate) {
+  return pickHigherVersionFloor(current, candidate) ?? current;
 }
 function pickHigherHeaderVersionFloor(policyValue, currentValue) {
   const normalizedCurrentValue = currentValue.trim();
@@ -11661,7 +12220,7 @@ function pickHigherHeaderVersionFloor(policyValue, currentValue) {
     return policyValue;
   }
   try {
-    return pickHigherVersionFloor2(policyValue, normalizedCurrentValue);
+    return pickHigherScaffoldVersionFloor(policyValue, normalizedCurrentValue);
   } catch {
     return policyValue;
   }
@@ -11682,9 +12241,9 @@ function resolveScaffoldCompatibilityPolicy(selections, {
   baseline = DEFAULT_SCAFFOLD_COMPATIBILITY
 } = {}) {
   const capabilityPlan = resolveAiFeatureCapabilityPlan(selections);
-  const requiresAtLeast = pickHigherVersionFloor2(baseline.requiresAtLeast, capabilityPlan.hardMinimums.wordpress);
-  const requiresPhp = pickHigherVersionFloor2(baseline.requiresPhp, capabilityPlan.hardMinimums.php);
-  const testedUpTo = pickHigherVersionFloor2(baseline.testedUpTo, requiresAtLeast);
+  const requiresAtLeast = pickHigherScaffoldVersionFloor(baseline.requiresAtLeast, capabilityPlan.hardMinimums.wordpress);
+  const requiresPhp = pickHigherScaffoldVersionFloor(baseline.requiresPhp, capabilityPlan.hardMinimums.php);
+  const testedUpTo = pickHigherScaffoldVersionFloor(baseline.testedUpTo, requiresAtLeast);
   return {
     capabilityPlan,
     pluginHeader: {
@@ -13487,6 +14046,7 @@ import { useBlockProps, InspectorControls, RichText, BlockControls, AlignmentToo
 import { PanelBody, RangeControl, Button, Notice } from '@wordpress/components';
 import { useState } from '@wordpress/element';
 import currentManifest from './manifest-document';
+import { {{slugCamelCase}}Store } from './interactivity-store';
 import {
   InspectorFromManifest,
   useEditorFields,
@@ -13567,17 +14127,22 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
 
   const blockProps = useBlockProps({
     className: \`{{cssClassName}} {{cssClassName}}--\${interactiveMode}\`,
-    'data-wp-interactive': '{{slugKebabCase}}',
-    'data-wp-context': JSON.stringify({
-      clicks: clickCount,
-      isAnimating,
-      isVisible,
-      animation,
-      maxClicks,
-    })
+    'data-wp-interactive': {{slugCamelCase}}Store.directive.interactive,
+    'data-wp-context': JSON.stringify(
+      {{slugCamelCase}}Store.createContext({
+        clicks: clickCount,
+        isAnimating,
+        isVisible,
+        animation,
+        maxClicks,
+      })
+    )
   });
   const previewContentStyle = { textAlign: alignmentValue };
   const progressBarStyle = { width: \`\${(clickCount / maxClicks) * 100}%\` };
+  const clicksDirective = {{slugCamelCase}}Store.directive.state('clicks');
+  const isAnimatingDirective = {{slugCamelCase}}Store.directive.state('isAnimating');
+  const progressDirective = {{slugCamelCase}}Store.directive.state('progress') + " + '%'";
 
   const resetCounter = () => {
     updateField('clickCount', 0);
@@ -13674,9 +14239,9 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
         <div
           className={\`{{cssClassName}}__content \${isAnimating ? 'is-animating' : ''}\`}
           style={previewContentStyle}
-          data-wp-on--click={isPreviewing ? 'actions.handleClick' : undefined}
-          data-wp-on--mouseenter={isPreviewing && interactiveMode === 'hover' ? 'actions.handleMouseEnter' : undefined}
-          data-wp-on--mouseleave={isPreviewing && interactiveMode === 'hover' ? 'actions.handleMouseLeave' : undefined}
+          data-wp-on--click={isPreviewing ? {{slugCamelCase}}Store.directive.action('handleClick') : undefined}
+          data-wp-on--mouseenter={isPreviewing && interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseEnter') : undefined}
+          data-wp-on--mouseleave={isPreviewing && interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseLeave') : undefined}
         >
           <RichText
             tagName="p"
@@ -13705,7 +14270,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
               </span>
               <span
                 className="{{cssClassName}}__counter-value"
-                data-wp-text="state.clicks"
+                data-wp-text={clicksDirective}
               >
                 {clickCount}
               </span>
@@ -13717,7 +14282,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
               <div
                 className="{{cssClassName}}__progress-bar"
                 style={progressBarStyle}
-                data-wp-style--width="state.progress + '%'"
+                data-wp-style--width={progressDirective}
               />
             </div>
           )}
@@ -13725,7 +14290,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
           {animation !== 'none' && (
             <div
               className={\`{{cssClassName}}__animation \${isAnimating ? 'is-active' : ''}\`}
-              data-wp-class--is-active="state.isAnimating"
+              data-wp-class--is-active={isAnimatingDirective}
             >
               {animation}
             </div>
@@ -13738,6 +14303,7 @@ export default function Edit({ attributes, setAttributes, isSelected }: EditProp
 `;
 var INTERACTIVITY_SAVE_TEMPLATE = `import { useBlockProps, RichText } from '@wordpress/block-editor';
 import { __ } from '@wordpress/i18n';
+import { {{slugCamelCase}}Store } from './interactivity-store';
 import type { {{pascalCase}}Attributes } from './types';
 
 export default function Save({ attributes }: { attributes: {{pascalCase}}Attributes }) {
@@ -13749,27 +14315,41 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
   const maxClicks = attributes.maxClicks ?? 0;
   const showCounter = attributes.showCounter ?? true;
   const contentStyle = { textAlign: attributes.alignment };
+  const clickActionDirective = {{slugCamelCase}}Store.directive.action('handleClick');
+  const visibilityHiddenDirective = {{slugCamelCase}}Store.directive.negate(
+    {{slugCamelCase}}Store.directive.state('isVisible')
+  );
+  const clicksDirective = {{slugCamelCase}}Store.directive.state('clicks');
+  const clampedClicksDirective = {{slugCamelCase}}Store.directive.state('clampedClicks');
+  const isAnimatingDirective = {{slugCamelCase}}Store.directive.state('isAnimating');
+  const completionHiddenDirective = {{slugCamelCase}}Store.directive.negate(
+    {{slugCamelCase}}Store.directive.state('isComplete')
+  );
+  const resetActionDirective = {{slugCamelCase}}Store.directive.action('reset');
   const blockProps = useBlockProps.save({
     className: \`{{cssClassName}} {{cssClassName}}--\${interactiveMode}\`,
-    'data-wp-interactive': '{{slugKebabCase}}',
-    'data-wp-context': JSON.stringify({
-      clicks: clickCount,
-      isAnimating,
-      isVisible,
-      animation,
-      maxClicks,
-    })
+    'data-wp-interactive': {{slugCamelCase}}Store.directive.interactive,
+    'data-wp-context': JSON.stringify(
+      {{slugCamelCase}}Store.createContext({
+        clicks: clickCount,
+        isAnimating,
+        isVisible,
+        animation,
+        maxClicks,
+      })
+    )
   });
+  const progressDirective = {{slugCamelCase}}Store.directive.state('progress') + " + '%'";
 
   return (
     <div {...blockProps}>
       <div
         className={\`{{cssClassName}}__content \${isAnimating ? 'is-animating' : ''}\`}
         style={contentStyle}
-        data-wp-on--click="actions.handleClick"
-        data-wp-on--mouseenter={interactiveMode === 'hover' ? 'actions.handleMouseEnter' : undefined}
-        data-wp-on--mouseleave={interactiveMode === 'hover' ? 'actions.handleMouseLeave' : undefined}
-        data-wp-bind--hidden="!state.isVisible"
+        data-wp-on--click={clickActionDirective}
+        data-wp-on--mouseenter={interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseEnter') : undefined}
+        data-wp-on--mouseleave={interactiveMode === 'hover' ? {{slugCamelCase}}Store.directive.action('handleMouseLeave') : undefined}
+        data-wp-bind--hidden={visibilityHiddenDirective}
       >
         <RichText.Content
           tagName="p"
@@ -13789,7 +14369,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
             </span>
             <span
               className="{{cssClassName}}__counter-value"
-              data-wp-text="state.clicks"
+              data-wp-text={clicksDirective}
             >
               {clickCount}
             </span>
@@ -13805,8 +14385,8 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
               aria-valuemin={0}
               aria-valuemax={maxClicks}
               aria-valuenow={Math.min(clickCount, maxClicks)}
-              data-wp-bind--aria-valuenow="state.clampedClicks"
-              data-wp-style--width="state.progress + '%'"
+              data-wp-bind--aria-valuenow={clampedClicksDirective}
+              data-wp-style--width={progressDirective}
             />
           </div>
         )}
@@ -13814,7 +14394,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
         <div
           className={\`{{cssClassName}}__animation \${animation}\`}
           aria-hidden="true"
-          data-wp-class--is-active="state.isAnimating"
+          data-wp-class--is-active={isAnimatingDirective}
         />
 
         {maxClicks > 0 && (
@@ -13823,7 +14403,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
             role="status"
             aria-live="polite"
             aria-atomic="true"
-            data-wp-bind--hidden="!state.isComplete"
+            data-wp-bind--hidden={completionHiddenDirective}
           >
             { __( '\uD83C\uDF89 Complete!', '{{textDomain}}' ) }
           </div>
@@ -13831,7 +14411,7 @@ export default function Save({ attributes }: { attributes: {{pascalCase}}Attribu
 
         <button
           className="{{cssClassName}}__reset"
-          data-wp-on--click="actions.reset"
+          data-wp-on--click={resetActionDirective}
           aria-label={ __( 'Reset counter', '{{textDomain}}' ) }
         >
           <span aria-hidden="true">\u21BB</span>
@@ -13881,20 +14461,214 @@ const registration = buildScaffoldBlockRegistration(
 
 registerScaffoldBlockType(registration.name, registration.settings);
 `;
+var INTERACTIVITY_STORE_TEMPLATE = `import type {
+  {{pascalCase}}Context,
+  {{pascalCase}}State,
+} from './types';
+
+type InteractivityActionShape = object;
+type InteractivityCallbackShape = object;
+type InteractivityContextShape = object;
+type InteractivityStateShape = object;
+type InteractivityCallable = Function;
+type InteractivityKey<T extends object> = Extract<keyof T, string>;
+type InteractivityMethodKey<T extends object> = {
+  [Key in InteractivityKey<T>]: T[Key] extends InteractivityCallable ? Key : never;
+}[InteractivityKey<T>];
+
+type InteractivityDirectivePath<
+  Root extends string,
+  Key extends string,
+> = \`\${Root}.\${Key}\`;
+
+type NegatedInteractivityDirectivePath<Path extends string> = \`!\${Path}\`;
+
+export interface TypedInteractivityDirectiveHelpers<
+  State extends InteractivityStateShape,
+  Context extends InteractivityContextShape,
+  Actions extends InteractivityActionShape,
+  Callbacks extends InteractivityCallbackShape,
+  Namespace extends string,
+> {
+  readonly interactive: Namespace;
+  action<Key extends InteractivityMethodKey<Actions>>(
+    key: Key,
+  ): InteractivityDirectivePath<'actions', Key>;
+  callback<Key extends InteractivityMethodKey<Callbacks>>(
+    key: Key,
+  ): InteractivityDirectivePath<'callbacks', Key>;
+  state<Key extends InteractivityKey<State>>(
+    key: Key,
+  ): InteractivityDirectivePath<'state', Key>;
+  context<Key extends InteractivityKey<Context>>(
+    key: Key,
+  ): InteractivityDirectivePath<'context', Key>;
+  negate<Path extends string>(
+    path: Path,
+  ): NegatedInteractivityDirectivePath<Path>;
+}
+
+export interface TypedInteractivityStore<
+  Namespace extends string,
+  State extends InteractivityStateShape,
+  Context extends InteractivityContextShape,
+  Actions extends InteractivityActionShape,
+  Callbacks extends InteractivityCallbackShape,
+> {
+  readonly namespace: Namespace;
+  readonly state: State;
+  readonly context: Context;
+  readonly actions: Actions;
+  readonly callbacks: Callbacks;
+  readonly directive: TypedInteractivityDirectiveHelpers<
+    State,
+    Context,
+    Actions,
+    Callbacks,
+    Namespace
+  >;
+  createContext(value: Context): Context;
+}
+
+export function defineInteractivityStore<
+  Namespace extends string,
+  State extends InteractivityStateShape,
+  Context extends InteractivityContextShape,
+  Actions extends InteractivityActionShape,
+  Callbacks extends InteractivityCallbackShape,
+>(config: {
+  readonly namespace: Namespace;
+  readonly state: State;
+  readonly context: Context;
+  readonly actions: Actions;
+  readonly callbacks: Callbacks;
+}): TypedInteractivityStore<Namespace, State, Context, Actions, Callbacks> {
+  return {
+    namespace: config.namespace,
+    state: config.state,
+    context: config.context,
+    actions: config.actions,
+    callbacks: config.callbacks,
+    directive: {
+      interactive: config.namespace,
+      action<Key extends InteractivityMethodKey<Actions>>(key: Key) {
+        return \`actions.\${key}\` as InteractivityDirectivePath<'actions', Key>;
+      },
+      callback<Key extends InteractivityMethodKey<Callbacks>>(key: Key) {
+        return \`callbacks.\${key}\` as InteractivityDirectivePath<'callbacks', Key>;
+      },
+      state<Key extends InteractivityKey<State>>(key: Key) {
+        return \`state.\${key}\` as InteractivityDirectivePath<'state', Key>;
+      },
+      context<Key extends InteractivityKey<Context>>(key: Key) {
+        return \`context.\${key}\` as InteractivityDirectivePath<'context', Key>;
+      },
+      negate<Path extends string>(path: Path) {
+        return \`!\${path}\` as NegatedInteractivityDirectivePath<Path>;
+      },
+    },
+    createContext(value) {
+      return value;
+    },
+  };
+}
+
+type InteractivityActionHandler = Function;
+
+export interface {{pascalCase}}StoreActions {
+  handleClick: InteractivityActionHandler;
+  handleMouseEnter: InteractivityActionHandler;
+  handleMouseLeave: InteractivityActionHandler;
+  reset: InteractivityActionHandler;
+}
+
+export interface {{pascalCase}}StoreCallbacks {}
+
+export const {{slugCamelCase}}Store = defineInteractivityStore({
+  namespace: '{{slugKebabCase}}',
+  state: {} as {{pascalCase}}State,
+  context: {} as {{pascalCase}}Context,
+  actions: {} as {{pascalCase}}StoreActions,
+  callbacks: {} as {{pascalCase}}StoreCallbacks,
+});
+`;
 var INTERACTIVITY_SCRIPT_TEMPLATE = `/**
  * WordPress Interactivity API implementation for {{title}} block
  */
 import { store, getContext, getElement, withSyncEvent } from '@wordpress/interactivity';
-import type { {{pascalCase}}Context } from './types';
+import {
+  {{slugCamelCase}}Store,
+  type {{pascalCase}}StoreActions,
+} from './interactivity-store';
+import type { {{pascalCase}}Context, {{pascalCase}}State } from './types';
 
 function getBlockContext() {
   return getContext<{{pascalCase}}Context>();
 }
 
-// Store configuration
-store('{{slugKebabCase}}', {
-  // State - reactive data that updates the UI
-  state: {
+const actions: {{pascalCase}}StoreActions = {
+  // Handle block click
+  handleClick: () => {
+    const context = getBlockContext();
+    const { ref } = getElement();
+
+    if (!ref) {
+      return;
+    }
+
+    if (context.maxClicks > 0 && context.clicks >= context.maxClicks) {
+      return;
+    }
+
+    const previousClicks = context.clicks;
+
+    // Increment click counter
+    context.clicks += 1;
+
+    // Trigger animation
+    if (context.animation !== 'none') {
+      context.isAnimating = true;
+      setTimeout(() => {
+        context.isAnimating = false;
+      }, 1000);
+    }
+
+    // Emit custom event
+    ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:click', {
+      detail: { clicks: context.clicks }
+    }));
+
+    // Check if max clicks reached
+    if (context.maxClicks > 0 && previousClicks < context.maxClicks && context.clicks === context.maxClicks) {
+      ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:complete', {
+        detail: { totalClicks: context.clicks }
+      }));
+    }
+  },
+
+  // Handle hover events
+  handleMouseEnter: () => {
+    const context = getBlockContext();
+    if (context.animation === 'none') return;
+    context.isAnimating = true;
+  },
+
+  handleMouseLeave: () => {
+    const context = getBlockContext();
+    if (context.animation === 'none') return;
+    context.isAnimating = false;
+  },
+
+  // Reset counter
+  reset: withSyncEvent((event: Event) => {
+    event.stopPropagation();
+    const context = getBlockContext();
+    context.clicks = 0;
+    context.isAnimating = false;
+  })
+};
+
+const state = {
     get clicks() {
       return getBlockContext().clicks;
     },
@@ -13922,70 +14696,14 @@ store('{{slugKebabCase}}', {
       const context = getBlockContext();
       return context.clicks >= context.maxClicks && context.maxClicks > 0;
     }
-  },
+} satisfies {{pascalCase}}State;
 
-  // Actions - user interactions
-  actions: {
-    // Handle block click
-    handleClick: () => {
-      const context = getBlockContext();
-      const { ref } = getElement();
-
-      if (!ref) {
-        return;
-      }
-
-      if (context.maxClicks > 0 && context.clicks >= context.maxClicks) {
-        return;
-      }
-
-      const previousClicks = context.clicks;
-
-      // Increment click counter
-      context.clicks += 1;
-
-      // Trigger animation
-      if (context.animation !== 'none') {
-        context.isAnimating = true;
-        setTimeout(() => {
-          context.isAnimating = false;
-        }, 1000);
-      }
-
-      // Emit custom event
-      ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:click', {
-        detail: { clicks: context.clicks }
-      }));
-
-      // Check if max clicks reached
-      if (context.maxClicks > 0 && previousClicks < context.maxClicks && context.clicks === context.maxClicks) {
-        ref.dispatchEvent(new CustomEvent('{{slugKebabCase}}:complete', {
-          detail: { totalClicks: context.clicks }
-        }));
-      }
-    },
-
-    // Handle hover events
-    handleMouseEnter: () => {
-      const context = getBlockContext();
-      if (context.animation === 'none') return;
-      context.isAnimating = true;
-    },
-
-    handleMouseLeave: () => {
-      const context = getBlockContext();
-      if (context.animation === 'none') return;
-      context.isAnimating = false;
-    },
-
-    // Reset counter
-    reset: withSyncEvent((event: Event) => {
-      event.stopPropagation();
-      const context = getBlockContext();
-      context.clicks = 0;
-      context.isAnimating = false;
-    })
-  }
+// Store configuration
+store({{slugCamelCase}}Store.namespace, {
+  // State - reactive data that updates the UI
+  state,
+  actions,
+  callbacks: {{slugCamelCase}}Store.callbacks,
 });
 `;
 var INTERACTIVITY_VALIDATORS_TEMPLATE = `import typia from 'typia';
@@ -15798,6 +16516,10 @@ function buildInteractivityCodeArtifacts(variables) {
         relativePath: "src/interactivity.ts",
         template: INTERACTIVITY_SCRIPT_TEMPLATE
       },
+      {
+        relativePath: "src/interactivity-store.ts",
+        template: INTERACTIVITY_STORE_TEMPLATE
+      },
       {
         relativePath: "src/validators.ts",
         template: INTERACTIVITY_VALIDATORS_TEMPLATE
@@ -16505,17 +17227,17 @@ async function scaffoldProject({
     phase: "finalize-project",
     title: "Finalizing scaffold output"
   });
-  const readmePath = path17.join(projectDir, "README.md");
-  if (!fs14.existsSync(readmePath)) {
-    await fsp10.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
+  const readmePath = path18.join(projectDir, "README.md");
+  if (!fs15.existsSync(readmePath)) {
+    await fsp11.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
       withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
       withTestPreset: isBuiltInTemplate ? withTestPreset : false,
       withWpEnv: isBuiltInTemplate ? withWpEnv : false
     }), "utf8");
   }
-  const gitignorePath = path17.join(projectDir, ".gitignore");
-  const existingGitignore = fs14.existsSync(gitignorePath) ? await fsp10.readFile(gitignorePath, "utf8") : "";
-  await fsp10.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "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");
   await normalizePackageJson(projectDir, resolvedPackageManager);
   if (isBuiltInTemplate) {
     const variableGroups = getScaffoldTemplateVariableGroups(variables);
@@ -16560,6 +17282,8 @@ async function resolveOptionalInteractiveExternalLayerId({
   callerCwd,
   externalLayerId,
   externalLayerSource,
+  listExternalTemplateLayers = listSelectableExternalTemplateLayers,
+  resolveExternalTemplateSeed = resolveTemplateSeed,
   selectExternalLayerId
 }) {
   if (!externalLayerSource || externalLayerId || !selectExternalLayerId) {
@@ -16568,9 +17292,9 @@ async function resolveOptionalInteractiveExternalLayerId({
       externalLayerSource
     };
   }
-  const layerSeed = await resolveTemplateSeed(parseTemplateLocator(externalLayerSource), callerCwd);
+  const layerSeed = await resolveExternalTemplateSeed(parseTemplateLocator(externalLayerSource), callerCwd);
   try {
-    const selectableLayers = await listSelectableExternalTemplateLayers(layerSeed.rootDir);
+    const selectableLayers = await listExternalTemplateLayers(layerSeed.rootDir);
     if (selectableLayers.length <= 1) {
       await layerSeed.cleanup?.();
       return {
@@ -16586,7 +17310,6 @@ async function resolveOptionalInteractiveExternalLayerId({
         externalLayerSource: layerSeed.rootDir
       };
     }
-    await layerSeed.cleanup?.();
     throw new Error(`Unknown external layer "${selectedLayerId}". Expected one of: ${selectableLayers.map((layer) => layer.id).join(", ")}`);
   } catch (error) {
     await layerSeed.cleanup?.();
@@ -16596,4 +17319,4 @@ 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, renderScaffoldCompatibilityConfig, updatePluginHeaderCompatibility, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
 
-//# debugId=8415ABFCC6733BCA64756E2164756E21
+//# debugId=C53957BD2FAAAD8464756E2164756E21