@wp-typia/project-tools 0.16.2 → 0.16.4

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

@@ -0,0 +1,405 @@
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { applyGeneratedProjectDxPackageJson, applyLocalDevPresetFiles, getPrimaryDevelopmentScript, } from "./local-dev-presets.js";
+import { applyMigrationUiCapability } from "./migration-ui-capability.js";
+import { getPackageVersions } from "./package-versions.js";
+import { ensureMigrationDirectories, writeInitialMigrationScaffold, writeMigrationConfig, } from "./migration-project.js";
+import { syncPersistenceRestArtifacts, } from "./persistence-rest-artifacts.js";
+import { getCompoundExtensionWorkflowSection, getOptionalOnboardingNote, getOptionalOnboardingSteps, getPhpRestExtensionPointsSection, getTemplateSourceOfTruthNote, } from "./scaffold-onboarding.js";
+import { getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
+import { stringifyBuiltInBlockJsonDocument, } from "./built-in-block-artifacts.js";
+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";
+const EPHEMERAL_NODE_MODULES_LINK_TYPE = process.platform === "win32" ? "junction" : "dir";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LOCKFILES = {
+    bun: ["bun.lock", "bun.lockb"],
+    npm: ["package-lock.json"],
+    pnpm: ["pnpm-lock.yaml"],
+    yarn: ["yarn.lock"],
+};
+export async function ensureDirectory(targetDir, allowExisting = false) {
+    if (!fs.existsSync(targetDir)) {
+        await fsp.mkdir(targetDir, { recursive: true });
+        return;
+    }
+    if (allowExisting) {
+        return;
+    }
+    const entries = await fsp.readdir(targetDir);
+    if (entries.length > 0) {
+        throw new Error(`Target directory is not empty: ${targetDir}`);
+    }
+}
+export function buildReadme(templateId, variables, packageManager, { withMigrationUi = false, withTestPreset = false, withWpEnv = false, } = {}) {
+    const optionalOnboardingSteps = getOptionalOnboardingSteps(packageManager, templateId, {
+        compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true",
+    });
+    const sourceOfTruthNote = getTemplateSourceOfTruthNote(templateId, {
+        compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true",
+    });
+    const compoundPersistenceEnabled = variables.compoundPersistenceEnabled === "true";
+    const publicPersistencePolicyNote = variables.isPublicPersistencePolicy === "true"
+        ? "Public persistence writes use signed short-lived tokens, per-request ids, and coarse rate limiting by default. Add application-specific abuse controls before using the same pattern for high-value metrics or experiments."
+        : null;
+    const compoundExtensionWorkflowSection = getCompoundExtensionWorkflowSection(packageManager, templateId);
+    const phpRestExtensionPointsSection = getPhpRestExtensionPointsSection(templateId, {
+        compoundPersistenceEnabled,
+        slug: variables.slug,
+    });
+    const developmentScript = getPrimaryDevelopmentScript(templateId);
+    const wpEnvSection = withWpEnv
+        ? `## Local WordPress\n\n\`\`\`bash\n${formatRunScript(packageManager, "wp-env:start")}\n${formatRunScript(packageManager, "wp-env:stop")}\n${formatRunScript(packageManager, "wp-env:reset")}\n\`\`\``
+        : "";
+    const testPresetSection = withTestPreset
+        ? `## Local Test Preset\n\n\`\`\`bash\n${formatRunScript(packageManager, "wp-env:start:test")}\n${formatRunScript(packageManager, "wp-env:wait:test")}\n${formatRunScript(packageManager, "test:e2e")}\n\`\`\`\n\nThe generated smoke test uses \`.wp-env.test.json\` and verifies that the scaffolded block registers in the WordPress editor.`
+        : "";
+    const migrationSection = withMigrationUi
+        ? `## Migration UI\n\nThis scaffold already includes an initialized migration workspace at \`v1\`, generated deprecated/runtime artifacts, and an editor-embedded migration dashboard. Migration versions are schema lineage labels and are separate from your package or plugin release version. Use the existing CLI commands to snapshot, diff, scaffold, verify, and fuzz future schema changes.\n\n\`\`\`bash\n${formatRunScript(packageManager, "migration:doctor")}\n${formatRunScript(packageManager, "migration:verify")}\n${formatRunScript(packageManager, "migration:fuzz")}\n\`\`\`\n\nRun \`migration:init\` only when retrofitting migration support into an older project that was not scaffolded with \`--with-migration-ui\`.`
+        : "";
+    return `# ${variables.title}
+
+${variables.description}
+
+## Template
+
+${templateId}
+
+## Development
+
+\`\`\`bash
+${formatInstallCommand(packageManager)}
+${formatRunScript(packageManager, developmentScript)}
+\`\`\`
+
+## Build
+
+\`\`\`bash
+${formatRunScript(packageManager, "build")}
+\`\`\`
+
+## Optional First Sync
+
+\`\`\`bash
+${optionalOnboardingSteps.join("\n")}
+\`\`\`
+
+${getOptionalOnboardingNote(packageManager, templateId, {
+        compoundPersistenceEnabled,
+    })}
+
+${sourceOfTruthNote}${publicPersistencePolicyNote ? `\n\n${publicPersistencePolicyNote}` : ""}${migrationSection ? `\n\n${migrationSection}` : ""}${compoundExtensionWorkflowSection ? `\n\n${compoundExtensionWorkflowSection}` : ""}${wpEnvSection ? `\n\n${wpEnvSection}` : ""}${testPresetSection ? `\n\n${testPresetSection}` : ""}${phpRestExtensionPointsSection ? `\n\n${phpRestExtensionPointsSection}` : ""}
+`;
+}
+export function buildGitignore() {
+    return `# Dependencies
+node_modules/
+.yarn/
+.pnp.*
+
+# Build
+build/
+dist/
+
+# Editor
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# WordPress
+*.log
+.wp-env/
+`;
+}
+export function mergeTextLines(primaryContent, existingContent) {
+    const normalizedPrimary = primaryContent.replace(/\r\n/g, "\n").trimEnd();
+    const normalizedExisting = existingContent.replace(/\r\n/g, "\n").trimEnd();
+    const mergedLines = [];
+    const seen = new Set();
+    for (const line of [...normalizedPrimary.split("\n"), ...normalizedExisting.split("\n")]) {
+        if (line.length === 0 && mergedLines[mergedLines.length - 1] === "") {
+            continue;
+        }
+        if (line.length > 0 && seen.has(line)) {
+            continue;
+        }
+        if (line.length > 0) {
+            seen.add(line);
+        }
+        mergedLines.push(line);
+    }
+    return `${mergedLines.join("\n").replace(/\n{3,}/g, "\n\n")}\n`;
+}
+export async function writeStarterManifestFiles(targetDir, templateId, variables, artifacts) {
+    const manifests = artifacts
+        ? artifacts.map((artifact) => ({
+            document: artifact.manifestDocument,
+            relativePath: `${artifact.relativeDir}/typia.manifest.json`,
+        }))
+        : getStarterManifestFiles(templateId, variables);
+    for (const { document, relativePath } of manifests) {
+        const destinationPath = path.join(targetDir, relativePath);
+        await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
+        await fsp.writeFile(destinationPath, stringifyStarterManifest(document), "utf8");
+    }
+}
+async function writeBuiltInStructuralArtifacts(targetDir, artifacts) {
+    for (const artifact of artifacts) {
+        const destinationDir = path.join(targetDir, artifact.relativeDir);
+        await fsp.mkdir(destinationDir, { recursive: true });
+        await fsp.writeFile(path.join(destinationDir, "types.ts"), artifact.typesSource, "utf8");
+        await fsp.writeFile(path.join(destinationDir, "block.json"), stringifyBuiltInBlockJsonDocument(artifact.blockJsonDocument), "utf8");
+    }
+}
+async function writeBuiltInCodeArtifacts(targetDir, codeArtifacts) {
+    for (const artifact of codeArtifacts) {
+        const destinationPath = path.join(targetDir, artifact.relativePath);
+        await fsp.mkdir(path.dirname(destinationPath), { recursive: true });
+        await fsp.writeFile(destinationPath, artifact.source, "utf8");
+    }
+}
+function resolveScaffoldGeneratorNodeModulesPath() {
+    const projectToolsPackageRoot = path.resolve(__dirname, "..", "..");
+    const candidates = [
+        path.join(projectToolsPackageRoot, "node_modules"),
+        path.resolve(projectToolsPackageRoot, "..", ".."),
+        path.resolve(projectToolsPackageRoot, "..", "..", "node_modules"),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(path.join(candidate, "typia", "package.json"))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function withEphemeralScaffoldNodeModules(targetDir, callback) {
+    const targetNodeModulesPath = path.join(targetDir, "node_modules");
+    if (fs.existsSync(targetNodeModulesPath)) {
+        await callback();
+        return;
+    }
+    const sourceNodeModulesPath = resolveScaffoldGeneratorNodeModulesPath();
+    if (!sourceNodeModulesPath) {
+        throw new Error("Unable to resolve a node_modules directory with typia for scaffold-time REST artifact generation.");
+    }
+    await fsp.symlink(sourceNodeModulesPath, targetNodeModulesPath, EPHEMERAL_NODE_MODULES_LINK_TYPE);
+    try {
+        await callback();
+    }
+    finally {
+        await fsp.rm(targetNodeModulesPath, { force: true, recursive: true });
+    }
+}
+/**
+ * Seed REST-derived persistence artifacts into a newly scaffolded built-in
+ * project before the first manual `sync-rest` run.
+ */
+export async function seedBuiltInPersistenceArtifacts(targetDir, templateId, variables) {
+    const needsPersistenceArtifacts = templateId === "persistence" ||
+        (templateId === "compound" && variables.compoundPersistenceEnabled === "true");
+    if (!needsPersistenceArtifacts) {
+        return;
+    }
+    await withEphemeralScaffoldNodeModules(targetDir, async () => {
+        if (templateId === "persistence") {
+            await syncPersistenceRestArtifacts({
+                apiTypesFile: path.join("src", "api-types.ts"),
+                outputDir: "src",
+                projectDir: targetDir,
+                variables,
+            });
+            return;
+        }
+        await syncPersistenceRestArtifacts({
+            apiTypesFile: path.join("src", "blocks", variables.slugKebabCase, "api-types.ts"),
+            outputDir: path.join("src", "blocks", variables.slugKebabCase),
+            projectDir: targetDir,
+            variables,
+        });
+    });
+}
+export async function normalizePackageManagerFiles(targetDir, packageManagerId) {
+    const yarnRcPath = path.join(targetDir, ".yarnrc.yml");
+    if (packageManagerId === "yarn") {
+        await fsp.writeFile(yarnRcPath, "nodeLinker: node-modules\n", "utf8");
+        return;
+    }
+    if (fs.existsSync(yarnRcPath)) {
+        await fsp.rm(yarnRcPath, { force: true });
+    }
+}
+export async function normalizePackageJson(targetDir, packageManagerId) {
+    const packageJsonPath = path.join(targetDir, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        return;
+    }
+    const packageManager = getPackageManager(packageManagerId);
+    const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, "utf8"));
+    packageJson.packageManager = packageManager.packageManagerField;
+    if (packageJson.scripts) {
+        for (const [key, value] of Object.entries(packageJson.scripts)) {
+            if (typeof value === "string") {
+                packageJson.scripts[key] = transformPackageManagerText(value, packageManagerId);
+            }
+        }
+    }
+    await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}\n`, "utf8");
+}
+export async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
+    const keep = new Set(LOCKFILES[packageManagerId] ?? []);
+    const allLockfiles = Object.values(LOCKFILES).flat();
+    await Promise.all(allLockfiles.map(async (filename) => {
+        if (keep.has(filename)) {
+            return;
+        }
+        const filePath = path.join(targetDir, filename);
+        if (fs.existsSync(filePath)) {
+            await fsp.rm(filePath, { force: true });
+        }
+    }));
+}
+export 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);
+}
+export async function defaultInstallDependencies({ projectDir, packageManager, }) {
+    execSync(formatInstallCommand(packageManager), {
+        cwd: projectDir,
+        stdio: "inherit",
+    });
+}
+export function isOfficialWorkspaceProject(projectDir) {
+    const packageJsonPath = path.join(projectDir, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+        return false;
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return (packageJson.wpTypia?.projectType === "workspace" &&
+        packageJson.wpTypia?.templatePackage === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE);
+}
+export async function applyWorkspaceMigrationCapability(projectDir, packageManager) {
+    const packageJsonPath = path.join(projectDir, "package.json");
+    const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, "utf8"));
+    const wpTypiaPackageVersion = getPackageVersions().wpTypiaPackageVersion;
+    const canonicalCliSpecifier = wpTypiaPackageVersion === "^0.0.0"
+        ? "wp-typia"
+        : `wp-typia@${wpTypiaPackageVersion.replace(/^[~^]/u, "")}`;
+    const migrationCli = (args) => formatPackageExecCommand(packageManager, canonicalCliSpecifier, `migrate ${args}`);
+    packageJson.scripts = {
+        ...(packageJson.scripts ?? {}),
+        "migration:init": migrationCli("init --current-migration-version v1"),
+        "migration:snapshot": migrationCli("snapshot"),
+        "migration:diff": migrationCli("diff"),
+        "migration:scaffold": migrationCli("scaffold"),
+        "migration:doctor": migrationCli("doctor --all"),
+        "migration:fixtures": migrationCli("fixtures --all"),
+        "migration:verify": migrationCli("verify --all"),
+        "migration:fuzz": migrationCli("fuzz --all"),
+    };
+    await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}\n`, "utf8");
+    writeMigrationConfig(projectDir, {
+        blocks: [],
+        currentMigrationVersion: "v1",
+        snapshotDir: "src/migrations/versions",
+        supportedMigrationVersions: ["v1"],
+    });
+    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, }) {
+    await ensureDirectory(projectDir, allowExistingDir);
+    await copyInterpolatedDirectory(templateDir, projectDir, variables);
+    if (codeArtifacts && codeArtifacts.length > 0) {
+        await writeBuiltInCodeArtifacts(projectDir, codeArtifacts);
+    }
+    if (artifacts && artifacts.length > 0) {
+        await writeBuiltInStructuralArtifacts(projectDir, artifacts);
+    }
+    await writeStarterManifestFiles(projectDir, templateId, variables, artifacts);
+    await seedBuiltInPersistenceArtifacts(projectDir, templateId, variables);
+    await applyLocalDevPresetFiles({
+        projectDir,
+        variables,
+        withTestPreset,
+        withWpEnv,
+    });
+    if (withMigrationUi) {
+        await applyMigrationUiCapability({
+            packageManager,
+            projectDir,
+            templateId,
+            variables,
+        });
+    }
+    const readmePath = path.join(projectDir, "README.md");
+    if (!fs.existsSync(readmePath)) {
+        await fsp.writeFile(readmePath, readmeContent ??
+            buildReadme(templateId, variables, packageManager, {
+                withMigrationUi,
+                withTestPreset,
+                withWpEnv,
+            }), "utf8");
+    }
+    const gitignorePath = path.join(projectDir, ".gitignore");
+    const existingGitignore = fs.existsSync(gitignorePath)
+        ? await fsp.readFile(gitignorePath, "utf8")
+        : "";
+    await fsp.writeFile(gitignorePath, mergeTextLines(gitignoreContent ?? buildGitignore(), existingGitignore), "utf8");
+    await normalizePackageJson(projectDir, packageManager);
+    await applyGeneratedProjectDxPackageJson({
+        compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true",
+        packageManager,
+        projectDir,
+        templateId,
+        withTestPreset,
+        withWpEnv,
+    });
+    await normalizePackageManagerFiles(projectDir, packageManager);
+    await removeUnexpectedLockfiles(projectDir, packageManager);
+    await replaceTextRecursively(projectDir, packageManager);
+    if (!noInstall) {
+        const installer = installDependencies ?? defaultInstallDependencies;
+        await installer({
+            projectDir,
+            packageManager,
+        });
+    }
+}

