@wp-typia/project-tools 0.18.0 → 0.19.0

package/dist/runtime/scaffold.d.ts

@@ -8,6 +8,7 @@ import type { PackageManagerId } from "./package-managers.js";
  */
 export interface ScaffoldAnswers {
     author: string;
+    compoundInnerBlocksPreset?: import("./compound-inner-blocks.js").CompoundInnerBlocksPresetId;
     dataStorageMode?: DataStorageMode;
     description: string;
     /** Block namespace used in generated block names such as `namespace/slug`. */
@@ -29,6 +30,8 @@ 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> {
+    alternateRenderTargetsCsv: string;
+    alternateRenderTargetsJson: string;
     apiClientPackageVersion: string;
     author: string;
     blockRuntimePackageVersion: string;
@@ -42,6 +45,17 @@ export interface ScaffoldTemplateVariables extends Record<string, string> {
     compoundChildIcon: string;
     compoundChildTitleJson: string;
     compoundPersistenceEnabled: "false" | "true";
+    compoundInnerBlocksDirectInsert: "false" | "true";
+    compoundInnerBlocksOrientation: "" | "horizontal" | "vertical";
+    compoundInnerBlocksOrientationExpression: string;
+    compoundInnerBlocksPreset: string;
+    compoundInnerBlocksPresetDescription: string;
+    compoundInnerBlocksPresetLabel: string;
+    compoundInnerBlocksTemplateLockExpression: string;
+    hasAlternateEmailRenderTarget: "false" | "true";
+    hasAlternateMjmlRenderTarget: "false" | "true";
+    hasAlternatePlainTextRenderTarget: "false" | "true";
+    hasAlternateRenderTargets: "false" | "true";
     projectToolsPackageVersion: string;
     cssClassName: string;
     dashCase: string;
@@ -131,6 +145,7 @@ export interface ScaffoldProgressEvent {
 }
 interface ScaffoldProjectOptions {
     allowExistingDir?: boolean;
+    alternateRenderTargets?: string;
     answers: ScaffoldAnswers;
     cwd?: string;
     dataStorageMode?: DataStorageMode;
@@ -163,4 +178,4 @@ export { collectScaffoldAnswers, detectAuthor, getDefaultAnswers, resolvePackage
 export { getTemplateVariables } from "./scaffold-template-variables.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, dataStorageMode, persistencePolicy, packageManager, externalLayerId, externalLayerSource, externalLayerSourceLabel, repositoryReference, cwd, allowExistingDir, noInstall, installDependencies, onProgress, variant, withMigrationUi, withTestPreset, withWpEnv, }: ScaffoldProjectOptions): Promise<ScaffoldProjectResult>;
+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 { assertExternalLayerCompositionOptions, } from "./cli-validation.js";
 const WORKSPACE_TEMPLATE_ALIAS = "workspace";
 export const DATA_STORAGE_MODES = ["post-meta", "custom-table"];
 export const PERSISTENCE_POLICIES = ["authenticated", "public"];
@@ -32,13 +33,14 @@ function normalizeTemplateSelection(templateId) {
 async function reportScaffoldProgress(onProgress, event) {
     await onProgress?.(event);
 }
-export async function scaffoldProject({ projectDir, templateId, answers, dataStorageMode, persistencePolicy, packageManager, externalLayerId, externalLayerSource, externalLayerSourceLabel, repositoryReference, cwd = process.cwd(), allowExistingDir = false, noInstall = false, installDependencies = undefined, onProgress = undefined, variant, withMigrationUi = false, withTestPreset = false, withWpEnv = false, }) {
+export async function scaffoldProject({ projectDir, templateId, answers, alternateRenderTargets, dataStorageMode, persistencePolicy, packageManager, externalLayerId, externalLayerSource, externalLayerSourceLabel, repositoryReference, cwd = process.cwd(), allowExistingDir = false, noInstall = false, installDependencies = undefined, onProgress = undefined, variant, withMigrationUi = false, withTestPreset = false, withWpEnv = false, }) {
     const resolvedTemplateId = normalizeTemplateSelection(templateId);
     const resolvedPackageManager = getPackageManager(packageManager).id;
     const isBuiltInTemplate = isBuiltInTemplateId(resolvedTemplateId);
-    if (externalLayerId && !externalLayerSource) {
-        throw new Error("externalLayerId requires externalLayerSource when composing built-in template layers.");
-    }
+    assertExternalLayerCompositionOptions({
+        externalLayerId,
+        externalLayerSource,
+    });
     if (isBuiltInTemplate) {
         const blockGeneratorService = new BlockGeneratorService();
         await reportScaffoldProgress(onProgress, {
@@ -48,6 +50,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, dataSto
         });
         const plan = await blockGeneratorService.plan({
             allowExistingDir,
+            alternateRenderTargets,
             answers,
             cwd,
             dataStorageMode: dataStorageMode ?? answers.dataStorageMode,

package/dist/runtime/template-source.js

@@ -3,13 +3,15 @@ import { resolveBuiltInTemplateSource } from './template-builtins.js';
 import { parseTemplateLocator, } from './template-source-locators.js';
 import { detectTemplateSourceFormat, getTemplateProjectType, getDefaultCategory, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
 import { isOfficialWorkspaceTemplateSeed, resolveTemplateSeed, } from './template-source-seeds.js';
+import { assertBuiltInTemplateVariantAllowed, } from './cli-validation.js';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
 export { resolveTemplateSeed } from './template-source-seeds.js';
 export async function resolveTemplateSource(templateId, cwd, variables, variant) {
     if (isBuiltInTemplateId(templateId)) {
-        if (variant) {
-            throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for built-in template "${templateId}".`);
-        }
+        assertBuiltInTemplateVariantAllowed({
+            templateId,
+            variant,
+        });
         return resolveBuiltInTemplateSource(templateId, {
             persistenceEnabled: variables.compoundPersistenceEnabled === 'true',
             persistencePolicy: variables.persistencePolicy === 'public' ? 'public' : 'authenticated',

package/dist/runtime/workspace-project.js

@@ -148,5 +148,5 @@ export function resolveWorkspaceProject(startDir) {
     if (workspace) {
         return workspace;
     }
-    throw new Error(`This command must run inside a ${WORKSPACE_TEMPLATE_PACKAGE} project. Create one with \`wp-typia create my-plugin --template ${WORKSPACE_TEMPLATE_PACKAGE}\` first.`);
+    throw new Error(`This command must run inside an official wp-typia workspace. Create one with \`wp-typia create my-plugin --template workspace\` first (the short alias for \`${WORKSPACE_TEMPLATE_PACKAGE}\`).`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -37,6 +37,11 @@
       "import": "./dist/runtime/cli-scaffold.js",
       "default": "./dist/runtime/cli-scaffold.js"
     },
+    "./compound-inner-blocks": {
+      "types": "./dist/runtime/compound-inner-blocks.d.ts",
+      "import": "./dist/runtime/compound-inner-blocks.js",
+      "default": "./dist/runtime/compound-inner-blocks.js"
+    },
     "./cli-templates": {
       "types": "./dist/runtime/cli-templates.d.ts",
       "import": "./dist/runtime/cli-templates.js",
@@ -86,7 +91,7 @@
     "test:migration-planning": "bun run build && bun test tests/migration-init.test.ts tests/migration-config.test.ts tests/migration-plan-wizard.test.ts",
     "test:migration-execution": "bun run build && bun test tests/migration-scaffold-diff.test.ts tests/migration-doctor.test.ts tests/migration-fixtures-fuzz.test.ts",
     "test:project-tools": "bun run test:scaffold-core && bun run test:workspace && bun run test:compound && bun run test:migration-planning && bun run test:migration-execution",
-    "test:coverage": "bun run build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
+    "test:coverage": "bun run build && bun run --filter wp-typia build && bun test tests/*.test.ts --coverage --coverage-reporter=lcov --coverage-dir=coverage",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run build"
   },

package/templates/_shared/compound/core/scripts/add-compound-child.ts.mustache

@@ -28,25 +28,45 @@ type CompoundParentConfig = {
 };
 
 type ExistingCompoundChild = {
+	ancestorBlockNames: string[];
 	blockJsonPath: string;
 	blockName: string;
+	container: boolean;
+	directAllowedBlocks: string[];
 	folderSlug: string;
 	key: string;
+	parentBlockNames: string[];
+	placement: 'nested' | 'root';
+	supportsInserter: boolean;
+	title: string;
 };
 
 type ParsedArgs = {
 	ancestorValues: string[];
 	container: boolean;
+	dryRun: boolean;
 	inserter?: 'hidden' | 'visible';
 	slug?: string;
 	title?: string;
 };
 
+type CompoundChildGraphNode = {
+	blockName: string;
+	container: boolean;
+	directParentBlockName: string;
+	isProspective: boolean;
+	key: string;
+	placement: 'nested' | 'root';
+	supportsInserter: boolean;
+	title: string;
+};
+
 function parseArgs() {
 	const args = process.argv.slice( 2 );
 	const parsed: ParsedArgs = {
 		ancestorValues: [],
 		container: false,
+		dryRun: false,
 	};
 
 	for ( let index = 0; index < args.length; index += 1 ) {
@@ -86,6 +106,11 @@ function parseArgs() {
 			continue;
 		}
 
+		if ( arg === '--dry-run' ) {
+			parsed.dryRun = true;
+			continue;
+		}
+
 		if ( arg === '--inserter' ) {
 			const value = args[ index + 1 ];
 			if ( value !== 'hidden' && value !== 'visible' ) {
@@ -95,6 +120,10 @@ function parseArgs() {
 			index += 1;
 			continue;
 		}
+
+		if ( arg.startsWith( '--' ) ) {
+			throw new Error( `Unknown option: ${ arg }.` );
+		}
 	}
 
 	return parsed;
@@ -395,16 +424,149 @@ function listExistingCompoundChildren(): ExistingCompoundChild[] {
 				return null;
 			}
 
+			const ancestorBlockNames = Array.isArray( blockJson.ancestor )
+				? blockJson.ancestor.filter(
+					( value ): value is string => typeof value === 'string'
+				)
+				: [];
+			const parentBlockNames = Array.isArray( blockJson.parent )
+				? blockJson.parent.filter(
+					( value ): value is string => typeof value === 'string'
+				)
+				: [];
+			const directAllowedBlocks = Array.isArray( blockJson.allowedBlocks )
+				? blockJson.allowedBlocks.filter(
+					( value ): value is string => typeof value === 'string'
+				)
+				: [];
+			const supports =
+				typeof blockJson.supports === 'object' &&
+				blockJson.supports &&
+				! Array.isArray( blockJson.supports )
+					? blockJson.supports
+					: null;
+			const supportsInserter =
+				supports && typeof supports.inserter === 'boolean'
+					? supports.inserter
+					: true;
+			const title =
+				typeof blockJson.title === 'string' &&
+				blockJson.title.trim().length > 0
+					? blockJson.title.trim()
+					: toTitleCase( deriveChildKey( folderSlug ) );
+
 			return {
+				ancestorBlockNames,
 				blockJsonPath,
 				blockName,
+				container: Object.prototype.hasOwnProperty.call(
+					blockJson,
+					'allowedBlocks'
+				),
+				directAllowedBlocks,
 				folderSlug,
 				key: deriveChildKey( folderSlug ),
+				parentBlockNames,
+				placement: ancestorBlockNames.length > 0 ? 'nested' : 'root',
+				supportsInserter,
+				title,
 			} satisfies ExistingCompoundChild;
 		} )
 		.filter( ( child ): child is ExistingCompoundChild => child !== null );
 }
 
+function buildCompoundChildGraphMap(
+	existingChildren: ExistingCompoundChild[]
+): Map< string, ExistingCompoundChild > {
+	return new Map(
+		existingChildren.map( ( child ) => [ child.blockName, child ] )
+	);
+}
+
+function resolveDirectParentBlockName( child: ExistingCompoundChild ): string {
+	return (
+		child.ancestorBlockNames[ child.ancestorBlockNames.length - 1 ] ??
+		child.parentBlockNames[ 0 ] ??
+		PARENT_BLOCK_NAME
+	);
+}
+
+function validateExistingCompoundChildGraph(
+	existingChildren: ExistingCompoundChild[]
+) {
+	const seenKeys = new Set< string >();
+	const seenBlockNames = new Set< string >();
+	const childByBlockName = buildCompoundChildGraphMap( existingChildren );
+
+	for ( const child of existingChildren ) {
+		if ( seenKeys.has( child.key ) ) {
+			throw new Error(
+				`Existing compound child graph is invalid: child key "${ child.key }" is declared more than once.`
+			);
+		}
+
+		if ( seenBlockNames.has( child.blockName ) ) {
+			throw new Error(
+				`Existing compound child graph is invalid: ${ child.blockName } is declared more than once.`
+			);
+		}
+
+		seenKeys.add( child.key );
+		seenBlockNames.add( child.blockName );
+
+		if ( child.ancestorBlockNames.length === 0 ) {
+			if ( child.parentBlockNames.length === 0 ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ child.blockName } must declare a parent block.`
+				);
+			}
+			continue;
+		}
+
+		for ( let index = 0; index < child.ancestorBlockNames.length; index += 1 ) {
+			const ancestorBlockName = child.ancestorBlockNames[ index ];
+			const ancestorChild = childByBlockName.get( ancestorBlockName );
+
+			if ( ! ancestorChild ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ child.blockName } references missing ancestor ${ ancestorBlockName }.`
+				);
+			}
+
+			if ( ! ancestorChild.container ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ ancestorChild.blockName } is not declared as a container child but has nested descendants.`
+				);
+			}
+
+			const expectedAncestorRoute = child.ancestorBlockNames.slice( 0, index );
+			const ancestorRouteMatches =
+				ancestorChild.ancestorBlockNames.length === expectedAncestorRoute.length &&
+				expectedAncestorRoute.every(
+					( expectedAncestorBlockName, expectedIndex ) =>
+						ancestorChild.ancestorBlockNames[ expectedIndex ] ===
+						expectedAncestorBlockName
+				);
+
+			if ( ! ancestorRouteMatches ) {
+				throw new Error(
+					`Existing compound child graph is invalid: ${ ancestorChild.blockName } is not on the declared ancestor route for ${ child.blockName }.`
+				);
+			}
+
+			const nextBlockName =
+				child.ancestorBlockNames[ index + 1 ] ?? child.blockName;
+			if ( ancestorChild.directAllowedBlocks.includes( nextBlockName ) ) {
+				continue;
+			}
+
+			throw new Error(
+				`Existing compound child graph is invalid: ${ ancestorChild.blockName } does not currently allow ${ nextBlockName } as a direct child.`
+			);
+		}
+	}
+}
+
 function resolveExistingCompoundChild(
 	value: string,
 	existingChildren: ExistingCompoundChild[]
@@ -457,14 +619,8 @@ function validateAncestorChain(
 	for ( let index = 0; index < ancestorChain.length - 1; index += 1 ) {
 		const currentAncestor = ancestorChain[ index ];
 		const nextAncestor = ancestorChain[ index + 1 ];
-		const blockJson = readBlockJsonDocument( currentAncestor.blockJsonPath );
-		const allowedBlocks = Array.isArray( blockJson.allowedBlocks )
-			? blockJson.allowedBlocks.filter(
-				( value ): value is string => typeof value === 'string'
-			)
-			: [];
-
-		if ( allowedBlocks.includes( nextAncestor.blockName ) ) {
+
+		if ( currentAncestor.directAllowedBlocks.includes( nextAncestor.blockName ) ) {
 			continue;
 		}
 
@@ -474,6 +630,22 @@ function validateAncestorChain(
 	}
 }
 
+function validateNestedAncestorTarget( ancestorChain: ExistingCompoundChild[] ) {
+	const directAncestor = ancestorChain[ ancestorChain.length - 1 ];
+
+	if ( ! directAncestor ) {
+		return;
+	}
+
+	if ( directAncestor.container ) {
+		return;
+	}
+
+	throw new Error(
+		`Cannot nest descendants under ${ directAncestor.blockName } because it is not declared as a container child. Re-add that child with --container or target an existing container child.`
+	);
+}
+
 function findCompoundChildSpecSource(
 	childrenRegistrySource: string,
 	childKey: string
@@ -528,6 +700,86 @@ function validateAncestorInstantiability(
 	}
 }
 
+function formatProjectRelativePath( filePath: string ): string {
+	return path.relative( PROJECT_ROOT, filePath ) || '.';
+}
+
+function buildCompoundChildGraphNodes(
+	existingChildren: ExistingCompoundChild[],
+	prospectiveChild: CompoundChildGraphNode
+): CompoundChildGraphNode[] {
+	return [
+		...existingChildren.map( ( child ) => ( {
+			blockName: child.blockName,
+			container: child.container,
+			directParentBlockName: resolveDirectParentBlockName( child ),
+			isProspective: false,
+			key: child.key,
+			placement: child.placement,
+			supportsInserter: child.supportsInserter,
+			title: child.title,
+		} ) ),
+		prospectiveChild,
+	];
+}
+
+function renderCompoundChildGraphPreview(
+	graphNodes: CompoundChildGraphNode[],
+	plannedWritePaths: string[],
+	options: {
+		dryRun: boolean;
+	}
+): string {
+	const childrenByParent = new Map< string, CompoundChildGraphNode[] >();
+
+	for ( const graphNode of graphNodes ) {
+		const existingChildren = childrenByParent.get( graphNode.directParentBlockName ) ?? [];
+		existingChildren.push( graphNode );
+		childrenByParent.set( graphNode.directParentBlockName, existingChildren );
+	}
+
+	const renderChildLines = (
+		parentBlockName: string,
+		indent: string
+	): string[] => {
+		const directChildren = [ ...( childrenByParent.get( parentBlockName ) ?? [] ) ].sort(
+			( left, right ) => left.key.localeCompare( right.key )
+		);
+
+		return directChildren.flatMap( ( child ) => {
+			const labels = [
+				child.isProspective ? 'new' : 'existing',
+				child.placement === 'root' ? 'root' : 'nested',
+				child.container ? 'container' : 'leaf',
+				child.supportsInserter ? 'visible' : 'hidden',
+			];
+			const line = `${ indent }- ${ child.key } -> ${ child.blockName } [${ labels.join( ', ' ) }]`;
+			return [ line, ...renderChildLines( child.blockName, `${ indent }  ` ) ];
+		} );
+	};
+
+	return [
+		'Compound child graph preview',
+		`Parent block: ${ PARENT_BLOCK_NAME }`,
+		...renderChildLines( PARENT_BLOCK_NAME, '' ),
+		'',
+		'Planned writes',
+		...plannedWritePaths.map( ( plannedWritePath ) => `- ${ plannedWritePath }` ),
+		options.dryRun ? '' : '',
+		options.dryRun
+			? 'Dry run only; no files were written.'
+			: 'Applying these updates now.',
+	]
+		.filter( ( line, index, lines ) => {
+			if ( line.length > 0 ) {
+				return true;
+			}
+
+			return index > 0 && lines[ index - 1 ].length > 0;
+		} )
+		.join( '\n' );
+}
+
 function updateAllowedBlocks(
 	filePath: string,
 	blockName: string
@@ -756,8 +1008,7 @@ import { __ } from '@wordpress/i18n';
 
 import metadata from './block-metadata';
 import {
-\tgetChildAllowedBlocks,
-\tgetChildTemplate,
+\tgetChildInnerBlocksPropsOptions,
 \thasNestedChildBlocks,
 } from '../${ PARENT_BLOCK_SLUG }/children';
 import { useTypiaValidation } from './hooks';
@@ -768,6 +1019,14 @@ import {
 } from './validators';
 
 type EditProps = BlockEditProps< ${ childTypeName } >;
+type CompoundInnerBlocksProps = Parameters< typeof InnerBlocks >[ 0 ] & {
+\tdefaultBlock?: [ string, Record< string, unknown > ];
+\tdirectInsert?: boolean;
+};
+
+const TypedInnerBlocks = InnerBlocks as unknown as (
+\tprops: CompoundInnerBlocksProps
+) => ReturnType< typeof InnerBlocks >;
 
 export default function Edit( {
 \tattributes,
@@ -778,8 +1037,9 @@ export default function Edit( {
 \t\tattributes,
 \t\tvalidate${ childInterfaceName }
 \t);
-\tconst nestedAllowedBlocks = getChildAllowedBlocks( metadata.name );
-\tconst nestedTemplate = getChildTemplate( metadata.name );
+\tconst nestedInnerBlocksPropsOptions = getChildInnerBlocksPropsOptions(
+\t\tmetadata.name
+\t);
 \tconst showsNestedChildren = hasNestedChildBlocks( metadata.name );
 
 \treturn (
@@ -809,11 +1069,8 @@ export default function Edit( {
 \t\t\t) }
 \t\t\t{ showsNestedChildren && (
 \t\t\t\t<div className="${ childCssClassName }__children">
-\t\t\t\t\t<InnerBlocks
-\t\t\t\t\t\tallowedBlocks={ nestedAllowedBlocks }
-\t\t\t\t\t\trenderAppender={ InnerBlocks.ButtonBlockAppender }
-\t\t\t\t\t\ttemplate={ nestedTemplate }
-\t\t\t\t\t\ttemplateLock={ false }
+\t\t\t\t\t<TypedInnerBlocks
+\t\t\t\t\t\t{ ...( nestedInnerBlocksPropsOptions ?? {} ) }
 \t\t\t\t\t/>
 \t\t\t\t</div>
 \t\t\t) }
@@ -936,6 +1193,7 @@ function main() {
 	const {
 		ancestorValues,
 		container,
+		dryRun,
 		inserter,
 		slug,
 		title,
@@ -947,6 +1205,7 @@ function main() {
 	}
 
 	const existingChildren = listExistingCompoundChildren();
+	validateExistingCompoundChildGraph( existingChildren );
 	const ancestorChain = ensureUniqueAncestorChain(
 		ancestorValues.map( ( value ) =>
 			resolveExistingCompoundChild( value, existingChildren )
@@ -984,7 +1243,7 @@ function main() {
 	}
 
 	validateAncestorInstantiability( childrenFile, ancestorChain );
-
+	validateNestedAncestorTarget( ancestorChain );
 	const supportsInserter =
 		inserter === 'visible'
 			? true
@@ -994,6 +1253,47 @@ function main() {
 	const placement = ancestorChain.length > 0 ? 'nested' : 'root';
 	const seedTemplate = supportsInserter || container || ancestorChain.length > 0;
 	const directAllowedBlocks: string[] = [];
+	const directAncestor = ancestorChain[ ancestorChain.length - 1 ];
+	const plannedWritePaths = [
+		formatProjectRelativePath( path.join( childDir, 'block.json' ) ),
+		formatProjectRelativePath( path.join( childDir, 'types.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'typia.manifest.json' ) ),
+		formatProjectRelativePath( path.join( childDir, 'block-metadata.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'manifest-document.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'manifest-defaults-document.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'hooks.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'validators.ts' ) ),
+		formatProjectRelativePath( path.join( childDir, 'edit.tsx' ) ),
+		formatProjectRelativePath( path.join( childDir, 'save.tsx' ) ),
+		formatProjectRelativePath( path.join( childDir, 'index.tsx' ) ),
+		formatProjectRelativePath( childrenFile ),
+		formatProjectRelativePath( blockConfigFile ),
+		formatProjectRelativePath(
+			placement === 'root' ? PARENT_BLOCK_JSON_PATH : directAncestor.blockJsonPath
+		),
+	];
+
+	console.log(
+		renderCompoundChildGraphPreview(
+			buildCompoundChildGraphNodes( existingChildren, {
+				blockName: childBlockName,
+				container,
+				directParentBlockName:
+					directAncestor?.blockName ?? PARENT_BLOCK_NAME,
+				isProspective: true,
+				key: normalizedSlug,
+				placement,
+				supportsInserter,
+				title: childTitle,
+			} ),
+			plannedWritePaths,
+			{ dryRun }
+		)
+	);
+
+	if ( dryRun ) {
+		return;
+	}
 
 	fs.mkdirSync( childDir, { recursive: true } );