@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/templates/external-template-guards.js

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import { safeJsonParse } from "../shared/json-utils.js";
+export const TEMPLATE_SOURCE_TIMEOUT_CODE = "template-source-timeout";
+export const TEMPLATE_SOURCE_TOO_LARGE_CODE = "template-source-too-large";
+const DEFAULT_EXTERNAL_TEMPLATE_TIMEOUT_MS = 20000;
+const DEFAULT_EXTERNAL_TEMPLATE_CONFIG_MAX_BYTES = 256 * 1024;
+const DEFAULT_EXTERNAL_TEMPLATE_PACKAGE_JSON_MAX_BYTES = 1 * 1024 * 1024;
+const DEFAULT_EXTERNAL_TEMPLATE_METADATA_MAX_BYTES = 1 * 1024 * 1024;
+const DEFAULT_EXTERNAL_TEMPLATE_TARBALL_MAX_BYTES = 32 * 1024 * 1024;
+function parsePositiveIntegerEnv(value, fallback) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function createTemplateGuardError(code, message) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+}
+export function getExternalTemplateTimeoutMs() {
+    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_TIMEOUT_MS, DEFAULT_EXTERNAL_TEMPLATE_TIMEOUT_MS);
+}
+export function getExternalTemplateConfigMaxBytes() {
+    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_CONFIG_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_CONFIG_MAX_BYTES);
+}
+export function getExternalTemplatePackageJsonMaxBytes() {
+    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_PACKAGE_JSON_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_PACKAGE_JSON_MAX_BYTES);
+}
+export function getExternalTemplateMetadataMaxBytes() {
+    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_METADATA_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_METADATA_MAX_BYTES);
+}
+export function getExternalTemplateTarballMaxBytes() {
+    return parsePositiveIntegerEnv(process.env.WP_TYPIA_EXTERNAL_TEMPLATE_TARBALL_MAX_BYTES, DEFAULT_EXTERNAL_TEMPLATE_TARBALL_MAX_BYTES);
+}
+export function createExternalTemplateTimeoutError(label, timeoutMs) {
+    return createTemplateGuardError(TEMPLATE_SOURCE_TIMEOUT_CODE, `Timed out while ${label} after ${timeoutMs}ms.`);
+}
+export function createExternalTemplateTooLargeError(label, maxBytes) {
+    return createTemplateGuardError(TEMPLATE_SOURCE_TOO_LARGE_CODE, `${label} exceeded the external template size limit (${maxBytes} bytes).`);
+}
+export function assertExternalTemplateFileSize(filePath, options) {
+    const stats = fs.statSync(filePath);
+    if (stats.size > options.maxBytes) {
+        throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
+    }
+}
+export async function withExternalTemplateTimeout(label, task, timeoutMs = getExternalTemplateTimeoutMs()) {
+    let timeoutHandle;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+            reject(createExternalTemplateTimeoutError(label, timeoutMs));
+        }, timeoutMs);
+    });
+    try {
+        const pendingTask = typeof task === "function" ? task() : task;
+        return await Promise.race([pendingTask, timeoutPromise]);
+    }
+    finally {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
+export async function fetchWithExternalTemplateTimeout(input, options) {
+    const controller = new AbortController();
+    const timeoutMs = options.timeoutMs ?? getExternalTemplateTimeoutMs();
+    const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(input, {
+            ...(options.init ?? {}),
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            (error.name === "AbortError" || error.name === "TimeoutError")) {
+            throw createExternalTemplateTimeoutError(options.label, timeoutMs);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutHandle);
+    }
+}
+async function readResponseBodyWithLimit(response, options) {
+    const contentLengthHeader = response.headers.get("content-length");
+    if (typeof contentLengthHeader === "string") {
+        const declaredLength = Number.parseInt(contentLengthHeader, 10);
+        if (Number.isFinite(declaredLength) && declaredLength > options.maxBytes) {
+            throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
+        }
+    }
+    if (!response.body) {
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.length > options.maxBytes) {
+            throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
+        }
+        return buffer;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (!value) {
+            continue;
+        }
+        totalBytes += value.byteLength;
+        if (totalBytes > options.maxBytes) {
+            await reader.cancel();
+            throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
+        }
+        chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks);
+}
+export async function readJsonResponseWithLimit(response, options) {
+    const buffer = await readResponseBodyWithLimit(response, options);
+    return safeJsonParse(buffer.toString("utf8"), {
+        context: options.label,
+    });
+}
+export async function readBufferResponseWithLimit(response, options) {
+    return readResponseBodyWithLimit(response, options);
+}

