@wp-typia/project-tools 0.17.0 → 0.19.0

package/dist/runtime/scaffold-template-variables.js

@@ -2,6 +2,7 @@ import { buildTemplateVariablesFromBlockSpec, createBuiltInBlockSpec, } from './
 import { getPackageVersions } from './package-versions.js';
 import { buildBlockCssClassName, buildFrontendCssClassName, resolveScaffoldIdentifiers, } from './scaffold-identifiers.js';
 import { BUILTIN_BLOCK_METADATA_VERSION, COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS, getBuiltInTemplateMetadataDefaults, } from './template-defaults.js';
+import { DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID, getCompoundInnerBlocksPresetDefinition, } from './compound-inner-blocks.js';
 import { getTemplateById, isBuiltInTemplateId, } from './template-registry.js';
 import { toPascalCase, toSnakeCase, } from './string-case.js';
 /**
@@ -43,6 +44,8 @@ export function getTemplateVariables(templateId, answers) {
     const compoundChildTitle = `${title} Item`;
     const cssClassName = buildBlockCssClassName(namespace, slug);
     const compoundChildCssClassName = buildBlockCssClassName(namespace, `${slug}-item`);
+    const compoundInnerBlocksPreset = answers.compoundInnerBlocksPreset ?? DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID;
+    const compoundInnerBlocksPresetDefinition = getCompoundInnerBlocksPresetDefinition(compoundInnerBlocksPreset);
     const compoundPersistenceEnabled = templateId === 'persistence'
         ? true
         : templateId === 'compound'
@@ -55,6 +58,8 @@ export function getTemplateVariables(templateId, answers) {
         ? answers.persistencePolicy ?? 'authenticated'
         : 'authenticated';
     return {
+        alternateRenderTargetsCsv: '',
+        alternateRenderTargetsJson: '[]',
         apiClientPackageVersion,
         author: answers.author.trim(),
         blockRuntimePackageVersion,
@@ -68,6 +73,23 @@ export function getTemplateVariables(templateId, answers) {
         compoundChildIcon: COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS.icon,
         compoundChildTitleJson: JSON.stringify(compoundChildTitle),
         compoundPersistenceEnabled: compoundPersistenceEnabled ? 'true' : 'false',
+        compoundInnerBlocksDirectInsert: compoundInnerBlocksPresetDefinition.directInsert
+            ? 'true'
+            : 'false',
+        compoundInnerBlocksOrientation: compoundInnerBlocksPresetDefinition.orientation ?? '',
+        compoundInnerBlocksOrientationExpression: compoundInnerBlocksPresetDefinition.orientation
+            ? `'${compoundInnerBlocksPresetDefinition.orientation}'`
+            : 'undefined',
+        compoundInnerBlocksPreset,
+        compoundInnerBlocksPresetDescription: compoundInnerBlocksPresetDefinition.description,
+        compoundInnerBlocksPresetLabel: compoundInnerBlocksPresetDefinition.label,
+        compoundInnerBlocksTemplateLockExpression: compoundInnerBlocksPresetDefinition.templateLock === false
+            ? 'false'
+            : `'${compoundInnerBlocksPresetDefinition.templateLock}'`,
+        hasAlternateEmailRenderTarget: 'false',
+        hasAlternateMjmlRenderTarget: 'false',
+        hasAlternatePlainTextRenderTarget: 'false',
+        hasAlternateRenderTargets: 'false',
         projectToolsPackageVersion,
         cssClassName,
         dataStorageMode,

package/dist/runtime/scaffold.d.ts

@@ -8,6 +8,7 @@ import type { PackageManagerId } from "./package-managers.js";
  */
 export interface ScaffoldAnswers {
     author: string;
+    compoundInnerBlocksPreset?: import("./compound-inner-blocks.js").CompoundInnerBlocksPresetId;
     dataStorageMode?: DataStorageMode;
     description: string;
     /** Block namespace used in generated block names such as `namespace/slug`. */
@@ -29,6 +30,8 @@ export type PersistencePolicy = (typeof PERSISTENCE_POLICIES)[number];
  * Normalized template variables shared by built-in and remote scaffold flows.
  */
 export interface ScaffoldTemplateVariables extends Record<string, string> {
+    alternateRenderTargetsCsv: string;
+    alternateRenderTargetsJson: string;
     apiClientPackageVersion: string;
     author: string;
     blockRuntimePackageVersion: string;
@@ -42,6 +45,17 @@ export interface ScaffoldTemplateVariables extends Record<string, string> {
     compoundChildIcon: string;
     compoundChildTitleJson: string;
     compoundPersistenceEnabled: "false" | "true";
+    compoundInnerBlocksDirectInsert: "false" | "true";
+    compoundInnerBlocksOrientation: "" | "horizontal" | "vertical";
+    compoundInnerBlocksOrientationExpression: string;
+    compoundInnerBlocksPreset: string;
+    compoundInnerBlocksPresetDescription: string;
+    compoundInnerBlocksPresetLabel: string;
+    compoundInnerBlocksTemplateLockExpression: string;
+    hasAlternateEmailRenderTarget: "false" | "true";
+    hasAlternateMjmlRenderTarget: "false" | "true";
+    hasAlternatePlainTextRenderTarget: "false" | "true";
+    hasAlternateRenderTargets: "false" | "true";
     projectToolsPackageVersion: string;
     cssClassName: string;
     dashCase: string;
@@ -124,8 +138,14 @@ interface InstallDependenciesOptions {
     packageManager: PackageManagerId;
     projectDir: string;
 }
+export interface ScaffoldProgressEvent {
+    detail: string;
+    phase: "finalize-project" | "generate-files" | "install-dependencies" | "resolve-template" | "seed-artifacts";
+    title: string;
+}
 interface ScaffoldProjectOptions {
     allowExistingDir?: boolean;
+    alternateRenderTargets?: string;
     answers: ScaffoldAnswers;
     cwd?: string;
     dataStorageMode?: DataStorageMode;
@@ -134,6 +154,7 @@ interface ScaffoldProjectOptions {
     externalLayerSourceLabel?: string;
     installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
     noInstall?: boolean;
+    onProgress?: ((event: ScaffoldProgressEvent) => void | Promise<void>) | undefined;
     packageManager: PackageManagerId;
     persistencePolicy?: PersistencePolicy;
     projectDir: string;
@@ -157,4 +178,4 @@ export { collectScaffoldAnswers, detectAuthor, getDefaultAnswers, resolvePackage
 export { getTemplateVariables } from "./scaffold-template-variables.js";
 export declare function isDataStorageMode(value: string): value is DataStorageMode;
 export declare function isPersistencePolicy(value: string): value is PersistencePolicy;
-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 declare function scaffoldProject({ projectDir, templateId, answers, alternateRenderTargets, dataStorageMode, persistencePolicy, packageManager, externalLayerId, externalLayerSource, externalLayerSourceLabel, repositoryReference, cwd, allowExistingDir, noInstall, installDependencies, onProgress, variant, withMigrationUi, withTestPreset, withWpEnv, }: ScaffoldProjectOptions): Promise<ScaffoldProjectResult>;

package/dist/runtime/scaffold.js

@@ -2,16 +2,17 @@ import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { getPackageManager } from "./package-managers.js";
-import { buildGitignore, buildReadme, mergeTextLines, replaceTextRecursively, } from "./scaffold-apply-utils.js";
+import { buildGitignore, buildReadme, mergeTextLines, removeQueryLoopPlaceholderFiles, replaceTextRecursively, } from "./scaffold-apply-utils.js";
 import { applyGeneratedProjectDxPackageJson, applyLocalDevPresetFiles, } from "./local-dev-presets.js";
 import { applyMigrationUiCapability } from "./migration-ui-capability.js";
-import { applyWorkspaceMigrationCapability, ensureScaffoldDirectory, isOfficialWorkspaceProject, seedBuiltInPersistenceArtifacts, writeStarterManifestFiles, } from "./scaffold-bootstrap.js";
+import { applyWorkspaceMigrationCapability, ensureScaffoldDirectory, isWorkspaceProject, seedBuiltInPersistenceArtifacts, writeStarterManifestFiles, } from "./scaffold-bootstrap.js";
 import { defaultInstallDependencies, normalizePackageJson, normalizePackageManagerFiles, removeUnexpectedLockfiles, } from "./scaffold-package-manager-files.js";
 import { copyInterpolatedDirectory } from "./template-render.js";
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from "./template-registry.js";
 import { resolveTemplateSource } from "./template-source.js";
 import { BlockGeneratorService, } from "./block-generator-service.js";
 import { getTemplateVariables } from "./scaffold-template-variables.js";
+import { assertExternalLayerCompositionOptions, } from "./cli-validation.js";
 const WORKSPACE_TEMPLATE_ALIAS = "workspace";
 export const DATA_STORAGE_MODES = ["post-meta", "custom-table"];
 export const PERSISTENCE_POLICIES = ["authenticated", "public"];
@@ -29,17 +30,27 @@ function normalizeTemplateSelection(templateId) {
         ? OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE
         : templateId;
 }
-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, }) {
+async function reportScaffoldProgress(onProgress, event) {
+    await onProgress?.(event);
+}
+export async function scaffoldProject({ projectDir, templateId, answers, alternateRenderTargets, dataStorageMode, persistencePolicy, packageManager, externalLayerId, externalLayerSource, externalLayerSourceLabel, repositoryReference, cwd = process.cwd(), allowExistingDir = false, noInstall = false, installDependencies = undefined, onProgress = 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.");
-    }
+    assertExternalLayerCompositionOptions({
+        externalLayerId,
+        externalLayerSource,
+    });
     if (isBuiltInTemplate) {
         const blockGeneratorService = new BlockGeneratorService();
+        await reportScaffoldProgress(onProgress, {
+            detail: "Preparing template layers, variants, and generated artifact plans.",
+            phase: "resolve-template",
+            title: "Resolving scaffold template",
+        });
         const plan = await blockGeneratorService.plan({
             allowExistingDir,
+            alternateRenderTargets,
             answers,
             cwd,
             dataStorageMode: dataStorageMode ?? answers.dataStorageMode,
@@ -61,6 +72,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
         const rendered = await blockGeneratorService.render({ validated });
         return blockGeneratorService.apply({
             installDependencies,
+            onProgress,
             rendered,
         });
     }
@@ -72,13 +84,25 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
         dataStorageMode: dataStorageMode ?? answers.dataStorageMode,
         persistencePolicy: persistencePolicy ?? answers.persistencePolicy,
     });
+    await reportScaffoldProgress(onProgress, {
+        detail: "Loading template files, variants, and external package metadata when needed.",
+        phase: "resolve-template",
+        title: "Resolving scaffold template",
+    });
     const templateSource = await resolveTemplateSource(resolvedTemplateId, cwd, variables, variant);
-    const supportsMigrationUi = isBuiltInTemplate || templateSource.isOfficialWorkspaceTemplate === true;
+    const supportsMigrationUi = isBuiltInTemplate ||
+        templateSource.isOfficialWorkspaceTemplate === true ||
+        templateSource.supportsMigrationUi === true;
     if (withMigrationUi && !supportsMigrationUi) {
         await templateSource.cleanup?.();
-        throw new Error("`--with-migration-ui` is currently supported only for built-in templates and @wp-typia/create-workspace-template.");
+        throw new Error("`--with-migration-ui` is currently supported only for built-in templates and workspace-capable wp-typia templates.");
     }
     try {
+        await reportScaffoldProgress(onProgress, {
+            detail: "Copying scaffold files into the target project directory.",
+            phase: "generate-files",
+            title: "Generating project files",
+        });
         await ensureScaffoldDirectory(projectDir, allowExistingDir);
         await copyInterpolatedDirectory(templateSource.templateDir, projectDir, variables);
     }
@@ -87,8 +111,13 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
             await templateSource.cleanup();
         }
     }
-    const isOfficialWorkspace = isOfficialWorkspaceProject(projectDir);
+    const isWorkspace = isWorkspaceProject(projectDir);
     if (isBuiltInTemplate) {
+        await reportScaffoldProgress(onProgress, {
+            detail: "Writing starter manifests, local presets, and template-specific generated artifacts.",
+            phase: "seed-artifacts",
+            title: "Seeding scaffold artifacts",
+        });
         await writeStarterManifestFiles(projectDir, resolvedTemplateId, variables);
         await seedBuiltInPersistenceArtifacts(projectDir, resolvedTemplateId, variables);
         await applyLocalDevPresetFiles({
@@ -105,14 +134,25 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
                 variables,
             });
         }
+        await removeQueryLoopPlaceholderFiles(projectDir, resolvedTemplateId);
     }
-    else if (withMigrationUi && isOfficialWorkspace) {
+    else if (withMigrationUi && isWorkspace) {
+        await reportScaffoldProgress(onProgress, {
+            detail: "Initializing workspace migration scripts and starter migration files.",
+            phase: "seed-artifacts",
+            title: "Seeding scaffold artifacts",
+        });
         await applyWorkspaceMigrationCapability(projectDir, resolvedPackageManager);
     }
+    await reportScaffoldProgress(onProgress, {
+        detail: "Writing README, normalizing package metadata, and aligning package-manager files.",
+        phase: "finalize-project",
+        title: "Finalizing scaffold output",
+    });
     const readmePath = path.join(projectDir, "README.md");
     if (!fs.existsSync(readmePath)) {
         await fsp.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
-            withMigrationUi: isBuiltInTemplate || isOfficialWorkspace ? withMigrationUi : false,
+            withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
             withTestPreset: isBuiltInTemplate ? withTestPreset : false,
             withWpEnv: isBuiltInTemplate ? withWpEnv : false,
         }), "utf8");
@@ -139,6 +179,11 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
         repositoryReference,
     });
     if (!noInstall) {
+        await reportScaffoldProgress(onProgress, {
+            detail: "Installing project dependencies with the selected package manager.",
+            phase: "install-dependencies",
+            title: "Installing dependencies",
+        });
         const installer = installDependencies ?? defaultInstallDependencies;
         await installer({
             projectDir,

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

@@ -13,8 +13,9 @@ export interface CopyRawDirectoryOptions {
      *
      * Throwing or rejecting aborts the copy and bubbles to the caller.
      */
-    filter?: (sourcePath: string, targetPath: string, entry: fs.Dirent) => boolean | Promise<boolean>;
+    filter?: CopyDirectoryFilter;
 }
+export type CopyDirectoryFilter = (sourcePath: string, destinationPath: string, entry: fs.Dirent) => boolean | Promise<boolean>;
 /**
  * Render a Mustache template with full Mustache semantics while leaving values
  * unescaped for scaffold source generation.
@@ -28,7 +29,9 @@ export declare function copyRawDirectory(sourceDir: string, targetDir: string, o
  * 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>;
+export declare function copyRenderedDirectory(sourceDir: string, targetDir: string, view: TemplateRenderView, options?: {
+    filter?: CopyDirectoryFilter;
+}): Promise<void>;
 /**
  * Copy a template directory using direct `{{key}}` replacement only.
  *

package/dist/runtime/template-render.js

@@ -66,15 +66,19 @@ function stripTemplateExtension(entryName) {
 function renderTemplateDestinationName(entryName, view, renderString) {
     return renderString(stripTemplateExtension(entryName), view);
 }
-async function traverseTemplateDirectory({ prepareDirectory, renderString, sourceDir, targetDir, view, visitFile, }) {
+async function traverseTemplateDirectory({ filter, 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 (filter && !(await filter(sourcePath, destinationPath, entry))) {
+            continue;
+        }
         if (entry.isDirectory()) {
             await prepareDirectory?.(destinationPath);
             await traverseTemplateDirectory({
+                filter,
                 prepareDirectory,
                 renderString,
                 sourceDir: sourcePath,
@@ -90,9 +94,10 @@ async function traverseTemplateDirectory({ prepareDirectory, renderString, sourc
         });
     }
 }
-async function copyTemplateDirectory({ renderString, sourceDir, targetDir, view, }) {
+async function copyTemplateDirectory({ filter, renderString, sourceDir, targetDir, view, }) {
     await fsp.mkdir(targetDir, { recursive: true });
     await traverseTemplateDirectory({
+        filter,
         prepareDirectory: async (directoryPath) => {
             await fsp.mkdir(directoryPath, { recursive: true });
         },
@@ -134,8 +139,9 @@ export async function copyRawDirectory(sourceDir, targetDir, options = {}) {
  * 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) {
+export async function copyRenderedDirectory(sourceDir, targetDir, view, options = {}) {
     await copyTemplateDirectory({
+        filter: options.filter,
         renderString: renderMustacheTemplateString,
         sourceDir,
         targetDir,

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

@@ -35,6 +35,11 @@ export interface ResolvedTemplateSource {
     features: string[];
     format: TemplateSourceFormat;
     isOfficialWorkspaceTemplate?: boolean;
+    /**
+     * True when the resolved template can participate in scaffold migration UI
+     * seeding, such as rendered wp-typia workspace templates.
+     */
+    supportsMigrationUi?: boolean;
     templateDir: string;
     cleanup?: () => Promise<void>;
     selectedVariant?: string | null;
@@ -58,6 +63,11 @@ export interface ExternalTemplateConfig<TView extends UnknownRecord = TemplateVa
     blockTemplatesPath?: string;
     defaultValues?: Partial<TView>;
     folderName?: string;
+    /**
+     * Relative template root that renders a fuller wp-typia plugin/workspace
+     * scaffold instead of a create-block subset.
+     */
+    pluginTemplatesPath?: string;
     transformer?: (view: TView) => UnknownRecord | Promise<UnknownRecord>;
     variants?: Record<string, Partial<TView>>;
 }
@@ -65,6 +75,7 @@ export interface SeedSource {
     assetsDir?: string;
     blockDir: string;
     cleanup?: () => Promise<void>;
+    formatHint?: 'create-block-subset' | 'wp-typia';
     rootDir: string;
     selectedVariant?: string | null;
     warnings?: string[];

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

@@ -11,7 +11,7 @@ export declare const EXTERNAL_TEMPLATE_ENTRY_CANDIDATES: readonly ["index.js", "
  */
 export declare function getExternalTemplateEntry(sourceDir: string): string | null;
 /**
- * Load an official external create-block template config and render its seed.
+ * Load an official external template config and render its seed.
  *
  * @param sourceDir Source directory that contains the external template config.
  * @param context Template render context used for the selected variant.

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

@@ -55,7 +55,6 @@ async function loadExternalTemplateConfig(sourceDir) {
     }
     const warnings = [];
     for (const ignoredKey of [
-        'pluginTemplatesPath',
         'wpScripts',
         'wpEnv',
         'customScripts',
@@ -105,9 +104,42 @@ function extractVariantRenderValues(variantConfig) {
     delete values.assetsPath;
     delete values.blockTemplatesPath;
     delete values.folderName;
+    delete values.pluginTemplatesPath;
     delete values.transformer;
     return values;
 }
+function resolveConfiguredTemplatePath(config, variantConfig) {
+    const variantPluginTemplatesPath = typeof variantConfig.pluginTemplatesPath === 'string'
+        ? variantConfig.pluginTemplatesPath
+        : null;
+    const variantBlockTemplatesPath = typeof variantConfig.blockTemplatesPath === 'string'
+        ? variantConfig.blockTemplatesPath
+        : null;
+    const configBlockTemplatesPath = typeof config.blockTemplatesPath === 'string'
+        ? config.blockTemplatesPath
+        : null;
+    const configPluginTemplatesPath = typeof config.pluginTemplatesPath === 'string'
+        ? config.pluginTemplatesPath
+        : null;
+    const templatePath = variantPluginTemplatesPath ??
+        variantBlockTemplatesPath ??
+        configBlockTemplatesPath ??
+        configPluginTemplatesPath;
+    if (!templatePath) {
+        throw new Error('External template config must define blockTemplatesPath or pluginTemplatesPath.');
+    }
+    const configuredFolderName = (typeof variantConfig.folderName === 'string'
+        ? variantConfig.folderName
+        : config.folderName) ?? null;
+    return {
+        folderName: configuredFolderName || '.',
+        formatHint: templatePath === variantPluginTemplatesPath ||
+            templatePath === configPluginTemplatesPath
+            ? 'wp-typia'
+            : 'create-block-subset',
+        templatePath,
+    };
+}
 async function buildExternalTemplateView(context, config, selectedVariant, variantConfig) {
     const mergedView = {
         ...(config.defaultValues ?? {}),
@@ -131,7 +163,7 @@ async function buildExternalTemplateView(context, config, selectedVariant, varia
     };
 }
 /**
- * Load an official external create-block template config and render its seed.
+ * Load an official external template config and render its seed.
  *
  * @param sourceDir Source directory that contains the external template config.
  * @param context Template render context used for the selected variant.
@@ -141,25 +173,24 @@ async function buildExternalTemplateView(context, config, selectedVariant, varia
 export async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVariant) {
     const { config, warnings } = await loadExternalTemplateConfig(sourceDir);
     const { selectedVariant, variantConfig } = getVariantConfig(config, requestedVariant);
-    const blockTemplatesPath = (typeof variantConfig.blockTemplatesPath === 'string'
-        ? variantConfig.blockTemplatesPath
-        : config.blockTemplatesPath) ?? null;
-    if (!blockTemplatesPath) {
-        throw new Error('External template config must define blockTemplatesPath.');
-    }
+    const { folderName, formatHint, templatePath } = resolveConfiguredTemplatePath(config, variantConfig);
     const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-create-block-external-'));
     const cleanup = async () => {
         await fsp.rm(tempRoot, { force: true, recursive: true });
     };
     try {
         const renderedRoot = path.join(tempRoot, 'rendered');
-        const folderName = (typeof variantConfig.folderName === 'string'
-            ? variantConfig.folderName
-            : config.folderName) || '.';
         const blockDir = resolveSourceSubpath(renderedRoot, folderName);
         const view = await buildExternalTemplateView(context, config, selectedVariant, variantConfig);
-        const blockTemplateDir = resolveSourceSubpath(sourceDir, blockTemplatesPath);
-        await copyRenderedDirectory(blockTemplateDir, blockDir, view);
+        const blockTemplateDir = resolveSourceSubpath(sourceDir, templatePath);
+        await copyRenderedDirectory(blockTemplateDir, blockDir, view, {
+            filter: (sourcePath, _destinationPath, entry) => {
+                const mustacheVariantPath = path.join(path.dirname(sourcePath), `${entry.name}.mustache`);
+                return !(entry.isFile() &&
+                    (entry.name === 'package.json' || entry.name === 'README.md') &&
+                    fs.existsSync(mustacheVariantPath));
+            },
+        });
         const assetsPath = typeof variantConfig.assetsPath === 'string'
             ? variantConfig.assetsPath
             : config.assetsPath;
@@ -172,6 +203,7 @@ export async function renderCreateBlockExternalTemplate(sourceDir, context, requ
                 : undefined,
             blockDir,
             cleanup,
+            formatHint,
             rootDir: tempRoot,
             selectedVariant,
             warnings,

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

@@ -1,5 +1,5 @@
 export { renderCreateBlockExternalTemplate } from './template-source-external.js';
-export { getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
+export { getTemplateProjectType, getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
 import type { TemplateSourceFormat, TemplateVariableContext } from './template-source-contracts.js';
 export declare function getTemplateVariableContext(variables: {
     [key: string]: string;

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

@@ -4,8 +4,9 @@ import path from 'node:path';
 import { loadExternalTemplateLayerManifest } from './template-layers.js';
 import { getPackageVersions } from './package-versions.js';
 import { getExternalTemplateEntry } from './template-source-external.js';
+import { getTemplateProjectType } from './template-source-remote.js';
 export { renderCreateBlockExternalTemplate } from './template-source-external.js';
-export { getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
+export { getTemplateProjectType, getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
 export function getTemplateVariableContext(variables) {
     const { apiClientPackageVersion, blockRuntimePackageVersion, blockTypesPackageVersion, projectToolsPackageVersion, restPackageVersion, } = getPackageVersions();
     return {
@@ -35,6 +36,9 @@ export async function detectTemplateSourceFormat(sourceDir) {
     if (getExternalTemplateEntry(sourceDir)) {
         return 'create-block-external';
     }
+    if (getTemplateProjectType(sourceDir) !== null) {
+        return 'wp-typia';
+    }
     const sourceRoot = fs.existsSync(path.join(sourceDir, 'src'))
         ? path.join(sourceDir, 'src')
         : sourceDir;

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

@@ -6,6 +6,11 @@ import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from
  * @returns The declared block category, or "widgets" when detection fails.
  */
 export declare function getDefaultCategory(sourceDir: string): string;
+/**
+ * Read `wpTypia.projectType` from a rendered or source template package
+ * manifest and return it when present.
+ */
+export declare function getTemplateProjectType(sourceDir: string): string | null;
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *

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

@@ -39,6 +39,33 @@ export function getDefaultCategory(sourceDir) {
         return 'widgets';
     }
 }
+function readTemplatePackageJson(sourceDir) {
+    for (const candidate of [
+        path.join(sourceDir, 'package.json.mustache'),
+        path.join(sourceDir, 'package.json'),
+    ]) {
+        if (!fs.existsSync(candidate)) {
+            continue;
+        }
+        try {
+            return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Read `wpTypia.projectType` from a rendered or source template package
+ * manifest and return it when present.
+ */
+export function getTemplateProjectType(sourceDir) {
+    const packageJson = readTemplatePackageJson(sourceDir);
+    return typeof packageJson?.wpTypia?.projectType === 'string'
+        ? packageJson.wpTypia.projectType
+        : null;
+}
 /**
  * Copy a wp-typia seed into a normalized temporary template directory.
  *
@@ -57,6 +84,12 @@ export async function normalizeWpTypiaTemplateSeed(seed) {
                     fs.existsSync(mustacheVariantPath));
             },
         });
+        if (seed.assetsDir && fs.existsSync(seed.assetsDir)) {
+            await fsp.cp(seed.assetsDir, path.join(normalizedDir, 'assets'), {
+                recursive: true,
+                force: true,
+            });
+        }
     }
     catch (error) {
         await fsp.rm(tempRoot, { force: true, recursive: true });

package/dist/runtime/template-source.js

@@ -1,15 +1,17 @@
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from './template-registry.js';
 import { resolveBuiltInTemplateSource } from './template-builtins.js';
 import { parseTemplateLocator, } from './template-source-locators.js';
-import { detectTemplateSourceFormat, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
+import { detectTemplateSourceFormat, getTemplateProjectType, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
 import { isOfficialWorkspaceTemplateSeed, resolveTemplateSeed, } from './template-source-seeds.js';
+import { assertBuiltInTemplateVariantAllowed, } from './cli-validation.js';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
 export { resolveTemplateSeed } from './template-source-seeds.js';
 export async function resolveTemplateSource(templateId, cwd, variables, variant) {
     if (isBuiltInTemplateId(templateId)) {
-        if (variant) {
-            throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for built-in template "${templateId}".`);
-        }
+        assertBuiltInTemplateVariantAllowed({
+            templateId,
+            variant,
+        });
         return resolveBuiltInTemplateSource(templateId, {
             persistenceEnabled: variables.compoundPersistenceEnabled === 'true',
             persistencePolicy: variables.persistencePolicy === 'public' ? 'public' : 'authenticated',
@@ -28,6 +30,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
             }
             normalizedSeed = await normalizeWpTypiaTemplateSeed(seed);
+            const supportsMigrationUi = getTemplateProjectType(seed.blockDir) === 'workspace';
             return {
                 id: templateId,
                 defaultCategory: getDefaultCategory(seed.blockDir),
@@ -35,6 +38,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                 features: ['Remote source', 'wp-typia format'],
                 format,
                 isOfficialWorkspaceTemplate,
+                supportsMigrationUi,
                 templateDir: normalizedSeed.blockDir,
                 cleanup: normalizedSeed.cleanup,
             };
@@ -48,6 +52,33 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
                     })()
                     : seed;
         if (format === 'create-block-external') {
+            const renderedFormat = normalizedSeed.formatHint ??
+                (await detectTemplateSourceFormat(normalizedSeed.blockDir));
+            if (renderedFormat === 'wp-typia') {
+                const normalized = await normalizeWpTypiaTemplateSeed(normalizedSeed);
+                const supportsMigrationUi = getTemplateProjectType(normalizedSeed.blockDir) === 'workspace';
+                return {
+                    cleanup: async () => {
+                        await normalized.cleanup?.();
+                        await seed.cleanup?.();
+                    },
+                    defaultCategory: getDefaultCategory(normalizedSeed.blockDir),
+                    description: 'A wp-typia scaffold normalized from an official external template config',
+                    features: [
+                        'Remote source',
+                        'official external template',
+                        'wp-typia format',
+                        ...(supportsMigrationUi ? ['workspace-capable scaffold'] : []),
+                    ],
+                    format,
+                    id: 'remote:create-block-external',
+                    isOfficialWorkspaceTemplate,
+                    selectedVariant: normalizedSeed.selectedVariant ?? null,
+                    supportsMigrationUi,
+                    templateDir: normalized.blockDir,
+                    warnings: normalizedSeed.warnings ?? [],
+                };
+            }
             const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
             return {
                 ...normalized,