@wp-typia/project-tools 0.24.11 → 0.24.13

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

@@ -2,6 +2,7 @@ import path from "node:path";
 import { SHARED_WORKSPACE_TEMPLATE_ROOT, } from "../templates/template-registry.js";
 import { isCompoundPersistenceEnabled } from "../templates/scaffold-template-variable-groups.js";
 import { quoteTsString, } from "./cli-add-shared.js";
+import { buildPersistenceEndpointManifest } from "./persistence-rest-artifacts.js";
 export function buildServerTemplateRoot(persistencePolicy) {
     return path.join(SHARED_WORKSPACE_TEMPLATE_ROOT, persistencePolicy === "public" ? "persistence-public" : "persistence-auth");
 }
@@ -15,27 +16,18 @@ function buildSingleBlockConfigEntry(variables) {
     ].join("\n");
 }
 function buildPersistenceBlockConfigEntry(variables) {
+    const contractLines = Object.entries(buildPersistenceEndpointManifest(variables).contracts).flatMap(([contractName, contract]) => [
+        `\t\t\t\t${quoteTsString(contractName)}: {`,
+        `\t\t\t\t\tsourceTypeName: ${quoteTsString(contract.sourceTypeName)},`,
+        "\t\t\t\t},",
+    ]);
     return [
         "\t{",
         `\t\tapiTypesFile: ${quoteTsString(`src/blocks/${variables.slugKebabCase}/api-types.ts`)},`,
         `\t\tattributeTypeName: ${quoteTsString(`${variables.pascalCase}Attributes`)},`,
         "\t\trestManifest: defineEndpointManifest( {",
         "\t\t\tcontracts: {",
-        "\t\t\t\t'bootstrap-query': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}BootstrapQuery`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'bootstrap-response': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}BootstrapResponse`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'state-query': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}StateQuery`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'state-response': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}StateResponse`)},`,
-        "\t\t\t\t},",
-        "\t\t\t\t'write-state-request': {",
-        `\t\t\t\t\tsourceTypeName: ${quoteTsString(`${variables.pascalCase}WriteStateRequest`)},`,
-        "\t\t\t\t},",
+        ...contractLines,
         "\t\t\t},",
         "\t\t\tendpoints: [",
         "\t\t\t\t{",

package/dist/runtime/add/cli-add-block-package-json.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Ensure legacy workspaces can resolve the editor store used by generated
+ * persistence blocks. Existing dependency ranges stay authoritative.
+ */
+export declare function ensurePersistentBlockIdentityDependency(projectDir: string, required: boolean): Promise<boolean>;

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

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { detectJsonIndent, safeJsonParse } from "../shared/json-utils.js";
+import { DEFAULT_WORDPRESS_DATA_VERSION } from "../shared/package-versions.js";
+import { patchFile } from "./cli-add-shared.js";
+/**
+ * Ensure legacy workspaces can resolve the editor store used by generated
+ * persistence blocks. Existing dependency ranges stay authoritative.
+ */
+export async function ensurePersistentBlockIdentityDependency(projectDir, required) {
+    if (!required) {
+        return false;
+    }
+    const packageJsonPath = path.join(projectDir, "package.json");
+    let added = false;
+    await patchFile(packageJsonPath, (source) => {
+        const packageJson = safeJsonParse(source, {
+            context: "workspace package manifest",
+            filePath: packageJsonPath,
+        });
+        if (packageJson.dependencies?.["@wordpress/data"] ||
+            packageJson.devDependencies?.["@wordpress/data"]) {
+            return source;
+        }
+        packageJson.dependencies = {
+            ...(packageJson.dependencies ?? {}),
+            "@wordpress/data": DEFAULT_WORDPRESS_DATA_VERSION,
+        };
+        added = true;
+        return `${JSON.stringify(packageJson, null, detectJsonIndent(source))}\n`;
+    });
+    return added;
+}

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

@@ -12,6 +12,7 @@ import { resolveWorkspaceProject, } from "../workspace/workspace-project.js";
 import { ADD_BLOCK_TEMPLATE_IDS, buildWorkspacePhpPrefix, isAddBlockTemplateId, patchFile, readOptionalFile, rollbackWorkspaceMutation, snapshotWorkspaceFiles, suggestAddBlockTemplateId, } from "./cli-add-shared.js";
 import { resolveNonEmptyNormalizedBlockSlug, } from "../templates/scaffold-identifiers.js";
 import { buildConfigEntries, buildMigrationBlocks, buildServerTemplateRoot, } from "./cli-add-block-config.js";
+import { ensurePersistentBlockIdentityDependency } from "./cli-add-block-package-json.js";
 import { COMPOUND_SHARED_SUPPORT_FILES, collectLegacyCompoundValidatorPaths, ensureBlockConfigCanAddRestManifests, ensureCompoundWorkspaceSupportFiles, } from "./cli-add-block-legacy-validator.js";
 import { parseTemplateLocator, resolveTemplateSeed, } from "../templates/template-source.js";
 import { resolveExternalTemplateLayers, } from "../templates/template-layers.js";
@@ -340,6 +341,7 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
             cleanup: cleanupTempRoot,
         } = await createManagedTempRoot("wp-typia-add-block-"));
         const tempProjectDir = path.join(tempRoot, normalizedSlug);
