@wp-typia/project-tools 0.16.11 → 0.16.13

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

@@ -0,0 +1,184 @@
+/// <reference path="./external-template-modules.d.ts" />
+import fs from 'node:fs';
+import { promises as fsp } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isPlainObject } from './object-utils.js';
+import { toSegmentPascalCase } from './string-case.js';
+import { copyRawDirectory, copyRenderedDirectory } from './template-render.js';
+/**
+ * Candidate filenames for official external template config entrypoints.
+ */
+export const EXTERNAL_TEMPLATE_ENTRY_CANDIDATES = [
+    'index.js',
+    'index.cjs',
+    'index.mjs',
+];
+const TEMPLATE_WARNING_MESSAGE = 'wp-typia owns package/tooling/sync setup for generated projects, so this external template setting is ignored.';
+function getTemplateWarning(key) {
+    return `Ignoring external template config key "${key}": ${TEMPLATE_WARNING_MESSAGE}`;
+}
+function resolveSourceSubpath(sourceDir, relativePath) {
+    const targetPath = path.resolve(sourceDir, relativePath);
+    const relativeTarget = path.relative(sourceDir, targetPath);
+    if (relativeTarget.startsWith('..') || path.isAbsolute(relativeTarget)) {
+        throw new Error(`Template path "${relativePath}" must stay within ${sourceDir}.`);
+    }
+    return targetPath;
+}
+/**
+ * Search a source directory for the first supported external template entry.
+ *
+ * @param sourceDir Directory that may contain an external template config entry.
+ * @returns The first matching entry path, or null when no supported entry exists.
+ */
+export function getExternalTemplateEntry(sourceDir) {
+    for (const filename of EXTERNAL_TEMPLATE_ENTRY_CANDIDATES) {
+        const candidate = path.join(sourceDir, filename);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function loadExternalTemplateConfig(sourceDir) {
+    const entryPath = getExternalTemplateEntry(sourceDir);
+    if (!entryPath) {
+        throw new Error(`No external template config entry found in ${sourceDir}.`);
+    }
+    const moduleUrl = `${pathToFileURL(entryPath).href}?mtime=${fs.statSync(entryPath).mtimeMs}`;
+    const loadedModule = (await import(moduleUrl));
+    const loadedConfig = loadedModule.default ?? loadedModule;
+    if (!isPlainObject(loadedConfig)) {
+        throw new Error(`External template config must export an object: ${entryPath}`);
+    }
+    const warnings = [];
+    for (const ignoredKey of [
+        'pluginTemplatesPath',
+        'wpScripts',
+        'wpEnv',
+        'customScripts',
+        'npmDependencies',
+        'npmDevDependencies',
+        'customPackageJSON',
+        'pluginReadme',
+        'pluginHeader',
+    ]) {
+        if (ignoredKey in loadedConfig) {
+            warnings.push(getTemplateWarning(ignoredKey));
+        }
+    }
+    return {
+        config: loadedConfig,
+        warnings,
+    };
+}
+function getVariantFlagName(variantName) {
+    return `is${toSegmentPascalCase(variantName)}Variant`;
+}
+function getVariantKeys(config) {
+    return isPlainObject(config.variants) ? Object.keys(config.variants) : [];
+}
+function getVariantConfig(config, requestedVariant) {
+    const variantKeys = getVariantKeys(config);
+    if (variantKeys.length === 0) {
+        if (requestedVariant) {
+            throw new Error(`Variant "${requestedVariant}" was requested, but the external template does not define any variants.`);
+        }
+        return {
+            selectedVariant: null,
+            variantConfig: {},
+        };
+    }
+    const selectedVariant = requestedVariant ?? variantKeys[0];
+    if (!selectedVariant || !isPlainObject(config.variants?.[selectedVariant])) {
+        throw new Error(`Unknown template variant "${requestedVariant}". Expected one of: ${variantKeys.join(', ')}`);
+    }
+    return {
+        selectedVariant,
+        variantConfig: config.variants?.[selectedVariant] ?? {},
+    };
+}
+function extractVariantRenderValues(variantConfig) {
+    const values = { ...variantConfig };
+    delete values.assetsPath;
+    delete values.blockTemplatesPath;
+    delete values.folderName;
+    delete values.transformer;
+    return values;
+}
+async function buildExternalTemplateView(context, config, selectedVariant, variantConfig) {
+    const mergedView = {
+        ...(config.defaultValues ?? {}),
+        ...extractVariantRenderValues(variantConfig),
+        ...context,
+    };
+    if (selectedVariant) {
+        mergedView.variant = selectedVariant;
+        mergedView[getVariantFlagName(selectedVariant)] = true;
+    }
+    if (!config.transformer) {
+        return mergedView;
+    }
+    const transformed = await config.transformer(mergedView);
+    if (!isPlainObject(transformed)) {
+        throw new Error('External template transformer(view) must return an object.');
+    }
+    return {
+        ...mergedView,
+        ...transformed,
+    };
+}
+/**
+ * Load an official external create-block 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.
+ * @param requestedVariant Optional explicit variant override.
+ * @returns A rendered temporary seed directory with optional assets and cleanup.
+ */
+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 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 assetsPath = typeof variantConfig.assetsPath === 'string'
+            ? variantConfig.assetsPath
+            : config.assetsPath;
+        if (typeof assetsPath === 'string' && assetsPath.trim().length > 0) {
+            await copyRawDirectory(resolveSourceSubpath(sourceDir, assetsPath), path.join(tempRoot, 'assets'));
+        }
+        return {
+            assetsDir: fs.existsSync(path.join(tempRoot, 'assets'))
+                ? path.join(tempRoot, 'assets')
+                : undefined,
+            blockDir,
+            cleanup,
+            rootDir: tempRoot,
+            selectedVariant,
+            warnings,
+        };
+    }
+    catch (error) {
+        await cleanup();
+        throw error;
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { GitHubTemplateLocator, NpmTemplateLocator, RemoteTemplateLocator } from './template-source-contracts.js';
+export declare function parseGitHubTemplateLocator(templateId: string): GitHubTemplateLocator | null;
+export declare function parseNpmTemplateLocator(templateId: string): NpmTemplateLocator | null;
+export declare function parseTemplateLocator(templateId: string): RemoteTemplateLocator;

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

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import npa from 'npm-package-arg';
+import { BUILTIN_TEMPLATE_IDS, isBuiltInTemplateId, } from './template-registry.js';
+import { getRemovedBuiltInTemplateMessage, isRemovedBuiltInTemplateId, } from './template-defaults.js';
+function isTemplatePathLocator(templateId) {
+    return (path.isAbsolute(templateId) ||
+        templateId.startsWith('./') ||
+        templateId.startsWith('../'));
+}
+export function parseGitHubTemplateLocator(templateId) {
+    if (!templateId.startsWith('github:')) {
+        return null;
+    }
+    const [locatorBody, refSegment] = templateId
+        .slice('github:'.length)
+        .split('#', 2);
+    const segments = locatorBody.split('/').filter(Boolean);
+    if (segments.length < 3) {
+        throw new Error(`GitHub template locators must look like github:owner/repo/path[#ref]. Received: ${templateId}`);
+    }
+    const [owner, repo, ...sourcePathSegments] = segments;
+    return {
+        owner,
+        repo,
+        ref: refSegment ?? null,
+        sourcePath: sourcePathSegments.join('/'),
+    };
+}
+export function parseNpmTemplateLocator(templateId) {
+    if (isBuiltInTemplateId(templateId) ||
+        isTemplatePathLocator(templateId) ||
+        templateId.startsWith('github:')) {
+        return null;
+    }
+    try {
+        const parsed = npa(templateId);
+        if (!parsed.registry || !parsed.name) {
+            return null;
+        }
+        const parsedWithRawSpec = parsed;
+        const rawSpec = typeof parsedWithRawSpec.rawSpec === 'string'
+            ? parsedWithRawSpec.rawSpec
+            : '';
+        return {
+            fetchSpec: typeof parsed.fetchSpec === 'string' ? parsed.fetchSpec : '',
+            name: parsed.name,
+            raw: templateId,
+            rawSpec,
+            type: parsed.type,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function parseTemplateLocator(templateId) {
+    if (isRemovedBuiltInTemplateId(templateId)) {
+        throw new Error(getRemovedBuiltInTemplateMessage(templateId));
+    }
+    const githubLocator = parseGitHubTemplateLocator(templateId);
+    if (githubLocator) {
+        return { kind: 'github', locator: githubLocator };
+    }
+    if (isTemplatePathLocator(templateId)) {
+        return { kind: 'path', templatePath: templateId };
+    }
+    const npmLocator = parseNpmTemplateLocator(templateId);
+    if (npmLocator) {
+        return { kind: 'npm', locator: npmLocator };
+    }
+    throw new Error(`Unknown template "${templateId}". Expected one of: ${BUILTIN_TEMPLATE_IDS.join(', ')}, a local path, github:owner/repo/path[#ref], or an npm package spec.`);
+}

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

@@ -0,0 +1,7 @@
+export { renderCreateBlockExternalTemplate } from './template-source-external.js';
+export { 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;
+}): TemplateVariableContext;
+export declare function detectTemplateSourceFormat(sourceDir: string): Promise<TemplateSourceFormat>;

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

@@ -0,0 +1,53 @@
+/// <reference path="./external-template-modules.d.ts" />
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadExternalTemplateLayerManifest } from './template-layers.js';
+import { getPackageVersions } from './package-versions.js';
+import { getExternalTemplateEntry } from './template-source-external.js';
+export { renderCreateBlockExternalTemplate } from './template-source-external.js';
+export { getDefaultCategory, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, } from './template-source-remote.js';
+export function getTemplateVariableContext(variables) {
+    const { apiClientPackageVersion, blockRuntimePackageVersion, blockTypesPackageVersion, projectToolsPackageVersion, restPackageVersion, } = getPackageVersions();
+    return {
+        ...variables,
+        apiClientPackageVersion: variables.apiClientPackageVersion ?? apiClientPackageVersion,
+        blockRuntimePackageVersion: variables.blockRuntimePackageVersion ?? blockRuntimePackageVersion,
+        blockTypesPackageVersion: variables.blockTypesPackageVersion ?? blockTypesPackageVersion,
+        projectToolsPackageVersion: variables.projectToolsPackageVersion ?? projectToolsPackageVersion,
+        description: variables.description,
+        keyword: variables.keyword,
+        namespace: variables.namespace,
+        pascalCase: variables.pascalCase,
+        phpPrefix: variables.phpPrefix,
+        restPackageVersion: variables.restPackageVersion ?? restPackageVersion,
+        slug: variables.slug,
+        textDomain: variables.textDomain,
+        title: variables.title,
+    };
+}
+export async function detectTemplateSourceFormat(sourceDir) {
+    if (fs.existsSync(path.join(sourceDir, 'package.json.mustache'))) {
+        return 'wp-typia';
+    }
+    if (await loadExternalTemplateLayerManifest(sourceDir)) {
+        throw new Error(`Template source at ${sourceDir} is an external layer package. External layers currently compose only through built-in scaffolds via the runtime API, not as standalone template ids.`);
+    }
+    if (getExternalTemplateEntry(sourceDir)) {
+        return 'create-block-external';
+    }
+    const sourceRoot = fs.existsSync(path.join(sourceDir, 'src'))
+        ? path.join(sourceDir, 'src')
+        : sourceDir;
+    const blockJsonCandidates = [
+        path.join(sourceDir, 'block.json'),
+        path.join(sourceRoot, 'block.json'),
+    ];
+    const hasBlockJson = blockJsonCandidates.some((candidate) => fs.existsSync(candidate));
+    const hasIndexFile = ['index.js', 'index.jsx', 'index.ts', 'index.tsx'].some((filename) => fs.existsSync(path.join(sourceRoot, filename)));
+    const hasEditFile = ['edit.js', 'edit.jsx', 'edit.ts', 'edit.tsx'].some((filename) => fs.existsSync(path.join(sourceRoot, filename)));
+    const hasSaveFile = ['save.js', 'save.jsx', 'save.ts', 'save.tsx'].some((filename) => fs.existsSync(path.join(sourceRoot, filename)));
+    if (hasBlockJson && hasIndexFile && hasEditFile && hasSaveFile) {
+        return 'create-block-subset';
+    }
+    throw new Error(`Unsupported template source at ${sourceDir}. Expected a wp-typia template directory, an official create-block external template config, or a create-block subset with block.json and src/index/edit/save files.`);
+}

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

@@ -0,0 +1,23 @@
+import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from './template-source-contracts.js';
+/**
+ * Read a remote block source and return its default block category.
+ *
+ * @param sourceDir Block source directory that may contain a block.json file.
+ * @returns The declared block category, or "widgets" when detection fails.
+ */
+export declare function getDefaultCategory(sourceDir: string): string;
+/**
+ * Copy a wp-typia seed into a normalized temporary template directory.
+ *
+ * @param seed Seed source whose files should be normalized into a temp root.
+ * @returns A cloned seed whose cleanup removes the temp root and original seed.
+ */
+export declare function normalizeWpTypiaTemplateSeed(seed: SeedSource): Promise<SeedSource>;
+/**
+ * Convert a create-block subset seed into a normalized wp-typia template source.
+ *
+ * @param seed Seed source produced from a remote create-block subset.
+ * @param context Template variable context used for generated artifacts.
+ * @returns A normalized template source rooted in a temporary directory.
+ */
+export declare function normalizeCreateBlockSubset(seed: SeedSource, context: TemplateVariableContext): Promise<ResolvedTemplateSource>;

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

@@ -0,0 +1,336 @@
+import fs from 'node:fs';
+import { promises as fsp } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { getBuiltInTemplateLayerDirs, isOmittableBuiltInTemplateLayerDir, } from './template-builtins.js';
+import { copyRawDirectory } from './template-render.js';
+function getDefaultCategoryFromBlockJson(blockJson) {
+    return typeof blockJson.category === 'string' &&
+        blockJson.category.trim().length > 0
+        ? blockJson.category.trim()
+        : 'widgets';
+}
+function readRemoteBlockJson(blockDir) {
+    const sourceRoot = fs.existsSync(path.join(blockDir, 'src'))
+        ? path.join(blockDir, 'src')
+        : blockDir;
+    for (const candidate of [
+        path.join(blockDir, 'block.json'),
+        path.join(sourceRoot, 'block.json'),
+    ]) {
+        if (fs.existsSync(candidate)) {
+            return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+        }
+    }
+    throw new Error(`Unable to locate block.json in ${blockDir}`);
+}
+/**
+ * Read a remote block source and return its default block category.
+ *
+ * @param sourceDir Block source directory that may contain a block.json file.
+ * @returns The declared block category, or "widgets" when detection fails.
+ */
+export function getDefaultCategory(sourceDir) {
+    try {
+        const blockJson = readRemoteBlockJson(sourceDir);
+        return getDefaultCategoryFromBlockJson(blockJson);
+    }
+    catch {
+        return 'widgets';
+    }
+}
+/**
+ * Copy a wp-typia seed into a normalized temporary template directory.
+ *
+ * @param seed Seed source whose files should be normalized into a temp root.
+ * @returns A cloned seed whose cleanup removes the temp root and original seed.
+ */
+export async function normalizeWpTypiaTemplateSeed(seed) {
+    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-template-source-'));
+    const normalizedDir = path.join(tempRoot, 'template');
+    try {
+        await copyRawDirectory(seed.blockDir, normalizedDir, {
+            filter: (sourcePath, _targetPath, entry) => {
+                const mustacheVariantPath = path.join(path.dirname(sourcePath), `${entry.name}.mustache`);
+                return !(entry.isFile() &&
+                    (entry.name === 'package.json' || entry.name === 'README.md') &&
+                    fs.existsSync(mustacheVariantPath));
+            },
+        });
+    }
+    catch (error) {
+        await fsp.rm(tempRoot, { force: true, recursive: true });
+        throw error;
+    }
+    return {
+        blockDir: normalizedDir,
+        cleanup: async () => {
+            await fsp.rm(tempRoot, { force: true, recursive: true });
+            await seed.cleanup?.();
+        },
+        rootDir: normalizedDir,
+        selectedVariant: seed.selectedVariant,
+        warnings: seed.warnings,
+    };
+}
+function renderTypeScriptLiteral(value) {
+    if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return 'undefined';
+}
+function renderTagsForAttribute(attribute) {
+    const tags = [];
+    if (typeof attribute.default === 'string' ||
+        typeof attribute.default === 'number' ||
+        typeof attribute.default === 'boolean') {
+        tags.push(`tags.Default<${renderTypeScriptLiteral(attribute.default)}>`);
+    }
+    return tags;
+}
+function renderAttributeBaseType(attributeName, attribute) {
+    if (Array.isArray(attribute.enum) && attribute.enum.length > 0) {
+        return attribute.enum
+            .map((item) => renderTypeScriptLiteral(item))
+            .join(' | ');
+    }
+    switch (attribute.type) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'array':
+            return 'unknown[]';
+        case 'object':
+            return 'Record<string, unknown>';
+        default:
+            if (typeof attributeName === 'string' &&
+                attributeName.toLowerCase().includes('class')) {
+                return 'string';
+            }
+            return 'unknown';
+    }
+}
+function buildRemoteTypesSource(blockJson, context) {
+    const attributes = (blockJson.attributes ?? {});
+    const lines = [
+        'import { tags } from "typia";',
+        '',
+        `export interface ${context.pascalCase}Attributes {`,
+    ];
+    for (const [name, attribute] of Object.entries(attributes)) {
+        const baseType = renderAttributeBaseType(name, attribute);
+        const tagList = renderTagsForAttribute(attribute);
+        const baseTypeWithGrouping = tagList.length > 0 && baseType.includes(' | ')
+            ? `(${baseType})`
+            : baseType;
+        const renderedType = [baseTypeWithGrouping, ...tagList].join(' & ');
+        lines.push(`  ${JSON.stringify(name)}?: ${renderedType};`);
+    }
+    lines.push('}', '');
+    return lines.join('\n');
+}
+function buildRemoteBlockJsonTemplate(blockJson) {
+    const merged = {
+        ...blockJson,
+        description: '{{description}}',
+        name: '{{namespace}}/{{slug}}',
+        textdomain: '{{textDomain}}',
+        title: '{{title}}',
+    };
+    if (!Array.isArray(merged.keywords) || merged.keywords.length === 0) {
+        merged.keywords = ['{{keyword}}', 'typia', 'block'];
+    }
+    return `${JSON.stringify(merged, null, '\t')}\n`;
+}
+async function rewriteBlockJsonImports(directory) {
+    const textExtensions = new Set(['.js', '.jsx', '.ts', '.tsx']);
+    const targetBlockJsonPath = path.join(directory, 'block.json');
+    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 (!textExtensions.has(path.extname(currentPath))) {
+            return;
+        }
+        const content = await fsp.readFile(currentPath, 'utf8');
+        const relativeSpecifier = path
+            .relative(path.dirname(currentPath), targetBlockJsonPath)
+            .replace(/\\/g, '/');
+        const normalizedSpecifier = relativeSpecifier.startsWith('.')
+            ? relativeSpecifier
+            : `./${relativeSpecifier}`;
+        const next = content.replace(/(['"])\.{1,2}\/[^'"]*block\.json\1/g, `$1${normalizedSpecifier}$1`);
+        if (next !== content) {
+            await fsp.writeFile(currentPath, next, 'utf8');
+        }
+    }
+    await visit(directory);
+}
+async function patchRemotePackageJson(templateDir, needsInteractivity) {
+    const packageJsonPath = path.join(templateDir, 'package.json.mustache');
+    const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, 'utf8'));
+    const existingDependencies = { ...(packageJson.dependencies ?? {}) };
+    const existingDevDependencies = { ...(packageJson.devDependencies ?? {}) };
+    delete existingDependencies['@wp-typia/project-tools'];
+    delete existingDevDependencies['@wp-typia/project-tools'];
+    packageJson.devDependencies = {
+        '@wp-typia/block-runtime': '{{blockRuntimePackageVersion}}',
+        '@wp-typia/block-types': '{{blockTypesPackageVersion}}',
+        ...existingDevDependencies,
+    };
+    if (needsInteractivity) {
+        packageJson.dependencies = {
+            ...existingDependencies,
+            '@wordpress/interactivity': '^6.29.0',
+        };
+    }
+    else if (Object.keys(existingDependencies).length > 0) {
+        packageJson.dependencies = existingDependencies;
+    }
+    else {
+        delete packageJson.dependencies;
+    }
+    await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+}
+function getSeedSourceRoot(blockDir) {
+    return fs.existsSync(path.join(blockDir, 'src'))
+        ? path.join(blockDir, 'src')
+        : blockDir;
+}
+function findSeedRenderPhp(seed) {
+    for (const candidate of [
+        path.join(seed.blockDir, 'render.php'),
+        path.join(seed.rootDir, 'render.php'),
+    ]) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function removeSeedEntryConflicts(templateDir) {
+    for (const filename of [
+        'block.json',
+        'block.json.mustache',
+        'edit.js',
+        'edit.jsx',
+        'edit.ts',
+        'edit.tsx',
+        'edit.tsx.mustache',
+        'hooks.ts',
+        'hooks.ts.mustache',
+        'index.js',
+        'index.jsx',
+        'index.ts',
+        'index.tsx',
+        'index.tsx.mustache',
+        'save.js',
+        'save.jsx',
+        'save.ts',
+        'save.tsx',
+        'save.tsx.mustache',
+        'style.css',
+        'style.scss',
+        'style.scss.mustache',
+        'types.ts',
+        'types.ts.mustache',
+        'validators.ts',
+        'validators.ts.mustache',
+        'view.js',
+        'view.jsx',
+        'view.ts',
+        'view.tsx',
+    ]) {
+        await fsp.rm(path.join(templateDir, 'src', filename), { force: true });
+    }
+}
+/**
+ * Convert a create-block subset seed into a normalized wp-typia template source.
+ *
+ * @param seed Seed source produced from a remote create-block subset.
+ * @param context Template variable context used for generated artifacts.
+ * @returns A normalized template source rooted in a temporary directory.
+ */
+export async function normalizeCreateBlockSubset(seed, context) {
+    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), 'wp-typia-remote-template-'));
+    try {
+        const templateDir = path.join(tempRoot, 'template');
+        const blockJson = readRemoteBlockJson(seed.blockDir);
+        const sourceRoot = getSeedSourceRoot(seed.blockDir);
+        await fsp.mkdir(templateDir, { recursive: true });
+        for (const layerDir of getBuiltInTemplateLayerDirs('basic')) {
+            if (!fs.existsSync(layerDir)) {
+                if (isOmittableBuiltInTemplateLayerDir('basic', layerDir)) {
+                    continue;
+                }
+                throw new Error(`Built-in template layer is missing: ${layerDir}`);
+            }
+            await fsp.cp(layerDir, templateDir, {
+                recursive: true,
+                force: true,
+            });
+        }
+        await removeSeedEntryConflicts(templateDir);
+        await fsp.cp(sourceRoot, path.join(templateDir, 'src'), {
+            recursive: true,
+            force: true,
+        });
+        const remoteRenderPath = findSeedRenderPhp(seed);
+        if (remoteRenderPath) {
+            await fsp.copyFile(remoteRenderPath, path.join(templateDir, 'render.php'));
+        }
+        if (seed.assetsDir && fs.existsSync(seed.assetsDir)) {
+            await fsp.cp(seed.assetsDir, path.join(templateDir, 'assets'), {
+                recursive: true,
+                force: true,
+            });
+        }
+        await fsp.writeFile(path.join(templateDir, 'src', 'types.ts'), buildRemoteTypesSource(blockJson, context), 'utf8');
+        await fsp.writeFile(path.join(templateDir, 'src', 'block.json'), buildRemoteBlockJsonTemplate(blockJson), 'utf8');
+        await rewriteBlockJsonImports(path.join(templateDir, 'src'));
+        const needsInteractivity = typeof blockJson.viewScriptModule === 'string' ||
+            typeof blockJson.viewScript === 'string' ||
+            fs.existsSync(path.join(templateDir, 'src', 'view.js')) ||
+            fs.existsSync(path.join(templateDir, 'src', 'view.ts')) ||
+            fs.existsSync(path.join(templateDir, 'src', 'view.tsx')) ||
+            fs.existsSync(path.join(templateDir, 'src', 'interactivity.js')) ||
+            fs.existsSync(path.join(templateDir, 'src', 'interactivity.ts'));
+        await patchRemotePackageJson(templateDir, needsInteractivity);
+        return {
+            id: 'remote:create-block-subset',
+            defaultCategory: getDefaultCategoryFromBlockJson(blockJson),
+            description: 'A wp-typia scaffold normalized from a create-block subset source',
+            features: [
+                'Remote source',
+                'create-block adapter',
+                'Typia metadata pipeline',
+            ],
+            format: 'create-block-subset',
+            selectedVariant: seed.selectedVariant ?? null,
+            templateDir,
+            warnings: seed.warnings ?? [],
+            cleanup: async () => {
+                await fsp.rm(tempRoot, { force: true, recursive: true });
+                if (seed.cleanup) {
+                    await seed.cleanup();
+                }
+            },
+        };
+    }
+    catch (error) {
+        await fsp.rm(tempRoot, { force: true, recursive: true });
+        await seed.cleanup?.();
+        throw error;
+    }
+}