@wp-typia/project-tools 0.19.0 → 0.19.1

package/dist/runtime/block-generator-service-spec.js

@@ -5,6 +5,7 @@ import { DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID, getCompoundInnerBlocksPresetDe
 import { getTemplateById, } from "./template-registry.js";
 import { toPascalCase, toSnakeCase, } from "./string-case.js";
 import { buildBlockCssClassName, buildFrontendCssClassName, resolveScaffoldIdentifiers, } from "./scaffold-identifiers.js";
+import { attachScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 function getBuiltInPersistenceSpec({ templateId, dataStorageMode, persistencePolicy, }) {
     if (templateId === "persistence") {
         return {
@@ -114,13 +115,14 @@ export function buildTemplateVariablesFromBlockSpec(spec) {
     const compoundChildCssClassName = buildBlockCssClassName(namespace, `${slug}-item`);
     const compoundInnerBlocksPreset = spec.compound.innerBlocksPreset;
     const compoundInnerBlocksPresetDefinition = getCompoundInnerBlocksPresetDefinition(compoundInnerBlocksPreset);
+    const compoundInnerBlocksOrientation = compoundInnerBlocksPresetDefinition.orientation ?? "";
     const persistenceEnabled = spec.persistence.enabled;
     const dataStorageMode = persistenceEnabled ? spec.persistence.dataStorageMode : "custom-table";
     const persistencePolicy = persistenceEnabled
         ? spec.persistence.persistencePolicy
         : "authenticated";
     const queryVariationNamespace = `${namespace}/${slug}`;
-    return {
+    const flatVariables = {
         alternateRenderTargetsCsv: formatAlternateRenderTargets(alternateRenderTargets),
         alternateRenderTargetsJson: JSON.stringify(alternateRenderTargets),
         apiClientPackageVersion,
@@ -137,7 +139,7 @@ export function buildTemplateVariablesFromBlockSpec(spec) {
         compoundChildTitleJson: JSON.stringify(compoundChildTitle),
         compoundPersistenceEnabled: spec.template.family === "compound" && persistenceEnabled ? "true" : "false",
         compoundInnerBlocksDirectInsert: compoundInnerBlocksPresetDefinition.directInsert ? "true" : "false",
-        compoundInnerBlocksOrientation: compoundInnerBlocksPresetDefinition.orientation ?? "",
+        compoundInnerBlocksOrientation: compoundInnerBlocksOrientation,
         compoundInnerBlocksOrientationExpression: compoundInnerBlocksPresetDefinition.orientation
             ? `'${compoundInnerBlocksPresetDefinition.orientation}'`
             : "undefined",
@@ -205,4 +207,206 @@ export function buildTemplateVariablesFromBlockSpec(spec) {
         titleCase: pascalCase,
         persistencePolicy,
     };
+    const shared = {
+        author: spec.project.author,
+        blockMetadataVersion: BUILTIN_BLOCK_METADATA_VERSION,
+        category: spec.metadata.category,
+        cssClassName,
+        description: spec.metadata.description,
+        descriptionJson: flatVariables.descriptionJson,
+        frontendCssClassName: flatVariables.frontendCssClassName,
+        icon: spec.metadata.icon,
+        keyword: spec.metadata.keyword,
+        namespace,
+        pascalCase,
+        phpPrefix,
+        phpPrefixUpper,
+        slug,
+        slugCamelCase: flatVariables.slugCamelCase,
+        slugKebabCase: slug,
+        slugSnakeCase,
+        textDomain,
+        title,
+        titleCase: pascalCase,
+        titleJson: flatVariables.titleJson,
+        versions: {
+            apiClient: apiClientPackageVersion,
+            blockRuntime: blockRuntimePackageVersion,
+            blockTypes: blockTypesPackageVersion,
+            projectTools: projectToolsPackageVersion,
+            rest: restPackageVersion,
+        },
+    };
+    const alternateRenderTargetsGroup = {
+        csv: flatVariables.alternateRenderTargetsCsv,
+        enabled: alternateRenderTargets.length > 0,
+        hasEmail: hasAlternateEmailRenderTarget,
+        hasMjml: hasAlternateMjmlRenderTarget,
+        hasPlainText: hasAlternatePlainTextRenderTarget,
+        json: flatVariables.alternateRenderTargetsJson,
+        targets: alternateRenderTargets,
+    };
+    const compoundGroup = {
+        child: {
+            category: COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS.category,
+            cssClassName: compoundChildCssClassName,
+            icon: COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS.icon,
+            title: compoundChildTitle,
+            titleJson: JSON.stringify(compoundChildTitle),
+        },
+        enabled: true,
+        innerBlocks: {
+            description: compoundInnerBlocksPresetDefinition.description,
+            directInsert: compoundInnerBlocksPresetDefinition.directInsert,
+            label: compoundInnerBlocksPresetDefinition.label,
+            orientation: compoundInnerBlocksOrientation,
+            orientationExpression: compoundInnerBlocksPresetDefinition.orientation
+                ? `'${compoundInnerBlocksPresetDefinition.orientation}'`
+                : "undefined",
+            preset: compoundInnerBlocksPreset,
+            templateLockExpression: compoundInnerBlocksPresetDefinition.templateLock === false
+                ? "false"
+                : `'${compoundInnerBlocksPresetDefinition.templateLock}'`,
+        },
+        persistenceEnabled: persistenceEnabled,
+    };
+    const persistenceGroup = persistenceEnabled
+        ? {
+            auth: {
+                bootstrapCredentialDeclarations: flatVariables.bootstrapCredentialDeclarations,
+                descriptionJson: flatVariables.persistencePolicyDescriptionJson,
+                intent: flatVariables.restWriteAuthIntent,
+                isAuthenticated: persistencePolicy === "authenticated",
+                isPublic: persistencePolicy === "public",
+                mechanism: flatVariables.restWriteAuthMechanism,
+                mode: flatVariables.restWriteAuthMode,
+                publicWriteRequestIdDeclaration: flatVariables.publicWriteRequestIdDeclaration,
+            },
+            dataStorageMode,
+            enabled: true,
+            policy: persistencePolicy,
+            scope: spec.persistence.scope,
+        }
+        : null;
+    const queryLoopGroup = {
+        allowedControls: spec.queryLoop.allowedControls,
+        allowedControlsJson: flatVariables.queryAllowedControlsJson,
+        enabled: true,
+        postType: spec.queryLoop.postType,
+        postTypeJson: flatVariables.queryPostTypeJson,
+        variationNamespace: queryVariationNamespace,
+        variationNamespaceJson: flatVariables.queryVariationNamespaceJson,
+    };
+    switch (spec.template.family) {
+        case "basic":
+            return attachScaffoldTemplateVariableGroups(flatVariables, {
+                alternateRenderTargets: alternateRenderTargetsGroup,
+                compound: {
+                    enabled: false,
+                    persistenceEnabled: false,
+                },
+                persistence: {
+                    enabled: false,
+                    scope: "none",
+                },
+                queryLoop: {
+                    enabled: false,
+                },
+                shared,
+                template: {
+                    description: spec.template.description,
+                },
+                templateFamily: "basic",
+            });
+        case "interactivity":
+            return attachScaffoldTemplateVariableGroups(flatVariables, {
+                alternateRenderTargets: alternateRenderTargetsGroup,
+                compound: {
+                    enabled: false,
+                    persistenceEnabled: false,
+                },
+                persistence: {
+                    enabled: false,
+                    scope: "none",
+                },
+                queryLoop: {
+                    enabled: false,
+                },
+                shared,
+                template: {
+                    description: spec.template.description,
+                },
+                templateFamily: "interactivity",
+            });
+        case "persistence": {
+            if (persistenceGroup === null) {
+                throw new Error("Persistence scaffolds must provide persistence template variables.");
+            }
+            return attachScaffoldTemplateVariableGroups(flatVariables, {
+                alternateRenderTargets: alternateRenderTargetsGroup,
+                compound: {
+                    enabled: false,
+                    persistenceEnabled: false,
+                },
+                persistence: {
+                    ...persistenceGroup,
+                    scope: "single",
+                },
+                queryLoop: {
+                    enabled: false,
+                },
+                shared,
+                template: {
+                    description: spec.template.description,
+                },
+                templateFamily: "persistence",
+            });
+        }
+        case "compound": {
+            const compoundPersistenceGroup = persistenceGroup === null
+                ? {
+                    enabled: false,
+                    scope: "none",
+                }
+                : {
+                    ...persistenceGroup,
+                    scope: "compound-parent",
+                };
+            return attachScaffoldTemplateVariableGroups(flatVariables, {
+                alternateRenderTargets: alternateRenderTargetsGroup,
+                compound: compoundGroup,
+                persistence: compoundPersistenceGroup,
+                queryLoop: {
+                    enabled: false,
+                },
+                shared,
+                template: {
+                    description: spec.template.description,
+                },
+                templateFamily: "compound",
+            });
+        }
+        case "query-loop":
+            return attachScaffoldTemplateVariableGroups(flatVariables, {
+                alternateRenderTargets: alternateRenderTargetsGroup,
+                compound: {
+                    enabled: false,
+                    persistenceEnabled: false,
+                },
+                persistence: {
+                    enabled: false,
+                    scope: "none",
+                },
+                queryLoop: queryLoopGroup,
+                shared,
+                template: {
+                    description: spec.template.description,
+                },
+                templateFamily: "query-loop",
+            });
+        default: {
+            const unreachableTemplateFamily = spec.template.family;
+            throw new Error(`Unhandled scaffold template family: ${unreachableTemplateFamily}`);
+        }
+    }
 }

package/dist/runtime/built-in-block-artifacts.js

@@ -1,5 +1,6 @@
 import { buildBasicAttributes, buildBlockJsonAttributes, buildCompoundChildAttributes, buildCompoundParentAttributes, buildInteractivityAttributes, buildManifestDocument, buildPersistenceAttributes, DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, } from "./built-in-block-artifact-documents.js";
 import { buildBasicTypesSource, buildCompoundChildTypesSource, buildCompoundTypesSource, buildInteractivityTypesSource, buildPersistenceTypesSource, } from "./built-in-block-artifact-types.js";
+import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 function stringifyBlockJsonDocument(document) {
     return `${JSON.stringify(document, null, "\t")}\n`;
 }
@@ -103,7 +104,8 @@ function buildPersistenceArtifact(variables) {
 }
 function buildCompoundParentArtifact(variables) {
     const attributes = buildCompoundParentAttributes(variables);
-    const persistenceEnabled = variables.compoundPersistenceEnabled === "true";
+    const compoundGroup = getScaffoldTemplateVariableGroups(variables).compound;
+    const persistenceEnabled = compoundGroup.enabled && compoundGroup.persistenceEnabled;
     return {
         blockJsonDocument: {
             $schema: "https://schemas.wp.org/trunk/block.json",

package/dist/runtime/built-in-block-code-artifacts.js

@@ -1,5 +1,6 @@
 import { buildBuiltInNonTsArtifacts } from "./built-in-block-non-ts-artifacts.js";
 import { BASIC_EDIT_TEMPLATE, BASIC_INDEX_TEMPLATE, BASIC_SAVE_TEMPLATE, BASIC_VALIDATORS_TEMPLATE, BLOCK_METADATA_WRAPPER_TEMPLATE, COMPOUND_CHILD_EDIT_TEMPLATE, COMPOUND_CHILD_INDEX_TEMPLATE, COMPOUND_CHILD_SAVE_TEMPLATE, COMPOUND_CHILD_VALIDATORS_TEMPLATE, COMPOUND_CHILDREN_TEMPLATE, COMPOUND_LOCAL_HOOKS_TEMPLATE, COMPOUND_PARENT_EDIT_TEMPLATE, COMPOUND_PARENT_INDEX_TEMPLATE, COMPOUND_PARENT_SAVE_TEMPLATE, COMPOUND_PARENT_VALIDATORS_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_EDIT_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_INTERACTIVITY_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_SAVE_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_VALIDATORS_TEMPLATE, INTERACTIVITY_EDIT_TEMPLATE, INTERACTIVITY_INDEX_TEMPLATE, INTERACTIVITY_SAVE_TEMPLATE, INTERACTIVITY_SCRIPT_TEMPLATE, INTERACTIVITY_VALIDATORS_TEMPLATE, MANIFEST_DEFAULTS_DOCUMENT_WRAPPER_TEMPLATE, MANIFEST_DOCUMENT_WRAPPER_TEMPLATE, PERSISTENCE_EDIT_TEMPLATE, PERSISTENCE_INDEX_TEMPLATE, PERSISTENCE_INTERACTIVITY_TEMPLATE, PERSISTENCE_SAVE_TEMPLATE, PERSISTENCE_VALIDATORS_TEMPLATE, QUERY_LOOP_INDEX_TEMPLATE, SHARED_HOOKS_TEMPLATE, } from "./built-in-block-code-templates.js";
+import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 import { renderMustacheTemplateString } from "./template-render.js";
 function renderCodeTemplate(template, variables) {
     const rendered = renderMustacheTemplateString(template, variables);
@@ -98,7 +99,8 @@ function buildInteractivityCodeArtifacts(variables) {
 function buildCompoundCodeArtifacts(variables) {
     const parentBasePath = `src/blocks/${variables.slugKebabCase}`;
     const childBasePath = `src/blocks/${variables.slugKebabCase}-item`;
-    const compoundPersistenceEnabled = variables.compoundPersistenceEnabled === "true";
+    const compoundGroup = getScaffoldTemplateVariableGroups(variables).compound;
+    const compoundPersistenceEnabled = compoundGroup.enabled && compoundGroup.persistenceEnabled;
     return ensureUniqueArtifactPaths([
         createCodeArtifact("src/hooks.ts", SHARED_HOOKS_TEMPLATE, variables),
         ...createTypedJsonWrapperArtifacts(parentBasePath, variables),

package/dist/runtime/cli-add-block.js

@@ -1,6 +1,5 @@
 import fs from "node:fs";
 import { promises as fsp } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { syncBlockMetadata, } from "@wp-typia/block-runtime/metadata-core";
 import { ensureMigrationDirectories, parseMigrationConfig, writeInitialMigrationScaffold, writeMigrationConfig, } from "./migration-project.js";
@@ -9,6 +8,7 @@ import { snapshotProjectVersion } from "./migrations.js";
 import { getDefaultAnswers, scaffoldProject } from "./scaffold.js";
 import { copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, } from "./template-render.js";
 import { appendWorkspaceInventoryEntries, } from "./workspace-inventory.js";
+import { createManagedTempRoot } from "./temp-roots.js";
 import { resolveWorkspaceProject, } from "./workspace-project.js";
 import { ADD_BLOCK_TEMPLATE_IDS, buildWorkspacePhpPrefix, isAddBlockTemplateId, patchFile, readOptionalFile, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
 import { resolveNonEmptyNormalizedBlockSlug, } from "./scaffold-identifiers.js";
@@ -310,6 +310,7 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
         selectExternalLayerId,
     });
     let tempRoot = "";
+    let cleanupTempRoot;
     try {
         const normalizedSlug = resolveNonEmptyNormalizedBlockSlug({
             input: blockName,
@@ -317,7 +318,10 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
             usage: "wp-typia add block <name> --template <family>",
         });
         const defaults = getDefaultAnswers(normalizedSlug, resolvedTemplateId);
-        tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "wp-typia-add-block-"));
+        ({
+            path: tempRoot,
+            cleanup: cleanupTempRoot,
+        } = await createManagedTempRoot("wp-typia-add-block-"));
         const tempProjectDir = path.join(tempRoot, normalizedSlug);
         const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
         const migrationConfigPath = path.join(workspace.projectDir, "src", "migrations", "config.ts");
@@ -397,9 +401,11 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
         }
     }
     finally {
-        await resolvedExternalLayerSelection.cleanup?.();
-        if (tempRoot) {
-            await fsp.rm(tempRoot, { force: true, recursive: true });
+        try {
+            await resolvedExternalLayerSelection.cleanup?.();
+        }
+        finally {
+            await cleanupTempRoot?.();
         }
     }
 }

package/dist/runtime/cli-diagnostics.d.ts

@@ -2,10 +2,24 @@
  * Shared human-readable diagnostics for non-interactive `wp-typia` CLI flows.
  */
 export interface CliDiagnosticMessage {
+    code: CliDiagnosticCode;
     command: string;
     detailLines: string[];
     summary: string;
 }
+export declare const CLI_DIAGNOSTIC_CODES: {
+    readonly COMMAND_EXECUTION: "command-execution";
+    readonly CONFIGURATION_MISSING: "configuration-missing";
+    readonly DEPENDENCIES_NOT_INSTALLED: "dependencies-not-installed";
+    readonly DOCTOR_CHECK_FAILED: "doctor-check-failed";
+    readonly INVALID_ARGUMENT: "invalid-argument";
+    readonly INVALID_COMMAND: "invalid-command";
+    readonly MISSING_ARGUMENT: "missing-argument";
+    readonly MISSING_BUILD_ARTIFACT: "missing-build-artifact";
+    readonly OUTSIDE_PROJECT_ROOT: "outside-project-root";
+    readonly UNSUPPORTED_COMMAND: "unsupported-command";
+};
+export type CliDiagnosticCode = (typeof CLI_DIAGNOSTIC_CODES)[keyof typeof CLI_DIAGNOSTIC_CODES];
 type DoctorCheckLike = {
     detail: string;
     label: string;
@@ -15,6 +29,7 @@ type DoctorCheckLike = {
  * Structured CLI failure carrying a stable summary/detail layout.
  */
 export declare class CliDiagnosticError extends Error {
+    readonly code: CliDiagnosticCode;
     readonly command: string;
     readonly detailLines: string[];
     readonly summary: string;
@@ -29,6 +44,7 @@ export declare function isCliDiagnosticError(error: unknown): error is CliDiagno
  */
 export declare function createCliCommandError(options: {
     command: string;
+    code?: CliDiagnosticCode;
     detailLines?: string[];
     error?: unknown;
     summary?: string;
@@ -38,6 +54,16 @@ export declare function createCliCommandError(options: {
  * plain message so existing non-command failures keep working.
  */
 export declare function formatCliDiagnosticError(error: unknown): string;
+export declare function serializeCliDiagnosticError(error: unknown): {
+    code: CliDiagnosticCode;
+    command?: string;
+    detailLines?: string[];
+    kind: "command-execution";
+    message: string;
+    name: string;
+    summary?: string;
+    tag: "CommandExecutionError";
+};
 /**
  * Format one human-readable doctor check row.
  */

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;
     }