package/dist/runtime/templates/local-dev-presets.d.ts

@@ -0,0 +1,26 @@
+import { type PackageManagerId } from "../shared/package-managers.js";
+import type { ScaffoldTemplateVariables } from "./scaffold.js";
+interface LocalDevPresetOptions {
+    compoundPersistenceEnabled?: boolean;
+    packageManager: PackageManagerId;
+    projectDir: string;
+    templateId: string;
+    variables: ScaffoldTemplateVariables;
+    withTestPreset?: boolean;
+    withWpEnv?: boolean;
+}
+/**
+ * Copies opt-in local development preset files into a generated project.
+ */
+export declare function applyLocalDevPresetFiles({ projectDir, variables, withTestPreset, withWpEnv, }: Pick<LocalDevPresetOptions, "projectDir" | "variables" | "withTestPreset" | "withWpEnv">): Promise<void>;
+/**
+ * Adds generated-project watch scripts and preset-specific dependencies to
+ * `package.json`.
+ */
+export declare function applyGeneratedProjectDxPackageJson({ compoundPersistenceEnabled, packageManager, projectDir, templateId, withTestPreset, withWpEnv, }: Omit<LocalDevPresetOptions, "variables">): Promise<void>;
+/**
+ * Returns the recommended first-run development command for the given
+ * scaffolded template.
+ */
+export declare function getPrimaryDevelopmentScript(templateId: string): "dev" | "start";
+export {};

package/dist/runtime/templates/local-dev-presets.js