+        const packageJsonPath = path.join(workspace.projectDir, "package.json");
         const blockConfigPath = path.join(workspace.projectDir, "scripts", "block-config.ts");
         const migrationConfigPath = path.join(workspace.projectDir, "src", "migrations", "config.ts");
         const blockPhpPrefix = buildWorkspacePhpPrefix(workspace.workspace.phpPrefix, normalizedSlug);
@@ -373,6 +375,7 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
                 packageManager: workspace.packageManager,
                 persistencePolicy: persistencePolicy,
                 projectDir: tempProjectDir,
+                seedCompilerArtifacts: false,
                 templateId: resolvedTemplateId,
             });
             await assertAddBlockSupportsExternalLayerOutputs({
@@ -385,8 +388,12 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
             return scaffoldResult;
         })();
         await assertBlockTargetsDoNotExist(workspace.projectDir, resolvedTemplateId, result.variables);
+        const requiresPersistentIdentity = resolvedTemplateId === "persistence" ||
+            (resolvedTemplateId === "compound" &&
+                isCompoundPersistenceEnabled(result.variables));
         const mutationSnapshot = {
             fileSources: await snapshotWorkspaceFiles([
+                packageJsonPath,
                 blockConfigPath,
                 migrationConfigPath,
                 ...compoundSupportPaths,
@@ -398,18 +405,24 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
             targetPaths: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables),
         };
         try {
+            const addedPersistentIdentityDependency = await ensurePersistentBlockIdentityDependency(workspace.projectDir, requiresPersistentIdentity);
             await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables, legacyCompoundValidatorPaths);
             await addCollectionImportsForTemplate(workspace.projectDir, resolvedTemplateId, result.variables);
-            await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" ||
-                (resolvedTemplateId === "compound" &&
-                    isCompoundPersistenceEnabled(result.variables)));
+            await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), requiresPersistentIdentity);
             await syncWorkspaceAddedBlockArtifacts(workspace.projectDir, resolvedTemplateId, result.variables);
             await updateWorkspaceMigrationConfigIfPresent(workspace.projectDir, buildMigrationBlocks(resolvedTemplateId, result.variables));
             return {
                 blockSlugs: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables).map((targetPath) => path.basename(targetPath)),
                 projectDir: workspace.projectDir,
                 templateId: resolvedTemplateId,