package/dist/runtime/scaffold-identifiers.d.ts

@@ -0,0 +1,34 @@
+export interface ResolvedScaffoldIdentifiers {
+    namespace: string;
+    phpPrefix: string;
+    slug: string;
+    textDomain: string;
+}
+export declare function validateBlockSlug(input: string): true | string;
+export declare function validateNamespace(input: string): true | string;
+export declare function validateTextDomain(input: string): true | string;
+export declare function validatePhpPrefix(input: string): true | string;
+export declare function assertValidIdentifier(label: string, value: string, validate: (value: string) => true | string): string;
+export declare function normalizeBlockSlug(input: string): string;
+export declare function resolveValidatedBlockSlug(value: string): string;
+export declare function resolveValidatedNamespace(value: string): string;
+export declare function resolveValidatedTextDomain(value: string): string;
+export declare function resolveValidatedPhpPrefix(value: string): string;
+/**
+ * Builds the generated WordPress wrapper CSS class for a scaffolded block.
+ *
+ * Returns `wp-block-{namespace}-{slug}` when a non-empty namespace is present,
+ * or `wp-block-{slug}` when the namespace is empty or undefined. When the
+ * normalized namespace equals the normalized slug, appends `-block` so the
+ * generated class avoids repeated namespace segments without colliding with the
+ * default core wrapper classes. Both inputs are normalized and validated with
+ * the same scaffold identifier rules used for block names.
+ */
+export declare function buildBlockCssClassName(namespace: string | undefined, slug: string): string;
+export declare function buildFrontendCssClassName(blockCssClassName: string): string;
+export declare function resolveScaffoldIdentifiers({ namespace, phpPrefix, slug, textDomain, }: {
+    namespace: string;
+    phpPrefix?: string;
+    slug: string;
+    textDomain?: string;
+}): ResolvedScaffoldIdentifiers;