@@ -0,0 +1,151 @@
+/**
+ * Helpers for the generated-project local development experience.
+ *
+ * These utilities apply optional preset files and watch-oriented package
+ * scripts after a scaffold has been rendered.
+ */
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { formatRunScript, } from "../shared/package-managers.js";
+import { DEFAULT_WORDPRESS_ENV_VERSION } from "../shared/package-versions.js";
+import { readJsonFile } from "../shared/json-utils.js";
+import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, SHARED_TEST_PRESET_TEMPLATE_ROOT, SHARED_WP_ENV_PRESET_TEMPLATE_ROOT, } from "./template-registry.js";
+import { copyInterpolatedDirectory } from "./template-render.js";
+function templateHasPersistenceSync(templateId, compoundPersistenceEnabled) {
+    return templateId === "persistence" || (templateId === "compound" && compoundPersistenceEnabled);
+}
+function templateSupportsGeneratedSyncWatchers(templateId) {
+    return (templateId === "basic" ||
+        templateId === "interactivity" ||
+        templateId === "persistence" ||
+        templateId === "compound");
+}
+function templateUsesDevAsPrimaryEntrypoint(templateId) {
+    return (templateSupportsGeneratedSyncWatchers(templateId) ||
+        templateId === "query-loop" ||
+        templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE);
+}
+function getWatchSyncTypesScript(packageManager, templateId) {
+    if (templateId === "compound") {
+        return `chokidar "src/blocks/**/types.ts" "scripts/block-config.ts" --debounce 200 -c "${formatRunScript(packageManager, "sync-types")}"`;
+    }
+    return `chokidar "src/types.ts" --debounce 200 -c "${formatRunScript(packageManager, "sync-types")}"`;
+}
+function getWatchSyncRestScript(packageManager, templateId) {
+    if (templateId === "compound") {
+        return `chokidar "src/blocks/**/api-types.ts" "scripts/block-config.ts" --debounce 200 -c "${formatRunScript(packageManager, "sync-rest")}"`;
+    }
+    return `chokidar "src/api-types.ts" --debounce 200 -c "${formatRunScript(packageManager, "sync-rest")}"`;
+}
+function getDevScript(packageManager, compoundPersistenceEnabled, templateId) {
+    const syncProcesses = [
+        `"${formatRunScript(packageManager, "watch:sync-types")}"`,
+    ];
+    const names = ["sync-types"];
+    const colors = ["yellow"];
+    if (templateHasPersistenceSync(templateId, compoundPersistenceEnabled)) {
+        syncProcesses.push(`"${formatRunScript(packageManager, "watch:sync-rest")}"`);
+        names.push("sync-rest");
+        colors.push("magenta");
+    }
+    syncProcesses.push(`"${formatRunScript(packageManager, "start:editor")}"`);
+    names.push("editor");
+    colors.push("blue");
+    return `concurrently -k -n ${names.join(",")} -c ${colors.join(",")} ${syncProcesses.join(" ")}`;
+}
+async function mutatePackageJson(projectDir, mutate) {
+    const packageJsonPath = path.join(projectDir, "package.json");
+    const packageJson = await readJsonFile(packageJsonPath, {
+        context: "local dev package manifest",
+    });
+    mutate(packageJson);
+    await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}\n`, "utf8");
+}
+async function appendGitignoreLines(projectDir, lines) {
+    if (lines.length === 0) {
+        return;
+    }
+    const gitignorePath = path.join(projectDir, ".gitignore");
+    const current = fs.existsSync(gitignorePath)
+        ? await fsp.readFile(gitignorePath, "utf8")
+        : "";
+    const missingLines = lines.filter((line) => !current.includes(`${line}\n`) && !current.endsWith(line));
+    if (missingLines.length === 0) {
+        return;
+    }
+    const suffix = current.endsWith("\n") ? "" : "\n";
+    await fsp.writeFile(gitignorePath, `${current}${suffix}${missingLines.join("\n")}\n`, "utf8");
+}
+/**
+ * Copies opt-in local development preset files into a generated project.
+ */
+export async function applyLocalDevPresetFiles({ projectDir, variables, withTestPreset = false, withWpEnv = false, }) {
+    if (withWpEnv) {
+        await copyInterpolatedDirectory(SHARED_WP_ENV_PRESET_TEMPLATE_ROOT, projectDir, variables);
+    }
+    if (withTestPreset) {
+        await copyInterpolatedDirectory(SHARED_TEST_PRESET_TEMPLATE_ROOT, projectDir, variables);
+        await appendGitignoreLines(projectDir, ["playwright-report/", "test-results/"]);
+    }
+}
+/**
+ * Adds generated-project watch scripts and preset-specific dependencies to
+ * `package.json`.
+ */
+export async function applyGeneratedProjectDxPackageJson({ compoundPersistenceEnabled = false, packageManager, projectDir, templateId, withTestPreset = false, withWpEnv = false, }) {
+    const hasPersistenceSync = templateHasPersistenceSync(templateId, compoundPersistenceEnabled);
+    const supportsGeneratedSyncWatchers = templateSupportsGeneratedSyncWatchers(templateId);
+    await mutatePackageJson(projectDir, (packageJson) => {
+        packageJson.devDependencies = {
+            ...(packageJson.devDependencies ?? {}),
+            ...(supportsGeneratedSyncWatchers
+                ? {
+                    "chokidar-cli": "^3.0.0",
+                    concurrently: "^9.0.1",
+                }
+                : {}),
+        };
+        if (withWpEnv || withTestPreset) {
+            packageJson.devDependencies["@wordpress/env"] = DEFAULT_WORDPRESS_ENV_VERSION;
+        }
+        if (withTestPreset) {
+            packageJson.devDependencies["@playwright/test"] = "^1.54.2";
+        }
+        const scripts = {
+            ...(packageJson.scripts ?? {}),
+        };
+        if (supportsGeneratedSyncWatchers) {
+            scripts["start:editor"] = "wp-scripts start --experimental-modules";
+            scripts["watch:sync-types"] = getWatchSyncTypesScript(packageManager, templateId);
+        }
+        if (hasPersistenceSync) {
+            scripts["watch:sync-rest"] = getWatchSyncRestScript(packageManager, templateId);
+        }
+        if (supportsGeneratedSyncWatchers) {
+            scripts.dev = getDevScript(packageManager, compoundPersistenceEnabled, templateId);
+        }
+        if (withWpEnv) {
+            scripts["wp-env:start"] = "wp-env start";
+            scripts["wp-env:stop"] = "wp-env stop";
+            scripts["wp-env:reset"] = "wp-env destroy all && wp-env start";
+        }
+        if (withTestPreset) {
+            scripts["wp-env:start:test"] = "wp-env start --config=.wp-env.test.json";
+            scripts["wp-env:stop:test"] = "wp-env stop --config=.wp-env.test.json";
+            scripts["wp-env:reset:test"] =
+                "wp-env destroy all --config=.wp-env.test.json && wp-env start --config=.wp-env.test.json";
+            scripts["wp-env:wait:test"] =
+                "node scripts/wait-for-wp-env.mjs http://localhost:8889 180000 .wp-env.test.json";
+            scripts["test:e2e"] = `${formatRunScript(packageManager, "wp-env:start:test")} && ${formatRunScript(packageManager, "wp-env:wait:test")} && playwright test`;
+        }
+        packageJson.scripts = scripts;
+    });
+}
+/**
+ * Returns the recommended first-run development command for the given
+ * scaffolded template.
+ */
+export function getPrimaryDevelopmentScript(templateId) {
+    return templateUsesDevAsPrimaryEntrypoint(templateId) ? "dev" : "start";
+}

package/dist/runtime/templates/scaffold-answer-resolution.d.ts

@@ -0,0 +1,37 @@
+import type { PackageManagerId } from '../shared/package-managers.js';
+import type { CollectScaffoldAnswersOptions, ResolvePackageManagerOptions, ResolveTemplateOptions, ScaffoldAnswers } from './scaffold.js';
+/**
+ * Detect the current author name from local Git config.
+ *
+ * @returns The configured Git author name, or `"Your Name"` when unavailable.
+ */
+export declare function detectAuthor(): string;
+/**
+ * Compute the default scaffold answers for one project and template pair.
+ *
+ * @param projectName User-supplied project directory or block name seed.
+ * @param templateId Selected scaffold template identifier.
+ * @returns Normalized default answers for scaffold prompts and non-interactive flows.
+ */
+export declare function getDefaultAnswers(projectName: string, templateId: string): ScaffoldAnswers;
+/**
+ * Resolve the scaffold template id from flags, defaults, and interactive selection.
+ *
+ * @param options Template resolution options for interactive and non-interactive flows.
+ * @returns The normalized template identifier to scaffold.
+ */
+export declare function resolveTemplateId({ templateId, yes, isInteractive, selectTemplate, }: ResolveTemplateOptions): Promise<string>;
+/**
+ * Resolve the package manager id from flags, defaults, and interactive selection.
+ *
+ * @param options Package manager resolution options for interactive and non-interactive flows.
+ * @returns The normalized package manager id.
+ */
+export declare function resolvePackageManagerId({ packageManager, yes, isInteractive, selectPackageManager, }: ResolvePackageManagerOptions): Promise<PackageManagerId>;
+/**
+ * Collect scaffold answers from defaults, CLI overrides, and optional prompts.
+ *
+ * @param options Answer collection inputs including prompt callbacks and explicit overrides.
+ * @returns The normalized scaffold answers used for rendering and file generation.
+ */
+export declare function collectScaffoldAnswers({ projectName, templateId, yes, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, queryPostType, textDomain, }: CollectScaffoldAnswersOptions): Promise<ScaffoldAnswers>;

package/dist/runtime/templates/scaffold-answer-resolution.js

@@ -0,0 +1,155 @@
+import { execSync } from 'node:child_process';
+import { PACKAGE_MANAGER_IDS, getPackageManager, } from '../shared/package-managers.js';
+import { normalizeBlockSlug, resolveScaffoldIdentifiers, validateBlockSlug, validateNamespace, } from './scaffold-identifiers.js';
+import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from '../cli/cli-diagnostics.js';
+import { getTemplateById, isBuiltInTemplateId, } from './template-registry.js';
+import { CREATE_TEMPLATE_SELECTION_HINT, validateExplicitCreateTemplateId, } from './create-template-validation.js';
+import { toSnakeCase, toTitleCase, } from '../shared/string-case.js';
+const QUERY_POST_TYPE_RULE = 'Use lowercase, 1-20 chars, and only a-z, 0-9, "_" or "-".';
+/**
+ * Detect the current author name from local Git config.
+ *
+ * @returns The configured Git author name, or `"Your Name"` when unavailable.
+ */
+export function detectAuthor() {
+    try {
+        return (execSync('git config user.name', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim() || 'Your Name');
+    }
+    catch {
+        return 'Your Name';
+    }
+}
+/**
+ * Compute the default scaffold answers for one project and template pair.
+ *
+ * @param projectName User-supplied project directory or block name seed.
+ * @param templateId Selected scaffold template identifier.
+ * @returns Normalized default answers for scaffold prompts and non-interactive flows.
+ */
+export function getDefaultAnswers(projectName, templateId) {
+    const template = isBuiltInTemplateId(templateId) ? getTemplateById(templateId) : null;
+    const slugDefault = normalizeBlockSlug(projectName) || 'my-wp-typia-block';
+    return {
+        author: detectAuthor(),
+        dataStorageMode: templateId === 'persistence' ? 'custom-table' : undefined,
+        description: template?.description ?? 'A WordPress block scaffolded from a remote template',
+        namespace: slugDefault,
+        persistencePolicy: templateId === 'persistence' ? 'authenticated' : undefined,
+        phpPrefix: toSnakeCase(slugDefault),
+        queryPostType: templateId === 'query-loop' ? 'post' : undefined,
+        slug: slugDefault,
+        textDomain: slugDefault,
+        title: toTitleCase(slugDefault),
+    };
+}
+function validateQueryPostType(value) {
+    const rawValue = value.trim();
+    const normalizedValue = rawValue.toLowerCase();
+    if (normalizedValue.length === 0) {
+        return 'Query post type is required.';
+    }
+    if (!/^[a-z0-9_-]{1,20}$/u.test(normalizedValue)) {
+        return rawValue === normalizedValue
+            ? `Query post type "${rawValue}" is invalid. ${QUERY_POST_TYPE_RULE}`
+            : `Query post type "${rawValue}" normalizes to "${normalizedValue}", which is invalid. ${QUERY_POST_TYPE_RULE}`;
+    }
+    return true;
+}
+function normalizeQueryPostType(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const validationResult = validateQueryPostType(value);
+    if (validationResult !== true) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, validationResult);
+    }
+    return value.trim().toLowerCase();
+}
+/**
+ * Resolve the scaffold template id from flags, defaults, and interactive selection.
+ *
+ * @param options Template resolution options for interactive and non-interactive flows.
+ * @returns The normalized template identifier to scaffold.
+ */
+export async function resolveTemplateId({ templateId, yes = false, isInteractive = false, selectTemplate, }) {
+    if (templateId) {
+        return validateExplicitCreateTemplateId(templateId);
+    }
+    if (yes) {
+        return 'basic';
+    }
+    if (!isInteractive || !selectTemplate) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Template is required in non-interactive mode. Use ${CREATE_TEMPLATE_SELECTION_HINT}.`);
+    }
+    return validateExplicitCreateTemplateId(await selectTemplate());
+}
+/**
+ * Resolve the package manager id from flags, defaults, and interactive selection.
+ *
+ * @param options Package manager resolution options for interactive and non-interactive flows.
+ * @returns The normalized package manager id.
+ */
+export async function resolvePackageManagerId({ packageManager, yes = false, isInteractive = false, selectPackageManager, }) {
+    if (packageManager) {
+        return getPackageManager(packageManager).id;
+    }
+    if (yes) {
+        return 'npm';
+    }
+    if (!isInteractive || !selectPackageManager) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `Package manager is required in non-interactive mode. Use --package-manager <${PACKAGE_MANAGER_IDS.join('|')}>.`);
+    }
+    return selectPackageManager();
+}
+/**
+ * Collect scaffold answers from defaults, CLI overrides, and optional prompts.
+ *
+ * @param options Answer collection inputs including prompt callbacks and explicit overrides.
+ * @returns The normalized scaffold answers used for rendering and file generation.
+ */
+export async function collectScaffoldAnswers({ projectName, templateId, yes = false, dataStorageMode, namespace, persistencePolicy, phpPrefix, promptText, queryPostType, textDomain, }) {
+    const defaults = getDefaultAnswers(projectName, templateId);
+    if (yes || (!isBuiltInTemplateId(templateId) && !promptText)) {
+        const identifiers = resolveScaffoldIdentifiers({
+            namespace: namespace ?? defaults.namespace,
+            phpPrefix,
+            slug: defaults.slug,
+            textDomain,
+        });
+        return {
+            ...defaults,
+            dataStorageMode: dataStorageMode ?? defaults.dataStorageMode,
+            namespace: identifiers.namespace,
+            persistencePolicy: persistencePolicy ?? defaults.persistencePolicy,
+            phpPrefix: identifiers.phpPrefix,
+            queryPostType: normalizeQueryPostType(queryPostType ?? defaults.queryPostType),
+            textDomain: identifiers.textDomain,
+        };
+    }
+    if (!promptText) {
+        throw new Error('Interactive answers require a promptText callback.');
+    }
+    const identifiers = resolveScaffoldIdentifiers({
+        namespace: namespace ?? (await promptText('Namespace', defaults.namespace, validateNamespace)),
+        phpPrefix,
+        slug: await promptText('Block slug', defaults.slug, validateBlockSlug),
+        textDomain,
+    });
+    return {
+        author: await promptText('Author', defaults.author),
+        dataStorageMode: dataStorageMode ?? defaults.dataStorageMode,
+        description: await promptText('Description', defaults.description),
+        namespace: identifiers.namespace,
+        persistencePolicy: persistencePolicy ?? defaults.persistencePolicy,
+        phpPrefix: identifiers.phpPrefix,
+        queryPostType: templateId === 'query-loop'
+            ? normalizeQueryPostType(await promptText('Query post type', queryPostType ?? defaults.queryPostType ?? 'post', validateQueryPostType))
+            : normalizeQueryPostType(queryPostType ?? defaults.queryPostType),
+        slug: identifiers.slug,
+        textDomain: identifiers.textDomain,
+        title: await promptText('Block title', toTitleCase(identifiers.slug)),
+    };
+}

