@wp-typia/project-tools 0.18.0 → 0.19.1

package/dist/runtime/cli-scaffold.js

@@ -1,14 +1,17 @@
 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";
 import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
+import { assertBuiltInTemplateVariantAllowed, resolveLocalCliPathOption, normalizeOptionalCliString, } from "./cli-validation.js";
 async function listRelativeProjectFiles(rootDir) {
     const relativeFiles = [];
     async function visit(currentDir) {
@@ -36,13 +39,14 @@ async function assertDryRunTargetDirectoryReady(projectDir, allowExistingDir) {
         throw new Error(formatNonEmptyTargetDirectoryError(projectDir));
     }
 }
-async function buildScaffoldDryRunPlan({ allowExistingDir, answers, cwd, dataStorageMode, externalLayerId, externalLayerSource, externalLayerSourceLabel, installDependencies, noInstall, onProgress, packageManager, persistencePolicy, projectDir, templateId, variant, withMigrationUi, withTestPreset, withWpEnv, }) {
+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({
             allowExistingDir: false,
+            alternateRenderTargets,
             answers,
             cwd,
             dataStorageMode,
@@ -71,7 +75,7 @@ async function buildScaffoldDryRunPlan({ allowExistingDir, answers, cwd, dataSto
         };
     }
     finally {
-        await fsp.rm(tempRoot, { force: true, recursive: true });
+        await cleanup();
     }
 }
 function validateCreateProjectInput(projectInput) {
@@ -109,14 +113,74 @@ function templateUsesPersistenceSettings(templateId, options) {
 function templateSupportsPersistenceFlags(templateId) {
     return templateId === "persistence" || templateId === "compound";
 }
+function templateSupportsCompoundInnerBlocksPreset(templateId) {
+    return templateId === "compound";
+}
+function createTemplateLabel(templateId) {
+    return templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE
+        ? "`--template workspace`"
+        : `"${templateId}"`;
+}
+function collectTemplateCapabilityWarnings(options) {
+    const warnings = [];
+    const trimmedQueryPostType = options.queryPostType?.trim();
+    if (trimmedQueryPostType &&
+        options.templateId !== "query-loop" &&
+        (isBuiltInTemplateId(options.templateId) ||
+            options.templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE)) {
+        warnings.push(`\`--query-post-type\` only applies to \`wp-typia create --template query-loop\`, which scaffolds a create-time \`core/query\` variation instead of a standalone block. ${createTemplateLabel(options.templateId)} will ignore "${trimmedQueryPostType}".`);
+    }
+    if (options.withMigrationUi === true &&
+        !isBuiltInTemplateId(options.templateId) &&
+        options.templateId !== OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
+        warnings.push(`\`--with-migration-ui\` was ignored for ${createTemplateLabel(options.templateId)}. Migration UI currently scaffolds built-in templates and the official \`--template workspace\` flow; external templates still need to opt into that surface explicitly.`);
+    }
+    return warnings;
+}
+function templateSupportsAlternateRenderTargets(options) {
+    if (!options.alternateRenderTargets) {
+        return false;
+    }
+    if (options.templateId === "persistence") {
+        return true;
+    }
+    if (options.templateId !== "compound") {
+        return false;
+    }
+    return templateUsesPersistenceSettings(options.templateId, {
+        dataStorageMode: options.dataStorageMode,
+        persistencePolicy: options.persistencePolicy,
+    });
+}
 function validateCreateFlagContract(options) {
-    const { dataStorageMode, persistencePolicy, templateId, variant } = options;
+    const { alternateRenderTargets, dataStorageMode, innerBlocksPreset, persistencePolicy, templateId, variant, } = options;
     if ((dataStorageMode || persistencePolicy) &&
         !templateSupportsPersistenceFlags(templateId)) {
         throw new Error("`--data-storage` and `--persistence-policy` are supported only for `wp-typia create --template persistence` or `--template compound`.");
     }
-    if (variant && isBuiltInTemplateId(templateId)) {
-        throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for built-in template "${templateId}".`);
+    if (alternateRenderTargets &&
+        !templateSupportsAlternateRenderTargets({
+            alternateRenderTargets,
+            dataStorageMode,
+            persistencePolicy,
+            templateId,
+        })) {
+        if (templateId === "compound") {
+            throw new Error("`--alternate-render-targets` on `wp-typia create --template compound` requires the persistence-enabled server render path. Add `--data-storage <post-meta|custom-table>` or `--persistence-policy <authenticated|public>` first.");
+        }
+        throw new Error("`--alternate-render-targets` is supported only for `wp-typia create --template persistence` or persistence-enabled `--template compound` scaffolds.");
+    }
+    parseAlternateRenderTargets(alternateRenderTargets);
+    if (innerBlocksPreset &&
+        !templateSupportsCompoundInnerBlocksPreset(templateId)) {
+        throw new Error("`--inner-blocks-preset` is supported only for `wp-typia create --template compound`.");
+    }
+    parseCompoundInnerBlocksPreset(innerBlocksPreset);
+    if (isBuiltInTemplateId(templateId)) {
+        assertBuiltInTemplateVariantAllowed({
+            templateId,
+            variant,
+        });
     }
 }
 function parseSelectableValue(label, value, isValue, allowedValues) {
@@ -203,14 +267,13 @@ export function getOptionalOnboarding({ availableScripts, packageManager, templa
  * project.
  * @returns The scaffold result together with next-step guidance.
  */
-export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templateId, dataStorageMode, dryRun = false, externalLayerId, externalLayerSource, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, queryPostType, yes = false, noInstall = false, onProgress, isInteractive = false, allowExistingDir = false, selectTemplate, selectDataStorage, selectExternalLayerId, selectPersistencePolicy, selectPackageManager, promptText, installDependencies = undefined, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }) {
-    const normalizedExternalLayerId = typeof externalLayerId === "string" && externalLayerId.trim().length > 0
-        ? externalLayerId.trim()
-        : undefined;
-    const normalizedExternalLayerSource = typeof externalLayerSource === "string" &&
-        externalLayerSource.trim().length > 0
-        ? externalLayerSource.trim()
-        : undefined;
+export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templateId, alternateRenderTargets, dataStorageMode, dryRun = false, externalLayerId, externalLayerSource, innerBlocksPreset, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, queryPostType, yes = false, noInstall = false, onProgress, isInteractive = false, allowExistingDir = false, selectTemplate, selectDataStorage, selectExternalLayerId, selectPersistencePolicy, selectPackageManager, promptText, installDependencies = undefined, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }) {
+    const normalizedExternalLayerId = normalizeOptionalCliString(externalLayerId);
+    const normalizedExternalLayerSource = resolveLocalCliPathOption({
+        cwd,
+        label: "--external-layer-source",
+        value: externalLayerSource,
+    });
     validateCreateProjectInput(projectInput);
     const resolvedTemplateId = await resolveTemplateId({
         templateId,
@@ -219,11 +282,14 @@ export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templ
         selectTemplate,
     });
     validateCreateFlagContract({
+        alternateRenderTargets,
         dataStorageMode,
+        innerBlocksPreset,
         persistencePolicy,
         templateId: resolvedTemplateId,
         variant,
     });
+    const resolvedInnerBlocksPreset = parseCompoundInnerBlocksPreset(innerBlocksPreset);
     const resolvedExternalLayerSelection = isBuiltInTemplateId(resolvedTemplateId) && isInteractive
         ? await resolveOptionalInteractiveExternalLayerId({
             callerCwd: cwd,
@@ -302,9 +368,13 @@ export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templ
             yes,
             promptText,
         });
+        if (resolvedTemplateId === "compound" && resolvedInnerBlocksPreset) {
+            answers.compoundInnerBlocksPreset = resolvedInnerBlocksPreset;
+        }
         const resolvedResult = dryRun
             ? await buildScaffoldDryRunPlan({
                 allowExistingDir,
+                alternateRenderTargets,
                 answers,
                 cwd,
                 dataStorageMode: resolvedDataStorage,
@@ -326,6 +396,7 @@ export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templ
             : {
                 plan: undefined,
                 result: await scaffoldProject({
+                    alternateRenderTargets,
                     answers,
                     allowExistingDir,
                     cwd,
@@ -386,6 +457,11 @@ export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templ
                 ...resolvedResult.result,
                 warnings: [
                     ...resolvedResult.result.warnings,
+                    ...collectTemplateCapabilityWarnings({
+                        queryPostType,
+                        templateId: resolvedTemplateId,
+                        withMigrationUi,
+                    }),
                     ...collectProjectDirectoryWarnings(projectDir),
                 ],
             },

package/dist/runtime/cli-templates.js

@@ -21,6 +21,10 @@ export function formatTemplateFeatures(template) {
     if (capabilityHints.length > 0) {
         lines.push(`  Supports: ${capabilityHints.join(" • ")}`);
     }
+    const specialNotes = getTemplateSpecialNotes(template);
+    if (specialNotes.length > 0) {
+        lines.push(`  Notes: ${specialNotes.join(" • ")}`);
+    }
     if (template.id === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
         lines.push(`  Alias: ${WORKSPACE_TEMPLATE_ALIAS} (\`--template ${WORKSPACE_TEMPLATE_ALIAS}\`)`);
     }
@@ -51,6 +55,13 @@ export function formatTemplateDetails(template) {
             detailLines.push(`  - ${capabilityHint}`);
         }
     }
+    const specialNotes = getTemplateSpecialNotes(template);
+    if (specialNotes.length > 0) {
+        detailLines.push("Notes:");
+        for (const specialNote of specialNotes) {
+            detailLines.push(`  - ${specialNote}`);
+        }
+    }
     detailLines.push("Logical layers:");
     for (const logicalLayer of getTemplateLogicalLayerSummaries(template)) {
         detailLines.push(`  - ${logicalLayer}`);
@@ -60,7 +71,12 @@ export function formatTemplateDetails(template) {
 }
 function getTemplateCapabilityHints(template) {
     if (template.id === "persistence" || template.id === "compound") {
-        return ["--data-storage", "--persistence-policy", "external layers"];
+        return [
+            "--alternate-render-targets",
+            "--data-storage",
+            "--persistence-policy",
+            "external layers",
+        ];
     }
     if (template.id === "query-loop") {
         return ["--query-post-type", "external layers"];
@@ -70,6 +86,15 @@ function getTemplateCapabilityHints(template) {
     }
     return [];
 }
+function getTemplateSpecialNotes(template) {
+    if (template.id === "query-loop") {
+        return [
+            "Create-time variation scaffold only; use `wp-typia create <project-dir> --template query-loop` instead of `wp-typia add block`.",
+            "Owns a `core/query` variation, so it does not generate `src/types.ts`, `block.json`, or Typia manifests.",
+        ];
+    }
+    return [];
+}
 function getTemplateIdentityLines(template) {
     if (template.id === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
         return [

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

@@ -0,0 +1,66 @@
+/**
+ * Normalize one optional CLI string flag by trimming whitespace and collapsing
+ * empty strings to `undefined`.
+ *
+ * @param value Raw CLI value before normalization.
+ * @returns The trimmed string when present, otherwise `undefined`.
+ */
+export declare function normalizeOptionalCliString(value?: string): string | undefined;
+/**
+ * Resolve one CLI path flag relative to the caller when it is expressed as a
+ * local filesystem path.
+ *
+ * Non-local values such as npm package specs or `github:` locators pass
+ * through unchanged. Local relative and absolute paths are resolved against the
+ * provided `cwd` and must exist on disk.
+ *
+ * @param options Path resolution inputs for one CLI flag.
+ * @param options.cwd Caller working directory used for relative path
+ * resolution.
+ * @param options.label Human-readable option label used in thrown errors.
+ * @param options.value Raw CLI value before trimming and path resolution.
+ * @returns The normalized string, or `undefined` when the option was omitted.
+ * @throws When a local-looking path resolves to a missing filesystem entry.
+ */
+export declare function resolveLocalCliPathOption(options: {
+    cwd: string;
+    label: string;
+    value?: string;
+}): string | undefined;
+/**
+ * Validate the built-in template composition rule for external layers.
+ *
+ * @param options External layer CLI options after normalization.
+ * @param options.externalLayerId Optional selected layer id.
+ * @param options.externalLayerSource Optional layer source locator or path.
+ * @throws When `externalLayerId` is provided without `externalLayerSource`.
+ */
+export declare function assertExternalLayerCompositionOptions(options: {
+    externalLayerId?: string;
+    externalLayerSource?: string;
+}): void;
+/**
+ * Build the shared error message used when a built-in template receives a
+ * `--variant` override.
+ *
+ * @param options Built-in template context.
+ * @param options.templateId Built-in template id that rejected the variant.
+ * @param options.variant User-supplied variant override.
+ * @returns The canonical user-facing error message.
+ */
+export declare function createBuiltInVariantErrorMessage(options: {
+    templateId: string;
+    variant: string;
+}): string;
+/**
+ * Reject unsupported `--variant` usage for built-in templates.
+ *
+ * @param options Built-in template validation context.
+ * @param options.templateId Built-in template id being scaffolded.
+ * @param options.variant Optional variant override from CLI flags.
+ * @throws When a built-in template receives any explicit `--variant` value.
+ */
+export declare function assertBuiltInTemplateVariantAllowed(options: {
+    templateId: string;
+    variant?: string;
+}): void;

package/dist/runtime/cli-validation.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Normalize one optional CLI string flag by trimming whitespace and collapsing
+ * empty strings to `undefined`.
+ *
+ * @param value Raw CLI value before normalization.
+ * @returns The trimmed string when present, otherwise `undefined`.
+ */
+export function normalizeOptionalCliString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function looksLikeLocalCliPath(value) {
+    return (path.isAbsolute(value) ||
+        value.startsWith("./") ||
+        value.startsWith("../") ||
+        value.startsWith(".\\") ||
+        value.startsWith("..\\"));
+}
+/**
+ * Resolve one CLI path flag relative to the caller when it is expressed as a
+ * local filesystem path.
+ *
+ * Non-local values such as npm package specs or `github:` locators pass
+ * through unchanged. Local relative and absolute paths are resolved against the
+ * provided `cwd` and must exist on disk.
+ *
+ * @param options Path resolution inputs for one CLI flag.
+ * @param options.cwd Caller working directory used for relative path
+ * resolution.
+ * @param options.label Human-readable option label used in thrown errors.
+ * @param options.value Raw CLI value before trimming and path resolution.
+ * @returns The normalized string, or `undefined` when the option was omitted.
+ * @throws When a local-looking path resolves to a missing filesystem entry.
+ */
+export function resolveLocalCliPathOption(options) {
+    const normalizedValue = normalizeOptionalCliString(options.value);
+    if (!normalizedValue || !looksLikeLocalCliPath(normalizedValue)) {
+        return normalizedValue;
+    }
+    const resolvedPath = path.resolve(options.cwd, normalizedValue);
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`\`${options.label}\` path does not exist: ${resolvedPath}. Check the path relative to ${options.cwd}.`);
+    }
+    return resolvedPath;
+}
+/**
+ * Validate the built-in template composition rule for external layers.
+ *
+ * @param options External layer CLI options after normalization.
+ * @param options.externalLayerId Optional selected layer id.
+ * @param options.externalLayerSource Optional layer source locator or path.
+ * @throws When `externalLayerId` is provided without `externalLayerSource`.
+ */
+export function assertExternalLayerCompositionOptions(options) {
+    if (options.externalLayerId && !options.externalLayerSource) {
+        throw new Error("externalLayerId requires externalLayerSource when composing built-in template layers.");
+    }
+}
+/**
+ * Build the shared error message used when a built-in template receives a
+ * `--variant` override.
+ *
+ * @param options Built-in template context.
+ * @param options.templateId Built-in template id that rejected the variant.
+ * @param options.variant User-supplied variant override.
+ * @returns The canonical user-facing error message.
+ */
+export function createBuiltInVariantErrorMessage(options) {
+    return `--variant is only supported for official external template configs. Received variant "${options.variant}" for built-in template "${options.templateId}".`;
+}
+/**
+ * Reject unsupported `--variant` usage for built-in templates.
+ *
+ * @param options Built-in template validation context.
+ * @param options.templateId Built-in template id being scaffolded.
+ * @param options.variant Optional variant override from CLI flags.
+ * @throws When a built-in template receives any explicit `--variant` value.
+ */
+export function assertBuiltInTemplateVariantAllowed(options) {
+    if (!options.variant) {
+        return;
+    }
+    throw new Error(createBuiltInVariantErrorMessage({
+        templateId: options.templateId,
+        variant: options.variant,
+    }));
+}

package/dist/runtime/compound-inner-blocks.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Stable preset ids exposed to scaffold and UI consumers for compound
+ * InnerBlocks authoring behavior.
+ */
+export declare const COMPOUND_INNER_BLOCKS_PRESET_IDS: readonly ["freeform", "ordered", "horizontal", "locked-structure"];
+export type CompoundInnerBlocksPresetId = (typeof COMPOUND_INNER_BLOCKS_PRESET_IDS)[number];
+/**
+ * Default preset applied when callers do not provide an explicit compound
+ * InnerBlocks mode.
+ */
+export declare const DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID: CompoundInnerBlocksPresetId;
+export type CompoundInnerBlocksOrientation = "horizontal" | "vertical";
+export type CompoundInnerBlocksTemplateLock = false | "insert" | "all";
+/**
+ * Runtime-facing description of one compound InnerBlocks preset.
+ */
+export interface CompoundInnerBlocksPresetDefinition {
+    description: string;
+    directInsert: boolean;
+    label: string;
+    orientation?: CompoundInnerBlocksOrientation;
+    templateLock: CompoundInnerBlocksTemplateLock;
+}
+/**
+ * Canonical preset registry used by the CLI, generated scaffolds, and TUI
+ * forms.
+ */
+export declare const COMPOUND_INNER_BLOCKS_PRESET_REGISTRY: {
+    readonly freeform: {
+        readonly description: "Unlocked nested authoring with the default inserter and starter child template.";
+        readonly directInsert: false;
+        readonly label: "freeform";
+        readonly orientation: "vertical";
+        readonly templateLock: false;
+    };
+    readonly ordered: {
+        readonly description: "Vertical ordered flow that keeps starter structure fixed while allowing new sibling inserts.";
+        readonly directInsert: true;
+        readonly label: "ordered";
+        readonly orientation: "vertical";
+        readonly templateLock: "insert";
+    };
+    readonly horizontal: {
+        readonly description: "Horizontal nested layout with one-click direct inserts for row or tab style containers.";
+        readonly directInsert: true;
+        readonly label: "horizontal";
+        readonly orientation: "horizontal";
+        readonly templateLock: false;
+    };
+    readonly "locked-structure": {
+        readonly description: "Locked starter structure for guided document shells where authors should only edit seeded children.";
+        readonly directInsert: false;
+        readonly label: "locked-structure";
+        readonly orientation: "vertical";
+        readonly templateLock: "all";
+    };
+};
+/**
+ * Returns whether a string matches one of the supported compound preset ids.
+ */
+export declare function isCompoundInnerBlocksPresetId(value: string): value is CompoundInnerBlocksPresetId;
+/**
+ * Parses a raw CLI or config value into a supported preset id.
+ *
+ * Returns `undefined` for non-string or empty input, and throws when the input
+ * is a non-empty unsupported preset id.
+ */
+export declare function parseCompoundInnerBlocksPreset(value?: string): CompoundInnerBlocksPresetId | undefined;
+/**
+ * Resolves an optional preset id to a concrete preset, defaulting to
+ * `DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID`.
+ */
+export declare function resolveCompoundInnerBlocksPreset(value?: CompoundInnerBlocksPresetId): CompoundInnerBlocksPresetId;
+/**
+ * Looks up the preset definition for the provided preset id, applying the
+ * default preset when the input is omitted.
+ */
+export declare function getCompoundInnerBlocksPresetDefinition(value?: CompoundInnerBlocksPresetId): CompoundInnerBlocksPresetDefinition;

package/dist/runtime/compound-inner-blocks.js

@@ -0,0 +1,88 @@
+/**
+ * Stable preset ids exposed to scaffold and UI consumers for compound
+ * InnerBlocks authoring behavior.
+ */
+export const COMPOUND_INNER_BLOCKS_PRESET_IDS = [
+    "freeform",
+    "ordered",
+    "horizontal",
+    "locked-structure",
+];
+/**
+ * Default preset applied when callers do not provide an explicit compound
+ * InnerBlocks mode.
+ */
+export const DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID = "freeform";
+/**
+ * Canonical preset registry used by the CLI, generated scaffolds, and TUI
+ * forms.
+ */
+export const COMPOUND_INNER_BLOCKS_PRESET_REGISTRY = {
+    freeform: {
+        description: "Unlocked nested authoring with the default inserter and starter child template.",
+        directInsert: false,
+        label: "freeform",
+        orientation: "vertical",
+        templateLock: false,
+    },
+    ordered: {
+        description: "Vertical ordered flow that keeps starter structure fixed while allowing new sibling inserts.",
+        directInsert: true,
+        label: "ordered",
+        orientation: "vertical",
+        templateLock: "insert",
+    },
+    horizontal: {
+        description: "Horizontal nested layout with one-click direct inserts for row or tab style containers.",
+        directInsert: true,
+        label: "horizontal",
+        orientation: "horizontal",
+        templateLock: false,
+    },
+    "locked-structure": {
+        description: "Locked starter structure for guided document shells where authors should only edit seeded children.",
+        directInsert: false,
+        label: "locked-structure",
+        orientation: "vertical",
+        templateLock: "all",
+    },
+};
+/**
+ * Returns whether a string matches one of the supported compound preset ids.
+ */
+export function isCompoundInnerBlocksPresetId(value) {
+    return COMPOUND_INNER_BLOCKS_PRESET_IDS.includes(value);
+}
+/**
+ * Parses a raw CLI or config value into a supported preset id.
+ *
+ * Returns `undefined` for non-string or empty input, and throws when the input
+ * is a non-empty unsupported preset id.
+ */
+export function parseCompoundInnerBlocksPreset(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalizedValue = value.trim();
+    if (normalizedValue.length === 0) {
+        return undefined;
+    }
+    if (!isCompoundInnerBlocksPresetId(normalizedValue)) {
+        throw new Error(`Unsupported InnerBlocks preset "${value}". Expected one of: ${COMPOUND_INNER_BLOCKS_PRESET_IDS.join(", ")}.`);
+    }
+    return normalizedValue;
+}
+/**
+ * Resolves an optional preset id to a concrete preset, defaulting to
+ * `DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID`.
+ */
+export function resolveCompoundInnerBlocksPreset(value) {
+    return value ?? DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID;
+}
+/**
+ * Looks up the preset definition for the provided preset id, applying the
+ * default preset when the input is omitted.
+ */
+export function getCompoundInnerBlocksPresetDefinition(value) {
+    return COMPOUND_INNER_BLOCKS_PRESET_REGISTRY[resolveCompoundInnerBlocksPreset(value)];
+}

package/dist/runtime/index.d.ts

@@ -10,8 +10,11 @@
  * `runAddHookedBlockCommand`,
  * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
  */
-export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
+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, 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";
@@ -22,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

@@ -10,7 +10,8 @@
  * `runAddHookedBlockCommand`,
  * `HOOKED_BLOCK_POSITION_IDS`, and `runDoctor`.
  */
-export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
+export { COMPOUND_INNER_BLOCKS_PRESET_IDS, DEFAULT_COMPOUND_INNER_BLOCKS_PRESET_ID, getCompoundInnerBlocksPresetDefinition, isCompoundInnerBlocksPresetId, parseCompoundInnerBlocksPreset, resolveCompoundInnerBlocksPreset, } from "./compound-inner-blocks.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";
@@ -19,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/migration-command-surface.js

@@ -19,6 +19,8 @@ export function formatMigrationHelpText() {
 
 Notes:
   \`migrate init\` auto-detects supported single-block and \`src/blocks/*\` multi-block layouts.
+  \`migrate init\` only retrofits migration support into projects that already match those layouts.
+  A broader project-level \`wp-typia init\` path remains future work.
   Migration versions use strict schema labels like \`v1\`, \`v2\`, and \`v3\`.
   \`migrate wizard\` is TTY-only and helps you choose one legacy migration version to preview.
   \`migrate plan\` and \`migrate wizard\` are read-only previews; they do not scaffold rules or fixtures.

package/dist/runtime/package-versions.d.ts

@@ -4,6 +4,7 @@ interface PackageVersions {
     blockTypesPackageVersion: string;
     projectToolsPackageVersion: string;
     restPackageVersion: string;
+    wpTypiaPackageExactVersion: string;
     wpTypiaPackageVersion: string;
 }
 export declare function getPackageVersions(): PackageVersions;