package/dist/runtime/scaffold-identifiers.js

@@ -0,0 +1,82 @@
+import { toKebabCase, toSnakeCase, } from "./string-case.js";
+const BLOCK_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
+const PHP_PREFIX_PATTERN = /^[a-z_][a-z0-9_]*$/;
+const PHP_PREFIX_MAX_LENGTH = 50;
+export function validateBlockSlug(input) {
+    return BLOCK_SLUG_PATTERN.test(input) || "Use lowercase letters, numbers, and hyphens only";
+}
+export function validateNamespace(input) {
+    return BLOCK_SLUG_PATTERN.test(toKebabCase(input))
+        ? true
+        : "Use lowercase letters, numbers, and hyphens only";
+}
+export function validateTextDomain(input) {
+    return BLOCK_SLUG_PATTERN.test(toKebabCase(input))
+        ? true
+        : "Use lowercase letters, numbers, and hyphens only";
+}
+export function validatePhpPrefix(input) {
+    const normalizedPrefix = toSnakeCase(input);
+    if (normalizedPrefix.length > PHP_PREFIX_MAX_LENGTH) {
+        return `Use ${PHP_PREFIX_MAX_LENGTH} characters or fewer to keep generated database identifiers within MySQL limits`;
+    }
+    return PHP_PREFIX_PATTERN.test(normalizedPrefix)
+        ? true
+        : "Use letters, numbers, and underscores only, starting with a letter";
+}
+export function assertValidIdentifier(label, value, validate) {
+    const result = validate(value);
+    if (result !== true) {
+        throw new Error(typeof result === "string" ? `${label}: ${result}` : `${label} is invalid`);
+    }
+    return value;
+}
+export function normalizeBlockSlug(input) {
+    return toKebabCase(input);
+}
+export function resolveValidatedBlockSlug(value) {
+    return assertValidIdentifier("Block slug", normalizeBlockSlug(value), validateBlockSlug);
+}
+export function resolveValidatedNamespace(value) {
+    return assertValidIdentifier("Namespace", toKebabCase(value), validateNamespace);
+}
+export function resolveValidatedTextDomain(value) {
+    return assertValidIdentifier("Text domain", toKebabCase(value), validateTextDomain);
+}
+export function resolveValidatedPhpPrefix(value) {
+    return assertValidIdentifier("PHP prefix", toSnakeCase(value), validatePhpPrefix);
+}
+/**
+ * Builds the generated WordPress wrapper CSS class for a scaffolded block.
+ *
+ * Returns `wp-block-{namespace}-{slug}` when a non-empty namespace is present,
+ * or `wp-block-{slug}` when the namespace is empty or undefined. When the
+ * normalized namespace equals the normalized slug, appends `-block` so the
+ * generated class avoids repeated namespace segments without colliding with the
+ * default core wrapper classes. Both inputs are normalized and validated with
+ * the same scaffold identifier rules used for block names.
+ */
+export function buildBlockCssClassName(namespace, slug) {
+    const normalizedSlug = resolveValidatedBlockSlug(slug);
+    const normalizedNamespace = typeof namespace === "string" && namespace.trim().length > 0
+        ? resolveValidatedNamespace(namespace)
+        : "";
+    if (normalizedNamespace === normalizedSlug) {
+        return `wp-block-${normalizedSlug}-block`;
+    }
+    return normalizedNamespace.length > 0
+        ? `wp-block-${normalizedNamespace}-${normalizedSlug}`
+        : `wp-block-${normalizedSlug}`;
+}
+export function buildFrontendCssClassName(blockCssClassName) {
+    return `${blockCssClassName}-frontend`;
+}
+export function resolveScaffoldIdentifiers({ namespace, phpPrefix, slug, textDomain, }) {
+    const normalizedSlug = resolveValidatedBlockSlug(slug);
+    return {
+        namespace: resolveValidatedNamespace(namespace),
+        phpPrefix: resolveValidatedPhpPrefix(phpPrefix ?? normalizedSlug),
+        slug: normalizedSlug,
+        textDomain: resolveValidatedTextDomain(textDomain ?? normalizedSlug),
+    };
+}

