@wp-typia/project-tools 0.16.8 → 0.16.10

package/dist/runtime/scaffold-apply-utils.js

@@ -14,6 +14,7 @@ import { stringifyBuiltInBlockJsonDocument, } from "./built-in-block-artifacts.j
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, } from "./template-registry.js";
 import { copyInterpolatedDirectory } from "./template-render.js";
 import { formatInstallCommand, formatPackageExecCommand, formatRunScript, getPackageManager, transformPackageManagerText, } from "./package-managers.js";
+import { replaceRepositoryReferencePlaceholders, resolveScaffoldRepositoryReference, } from "./scaffold-repository-reference.js";
 const EPHEMERAL_NODE_MODULES_LINK_TYPE = process.platform === "win32" ? "junction" : "dir";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const LOCKFILES = {
@@ -265,7 +266,11 @@ export async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
         }
     }));
 }
-export async function replaceTextRecursively(targetDir, packageManagerId) {
+/**
+ * Recursively normalizes generated text files for the selected package manager
+ * and repository reference.
+ */
+export async function replaceTextRecursively(targetDir, packageManagerId, { repositoryManifestPaths, repositoryReference, } = {}) {
     const textExtensions = new Set([
         ".css",
         ".js",
@@ -278,6 +283,10 @@ export async function replaceTextRecursively(targetDir, packageManagerId) {
         ".tsx",
         ".txt",
     ]);
+    const resolvedRepositoryReference = repositoryReference ??
+        resolveScaffoldRepositoryReference({
+            manifestPaths: repositoryManifestPaths,
+        });
     async function visit(currentPath) {
         const stats = await fsp.stat(currentPath);
         if (stats.isDirectory()) {
@@ -291,9 +300,7 @@ export async function replaceTextRecursively(targetDir, packageManagerId) {
             return;
         }
         const content = await fsp.readFile(currentPath, "utf8");
-        const nextContent = transformPackageManagerText(content, packageManagerId)
-            .replace(/yourusername\/wp-typia-boilerplate/g, "imjlk/wp-typia")
-            .replace(/yourusername\/wp-typia/g, "imjlk/wp-typia");
+        const nextContent = replaceRepositoryReferencePlaceholders(transformPackageManagerText(content, packageManagerId), resolvedRepositoryReference);
         if (nextContent !== content) {
             await fsp.writeFile(currentPath, nextContent, "utf8");
         }
@@ -344,7 +351,11 @@ export async function applyWorkspaceMigrationCapability(projectDir, packageManag
     ensureMigrationDirectories(projectDir, []);
     writeInitialMigrationScaffold(projectDir, "v1", []);
 }
-export async function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir, templateId, variables, artifacts, codeArtifacts, readmeContent, gitignoreContent, allowExistingDir = false, packageManager, withMigrationUi = false, withTestPreset = false, withWpEnv = false, noInstall = false, installDependencies, }) {
+/**
+ * Applies a built-in scaffold into the target directory, including generated
+ * code artifacts, starter manifests, preset files, and placeholder rewrites.
+ */
+export async function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir, templateId, variables, artifacts, codeArtifacts, readmeContent, gitignoreContent, allowExistingDir = false, packageManager, withMigrationUi = false, withTestPreset = false, withWpEnv = false, noInstall = false, installDependencies, repositoryReference, }) {
     await ensureDirectory(projectDir, allowExistingDir);
     await copyInterpolatedDirectory(templateDir, projectDir, variables);
     if (codeArtifacts && codeArtifacts.length > 0) {
@@ -394,7 +405,9 @@ export async function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir
     });
     await normalizePackageManagerFiles(projectDir, packageManager);
     await removeUnexpectedLockfiles(projectDir, packageManager);
-    await replaceTextRecursively(projectDir, packageManager);
+    await replaceTextRecursively(projectDir, packageManager, {
+        repositoryReference,
+    });
     if (!noInstall) {
         const installer = installDependencies ?? defaultInstallDependencies;
         await installer({

package/dist/runtime/scaffold-repository-reference.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Default scaffold repository reference used when no GitHub repository metadata
+ * can be resolved from the current runtime package manifests.
+ */
+export declare const DEFAULT_SCAFFOLD_REPOSITORY_REFERENCE = "imjlk/wp-typia";
+/**
+ * Resolves the canonical scaffold repository reference in `owner/repo` format.
+ *
+ * The resolver checks candidate package manifests in priority order, extracts
+ * their `repository` field, and returns the first GitHub slug it can parse.
+ * When no candidate yields a GitHub repository reference, the fallback value
+ * is returned instead.
+ */
+export declare function resolveScaffoldRepositoryReference({ fallback, manifestPaths, }?: {
+    fallback?: string;
+    manifestPaths?: readonly string[];
+}): string;
+/**
+ * Replaces legacy scaffold repository placeholders with a concrete
+ * `owner/repo` reference.
+ */
+export declare function replaceRepositoryReferencePlaceholders(source: string, repositoryReference: string): string;

package/dist/runtime/scaffold-repository-reference.js

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { PROJECT_TOOLS_PACKAGE_ROOT } from "./template-registry.js";
+const require = createRequire(import.meta.url);
+/**
+ * Default scaffold repository reference used when no GitHub repository metadata
+ * can be resolved from the current runtime package manifests.
+ */
+export const DEFAULT_SCAFFOLD_REPOSITORY_REFERENCE = "imjlk/wp-typia";
+function getErrorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : undefined;
+}
+function readRepositoryPackageManifest(packageJsonPath) {
+    try {
+        return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    }
+    catch (error) {
+        if (getErrorCode(error) === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function resolveInstalledPackageManifestPath(packageName) {
+    try {
+        return require.resolve(`${packageName}/package.json`);
+    }
+    catch (error) {
+        if (getErrorCode(error) === "MODULE_NOT_FOUND") {
+            return null;
+        }
+        throw error;
+    }
+}
+function getRepositoryFieldValue(manifest) {
+    if (!manifest?.repository) {
+        return undefined;
+    }
+    return typeof manifest.repository === "string"
+        ? manifest.repository
+        : manifest.repository.url;
+}
+function parseRepositoryReference(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const githubShorthandMatch = trimmed.match(/^github:([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:#.*)?$/u);
+    if (githubShorthandMatch) {
+        return `${githubShorthandMatch[1]}/${githubShorthandMatch[2]}`;
+    }
+    if (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u.test(trimmed)) {
+        return trimmed;
+    }
+    const githubScpMatch = trimmed.match(/^git@github\.com:([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?(?:#.*)?$/u);
+    if (githubScpMatch) {
+        return `${githubScpMatch[1]}/${githubScpMatch[2]}`;
+    }
+    const normalizedValue = trimmed
+        .replace(/^git\+/u, "")
+        .replace(/#.*$/u, "");
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(normalizedValue);
+    }
+    catch {
+        return null;
+    }
+    if (parsedUrl.hostname !== "github.com") {
+        return null;
+    }
+    const pathSegments = parsedUrl.pathname
+        .replace(/^\/+/u, "")
+        .replace(/\.git$/u, "")
+        .split("/");
+    if (pathSegments.length < 2 || !pathSegments[0] || !pathSegments[1]) {
+        return null;
+    }
+    return `${pathSegments[0]}/${pathSegments[1]}`;
+}
+function getDefaultRepositoryManifestPaths() {
+    const candidatePaths = [
+        path.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "..", "package.json"),
+        path.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "wp-typia", "package.json"),
+        path.join(PROJECT_TOOLS_PACKAGE_ROOT, "package.json"),
+        resolveInstalledPackageManifestPath("wp-typia"),
+        resolveInstalledPackageManifestPath("@wp-typia/project-tools"),
+    ].filter((candidatePath) => Boolean(candidatePath));
+    return candidatePaths.filter((candidatePath, index, allPaths) => allPaths.indexOf(candidatePath) === index);
+}
+/**
+ * Resolves the canonical scaffold repository reference in `owner/repo` format.
+ *
+ * The resolver checks candidate package manifests in priority order, extracts
+ * their `repository` field, and returns the first GitHub slug it can parse.
+ * When no candidate yields a GitHub repository reference, the fallback value
+ * is returned instead.
+ */
+export function resolveScaffoldRepositoryReference({ fallback = DEFAULT_SCAFFOLD_REPOSITORY_REFERENCE, manifestPaths = getDefaultRepositoryManifestPaths(), } = {}) {
+    for (const manifestPath of manifestPaths) {
+        const repositoryReference = parseRepositoryReference(getRepositoryFieldValue(readRepositoryPackageManifest(manifestPath)));
+        if (repositoryReference) {
+            return repositoryReference;
+        }
+    }
+    return fallback;
+}
+/**
+ * Replaces legacy scaffold repository placeholders with a concrete
+ * `owner/repo` reference.
+ */
+export function replaceRepositoryReferencePlaceholders(source, repositoryReference) {
+    return source
+        .replace(/yourusername\/wp-typia-boilerplate/g, repositoryReference)
+        .replace(/yourusername\/wp-typia/g, repositoryReference);
+}

package/dist/runtime/scaffold.d.ts

@@ -115,11 +115,15 @@ interface ScaffoldProjectOptions {
     answers: ScaffoldAnswers;
     cwd?: string;
     dataStorageMode?: DataStorageMode;
+    externalLayerId?: string;
+    externalLayerSource?: string;
+    externalLayerSourceLabel?: string;
     installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
     noInstall?: boolean;
     packageManager: PackageManagerId;
     persistencePolicy?: PersistencePolicy;
     projectDir: string;
+    repositoryReference?: string;
     templateId: string;
     variant?: string;
     withMigrationUi?: boolean;
@@ -153,5 +157,5 @@ export declare function resolveTemplateId({ templateId, yes, isInteractive, sele
 export declare function resolvePackageManagerId({ packageManager, yes, isInteractive, selectPackageManager, }: ResolvePackageManagerOptions): Promise<PackageManagerId>;
 export declare function collectScaffoldAnswers({ projectName, templateId, yes, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, textDomain, }: CollectScaffoldAnswersOptions): Promise<ScaffoldAnswers>;
 export declare function getTemplateVariables(templateId: string, answers: ScaffoldAnswers): ScaffoldTemplateVariables;
-export declare function scaffoldProject({ projectDir, templateId, answers, dataStorageMode, persistencePolicy, packageManager, cwd, allowExistingDir, noInstall, installDependencies, variant, withMigrationUi, withTestPreset, withWpEnv, }: ScaffoldProjectOptions): Promise<ScaffoldProjectResult>;
+export declare function scaffoldProject({ projectDir, templateId, answers, dataStorageMode, persistencePolicy, packageManager, externalLayerId, externalLayerSource, externalLayerSourceLabel, repositoryReference, cwd, allowExistingDir, noInstall, installDependencies, variant, withMigrationUi, withTestPreset, withWpEnv, }: ScaffoldProjectOptions): Promise<ScaffoldProjectResult>;
 export {};

package/dist/runtime/scaffold.js

@@ -3,6 +3,7 @@ import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { execSync } from "node:child_process";
 import { PACKAGE_MANAGER_IDS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, transformPackageManagerText, } from "./package-managers.js";
+import { replaceTextRecursively } from "./scaffold-apply-utils.js";
 import { applyGeneratedProjectDxPackageJson, applyLocalDevPresetFiles, getPrimaryDevelopmentScript, } from "./local-dev-presets.js";
 import { applyMigrationUiCapability } from "./migration-ui-capability.js";
 import { getPackageVersions } from "./package-versions.js";
@@ -563,41 +564,6 @@ async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
         }
     }));
 }
-async function replaceTextRecursively(targetDir, packageManagerId) {
-    const textExtensions = new Set([
-        ".css",
-        ".js",
-        ".json",
-        ".jsx",
-        ".md",
-        ".php",
-        ".scss",
-        ".ts",
-        ".tsx",
-        ".txt",
-    ]);
-    async function visit(currentPath) {
-        const stats = await fsp.stat(currentPath);
-        if (stats.isDirectory()) {
-            const entries = await fsp.readdir(currentPath);
-            for (const entry of entries) {
-                await visit(path.join(currentPath, entry));
-            }
-            return;
-        }
-        if (path.basename(currentPath) === "package.json" || !textExtensions.has(path.extname(currentPath))) {
-            return;
-        }
-        const content = await fsp.readFile(currentPath, "utf8");
-        const nextContent = transformPackageManagerText(content, packageManagerId)
-            .replace(/yourusername\/wp-typia-boilerplate/g, "imjlk/wp-typia")
-            .replace(/yourusername\/wp-typia/g, "imjlk/wp-typia");
-        if (nextContent !== content) {
-            await fsp.writeFile(currentPath, nextContent, "utf8");
-        }
-    }
-    await visit(targetDir);
-}
 async function defaultInstallDependencies({ projectDir, packageManager, }) {
     execSync(formatInstallCommand(packageManager), {
         cwd: projectDir,
@@ -642,10 +608,13 @@ async function applyWorkspaceMigrationCapability(projectDir, packageManager) {
     ensureMigrationDirectories(projectDir, []);
     writeInitialMigrationScaffold(projectDir, "v1", []);
 }
-export async function scaffoldProject({ projectDir, templateId, answers, dataStorageMode, persistencePolicy, packageManager, cwd = process.cwd(), allowExistingDir = false, noInstall = false, installDependencies = undefined, variant, withMigrationUi = false, withTestPreset = false, withWpEnv = false, }) {
+export async function scaffoldProject({ projectDir, templateId, answers, dataStorageMode, persistencePolicy, packageManager, externalLayerId, externalLayerSource, externalLayerSourceLabel, repositoryReference, cwd = process.cwd(), allowExistingDir = false, noInstall = false, installDependencies = undefined, variant, withMigrationUi = false, withTestPreset = false, withWpEnv = false, }) {
     const resolvedTemplateId = normalizeTemplateSelection(templateId);
     const resolvedPackageManager = getPackageManager(packageManager).id;
     const isBuiltInTemplate = isBuiltInTemplateId(resolvedTemplateId);
+    if (externalLayerId && !externalLayerSource) {
+        throw new Error("externalLayerId requires externalLayerSource when composing built-in template layers.");
+    }
     if (isBuiltInTemplate) {
         const blockGeneratorService = new BlockGeneratorService();
         const plan = await blockGeneratorService.plan({
@@ -653,10 +622,14 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
             answers,
             cwd,
             dataStorageMode: dataStorageMode ?? answers.dataStorageMode,
+            externalLayerId,
+            externalLayerSource,
+            externalLayerSourceLabel,
             noInstall,
             packageManager: resolvedPackageManager,
             persistencePolicy: persistencePolicy ?? answers.persistencePolicy,
             projectDir,
+            repositoryReference,
             templateId: resolvedTemplateId,
             variant,
             withMigrationUi,
@@ -670,6 +643,9 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
             rendered,
         });
     }
+    if (externalLayerSource || externalLayerId) {
+        throw new Error("External template layers currently compose only with built-in templates via `wp-typia create --template <basic|interactivity|persistence|compound>` or `wp-typia add block --template <family>`.");
+    }
     const variables = getTemplateVariables(resolvedTemplateId, {
         ...answers,
         dataStorageMode: dataStorageMode ?? answers.dataStorageMode,
@@ -738,7 +714,9 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
     }
     await normalizePackageManagerFiles(projectDir, resolvedPackageManager);
     await removeUnexpectedLockfiles(projectDir, resolvedPackageManager);
-    await replaceTextRecursively(projectDir, resolvedPackageManager);
+    await replaceTextRecursively(projectDir, resolvedPackageManager, {
+        repositoryReference,
+    });
     if (!noInstall) {
         const installer = installDependencies ?? defaultInstallDependencies;
         await installer({

package/dist/runtime/template-layers.d.ts

@@ -18,7 +18,13 @@ export interface ResolvedExternalTemplateLayers {
     entries: ResolvedTemplateLayerEntry[];
     selectedLayerId: string;
 }
+export interface SelectableExternalTemplateLayer {
+    description?: string;
+    extends: string[];
+    id: string;
+}
 export declare function loadExternalTemplateLayerManifest(sourceRoot: string): Promise<ExternalTemplateLayerManifest | null>;
+export declare function listSelectableExternalTemplateLayers(sourceRoot: string): Promise<SelectableExternalTemplateLayer[]>;
 export declare function resolveExternalTemplateLayers({ externalLayerId, sourceRoot, }: {
     externalLayerId?: string;
     sourceRoot: string;

package/dist/runtime/template-layers.js

@@ -77,11 +77,8 @@ export async function loadExternalTemplateLayerManifest(sourceRoot) {
         version: TEMPLATE_LAYER_MANIFEST_VERSION,
     };
 }
-function getDefaultExternalLayerId(manifest) {
+function getSelectableExternalLayers(manifest) {
     const layerIds = Object.keys(manifest.layers);
-    if (layerIds.length === 1) {
-        return layerIds[0];
-    }
     const referencedExternalLayerIds = new Set();
     for (const definition of Object.values(manifest.layers)) {
         for (const ancestorId of definition.extends ?? []) {
@@ -91,10 +88,26 @@ function getDefaultExternalLayerId(manifest) {
         }
     }
     const publicLayerIds = layerIds.filter((layerId) => !referencedExternalLayerIds.has(layerId));
-    if (publicLayerIds.length === 1) {
-        return publicLayerIds[0];
+    return publicLayerIds.map((layerId) => ({
+        description: manifest.layers[layerId]?.description,
+        extends: [...(manifest.layers[layerId]?.extends ?? [])],
+        id: layerId,
+    }));
+}
+function getDefaultExternalLayerId(manifest) {
+    const selectableLayers = getSelectableExternalLayers(manifest);
+    if (selectableLayers.length === 1) {
+        return selectableLayers[0].id;
+    }
+    const layerIds = Object.keys(manifest.layers);
+    throw new Error(`External layer package defines multiple selectable layers (${layerIds.join(", ")}). Pass an explicit externalLayerId or rerun through the interactive CLI selector.`);
+}
+export async function listSelectableExternalTemplateLayers(sourceRoot) {
+    const manifest = await loadExternalTemplateLayerManifest(sourceRoot);
+    if (!manifest) {
+        throw new Error(`No ${TEMPLATE_LAYER_MANIFEST_FILENAME} manifest found in ${sourceRoot}.`);
     }
-    throw new Error(`External layer package defines multiple selectable layers (${layerIds.join(", ")}). Pass an explicit externalLayerId until a final CLI selection UX exists.`);
+    return getSelectableExternalLayers(manifest);
 }
 export async function resolveExternalTemplateLayers({ externalLayerId, sourceRoot, }) {
     const manifest = await loadExternalTemplateLayerManifest(sourceRoot);

package/dist/runtime/template-render.d.ts

@@ -16,15 +16,26 @@ export interface CopyRawDirectoryOptions {
     filter?: (sourcePath: string, targetPath: string, entry: fs.Dirent) => boolean | Promise<boolean>;
 }
 /**
- * Render a Mustache template while keeping HTML escaping disabled only for the
- * current render call.
+ * Render a Mustache template with full Mustache semantics while leaving values
+ * unescaped for scaffold source generation.
  */
 export declare function renderMustacheTemplateString(template: string, view: TemplateRenderView): string;
 /**
  * Recursively copies a directory tree without rendering template contents.
  */
 export declare function copyRawDirectory(sourceDir: string, targetDir: string, options?: CopyRawDirectoryOptions): Promise<void>;
+/**
+ * Copy a template directory using full Mustache semantics for filenames and
+ * text-file contents while leaving rendered values unescaped.
+ */
 export declare function copyRenderedDirectory(sourceDir: string, targetDir: string, view: TemplateRenderView): Promise<void>;
+/**
+ * Copy a template directory using direct `{{key}}` replacement only.
+ *
+ * This intentionally preserves literal Mustache sections, partials, and other
+ * advanced constructs so built-in scaffold copy paths keep their historical
+ * interpolation behavior.
+ */
 export declare function copyInterpolatedDirectory(sourceDir: string, targetDir: string, view: Record<string, string>): Promise<void>;
 /**
  * Lists the output file paths produced by an interpolated template directory

package/dist/runtime/template-render.js

@@ -19,25 +19,32 @@ const BINARY_EXTENSIONS = new Set([
     ".woff",
     ".woff2",
 ]);
+const IDENTITY_MUSTACHE_ESCAPE = (value) => value;
 /**
- * Render a Mustache template while keeping HTML escaping disabled only for the
- * current render call.
+ * Render a Mustache template with full Mustache semantics while leaving values
+ * unescaped for scaffold source generation.
  */
 export function renderMustacheTemplateString(template, view) {
-    const originalEscape = Mustache.escape;
-    Mustache.escape = (value) => value;
-    try {
-        return Mustache.render(template, view);
-    }
-    finally {
-        Mustache.escape = originalEscape;
-    }
+    const mustacheModule = Mustache;
+    const writer = new mustacheModule.Writer();
+    return writer.render(template, view, undefined, {
+        escape: IDENTITY_MUSTACHE_ESCAPE,
+    });
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+/**
+ * Render direct `{{key}}` placeholders without enabling sections, partials, or
+ * any other Mustache features.
+ */
 function renderInterpolatedString(template, view) {
-    return Object.entries(view).reduce((output, [key, value]) => output.replace(new RegExp(`{{${escapeRegExp(key)}}}`, "g"), value), template);
+    const keys = Object.keys(view);
+    if (keys.length === 0) {
+        return template;
+    }
+    const placeholderPattern = new RegExp(keys.map((key) => `({{${escapeRegExp(key)}}})`).join("|"), "g");
+    return template.replace(placeholderPattern, (match) => view[match.slice(2, -2)] ?? match);
 }
 function isBinaryTemplateFile(filePath) {
     return BINARY_EXTENSIONS.has(path.extname(filePath).toLowerCase());
@@ -51,6 +58,59 @@ function resolveRenderedPath(targetDir, destinationName) {
     }
     return resolvedDestinationPath;
 }
+function stripTemplateExtension(entryName) {
+    return entryName.endsWith(".mustache")
+        ? entryName.slice(0, -".mustache".length)
+        : entryName;
+}
+function renderTemplateDestinationName(entryName, view, renderString) {
+    return renderString(stripTemplateExtension(entryName), view);
+}
+async function traverseTemplateDirectory({ prepareDirectory, renderString, sourceDir, targetDir, view, visitFile, }) {
+    const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourcePath = path.join(sourceDir, entry.name);
+        const destinationName = renderTemplateDestinationName(entry.name, view, renderString);
+        const destinationPath = resolveRenderedPath(targetDir, destinationName);
+        if (entry.isDirectory()) {
+            await prepareDirectory?.(destinationPath);
+            await traverseTemplateDirectory({
+                prepareDirectory,
+                renderString,
+                sourceDir: sourcePath,
+                targetDir: destinationPath,
+                view,
+                visitFile,
+            });
+            continue;
+        }
+        await visitFile({
+            destinationPath,
+            sourcePath,
+        });
+    }
+}
+async function copyTemplateDirectory({ renderString, sourceDir, targetDir, view, }) {
+    await fsp.mkdir(targetDir, { recursive: true });
+    await traverseTemplateDirectory({
+        prepareDirectory: async (directoryPath) => {
+            await fsp.mkdir(directoryPath, { recursive: true });
+        },
+        renderString,
+        sourceDir,
+        targetDir,
+        view,
+        visitFile: async ({ destinationPath, sourcePath }) => {
+            await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
+            if (isBinaryTemplateFile(sourcePath)) {
+                await fsp.copyFile(sourcePath, destinationPath);
+                return;
+            }
+            const content = await fsp.readFile(sourcePath, "utf8");
+            await fsp.writeFile(destinationPath, renderString(content, view), "utf8");
+        },
+    });
+}
 /**
  * Recursively copies a directory tree without rendering template contents.
  */
@@ -70,53 +130,32 @@ export async function copyRawDirectory(sourceDir, targetDir, options = {}) {
         await fsp.copyFile(sourcePath, targetPath);
     }
 }
+/**
+ * Copy a template directory using full Mustache semantics for filenames and
+ * text-file contents while leaving rendered values unescaped.
+ */
 export async function copyRenderedDirectory(sourceDir, targetDir, view) {
-    const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        const destinationNameTemplate = entry.name.endsWith(".mustache")
-            ? entry.name.slice(0, -".mustache".length)
-            : entry.name;
-        const destinationName = renderMustacheTemplateString(destinationNameTemplate, view);
-        const destinationPath = resolveRenderedPath(targetDir, destinationName);
-        if (entry.isDirectory()) {
-            await fsp.mkdir(destinationPath, { recursive: true });
-            await copyRenderedDirectory(sourcePath, destinationPath, view);
-            continue;
-        }
-        if (isBinaryTemplateFile(sourcePath)) {
-            await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
-            await fsp.copyFile(sourcePath, destinationPath);
-            continue;
-        }
-        const content = await fsp.readFile(sourcePath, "utf8");
-        await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
-        await fsp.writeFile(destinationPath, renderMustacheTemplateString(content, view), "utf8");
-    }
+    await copyTemplateDirectory({
+        renderString: renderMustacheTemplateString,
+        sourceDir,
+        targetDir,
+        view,
+    });
 }
+/**
+ * Copy a template directory using direct `{{key}}` replacement only.
+ *
+ * This intentionally preserves literal Mustache sections, partials, and other
+ * advanced constructs so built-in scaffold copy paths keep their historical
+ * interpolation behavior.
+ */
 export async function copyInterpolatedDirectory(sourceDir, targetDir, view) {
-    const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        const destinationNameTemplate = entry.name.endsWith(".mustache")
-            ? entry.name.slice(0, -".mustache".length)
-            : entry.name;
-        const destinationName = renderInterpolatedString(destinationNameTemplate, view);
-        const destinationPath = resolveRenderedPath(targetDir, destinationName);
-        if (entry.isDirectory()) {
-            await fsp.mkdir(destinationPath, { recursive: true });
-            await copyInterpolatedDirectory(sourcePath, destinationPath, view);
-            continue;
-        }
-        if (isBinaryTemplateFile(sourcePath)) {
-            await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
-            await fsp.copyFile(sourcePath, destinationPath);
-            continue;
-        }
-        const content = await fsp.readFile(sourcePath, "utf8");
-        await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
-        await fsp.writeFile(destinationPath, renderInterpolatedString(content, view), "utf8");
-    }
+    await copyTemplateDirectory({
+        renderString: renderInterpolatedString,
+        sourceDir,
+        targetDir,
+        view,
+    });
 }
 /**
  * Lists the output file paths produced by an interpolated template directory
@@ -135,23 +174,15 @@ export async function copyInterpolatedDirectory(sourceDir, targetDir, view) {
 export async function listInterpolatedDirectoryOutputs(sourceDir, view) {
     const virtualRoot = path.resolve("/wp-typia-template-preview");
     const outputs = [];
-    async function visit(currentSourceDir, currentTargetDir) {
-        const entries = await fsp.readdir(currentSourceDir, { withFileTypes: true });
-        for (const entry of entries) {
-            const sourcePath = path.join(currentSourceDir, entry.name);
-            const destinationNameTemplate = entry.name.endsWith(".mustache")
-                ? entry.name.slice(0, -".mustache".length)
-                : entry.name;
-            const destinationName = renderInterpolatedString(destinationNameTemplate, view);
-            const destinationPath = resolveRenderedPath(currentTargetDir, destinationName);
-            if (entry.isDirectory()) {
-                await visit(sourcePath, destinationPath);
-                continue;
-            }
+    await traverseTemplateDirectory({
+        renderString: renderInterpolatedString,
+        sourceDir,
+        targetDir: virtualRoot,
+        view,
+        visitFile: async ({ destinationPath }) => {
             outputs.push(path.relative(virtualRoot, destinationPath).replace(/\\/g, "/"));
-        }
-    }
-    await visit(sourceDir, virtualRoot);
+        },
+    });
     return outputs.sort((left, right) => left.localeCompare(right));
 }
 export function pathExists(targetPath) {

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

@@ -1,9 +1,10 @@
-type TemplateSourceFormat = "wp-typia" | "create-block-external" | "create-block-subset";
+import { type UnknownRecord } from './object-utils.js';
+type TemplateSourceFormat = 'wp-typia' | 'create-block-external' | 'create-block-subset';
 /**
  * Public template variables exposed to external template seeds before wp-typia
  * normalizes them into a scaffold project.
  */
-export interface TemplateVariableContext extends Record<string, unknown> {
+export interface TemplateVariableContext extends UnknownRecord {
     /** Version string for `@wp-typia/api-client` used in generated dependencies. */
     apiClientPackageVersion: string;
     /** Version string for `@wp-typia/block-runtime` used in generated dependencies. */
@@ -61,13 +62,13 @@ interface SeedSource {
     warnings?: string[];
 }
 type RemoteTemplateLocator = {
-    kind: "github";
+    kind: 'github';
     locator: GitHubTemplateLocator;
 } | {
-    kind: "npm";
+    kind: 'npm';
     locator: NpmTemplateLocator;
 } | {
-    kind: "path";
+    kind: 'path';
     templatePath: string;
 };
 export declare function parseGitHubTemplateLocator(templateId: string): GitHubTemplateLocator | null;