-                warnings: result.warnings,
+                warnings: [
+                    ...result.warnings,
+                    ...(addedPersistentIdentityDependency
+                        ? [
+                            `Added @wordpress/data for persistent block identities. Run \`${formatInstallCommand(workspace.packageManager)}\` before building the workspace.`,
+                        ]
+                        : []),
+                ],
             };
         }
         catch (error) {

package/dist/runtime/add/cli-add-workspace-admin-view-scaffold.js

@@ -1,7 +1,7 @@
 import { promises as fsp } from 'node:fs';
 import path from 'node:path';
 import { pathExists, readOptionalUtf8File } from '../shared/fs-async.js';
-import { safeJsonParse } from '../shared/json-utils.js';
+import { detectJsonIndent, safeJsonParse, } from '../shared/json-utils.js';
 import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from '../workspace/workspace-inventory.js';
 import { buildAdminViewConfigEntry, buildAdminViewConfigSource, buildAdminViewEntrySource, buildAdminViewPhpSource, buildAdminViewRegistrySource, buildAdminViewScreenSource, buildAdminViewStyleSource, buildAdminViewTypesSource, buildCoreDataAdminViewDataSource, buildCoreDataAdminViewScreenSource, buildDefaultAdminViewDataSource, buildRestAdminViewDataSource, buildRestSettingsAdminViewConfigSource, buildRestSettingsAdminViewDataSource, buildRestSettingsAdminViewScreenSource, buildRestSettingsAdminViewTypesSource, } from './cli-add-workspace-admin-view-templates.js';
 import { ADMIN_VIEWS_PHP_GLOB, isAdminViewCoreDataSource, isAdminViewManualSettingsRestResource, } from './cli-add-workspace-admin-view-types.js';
@@ -10,10 +10,6 @@ import { getWorkspaceBootstrapPath, patchFile, } from './cli-add-shared.js';
 import { appendPhpSnippetBeforeClosingTag, executeWorkspaceMutationPlan, insertPhpSnippetBeforeWorkspaceAnchors, } from './cli-add-workspace-mutation.js';
 import { DEFAULT_WORDPRESS_CORE_DATA_VERSION, DEFAULT_WORDPRESS_DATA_VERSION, DEFAULT_WORDPRESS_DATAVIEWS_VERSION, DEFAULT_WP_TYPIA_DATAVIEWS_VERSION, resolveManagedPackageVersionRange, } from '../shared/package-versions.js';
 import { findPhpFunctionRange, hasPhpFunctionDefinition, replacePhpFunctionDefinition, } from '../shared/php-utils.js';
-function detectJsonIndent(source) {
-    const indentMatch = /\n([ \t]+)"/u.exec(source);
-    return indentMatch?.[1] ?? 2;
-}
 const LEGACY_MANUAL_REST_API_SOURCE_PATTERN = /^\s*export\s+\*\s+from\s+["']\.\/api-client["'];?\s*$/u;
 const MANUAL_REST_API_DIRECT_CALL_EXPORT_PATTERN = /(?:^|\n)\s*export\s+(?:(?:async\s+)?function|const|let|var)\s+callManualRestContract\b/u;
 const MANUAL_REST_API_NAMED_EXPORT_PATTERN = /(?:^|\n)\s*export\s*\{([^}]*)\}/gu;

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

@@ -1,6 +1,7 @@
 import { promises as fsp } from "node:fs";
 import path from "node:path";
-import { assertValidHookAnchor, assertValidHookedBlockPosition, getMutableBlockHooks, normalizeBlockSlug, readWorkspaceBlockJson, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { executeWorkspaceMutationPlan } from "./cli-add-workspace-mutation.js";
+import { assertValidHookAnchor, assertValidHookedBlockPosition, getMutableBlockHooks, normalizeBlockSlug, readWorkspaceBlockJson, resolveWorkspaceBlock, } from "./cli-add-shared.js";
 import { readWorkspaceInventoryAsync } from "../workspace/workspace-inventory.js";
 import { resolveWorkspaceProject } from "../workspace/workspace-project.js";
 /**
@@ -35,23 +36,17 @@ export async function runAddHookedBlockCommand({ anchorBlockName, blockName, cwd
     if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {
         throw new Error(`${blockJsonRelativePath} already defines a blockHooks entry for "${resolvedAnchorBlockName}".`);
     }
-    const mutationSnapshot = {
-        fileSources: await snapshotWorkspaceFiles([blockJsonPath]),
-        snapshotDirs: [],
-        targetPaths: [],
-    };
-    try {
-        blockHooks[resolvedAnchorBlockName] = resolvedPosition;
-        await fsp.writeFile(blockJsonPath, JSON.stringify(blockJson, null, "\t"), "utf8");
-        return {
-            anchorBlockName: resolvedAnchorBlockName,
-            blockSlug,
-            position: resolvedPosition,
-            projectDir: workspace.projectDir,
-        };
-    }
-    catch (error) {
-        await rollbackWorkspaceMutation(mutationSnapshot);
-        throw error;
-    }
+    return executeWorkspaceMutationPlan({
+        filePaths: [blockJsonPath],
+        run: async () => {
+            blockHooks[resolvedAnchorBlockName] = resolvedPosition;
+            await fsp.writeFile(blockJsonPath, JSON.stringify(blockJson, null, "\t"), "utf8");
+            return {
+                anchorBlockName: resolvedAnchorBlockName,
+                blockSlug,
+                position: resolvedPosition,
+                projectDir: workspace.projectDir,
+            };
+        },
+    });
 }

package/dist/runtime/add/cli-add-workspace-mutation.d.ts

@@ -1,10 +1,19 @@
-export interface WorkspaceMutationPlan<TResult> {
+import { type WorkspaceMutationSnapshot } from "./cli-add-shared.js";
+/**
+ * Paths captured before a workspace mutation so its filesystem changes can be rolled back.
+ */
+export interface WorkspaceMutationSnapshotPlan {
     /** Files to capture before the mutation starts. Missing files are restored as absent. */
     filePaths: string[];
     /** Snapshot directories created by the mutation, usually migration fixtures. */
     snapshotDirs?: string[];
     /** Created files or directories to remove if the mutation fails. */
     targetPaths?: string[];
+}
+/**
+ * A workspace mutation snapshot plan paired with the operation to execute.
+ */
+export interface WorkspaceMutationPlan<TResult> extends WorkspaceMutationSnapshotPlan {
     /** Mutating work to execute after the snapshot is captured. */
     run: () => Promise<TResult>;
 }
@@ -16,10 +25,14 @@ export declare class WorkspaceMutationRollbackError extends Error {
     readonly rollbackError: unknown;
     constructor(mutationError: unknown, rollbackError: unknown);
 }
+/**
+ * Capture the files and paths needed to roll back a workspace add mutation.
+ */
+export declare function createWorkspaceMutationSnapshot({ filePaths, snapshotDirs, targetPaths, }: WorkspaceMutationSnapshotPlan): Promise<WorkspaceMutationSnapshot>;
 /**
  * Execute a workspace add mutation with rollback on any failure.
  */
-export declare function executeWorkspaceMutationPlan<TResult>({ filePaths, run, snapshotDirs, targetPaths, }: WorkspaceMutationPlan<TResult>): Promise<TResult>;
+export declare function executeWorkspaceMutationPlan<TResult>(plan: WorkspaceMutationPlan<TResult>): Promise<TResult>;
 /**
  * Insert a PHP snippet before the workspace textdomain hook or closing tag.
  */

package/dist/runtime/add/cli-add-workspace-mutation.js

@@ -15,16 +15,22 @@ export class WorkspaceMutationRollbackError extends Error {
     }
 }
 /**
- * Execute a workspace add mutation with rollback on any failure.
+ * Capture the files and paths needed to roll back a workspace add mutation.
  */
-export async function executeWorkspaceMutationPlan({ filePaths, run, snapshotDirs = [], targetPaths = [], }) {
-    const mutationSnapshot = {
+export async function createWorkspaceMutationSnapshot({ filePaths, snapshotDirs = [], targetPaths = [], }) {
+    return {
         fileSources: await snapshotWorkspaceFiles(filePaths),
         snapshotDirs: [...snapshotDirs],
         targetPaths: [...targetPaths],
     };
+}
+/**
+ * Execute a workspace add mutation with rollback on any failure.
+ */
+export async function executeWorkspaceMutationPlan(plan) {
+    const mutationSnapshot = await createWorkspaceMutationSnapshot(plan);
     try {
-        return await run();
+        return await plan.run();
     }
     catch (error) {
         try {

package/dist/runtime/add/persistence-rest-artifacts.d.ts

@@ -6,7 +6,8 @@ interface PersistenceTemplateVariablesLike {
     slugKebabCase: string;
     title: string;
 }
-interface SyncPersistenceRestArtifactsOptions {
+/** Inputs used to plan and sync one persistence scaffold's REST artifacts. */
+export interface SyncPersistenceRestArtifactsOptions {
     apiTypesFile: string;
     outputDir: string;
     projectDir: string;
@@ -20,21 +21,21 @@ interface SyncPersistenceRestArtifactsOptions {
  * @returns Endpoint manifest covering bootstrap, state read, and state write operations.
  */
 export declare function buildPersistenceEndpointManifest(variables: PersistenceTemplateVariablesLike): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<{
+    readonly "state-query": {
+        readonly sourceTypeName: `${string}StateQuery`;
+    };
     readonly "bootstrap-query": {
         readonly sourceTypeName: `${string}BootstrapQuery`;
     };
+    readonly "write-state-request": {
+        readonly sourceTypeName: `${string}WriteStateRequest`;
+    };
     readonly "bootstrap-response": {
         readonly sourceTypeName: `${string}BootstrapResponse`;
     };
-    readonly "state-query": {
-        readonly sourceTypeName: `${string}StateQuery`;
-    };
     readonly "state-response": {
         readonly sourceTypeName: `${string}StateResponse`;
     };
-    readonly "write-state-request": {
-        readonly sourceTypeName: `${string}WriteStateRequest`;
-    };
 }, readonly [{
     readonly auth: "public";
     readonly method: "GET";
@@ -66,6 +67,30 @@ export declare function buildPersistenceEndpointManifest(variables: PersistenceT
     readonly summary: "Read fresh session bootstrap state for the current viewer.";
     readonly tags: readonly [string];
 }]>;
+/** Output paths and metadata for one persistence REST contract schema. */
+export interface PersistenceRestArtifactSchemaPlan {
+    jsonSchemaFile: string;
+    openApiFile: string;
+    openApiInfo: {
+        title: string;
+        version: string;
+    };
+    sourceTypeName: string;
+}
+/** Complete compiler-derived output plan for one persistence REST surface. */
+export interface PersistenceRestArtifactPlan {
+    clientFile: string;
+    manifest: ReturnType<typeof buildPersistenceEndpointManifest>;
+    openApiFile: string;
+    schemas: PersistenceRestArtifactSchemaPlan[];
+}
+/**
+ * Build the canonical output plan shared by scaffold generation and previews.
+ *
+ * @param options Scaffold output paths plus persistence template variables.
+ * @returns REST schema, aggregate OpenAPI, and client output paths.
+ */
+export declare function buildPersistenceRestArtifactPlan(options: SyncPersistenceRestArtifactsOptions): PersistenceRestArtifactPlan;
 /**
  * Generate the REST-derived persistence artifacts for a scaffolded block.
  *

package/dist/runtime/add/persistence-rest-artifacts.js

@@ -10,21 +10,21 @@ import { defineEndpointManifest, syncEndpointClient, syncRestOpenApi, syncTypeSc
 export function buildPersistenceEndpointManifest(variables) {
     return defineEndpointManifest({
         contracts: {
+            "state-query": {
+                sourceTypeName: `${variables.pascalCase}StateQuery`,
+            },
             "bootstrap-query": {
                 sourceTypeName: `${variables.pascalCase}BootstrapQuery`,
             },
+            "write-state-request": {
+                sourceTypeName: `${variables.pascalCase}WriteStateRequest`,
+            },
             "bootstrap-response": {
                 sourceTypeName: `${variables.pascalCase}BootstrapResponse`,
             },
-            "state-query": {
-                sourceTypeName: `${variables.pascalCase}StateQuery`,
-            },
             "state-response": {
                 sourceTypeName: `${variables.pascalCase}StateResponse`,
             },
-            "write-state-request": {
-                sourceTypeName: `${variables.pascalCase}WriteStateRequest`,
-            },
         },
         endpoints: [
             {
@@ -67,6 +67,29 @@ export function buildPersistenceEndpointManifest(variables) {
         },
     });
 }
+/**
+ * Build the canonical output plan shared by scaffold generation and previews.
+ *
+ * @param options Scaffold output paths plus persistence template variables.
+ * @returns REST schema, aggregate OpenAPI, and client output paths.
+ */
+export function buildPersistenceRestArtifactPlan(options) {
+    const manifest = buildPersistenceEndpointManifest(options.variables);
+    return {
+        clientFile: path.join(options.outputDir, "api-client.ts"),
+        manifest,
+        openApiFile: path.join(options.outputDir, "api.openapi.json"),
+        schemas: Object.entries(manifest.contracts).map(([baseName, contract]) => ({
+            jsonSchemaFile: path.join(options.outputDir, "api-schemas", `${baseName}.schema.json`),
+            openApiFile: path.join(options.outputDir, "api-schemas", `${baseName}.openapi.json`),
+            openApiInfo: {
+                title: contract.sourceTypeName,
+                version: "1.0.0",
+            },
+            sourceTypeName: contract.sourceTypeName,
+        })),
+    };
+}
 /**
  * Generate the REST-derived persistence artifacts for a scaffolded block.
  *
@@ -74,25 +97,28 @@ export function buildPersistenceEndpointManifest(variables) {
  * @returns A promise that resolves after schema, OpenAPI, and client files are written.
  */
 export async function syncPersistenceRestArtifacts({ apiTypesFile, outputDir, projectDir, variables, }) {
-    const manifest = buildPersistenceEndpointManifest(variables);
-    for (const [baseName, contract] of Object.entries(manifest.contracts)) {
+    const plan = buildPersistenceRestArtifactPlan({
+        apiTypesFile,
+        outputDir,
+        projectDir,
+        variables,
+    });
+    for (const schema of plan.schemas) {
         await syncTypeSchemas({
-            jsonSchemaFile: path.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-            openApiFile: path.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+            ...schema,
             projectRoot: projectDir,
-            sourceTypeName: contract.sourceTypeName,
             typesFile: apiTypesFile,
         });
     }
     await syncRestOpenApi({
-        manifest,
-        openApiFile: path.join(outputDir, "api.openapi.json"),
+        manifest: plan.manifest,
+        openApiFile: plan.openApiFile,
         projectRoot: projectDir,
         typesFile: apiTypesFile,
     });
     await syncEndpointClient({
-        clientFile: path.join(outputDir, "api-client.ts"),
-        manifest,
+        clientFile: plan.clientFile,
+        manifest: plan.manifest,
         projectRoot: projectDir,
         typesFile: apiTypesFile,
     });

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

@@ -4,6 +4,7 @@
 export interface CliDiagnosticMessage {
     code: CliDiagnosticCode;
     command: string;
+    data?: Record<string, unknown>;
     detailLines: string[];
     summary: string;
 }
@@ -12,6 +13,7 @@ export declare const CLI_DIAGNOSTIC_CODES: {
     readonly CONFIGURATION_MISSING: "configuration-missing";
     readonly DEPENDENCIES_NOT_INSTALLED: "dependencies-not-installed";
     readonly DOCTOR_CHECK_FAILED: "doctor-check-failed";
+    readonly GENERATED_ARTIFACT_DRIFT: "generated-artifact-drift";
     readonly INVALID_ARGUMENT: "invalid-argument";
     readonly INVALID_COMMAND: "invalid-command";
     readonly MISSING_ARGUMENT: "missing-argument";
@@ -52,6 +54,10 @@ export declare const CLI_DIAGNOSTIC_CODE_METADATA: {
         cause: string;
         recovery: string;
     };
+    "generated-artifact-drift": {
+        cause: string;
+        recovery: string;
+    };
     "invalid-argument": {
         cause: string;
         recovery: string;
@@ -104,6 +110,7 @@ type DoctorCheckLike = {
 export declare class CliDiagnosticError extends Error {
     readonly code: CliDiagnosticCode;
     readonly command: string;
+    readonly data?: Record<string, unknown>;
     readonly detailLines: string[];
     readonly summary: string;
     constructor(message: CliDiagnosticMessage, options?: ErrorOptions);
@@ -130,6 +137,7 @@ export declare function createCliDiagnosticCodeError<TCode extends CliDiagnostic
 export declare function createCliCommandError(options: {
     command: string;
     code?: CliDiagnosticCode;
+    data?: Record<string, unknown>;
     detailLines?: string[];
     error?: unknown;
     summary?: string;
@@ -142,6 +150,7 @@ export declare function formatCliDiagnosticError(error: unknown): string;
 export declare function serializeCliDiagnosticError(error: unknown): {
     code: CliDiagnosticCode;
     command?: string;
+    data?: Record<string, unknown>;
     detailLines?: string[];
     kind: "command-execution";
     message: string;

package/dist/runtime/cli/cli-diagnostics.js

@@ -3,6 +3,7 @@ export const CLI_DIAGNOSTIC_CODES = {
     CONFIGURATION_MISSING: "configuration-missing",
     DEPENDENCIES_NOT_INSTALLED: "dependencies-not-installed",
     DOCTOR_CHECK_FAILED: "doctor-check-failed",
+    GENERATED_ARTIFACT_DRIFT: "generated-artifact-drift",
     INVALID_ARGUMENT: "invalid-argument",
     INVALID_COMMAND: "invalid-command",
     MISSING_ARGUMENT: "missing-argument",
@@ -33,6 +34,10 @@ export const CLI_DIAGNOSTIC_CODE_METADATA = {
         cause: "One or more doctor checks reported a failing environment or workspace row.",
         recovery: "Inspect the failed check labels and details, fix the reported drift or missing prerequisite, then rerun `wp-typia doctor`.",
     },
+    [CLI_DIAGNOSTIC_CODES.GENERATED_ARTIFACT_DRIFT]: {
+        cause: "One or more generated project artifacts are missing or differ from the TypeScript source of truth.",
+        recovery: "Run the reported project sync command to regenerate artifacts, then rerun `wp-typia sync --check`.",
+    },
     [CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT]: {
         cause: "An argument was present but did not match the supported value, shape, or project state.",
         recovery: "Correct the argument value using command help or the detail lines, then rerun the command.",
@@ -182,6 +187,7 @@ export class CliDiagnosticError extends Error {
         super(formatCliDiagnosticBlock(message), options);
         this.code = message.code;
         this.command = message.command;
+        this.data = message.data ? { ...message.data } : undefined;
         this.detailLines = [...message.detailLines];
         this.name = "CliDiagnosticError";
         this.summary = message.summary;
@@ -301,6 +307,7 @@ export function createCliCommandError(options) {
     return new CliDiagnosticError({
         code,
         command: options.command,
+        ...(options.data ? { data: options.data } : {}),
         detailLines,
         summary,
     }, options.error instanceof Error ? { cause: options.error } : undefined);
@@ -325,6 +332,7 @@ export function serializeCliDiagnosticError(error) {
         return {
             code: error.code,
             command: error.command,
+            ...(error.data ? { data: { ...error.data } } : {}),
             detailLines: [...error.detailLines],
             kind: "command-execution",
             message: formatCliDiagnosticBlock({

package/dist/runtime/cli/cli-init-package-json.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from "./cli-diagnostics.js";
 import { getPackageManager, transformPackageManagerText, } from "../shared/package-managers.js";
-import { getPackageVersions } from "../shared/package-versions.js";
+import { DEFAULT_WORDPRESS_BLOCKS_TYPES_VERSION, DEFAULT_WORDPRESS_BLOCKS_VERSION, getPackageVersions, } from "../shared/package-versions.js";
 import { readJsonFileSync } from "../shared/json-utils.js";
 import { parseWorkspacePackageManagerId } from "../workspace/workspace-project.js";
 const BASE_RETROFIT_SCRIPTS = {
@@ -12,6 +12,8 @@ const BASE_RETROFIT_SCRIPTS = {
 };
 const BASE_RETROFIT_DEV_DEPENDENCIES = [
     "@typia/unplugin",
+    "@types/wordpress__blocks",
+    "@wordpress/blocks",
     "@wp-typia/block-runtime",
     "@wp-typia/block-types",
     "tsx",
@@ -72,6 +74,8 @@ function buildRequiredDevDependencyMap() {
     const versions = getPackageVersions();
     return {
         "@typia/unplugin": versions.typiaUnpluginPackageVersion,
+        "@types/wordpress__blocks": DEFAULT_WORDPRESS_BLOCKS_TYPES_VERSION,
+        "@wordpress/blocks": DEFAULT_WORDPRESS_BLOCKS_VERSION,
         "@wp-typia/block-runtime": versions.blockRuntimePackageVersion,
         "@wp-typia/block-types": versions.blockTypesPackageVersion,
         tsx: versions.tsxPackageVersion,

package/dist/runtime/doctor/cli-doctor-standalone-control-flow.d.ts

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+export interface CanonicalRuntimeImportShape {
+    defaultBinding?: string;
+    namedBindings?: ReadonlySet<string>;
+}
+/**
+ * Check whether a generated sync helper statement is inert until main() runs.
+ * Runtime imports are limited to the modules used by that helper; all other
+ * imports must be erased by TypeScript.
+ */
+export declare function isAllowedSyncHelperTopLevelStatement(statement: ts.Statement, allowedRuntimeImportModules: ReadonlySet<string>, isAllowedVariableStatement?: (statement: ts.VariableStatement) => boolean): boolean;
+/** Require runtime imports to match the generated helper's load-time API. */
+export declare function hasCanonicalRuntimeImports(sourceFile: ts.SourceFile, expectedImports: ReadonlyMap<string, CanonicalRuntimeImportShape>): boolean;
+/** Find a control-flow completion without crossing a nested function boundary. */
+export declare function containsCompletion(node: ts.Node, isTerminal: (candidate: ts.Node) => boolean): boolean;
+/** Unwrap supported static TypeScript wrappers to reach the underlying expression. */
+export declare function unwrapStaticExpression(expression: ts.Expression): ts.Expression;
+/** Validate the generated main().catch() failure boundary. */
+export declare function isCanonicalSyncMainCatchHandler(rawHandler: ts.Expression): boolean;
+/** Return a side-effect-free `new Error(message)` expression when present. */
+export declare function getSafeErrorConstruction(rawExpression: ts.Expression): ts.NewExpression | null;
+/** Validate a side-effect-free `new Error(message)` expression. */
+export declare function isSafeErrorConstruction(rawExpression: ts.Expression): boolean;
+/** Require the generated parser's terminal unknown-flag failure. */
+export declare function hasCanonicalUnknownFlagThrow(body: ts.Statement, argumentBinding: string): boolean;
+/**
+ * Reject executable parser work beyond the generated option assignments.
+ * Parser bodies are inspected rather than executed by doctor, so accepting an
+ * unrelated call or mutation here would let the real sync command diverge from
+ * the replayed options.
+ */
+export declare function hasOnlyCanonicalParserEffects(node: ts.Node, optionsBinding: string, indexBinding?: string | null): boolean;
+/** Count continues that target the generated parser's outer argument loop. */
+export declare function countOuterParserContinues(node: ts.Node): number;
+/** Detect a static process.exit() call, regardless of its exit code. */
+export declare function isProcessExitCompletion(node: ts.Node): boolean;
+/** Check whether a prior statement can terminate the current function. */
+export declare function hasEarlierAbruptCompletion(statements: readonly ts.Statement[], statementIndex: number): boolean;