package/dist/runtime/scaffold.js

@@ -15,6 +15,7 @@ import { BUILTIN_BLOCK_METADATA_VERSION, COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS,
 import { copyInterpolatedDirectory } from "./template-render.js";
 import { PROJECT_TOOLS_PACKAGE_ROOT, TEMPLATE_IDS, getTemplateById, isBuiltInTemplateId, } from "./template-registry.js";
 import { resolveTemplateSource } from "./template-source.js";
+import { BlockGeneratorService, buildTemplateVariablesFromBlockSpec, createBuiltInBlockSpec, } from "./block-generator-service.js";
 const BLOCK_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
 const PHP_PREFIX_PATTERN = /^[a-z_][a-z0-9_]*$/;
 const PHP_PREFIX_MAX_LENGTH = 50;
@@ -215,6 +216,14 @@ export async function collectScaffoldAnswers({ projectName, templateId, yes = fa
     };
 }
 export function getTemplateVariables(templateId, answers) {
+    if (isBuiltInTemplateId(templateId)) {
+        return buildTemplateVariablesFromBlockSpec(createBuiltInBlockSpec({
+            answers,
+            dataStorageMode: answers.dataStorageMode,
+            persistencePolicy: answers.persistencePolicy,
+            templateId,
+        }));
+    }
     const { apiClientPackageVersion, blockRuntimePackageVersion, blockTypesPackageVersion, projectToolsPackageVersion, restPackageVersion, } = getPackageVersions();
     const template = isBuiltInTemplateId(templateId) ? getTemplateById(templateId) : null;
     const metadataDefaults = isBuiltInTemplateId(templateId)
@@ -638,6 +647,30 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
     const resolvedTemplateId = normalizeTemplateSelection(templateId);
     const resolvedPackageManager = getPackageManager(packageManager).id;
     const isBuiltInTemplate = isBuiltInTemplateId(resolvedTemplateId);
+    if (isBuiltInTemplate) {
+        const blockGeneratorService = new BlockGeneratorService();
+        const plan = await blockGeneratorService.plan({
+            allowExistingDir,
+            answers,
+            cwd,
+            dataStorageMode: dataStorageMode ?? answers.dataStorageMode,
+            noInstall,
+            packageManager: resolvedPackageManager,
+            persistencePolicy: persistencePolicy ?? answers.persistencePolicy,
+            projectDir,
+            templateId: resolvedTemplateId,
+            variant,
+            withMigrationUi,
+            withTestPreset,
+            withWpEnv,
+        });
+        const validated = await blockGeneratorService.validate({ plan });
+        const rendered = await blockGeneratorService.render({ validated });
+        return blockGeneratorService.apply({
+            installDependencies,
+            rendered,
+        });
+    }
     const variables = getTemplateVariables(resolvedTemplateId, {
         ...answers,
         dataStorageMode: dataStorageMode ?? answers.dataStorageMode,

package/dist/runtime/starter-manifests.d.ts

@@ -1,8 +1,9 @@
 /**
  * Scaffold-time starter manifest builders for generated projects.
  *
- * These helpers create placeholder `typia.manifest.json` artifacts so fresh
- * scaffolds can resolve runtime imports before the first canonical sync run.
+ * These helpers now reuse the Phase 2 built-in artifact model so generated
+ * `types.ts`, `block.json`, and starter `typia.manifest.json` all share the
+ * same attribute metadata source of truth.
  */
 import type { ManifestDocument } from "./migration-types.js";
 import type { ScaffoldTemplateVariables } from "./scaffold.js";