@wp-typia/project-tools 0.19.0 → 0.19.2

package/dist/runtime/cli-diagnostics.js

@@ -1,8 +1,23 @@
+export const CLI_DIAGNOSTIC_CODES = {
+    COMMAND_EXECUTION: "command-execution",
+    CONFIGURATION_MISSING: "configuration-missing",
+    DEPENDENCIES_NOT_INSTALLED: "dependencies-not-installed",
+    DOCTOR_CHECK_FAILED: "doctor-check-failed",
+    INVALID_ARGUMENT: "invalid-argument",
+    INVALID_COMMAND: "invalid-command",
+    MISSING_ARGUMENT: "missing-argument",
+    MISSING_BUILD_ARTIFACT: "missing-build-artifact",
+    OUTSIDE_PROJECT_ROOT: "outside-project-root",
+    UNSUPPORTED_COMMAND: "unsupported-command",
+};
 const DEFAULT_CLI_FAILURE_SUMMARIES = {
     add: "Unable to complete the requested add workflow.",
     create: "Unable to complete the requested create workflow.",
     doctor: "One or more doctor checks failed.",
+    mcp: "Unable to inspect or sync MCP metadata.",
     migrate: "Unable to complete the requested migration command.",
+    sync: "Unable to complete the requested sync workflow.",
+    templates: "Unable to inspect scaffold templates.",
 };
 const MIN_CLI_WRAP_COLUMNS = 32;
 function parseCliColumns(value) {
@@ -104,6 +119,7 @@ function normalizeDetailLines(detailLines) {
 export class CliDiagnosticError extends Error {
     constructor(message, options) {
         super(formatCliDiagnosticBlock(message), options);
+        this.code = message.code;
         this.command = message.command;
         this.detailLines = [...message.detailLines];
         this.name = "CliDiagnosticError";
@@ -116,6 +132,59 @@ export class CliDiagnosticError extends Error {
 export function isCliDiagnosticError(error) {
     return error instanceof CliDiagnosticError;
 }
+function isCliDiagnosticCode(value) {
+    return Object.values(CLI_DIAGNOSTIC_CODES).includes(value);
+}
+function readCliDiagnosticCode(error) {
+    if (isCliDiagnosticError(error)) {
+        return error.code;
+    }
+    if (typeof error === "object" && error !== null && "code" in error) {
+        const { code } = error;
+        if (isCliDiagnosticCode(code)) {
+            return code;
+        }
+    }
+    return null;
+}
+function inferCliDiagnosticCode(options) {
+    const inheritedCode = readCliDiagnosticCode(options.error);
+    if (inheritedCode) {
+        return inheritedCode;
+    }
+    const haystack = normalizeDetailLines([
+        ...options.detailLines,
+        options.error === undefined ? undefined : getErrorMessage(options.error),
+    ]).join("\n");
+    if (/No MCP schema sources are configured\./u.test(haystack)) {
+        return CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING;
+    }
+    if (/Missing bundled build artifacts/u.test(haystack)) {
+        return CLI_DIAGNOSTIC_CODES.MISSING_BUILD_ARTIFACT;
+    }
+    if (/No generated wp-typia project root was found/u.test(haystack)) {
+        return CLI_DIAGNOSTIC_CODES.OUTSIDE_PROJECT_ROOT;
+    }
+    if (/dependencies have not been installed yet/u.test(haystack)) {
+        return CLI_DIAGNOSTIC_CODES.DEPENDENCIES_NOT_INSTALLED;
+    }
+    if (options.command === "doctor") {
+        return CLI_DIAGNOSTIC_CODES.DOCTOR_CHECK_FAILED;
+    }
+    if (/requires <|requires --/u.test(haystack)) {
+        return CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT;
+    }
+    if (/Unknown .*subcommand|Unknown add kind|Unknown template|removed in favor|does not support|The Bun-free fallback runtime does not support|The positional alias only accepts/u.test(haystack)) {
+        return haystack.includes("does not support") ||
+            haystack.includes("The Bun-free fallback runtime does not support")
+            ? CLI_DIAGNOSTIC_CODES.UNSUPPORTED_COMMAND
+            : CLI_DIAGNOSTIC_CODES.INVALID_COMMAND;
+    }
+    if (/Invalid |must start with|cannot hook|cannot nest|cannot use|cannot be|already defines|already exists|Expected one of/u.test(haystack)) {
+        return CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT;
+    }
+    return CLI_DIAGNOSTIC_CODES.COMMAND_EXECUTION;
+}
 /**
  * Build a shared diagnostic error for one CLI command failure.
  */
@@ -125,7 +194,14 @@ export function createCliCommandError(options) {
     }
     const summary = options.summary ?? DEFAULT_CLI_FAILURE_SUMMARIES[options.command] ?? "Command failed.";
     const detailLines = normalizeDetailLines(options.detailLines ?? [options.error === undefined ? undefined : getErrorMessage(options.error)]);
+    const code = options.code ??
+        inferCliDiagnosticCode({
+            command: options.command,
+            detailLines,
+            error: options.error,
+        });
     return new CliDiagnosticError({
+        code,
         command: options.command,
         detailLines,
         summary,
@@ -140,11 +216,42 @@ export function formatCliDiagnosticError(error) {
         return getErrorMessage(error);
     }
     return formatCliDiagnosticBlock({
+        code: error.code,
         command: error.command,
         detailLines: error.detailLines,
         summary: error.summary,
     });
 }
+export function serializeCliDiagnosticError(error) {
+    if (isCliDiagnosticError(error)) {
+        return {
+            code: error.code,
+            command: error.command,
+            detailLines: [...error.detailLines],
+            kind: "command-execution",
+            message: formatCliDiagnosticBlock({
+                code: error.code,
+                command: error.command,
+                detailLines: error.detailLines,
+                summary: error.summary,
+            }),
+            name: error.name,
+            summary: error.summary,
+            tag: "CommandExecutionError",
+        };
+    }
+    return {
+        code: inferCliDiagnosticCode({
+            command: "unknown",
+            detailLines: [],
+            error,
+        }),
+        kind: "command-execution",
+        message: getErrorMessage(error),
+        name: error instanceof Error ? error.name : "Error",
+        tag: "CommandExecutionError",
+    };
+}
 /**
  * Format one human-readable doctor check row.
  */

package/dist/runtime/cli-doctor-workspace.js

@@ -351,21 +351,21 @@ export function getWorkspaceDoctorChecks(cwd) {
         workspace = tryResolveWorkspaceProject(cwd);
     }
     catch (error) {
-        checks.push(createDoctorScopeCheck("fail", "Environment checks ran, but workspace discovery could not continue. Fix the nearby workspace package metadata and rerun `wp-typia doctor`."));
+        checks.push(createDoctorScopeCheck("fail", "Scope: blocked before workspace checks. Environment checks ran, but workspace discovery could not continue. Fix the nearby workspace package metadata and rerun `wp-typia doctor`."));
         checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
         return checks;
     }
     if (!workspace) {
         if (invalidWorkspaceReason) {
-            checks.push(createDoctorScopeCheck("fail", "Environment checks ran, but workspace diagnostics could not continue because a nearby wp-typia workspace candidate is invalid. Fix the workspace package metadata and rerun `wp-typia doctor`."));
+            checks.push(createDoctorScopeCheck("fail", "Scope: blocked before workspace checks. Environment checks ran, but workspace diagnostics could not continue because a nearby wp-typia workspace candidate is invalid. Fix the workspace package metadata and rerun `wp-typia doctor`."));
             checks.push(createDoctorCheck("Workspace package metadata", "fail", invalidWorkspaceReason));
         }
         else {
-            checks.push(createDoctorScopeCheck("pass", "No official wp-typia workspace root was detected, so this run only covered environment readiness. Re-run `wp-typia doctor` from a workspace root if you expected package metadata, inventory, or generated artifact checks."));
+            checks.push(createDoctorScopeCheck("pass", "Scope: environment-only. No official wp-typia workspace root was detected, so this run only covered environment readiness. Re-run `wp-typia doctor` from a workspace root if you expected package metadata, inventory, or generated artifact checks."));
         }
         return checks;
     }
-    checks.push(createDoctorScopeCheck("pass", `Official workspace detected for ${workspace.workspace.namespace}; environment readiness checks ran and workspace-scoped diagnostics are enabled for the package metadata, inventory, source-tree drift, and any configured migration hint rows below.`));
+    checks.push(createDoctorScopeCheck("pass", `Scope: full workspace diagnostics for ${workspace.workspace.namespace}. Environment readiness checks ran and workspace-scoped diagnostics are enabled for the package metadata, inventory, source-tree drift, and any configured migration hint rows below.`));
     let workspacePackageJson;
     try {
         workspacePackageJson = parseWorkspacePackageJson(workspace.projectDir);

package/dist/runtime/cli-scaffold.js

@@ -1,12 +1,12 @@
 import fs from "node:fs";
 import { promises as fsp } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, resolvePackageManagerId, resolveTemplateId, scaffoldProject, } from "./scaffold.js";
 import { parseAlternateRenderTargets } from "./alternate-render-targets.js";
 import { parseCompoundInnerBlocksPreset } from "./compound-inner-blocks.js";
 import { formatInstallCommand, formatRunScript, } from "./package-managers.js";
 import { getPrimaryDevelopmentScript } from "./local-dev-presets.js";
+import { createManagedTempRoot } from "./temp-roots.js";
 import { getOptionalOnboardingNote, getOptionalOnboardingSteps, } from "./scaffold-onboarding.js";
 import { formatNonEmptyTargetDirectoryError } from "./scaffold-bootstrap.js";
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from "./template-registry.js";
@@ -41,7 +41,7 @@ async function assertDryRunTargetDirectoryReady(projectDir, allowExistingDir) {
 }
 async function buildScaffoldDryRunPlan({ allowExistingDir, alternateRenderTargets, answers, cwd, dataStorageMode, externalLayerId, externalLayerSource, externalLayerSourceLabel, installDependencies, noInstall, onProgress, packageManager, persistencePolicy, projectDir, templateId, variant, withMigrationUi, withTestPreset, withWpEnv, }) {
     await assertDryRunTargetDirectoryReady(projectDir, allowExistingDir);
-    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "wp-typia-scaffold-plan-"));
+    const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-scaffold-plan-");
     const previewProjectDir = path.join(tempRoot, "preview-project");
     try {
         const result = await scaffoldProject({
@@ -75,7 +75,7 @@ async function buildScaffoldDryRunPlan({ allowExistingDir, alternateRenderTarget
         };
     }
     finally {
-        await fsp.rm(tempRoot, { force: true, recursive: true });
+        await cleanup();
     }
 }
 function validateCreateProjectInput(projectInput) {

package/dist/runtime/index.d.ts

@@ -12,8 +12,9 @@
  */
 export { COMPOUND_INNER_BLOCKS_PRESET_IDS, DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID, getCompoundInnerBlocksPresetDefinition, isCompoundInnerBlocksPresetId, parseCompoundInnerBlocksPreset, resolveCompoundInnerBlocksPreset, } from "./compound-inner-blocks.js";
 export type { CompoundInnerBlocksPresetDefinition, CompoundInnerBlocksPresetId, CompoundInnerBlocksTemplateLock, } from "./compound-inner-blocks.js";
-export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
+export { scaffoldProject, collectScaffoldAnswers, getScaffoldTemplateVariableGroups, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { BlockGeneratorService } from "./block-generator-service.js";
+export type { BasicScaffoldTemplateVariableGroups, CompoundScaffoldTemplateVariableGroups, ExternalScaffoldTemplateVariableGroups, FlatScaffoldTemplateVariables, InteractivityScaffoldTemplateVariableGroups, PersistenceScaffoldTemplateVariableGroups, QueryLoopScaffoldTemplateVariableGroups, ScaffoldTemplateFamily, ScaffoldTemplateVariableGroups, } from "./scaffold.js";
 export type { ApplyBlockInput, BlockGenerationTarget, BlockSpec, PlanBlockInput, PlanBlockResult, RenderBlockInput, RenderBlockResult, ValidateBlockInput, ValidateBlockResult, } from "./block-generator-service.js";
 export { BLOCK_GENERATION_TOOL_CONTRACT_VERSION, inspectBlockGeneration, } from "./block-generator-tool-contract.js";
 export type { BlockGenerationEmittedFilePreview, BlockGenerationRenderPreview, BlockGenerationStarterManifestPreview, BlockGenerationTemplateCopyPreview, BlockGenerationToolStage, InspectBlockGenerationInput, InspectBlockGenerationPlanResult, InspectBlockGenerationRenderResult, InspectBlockGenerationResult, InspectBlockGenerationValidateResult, } from "./block-generator-tool-contract.js";
@@ -24,5 +25,6 @@ export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, str
 export type { EndpointAuthIntent, EndpointOpenApiAuthMode, EndpointOpenApiContractDocument, EndpointOpenApiDocumentOptions, EndpointOpenApiEndpointDefinition, EndpointOpenApiMethod, EndpointWordPressAuthDefinition, EndpointWordPressAuthMechanism, JsonSchemaDocument, JsonSchemaProjectionProfile, JsonSchemaObject, NormalizedEndpointAuthDefinition, OpenApiDocument, OpenApiInfo, OpenApiOperation, OpenApiParameter, OpenApiPathItem, OpenApiSecurityScheme, } from "./schema-core.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
+export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
 export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
 export type { CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, } from "./cli-core.js";

package/dist/runtime/index.js

@@ -11,7 +11,7 @@
  * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
  */
 export { COMPOUND_INNER_BLOCKS_PRESET_IDS, DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID, getCompoundInnerBlocksPresetDefinition, isCompoundInnerBlocksPresetId, parseCompoundInnerBlocksPreset, resolveCompoundInnerBlocksPreset, } from "./compound-inner-blocks.js";
-export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
+export { scaffoldProject, collectScaffoldAnswers, getScaffoldTemplateVariableGroups, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { BlockGeneratorService } from "./block-generator-service.js";
 export { BLOCK_GENERATION_TOOL_CONTRACT_VERSION, inspectBlockGeneration, } from "./block-generator-tool-contract.js";
 export { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand, } from "./migrations.js";
@@ -20,4 +20,5 @@ export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJso
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
+export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
 export { createReadlinePrompt, createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/scaffold-bootstrap.js

@@ -7,6 +7,7 @@ import { syncPersistenceRestArtifacts } from "./persistence-rest-artifacts.js";
 import { getPackageVersions } from "./package-versions.js";
 import { getStarterManifestFiles, stringifyStarterManifest } from "./starter-manifests.js";
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, PROJECT_TOOLS_PACKAGE_ROOT, } from "./template-registry.js";
+import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 const EPHEMERAL_NODE_MODULES_LINK_TYPE = process.platform === "win32" ? "junction" : "dir";
 /**
  * Ensures the scaffold target directory exists and is empty unless explicitly allowed.
@@ -71,8 +72,11 @@ export async function writeStarterManifestFiles(targetDir, templateId, variables
  * @returns A promise that resolves after any required persistence artifacts are generated.
  */
 export async function seedBuiltInPersistenceArtifacts(targetDir, templateId, variables) {
+    const compoundGroup = getScaffoldTemplateVariableGroups(variables).compound;
     const needsPersistenceArtifacts = templateId === "persistence" ||
-        (templateId === "compound" && variables.compoundPersistenceEnabled === "true");
+        (templateId === "compound" &&
+            compoundGroup.enabled &&
+            compoundGroup.persistenceEnabled);
     if (!needsPersistenceArtifacts) {
         return;
     }

package/dist/runtime/scaffold-documents.js

@@ -2,6 +2,7 @@ import { getPrimaryDevelopmentScript } from './local-dev-presets.js';
 import { getCompoundExtensionWorkflowSection, getInitialCommitCommands, getInitialCommitNote, getOptionalOnboardingNote, getOptionalOnboardingSteps, getQuickStartWorkflowNote, getPhpRestExtensionPointsSection, getTemplateSourceOfTruthNote, } from './scaffold-onboarding.js';
 import { formatPackageExecCommand, formatInstallCommand, formatRunScript, } from './package-managers.js';
 import { getPackageVersions } from './package-versions.js';
+import { getScaffoldTemplateVariableGroups } from './scaffold-template-variable-groups.js';
 /**
  * Builds the generated README markdown for one scaffolded project.
  *
@@ -12,26 +13,28 @@ import { getPackageVersions } from './package-versions.js';
  * @returns Markdown README content for the generated project root.
  */
 export function buildReadme(templateId, variables, packageManager, { withMigrationUi = false, withTestPreset = false, withWpEnv = false, } = {}) {
+    const variableGroups = getScaffoldTemplateVariableGroups(variables);
+    const compoundPersistenceEnabled = variableGroups.compound.enabled &&
+        variableGroups.compound.persistenceEnabled;
     const optionalOnboardingSteps = getOptionalOnboardingSteps(packageManager, templateId, {
-        compoundPersistenceEnabled: variables.compoundPersistenceEnabled === 'true',
+        compoundPersistenceEnabled,
     });
     const initialCommitCommands = getInitialCommitCommands();
     const sourceOfTruthNote = getTemplateSourceOfTruthNote(templateId, {
-        compoundPersistenceEnabled: variables.compoundPersistenceEnabled === 'true',
+        compoundPersistenceEnabled,
     });
-    const compoundPersistenceEnabled = variables.compoundPersistenceEnabled === 'true';
-    const publicPersistencePolicyNote = variables.isPublicPersistencePolicy === 'true'
+    const publicPersistencePolicyNote = variableGroups.persistence.enabled && variableGroups.persistence.auth.isPublic
         ? '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 alternateRenderTargetSection = variables.hasAlternateRenderTargets === 'true'
+    const alternateRenderTargetSection = variableGroups.alternateRenderTargets.enabled
         ? `## Alternate Render Targets\n\nThis scaffold keeps \`${templateId === 'compound' ? `src/blocks/${variables.slugKebabCase}/render.php` : 'src/render.php'}\` as the default web render boundary and also generates ${[
-            variables.hasAlternateEmailRenderTarget === 'true'
+            variableGroups.alternateRenderTargets.hasEmail
                 ? `\`${templateId === 'compound' ? `src/blocks/${variables.slugKebabCase}/render-email.php` : 'src/render-email.php'}\``
                 : null,
-            variables.hasAlternateMjmlRenderTarget === 'true'
+            variableGroups.alternateRenderTargets.hasMjml
                 ? `\`${templateId === 'compound' ? `src/blocks/${variables.slugKebabCase}/render-mjml.php` : 'src/render-mjml.php'}\``
                 : null,
-            variables.hasAlternatePlainTextRenderTarget === 'true'
+            variableGroups.alternateRenderTargets.hasPlainText
                 ? `\`${templateId === 'compound' ? `src/blocks/${variables.slugKebabCase}/render-text.php` : 'src/render-text.php'}\``
                 : null,
         ]

package/dist/runtime/scaffold-template-variable-groups.d.ts

@@ -0,0 +1,154 @@
+export declare const SCAFFOLD_TEMPLATE_VARIABLE_GROUPS: unique symbol;
+export type ScaffoldTemplateFamily = "basic" | "interactivity" | "persistence" | "compound" | "query-loop" | "external";
+export interface ScaffoldSharedTemplateVariableGroup {
+    author: string;
+    blockMetadataVersion: string;
+    category: string;
+    cssClassName: string;
+    description: string;
+    descriptionJson: string;
+    frontendCssClassName: string;
+    icon: string;
+    keyword: string;
+    namespace: string;
+    pascalCase: string;
+    phpPrefix: string;
+    phpPrefixUpper: string;
+    slug: string;
+    slugCamelCase: string;
+    slugKebabCase: string;
+    slugSnakeCase: string;
+    textDomain: string;
+    title: string;
+    titleCase: string;
+    titleJson: string;
+    versions: {
+        apiClient: string;
+        blockRuntime: string;
+        blockTypes: string;
+        projectTools: string;
+        rest: string;
+    };
+}
+export interface ScaffoldAlternateRenderTargetVariableGroup {
+    csv: string;
+    enabled: boolean;
+    hasEmail: boolean;
+    hasMjml: boolean;
+    hasPlainText: boolean;
+    json: string;
+    targets: readonly string[];
+}
+export interface DisabledScaffoldCompoundVariableGroup {
+    enabled: false;
+    persistenceEnabled: false;
+}
+export interface EnabledScaffoldCompoundVariableGroup {
+    child: {
+        category: string;
+        cssClassName: string;
+        icon: string;
+        title: string;
+        titleJson: string;
+    };
+    enabled: true;
+    innerBlocks: {
+        description: string;
+        directInsert: boolean;
+        label: string;
+        orientation: "" | "horizontal" | "vertical";
+        orientationExpression: string;
+        preset: string;
+        templateLockExpression: string;
+    };
+    persistenceEnabled: boolean;
+}
+export type ScaffoldCompoundVariableGroup = DisabledScaffoldCompoundVariableGroup | EnabledScaffoldCompoundVariableGroup;
+export interface DisabledScaffoldPersistenceVariableGroup {
+    enabled: false;
+    scope: "none";
+}
+export interface EnabledScaffoldPersistenceVariableGroup {
+    auth: {
+        bootstrapCredentialDeclarations: string;
+        descriptionJson: string;
+        intent: "authenticated" | "public-write-protected";
+        isAuthenticated: boolean;
+        isPublic: boolean;
+        mechanism: "public-signed-token" | "rest-nonce";
+        mode: "authenticated-rest-nonce" | "public-signed-token";
+        publicWriteRequestIdDeclaration: string;
+    };
+    dataStorageMode: "custom-table" | "post-meta";
+    enabled: true;
+    policy: "authenticated" | "public";
+    scope: "compound-parent" | "single";
+}
+export type ScaffoldPersistenceVariableGroup = DisabledScaffoldPersistenceVariableGroup | EnabledScaffoldPersistenceVariableGroup;
+export interface DisabledScaffoldQueryLoopVariableGroup {
+    enabled: false;
+}
+export interface EnabledScaffoldQueryLoopVariableGroup {
+    allowedControls: readonly string[];
+    allowedControlsJson: string;
+    enabled: true;
+    postType: string;
+    postTypeJson: string;
+    variationNamespace: string;
+    variationNamespaceJson: string;
+}
+export type ScaffoldQueryLoopVariableGroup = DisabledScaffoldQueryLoopVariableGroup | EnabledScaffoldQueryLoopVariableGroup;
+interface ScaffoldTemplateVariableGroupsBase {
+    alternateRenderTargets: ScaffoldAlternateRenderTargetVariableGroup;
+    shared: ScaffoldSharedTemplateVariableGroup;
+    template: {
+        description: string;
+    };
+}
+type DisabledTemplateFamilyGroups<TFamily extends "basic" | "interactivity" | "external"> = ScaffoldTemplateVariableGroupsBase & {
+    compound: DisabledScaffoldCompoundVariableGroup;
+    persistence: DisabledScaffoldPersistenceVariableGroup;
+    queryLoop: DisabledScaffoldQueryLoopVariableGroup;
+    templateFamily: TFamily;
+};
+export type BasicScaffoldTemplateVariableGroups = DisabledTemplateFamilyGroups<"basic">;
+export type InteractivityScaffoldTemplateVariableGroups = DisabledTemplateFamilyGroups<"interactivity">;
+export interface PersistenceScaffoldTemplateVariableGroups extends ScaffoldTemplateVariableGroupsBase {
+    compound: DisabledScaffoldCompoundVariableGroup;
+    persistence: EnabledScaffoldPersistenceVariableGroup & {
+        scope: "single";
+    };
+    queryLoop: DisabledScaffoldQueryLoopVariableGroup;
+    templateFamily: "persistence";
+}
+export interface CompoundScaffoldTemplateVariableGroups extends ScaffoldTemplateVariableGroupsBase {
+    compound: EnabledScaffoldCompoundVariableGroup;
+    persistence: DisabledScaffoldPersistenceVariableGroup | (EnabledScaffoldPersistenceVariableGroup & {
+        scope: "compound-parent";
+    });
+    queryLoop: DisabledScaffoldQueryLoopVariableGroup;
+    templateFamily: "compound";
+}
+export interface QueryLoopScaffoldTemplateVariableGroups extends ScaffoldTemplateVariableGroupsBase {
+    compound: DisabledScaffoldCompoundVariableGroup;
+    persistence: DisabledScaffoldPersistenceVariableGroup;
+    queryLoop: EnabledScaffoldQueryLoopVariableGroup;
+    templateFamily: "query-loop";
+}
+export type ExternalScaffoldTemplateVariableGroups = DisabledTemplateFamilyGroups<"external">;
+export type ScaffoldTemplateVariableGroups = BasicScaffoldTemplateVariableGroups | InteractivityScaffoldTemplateVariableGroups | PersistenceScaffoldTemplateVariableGroups | CompoundScaffoldTemplateVariableGroups | QueryLoopScaffoldTemplateVariableGroups | ExternalScaffoldTemplateVariableGroups;
+export interface ScaffoldTemplateVariableGroupsCarrier {
+    readonly [SCAFFOLD_TEMPLATE_VARIABLE_GROUPS]: ScaffoldTemplateVariableGroups;
+}
+export type CompoundScaffoldTemplateVariablesLike = ScaffoldTemplateVariableGroupsCarrier & {
+    slugKebabCase: string;
+};
+export type PersistenceScaffoldTemplateVariablesLike = ScaffoldTemplateVariableGroupsCarrier & {
+    namespace: string;
+    pascalCase: string;
+    slugKebabCase: string;
+    title: string;
+};
+export declare function attachScaffoldTemplateVariableGroups<TVariables extends Record<string, string>>(variables: TVariables, groups: ScaffoldTemplateVariableGroups): TVariables & ScaffoldTemplateVariableGroupsCarrier;
+export declare function getScaffoldTemplateVariableGroups(variables: ScaffoldTemplateVariableGroupsCarrier): ScaffoldTemplateVariableGroups;
+export {};

package/dist/runtime/scaffold-template-variable-groups.js

@@ -0,0 +1,13 @@
+export const SCAFFOLD_TEMPLATE_VARIABLE_GROUPS = Symbol("wp-typia.scaffold-template-variable-groups");
+export function attachScaffoldTemplateVariableGroups(variables, groups) {
+    Object.defineProperty(variables, SCAFFOLD_TEMPLATE_VARIABLE_GROUPS, {
+        configurable: false,
+        enumerable: false,
+        value: groups,
+        writable: false,
+    });
+    return variables;
+}
+export function getScaffoldTemplateVariableGroups(variables) {
+    return variables[SCAFFOLD_TEMPLATE_VARIABLE_GROUPS];
+}

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

@@ -5,6 +5,7 @@ import { BUILTIN_BLOCK_METADATA_VERSION, COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS,
 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';
+import { attachScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 /**
  * Build the normalized template variables used by scaffold rendering.
  *
@@ -57,7 +58,7 @@ export function getTemplateVariables(templateId, answers) {
     const persistencePolicy = templateId === 'persistence' || compoundPersistenceEnabled
         ? answers.persistencePolicy ?? 'authenticated'
         : 'authenticated';
-    return {
+    const flatVariables = {
         alternateRenderTargetsCsv: '',
         alternateRenderTargetsJson: '[]',
         apiClientPackageVersion,
@@ -136,4 +137,60 @@ export function getTemplateVariables(templateId, answers) {
         titleCase: pascalCase,
         persistencePolicy,
     };
+    return attachScaffoldTemplateVariableGroups(flatVariables, {
+        alternateRenderTargets: {
+            csv: '',
+            enabled: false,
+            hasEmail: false,
+            hasMjml: false,
+            hasPlainText: false,
+            json: '[]',
+            targets: [],
+        },
+        compound: {
+            enabled: false,
+            persistenceEnabled: false,
+        },
+        persistence: {
+            enabled: false,
+            scope: 'none',
+        },
+        queryLoop: {
+            enabled: false,
+        },
+        shared: {
+            author: answers.author.trim(),
+            blockMetadataVersion: BUILTIN_BLOCK_METADATA_VERSION,
+            category: metadataDefaults?.category ?? template?.defaultCategory ?? 'widgets',
+            cssClassName,
+            description,
+            descriptionJson: JSON.stringify(description),
+            frontendCssClassName: buildFrontendCssClassName(cssClassName),
+            icon: metadataDefaults?.icon ?? 'smiley',
+            keyword: slug.replace(/-/g, ' '),
+            namespace,
+            pascalCase,
+            phpPrefix,
+            phpPrefixUpper,
+            slug,
+            slugCamelCase: pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1),
+            slugKebabCase: slug,
+            slugSnakeCase,
+            textDomain,
+            title,
+            titleCase: pascalCase,
+            titleJson: JSON.stringify(title),
+            versions: {
+                apiClient: apiClientPackageVersion,
+                blockRuntime: blockRuntimePackageVersion,
+                blockTypes: blockTypesPackageVersion,
+                projectTools: projectToolsPackageVersion,
+                rest: restPackageVersion,
+            },
+        },
+        template: {
+            description: template?.description ?? 'External scaffold template variables',
+        },
+        templateFamily: 'external',
+    });
 }

package/dist/runtime/scaffold.d.ts

@@ -1,4 +1,5 @@
 import type { PackageManagerId } from "./package-managers.js";
+import type { ScaffoldTemplateVariableGroupsCarrier } from "./scaffold-template-variable-groups.js";
 /**
  * User-facing scaffold answers before template rendering.
  *
@@ -29,7 +30,7 @@ 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> {
+export interface FlatScaffoldTemplateVariables extends Record<string, string> {
     alternateRenderTargetsCsv: string;
     alternateRenderTargetsJson: string;
     apiClientPackageVersion: string;
@@ -94,6 +95,8 @@ export interface ScaffoldTemplateVariables extends Record<string, string> {
     titleCase: string;
     persistencePolicy: PersistencePolicy;
 }
+export interface ScaffoldTemplateVariables extends FlatScaffoldTemplateVariables, ScaffoldTemplateVariableGroupsCarrier {
+}
 /**
  * Resolve scaffold template input from either built-in template ids or custom
  * template identifiers such as local paths, GitHub refs, and npm packages.
@@ -176,6 +179,7 @@ export interface ScaffoldProjectResult {
 export { buildBlockCssClassName } from "./scaffold-identifiers.js";
 export { collectScaffoldAnswers, detectAuthor, getDefaultAnswers, resolvePackageManagerId, resolveTemplateId, } from "./scaffold-answer-resolution.js";
 export { getTemplateVariables } from "./scaffold-template-variables.js";
+export { getScaffoldTemplateVariableGroups, type BasicScaffoldTemplateVariableGroups, type CompoundScaffoldTemplateVariableGroups, type ExternalScaffoldTemplateVariableGroups, type InteractivityScaffoldTemplateVariableGroups, type PersistenceScaffoldTemplateVariableGroups, type QueryLoopScaffoldTemplateVariableGroups, type ScaffoldTemplateFamily, type ScaffoldTemplateVariableGroups, type ScaffoldTemplateVariableGroupsCarrier, } from "./scaffold-template-variable-groups.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, 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

@@ -12,6 +12,7 @@ import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from "./tem
 import { resolveTemplateSource } from "./template-source.js";
 import { BlockGeneratorService, } from "./block-generator-service.js";
 import { getTemplateVariables } from "./scaffold-template-variables.js";
+import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 import { assertExternalLayerCompositionOptions, } from "./cli-validation.js";
 const WORKSPACE_TEMPLATE_ALIAS = "workspace";
 export const DATA_STORAGE_MODES = ["post-meta", "custom-table"];
@@ -19,6 +20,7 @@ export const PERSISTENCE_POLICIES = ["authenticated", "public"];
 export { buildBlockCssClassName } from "./scaffold-identifiers.js";
 export { collectScaffoldAnswers, detectAuthor, getDefaultAnswers, resolvePackageManagerId, resolveTemplateId, } from "./scaffold-answer-resolution.js";
 export { getTemplateVariables } from "./scaffold-template-variables.js";
+export { getScaffoldTemplateVariableGroups, } from "./scaffold-template-variable-groups.js";
 export function isDataStorageMode(value) {
     return DATA_STORAGE_MODES.includes(value);
 }
@@ -164,8 +166,10 @@ export async function scaffoldProject({ projectDir, templateId, answers, alterna
     await fsp.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
     await normalizePackageJson(projectDir, resolvedPackageManager);
     if (isBuiltInTemplate) {
+        const variableGroups = getScaffoldTemplateVariableGroups(variables);
         await applyGeneratedProjectDxPackageJson({
-            compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true",
+            compoundPersistenceEnabled: variableGroups.compound.enabled &&
+                variableGroups.compound.persistenceEnabled,
             packageManager: resolvedPackageManager,
             projectDir,
             templateId: resolvedTemplateId,