package/dist/runtime/templates/scaffold-apply-utils.d.ts

@@ -0,0 +1,53 @@
+import { type BuiltInBlockArtifact } from "./built-in-block-artifacts.js";
+import type { BuiltInCodeArtifact } from "./built-in-block-code-artifacts.js";
+import { type BuiltInTemplateId } from "./template-registry.js";
+import type { PackageManagerId } from "../shared/package-managers.js";
+export { applyWorkspaceMigrationCapability, isOfficialWorkspaceProject, } from "./scaffold-bootstrap.js";
+import type { ScaffoldProgressEvent, ScaffoldTemplateVariables } from "./scaffold.js";
+export { buildGitignore, buildReadme, mergeTextLines } from "./scaffold-documents.js";
+export interface InstallDependenciesOptions {
+    packageManager: PackageManagerId;
+    projectDir: string;
+}
+export declare function ensureDirectory(targetDir: string, allowExisting?: boolean): Promise<void>;
+export declare function writeStarterManifestFiles(targetDir: string, templateId: string, variables: ScaffoldTemplateVariables, artifacts?: readonly BuiltInBlockArtifact[]): Promise<void>;
+/**
+ * Seed REST-derived persistence artifacts into a newly scaffolded built-in
+ * project before the first manual `sync-rest` run.
+ */
+export declare function seedBuiltInPersistenceArtifacts(targetDir: string, templateId: BuiltInTemplateId, variables: ScaffoldTemplateVariables): Promise<void>;
+export declare function normalizePackageManagerFiles(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
+export declare function removeQueryLoopPlaceholderFiles(projectDir: string, templateId: string): Promise<void>;
+export declare function removeUnexpectedLockfiles(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
+/**
+ * Recursively normalizes generated text files for the selected package manager
+ * and repository reference.
+ */
+export declare function replaceTextRecursively(targetDir: string, packageManagerId: PackageManagerId, { repositoryManifestPaths, repositoryReference, }?: {
+    repositoryManifestPaths?: readonly string[];
+    repositoryReference?: string;
+}): Promise<void>;
+export declare function defaultInstallDependencies({ projectDir, packageManager, }: InstallDependenciesOptions): Promise<void>;
+/**
+ * Applies a built-in scaffold into the target directory, including generated
+ * code artifacts, starter manifests, preset files, and placeholder rewrites.
+ */
+export declare function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir, templateId, variables, artifacts, codeArtifacts, readmeContent, gitignoreContent, allowExistingDir, packageManager, withMigrationUi, withTestPreset, withWpEnv, noInstall, installDependencies, repositoryReference, onProgress, }: {
+    projectDir: string;
+    templateDir: string;
+    templateId: BuiltInTemplateId;
+    variables: ScaffoldTemplateVariables;
+    artifacts?: readonly BuiltInBlockArtifact[];
+    codeArtifacts?: readonly BuiltInCodeArtifact[];
+    readmeContent?: string;
+    gitignoreContent?: string;
+    allowExistingDir?: boolean;
+    packageManager: PackageManagerId;
+    withMigrationUi?: boolean;
+    withTestPreset?: boolean;
+    withWpEnv?: boolean;
+    noInstall?: boolean;
+    installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
+    repositoryReference?: string;
+    onProgress?: ((event: ScaffoldProgressEvent) => void | Promise<void>) | undefined;
+}): Promise<void>;