@wp-typia/project-tools 0.11.1 → 0.12.0

package/dist/runtime/cli-doctor.js

@@ -5,6 +5,17 @@ import { execFileSync } from "node:child_process";
 import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
 import { getBuiltInTemplateLayerDirs } from "./template-builtins.js";
 import { listTemplates } from "./template-registry.js";
+import { readWorkspaceInventory } from "./workspace-inventory.js";
+import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, WORKSPACE_TEMPLATE_PACKAGE, tryResolveWorkspaceProject, } from "./workspace-project.js";
+const WORKSPACE_COLLECTION_IMPORT_LINE = "import '../../collection';";
+const WORKSPACE_COLLECTION_IMPORT_PATTERN = /^\s*import\s+["']\.\.\/\.\.\/collection["']\s*;?\s*$/m;
+const WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
+    "block.json",
+    "typia.manifest.json",
+    "typia.schema.json",
+    "typia-validator.php",
+    "typia.openapi.json",
+];
 function readCommandVersion(command, args = ["--version"]) {
     try {
         return execFileSync(command, args, {
@@ -40,6 +51,132 @@ async function checkTempDirectory() {
         return false;
     }
 }
+function createDoctorCheck(label, status, detail) {
+    return { detail, label, status };
+}
+function getWorkspaceBootstrapRelativePath(packageName) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    return `${packageBaseName}.php`;
+}
+function checkExistingFiles(projectDir, label, filePaths) {
+    const missing = filePaths
+        .filter((filePath) => typeof filePath === "string")
+        .filter((filePath) => !fs.existsSync(path.join(projectDir, filePath)));
+    return createDoctorCheck(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
+}
+function checkWorkspacePackageMetadata(workspace, packageJson) {
+    const issues = [];
+    const packageName = packageJson.name;
+    const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0 ? packageName : workspace.packageName);
+    const wpTypia = packageJson.wpTypia;
+    if (typeof packageName !== "string" || packageName.length === 0) {
+        issues.push("package.json must define a string name for workspace bootstrap resolution");
+    }
+    if (wpTypia?.projectType !== "workspace") {
+        issues.push('wpTypia.projectType must be "workspace"');
+    }
+    if (wpTypia?.templatePackage !== WORKSPACE_TEMPLATE_PACKAGE) {
+        issues.push(`wpTypia.templatePackage must be "${WORKSPACE_TEMPLATE_PACKAGE}"`);
+    }
+    if (wpTypia?.namespace !== workspace.workspace.namespace) {
+        issues.push(`wpTypia.namespace must equal "${workspace.workspace.namespace}"`);
+    }
+    if (wpTypia?.textDomain !== workspace.workspace.textDomain) {
+        issues.push(`wpTypia.textDomain must equal "${workspace.workspace.textDomain}"`);
+    }
+    if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
+        issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
+    }
+    if (!fs.existsSync(path.join(workspace.projectDir, bootstrapRelativePath))) {
+        issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
+    }
+    return createDoctorCheck("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}`
+        : issues.join("; "));
+}
+function getWorkspaceBlockRequiredFiles(block) {
+    const blockDir = path.join("src", "blocks", block.slug);
+    return Array.from(new Set([
+        block.typesFile,
+        block.apiTypesFile,
+        block.openApiFile,
+        path.join(blockDir, "index.tsx"),
+        ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path.join(blockDir, fileName)),
+    ].filter((filePath) => typeof filePath === "string")));
+}
+function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
+    const blockJsonRelativePath = path.join("src", "blocks", block.slug, "block.json");
+    const blockJsonPath = path.join(projectDir, blockJsonRelativePath);
+    if (!fs.existsSync(blockJsonPath)) {
+        return createDoctorCheck(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
+    }
+    let blockJson;
+    try {
+        blockJson = JSON.parse(fs.readFileSync(blockJsonPath, "utf8"));
+    }
+    catch (error) {
+        return createDoctorCheck(`Block metadata ${block.slug}`, "fail", error instanceof Error ? error.message : String(error));
+    }
+    const expectedName = `${workspace.workspace.namespace}/${block.slug}`;
+    const issues = [];
+    if (blockJson.name !== expectedName) {
+        issues.push(`block.json name must equal "${expectedName}"`);
+    }
+    if (blockJson.textdomain !== workspace.workspace.textDomain) {
+        issues.push(`block.json textdomain must equal "${workspace.workspace.textDomain}"`);
+    }
+    return createDoctorCheck(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}`
+        : issues.join("; "));
+}
+function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
+    const entryRelativePath = path.join("src", "blocks", blockSlug, "index.tsx");
+    const entryPath = path.join(projectDir, entryRelativePath);
+    if (!fs.existsSync(entryPath)) {
+        return createDoctorCheck(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
+    }
+    const source = fs.readFileSync(entryPath, "utf8");
+    const hasCollectionImport = WORKSPACE_COLLECTION_IMPORT_PATTERN.test(source);
+    return createDoctorCheck(`Block collection ${blockSlug}`, hasCollectionImport ? "pass" : "fail", hasCollectionImport
+        ? "Shared block collection import is present"
+        : `Missing a shared collection import like ${WORKSPACE_COLLECTION_IMPORT_LINE}`);
+}
+function checkWorkspacePatternBootstrap(projectDir, packageName) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Pattern bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const hasCategoryAnchor = source.includes("register_block_pattern_category");
+    const hasPatternGlob = source.includes("/src/patterns/*.php");
+    return createDoctorCheck("Pattern bootstrap", hasCategoryAnchor && hasPatternGlob ? "pass" : "fail", hasCategoryAnchor && hasPatternGlob
+        ? "Pattern category and loader hooks are present"
+        : "Missing pattern category registration or src/patterns loader hook");
+}
+function checkVariationEntrypoint(projectDir, blockSlug) {
+    const entryPath = path.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+    if (!fs.existsSync(entryPath)) {
+        return createDoctorCheck(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path.relative(projectDir, entryPath)}`);
+    }
+    const source = fs.readFileSync(entryPath, "utf8");
+    const hasImport = source.includes("./variations");
+    const hasCall = source.includes("registerWorkspaceVariations()");
+    return createDoctorCheck(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall
+        ? "Variations registration hook is present"
+        : "Missing ./variations import or registerWorkspaceVariations() call");
+}
+function checkMigrationWorkspaceHint(workspace, packageJson) {
+    const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
+    const migrationConfigRelativePath = path.join("src", "migrations", "config.ts");
+    const hasMigrationConfig = fs.existsSync(path.join(workspace.projectDir, migrationConfigRelativePath));
+    if (!hasMigrationScript && !hasMigrationConfig) {
+        return null;
+    }
+    return createDoctorCheck("Migration workspace", hasMigrationConfig ? "pass" : "fail", hasMigrationConfig
+        ? "Run `wp-typia migrate doctor --all` for migration target, snapshot, fixture, and generated artifact checks"
+        : `Missing ${migrationConfigRelativePath} for the configured migration workspace`);
+}
 /**
  * Collect all runtime doctor checks for the current environment.
  *
@@ -109,6 +246,71 @@ export async function getDoctorChecks(cwd) {
             detail: hasAssets ? layerDirs.join(" + ") : "Missing core template assets",
         });
     }
+    let workspace = null;
+    let invalidWorkspaceReason = null;
+    try {
+        invalidWorkspaceReason = getInvalidWorkspaceProjectReason(cwd);
+        workspace = tryResolveWorkspaceProject(cwd);
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+        return checks;
+    }
+    if (!workspace) {
+        if (invalidWorkspaceReason) {
+            checks.push(createDoctorCheck("Workspace package metadata", "fail", invalidWorkspaceReason));
+        }
+        return checks;
+    }
+    checks.push(createDoctorCheck("Workspace marker", "pass", `Official workspace detected for ${workspace.workspace.namespace}`));
+    let workspacePackageJson;
+    try {
+        workspacePackageJson = parseWorkspacePackageJson(workspace.projectDir);
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+        return checks;
+    }
+    checks.push(checkWorkspacePackageMetadata(workspace, workspacePackageJson));
+    try {
+        const inventory = readWorkspaceInventory(workspace.projectDir);
+        checks.push(createDoctorCheck("Workspace inventory", "pass", `${inventory.blocks.length} block(s), ${inventory.variations.length} variation(s), ${inventory.patterns.length} pattern(s)`));
+        for (const block of inventory.blocks) {
+            checks.push(checkExistingFiles(workspace.projectDir, `Block ${block.slug}`, [
+                ...getWorkspaceBlockRequiredFiles(block),
+            ]));
+            checks.push(checkWorkspaceBlockMetadata(workspace.projectDir, workspace, block));
+            checks.push(checkWorkspaceBlockCollectionImport(workspace.projectDir, block.slug));
+        }
+        const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
+        const variationTargetBlocks = new Set();
+        for (const variation of inventory.variations) {
+            if (!registeredBlockSlugs.has(variation.block)) {
+                checks.push(createDoctorCheck(`Variation ${variation.block}/${variation.slug}`, "fail", `Variation references unknown block "${variation.block}"`));
+                continue;
+            }
+            variationTargetBlocks.add(variation.block);
+            checks.push(checkExistingFiles(workspace.projectDir, `Variation ${variation.block}/${variation.slug}`, [variation.file]));
+        }
+        for (const blockSlug of variationTargetBlocks) {
+            checks.push(checkVariationEntrypoint(workspace.projectDir, blockSlug));
+        }
+        const shouldCheckPatternBootstrap = inventory.patterns.length > 0 ||
+            fs.existsSync(path.join(workspace.projectDir, "src", "patterns"));
+        if (shouldCheckPatternBootstrap) {
+            checks.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
+        }
+        for (const pattern of inventory.patterns) {
+            checks.push(checkExistingFiles(workspace.projectDir, `Pattern ${pattern.slug}`, [pattern.file]));
+        }
+        const migrationWorkspaceCheck = checkMigrationWorkspaceHint(workspace, workspacePackageJson);
+        if (migrationWorkspaceCheck) {
+            checks.push(migrationWorkspaceCheck);
+        }
+    }
+    catch (error) {
+        checks.push(createDoctorCheck("Workspace inventory", "fail", error instanceof Error ? error.message : String(error)));
+    }
     return checks;
 }
 /**

package/dist/runtime/cli-help.js

@@ -17,8 +17,8 @@ export function formatHelpText() {
   wp-typia create <project-dir> [--template compound] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
   wp-typia <project-dir> [create flags...]
   wp-typia add block <name> --template <basic|interactivity|persistence|compound> [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
-  wp-typia add variation
-  wp-typia add pattern
+  wp-typia add variation <name> --block <block-slug>
+  wp-typia add pattern <name>
   wp-typia migrate <init|snapshot|diff|scaffold|verify|doctor|fixtures|fuzz> [...]
   wp-typia templates list
   wp-typia templates inspect <id>
@@ -32,6 +32,9 @@ Package managers: ${PACKAGE_MANAGER_IDS.join(", ")}
 Notes:
   \`wp-typia create\` is the canonical scaffold command.
   \`wp-typia <project-dir>\` remains a backward-compatible alias to \`create\`.
-  \`add variation\` and \`add pattern\` are reserved placeholders in this release.
+  \`add variation\` uses an existing workspace block from \`scripts/block-config.ts\`.
+  \`add pattern\` scaffolds a namespaced PHP pattern shell under \`src/patterns/\`.
+  \`wp-typia doctor\` checks environment readiness plus workspace inventory and source-tree drift.
+  \`wp-typia migrate doctor --all\` checks migration target alignment, snapshots, fixtures, and generated migration artifacts.
   \`migrate\` is the canonical migration command; \`migrations\` is no longer supported.`;
 }

package/dist/runtime/index.d.ts

@@ -1,9 +1,20 @@
+/**
+ * Public runtime surface for wp-typia project tools.
+ *
+ * This barrel exposes the stable orchestration APIs that power the `wp-typia`
+ * CLI while keeping reusable project logic out of the CLI package itself.
+ * Consumers should prefer these exports for scaffold, add, migrate, doctor,
+ * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`, and
+ * `runDoctor`.
+ */
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand, } from "./migrations.js";
+export { parseWorkspacePackageManagerId, resolveWorkspaceProject, tryResolveWorkspaceProject, } from "./workspace-project.js";
 export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, } from "./schema-core.js";
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 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 { createAddPlaceholderMessage, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, runAddBlockCommand, runDoctor, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, runAddBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
 export type { DoctorCheck, ReadlinePrompt } from "./cli-core.js";

package/dist/runtime/index.js

@@ -1,7 +1,18 @@
+/**
+ * Public runtime surface for wp-typia project tools.
+ *
+ * This barrel exposes the stable orchestration APIs that power the `wp-typia`
+ * CLI while keeping reusable project logic out of the CLI package itself.
+ * Consumers should prefer these exports for scaffold, add, migrate, doctor,
+ * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `runAddBlockCommand`, `runAddVariationCommand`, `runAddPatternCommand`, and
+ * `runDoctor`.
+ */
 export { scaffoldProject, collectScaffoldAnswers, getDefaultAnswers, getTemplateVariables, resolvePackageManagerId, resolveTemplateId, } from "./scaffold.js";
 export { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand, } from "./migrations.js";
+export { parseWorkspacePackageManagerId, resolveWorkspaceProject, tryResolveWorkspaceProject, } from "./workspace-project.js";
 export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, } from "./schema-core.js";
 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 { createAddPlaceholderMessage, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, runAddBlockCommand, runDoctor, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, formatAddHelpText, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, runAddBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/migrations.d.ts

@@ -1,7 +1,7 @@
 import { createMigrationDiff } from "./migration-diff.js";
 import { formatDiffReport } from "./migration-render.js";
 import { createMigrationRiskSummary } from "./migration-risk.js";
-import type { MigrationBlockConfig, ParsedMigrationArgs, RenderLine } from "./migration-types.js";
+import type { MigrationBlockConfig, MigrationProjectState, ParsedMigrationArgs, RenderLine } from "./migration-types.js";
 import type { ReadlinePrompt } from "./cli-prompt.js";
 type CommandRenderOptions = {
     prompt?: ReadlinePrompt;
@@ -78,7 +78,7 @@ export { formatDiffReport };
  * @param options Optional prompt/render hooks for testable and interactive execution.
  * @returns The command result, or a promise when the selected command is interactive.
  */
-export declare function runMigrationCommand(command: ParsedMigrationArgs, cwd: string, { prompt, renderLine }?: CommandRenderOptions): import("./migration-types.js").MigrationProjectState | import("./migration-types.js").MigrationDiff | MigrationPlanSummary | Promise<MigrationPlanSummary | {
+export declare function runMigrationCommand(command: ParsedMigrationArgs, cwd: string, { prompt, renderLine }?: CommandRenderOptions): MigrationProjectState | import("./migration-types.js").MigrationDiff | MigrationPlanSummary | Promise<MigrationPlanSummary | {
     cancelled: true;
 }> | {
     block: import("./migration-types.js").ResolvedMigrationBlockTarget;
@@ -139,7 +139,7 @@ export declare function wizardProjectMigrations(projectDir: string, { isInteract
  * @returns The loaded migration project state after the config, snapshots, and generated files are written.
  * @throws Error When the project layout is unsupported or the migration version label is invalid.
  */
-export declare function initProjectMigrations(projectDir: string, currentMigrationVersion: string, { renderLine }?: CommandRenderOptions): import("./migration-types.js").MigrationProjectState;
+export declare function initProjectMigrations(projectDir: string, currentMigrationVersion: string, { renderLine }?: CommandRenderOptions): MigrationProjectState;
 /**
  * Captures the current project state as a named migration snapshot and refreshes generated artifacts.
  *
@@ -152,7 +152,7 @@ export declare function initProjectMigrations(projectDir: string, currentMigrati
 export declare function snapshotProjectVersion(projectDir: string, migrationVersion: string, { renderLine, skipConfigUpdate, skipSyncTypes, }?: CommandRenderOptions & {
     skipConfigUpdate?: boolean;
     skipSyncTypes?: boolean;
-}): import("./migration-types.js").MigrationProjectState;
+}): MigrationProjectState;
 /**
  * Computes and renders migration diffs for a selected legacy-to-target edge.
  *
@@ -246,4 +246,4 @@ export declare function fuzzProjectMigrations(projectDir: string, { all, fromMig
  * @param options Console rendering options for initialization output.
  * @returns The loaded migration project state after initialization completes.
  */
-export declare function seedProjectMigrations(projectDir: string, currentMigrationVersion: string, blocks: MigrationBlockConfig[], { renderLine }?: CommandRenderOptions): import("./migration-types.js").MigrationProjectState;
+export declare function seedProjectMigrations(projectDir: string, currentMigrationVersion: string, blocks: MigrationBlockConfig[], { renderLine }?: CommandRenderOptions): MigrationProjectState;

package/dist/runtime/migrations.js

@@ -11,6 +11,8 @@ import { assertRuleHasNoTodos, assertNoLegacySemverMigrationWorkspace, discoverM
 import { formatDiffReport, renderFuzzFile, renderGeneratedDeprecatedFile, renderGeneratedMigrationIndexFile, renderMigrationRegistryFile, renderMigrationRuleFile, renderPhpMigrationRegistryFile, renderVerifyFile, } from "./migration-render.js";
 import { createMigrationRiskSummary, formatMigrationRiskSummary } from "./migration-risk.js";
 import { assertMigrationVersionLabel, compareMigrationVersionLabels, copyFile, detectPackageManagerId, formatLegacyMigrationWorkspaceResetGuidance, getLocalTsxBinary, isInteractiveTerminal, readJson, resolveTargetMigrationVersion, runProjectScriptIfPresent, sanitizeSaveSnapshotSource, sanitizeSnapshotBlockJson, } from "./migration-utils.js";
+import { readWorkspaceInventory } from "./workspace-inventory.js";
+import { getInvalidWorkspaceProjectReason, tryResolveWorkspaceProject } from "./workspace-project.js";
 /**
  * Returns the formatted help text for migration CLI commands and flags.
  *
@@ -561,6 +563,48 @@ export function verifyProjectMigrations(projectDir, { all = false, fromMigration
     }
     return { verifiedVersions: targetVersions };
 }
+function recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck) {
+    let invalidWorkspaceReason = null;
+    let workspace;
+    try {
+        invalidWorkspaceReason = getInvalidWorkspaceProjectReason(projectDir);
+        workspace = tryResolveWorkspaceProject(projectDir);
+    }
+    catch (error) {
+        recordCheck("fail", "Workspace migration targets", error instanceof Error ? error.message : String(error));
+        return;
+    }
+    if (!workspace) {
+        if (invalidWorkspaceReason) {
+            recordCheck("fail", "Workspace migration targets", invalidWorkspaceReason);
+        }
+        return;
+    }
+    try {
+        const inventory = readWorkspaceInventory(workspace.projectDir);
+        const expectedTargets = inventory.blocks.map((block) => `${workspace.workspace.namespace}/${block.slug}`);
+        const configuredTargets = state.blocks.map((block) => block.blockName);
+        const expectedTargetSet = new Set(expectedTargets);
+        const configuredTargetSet = new Set(configuredTargets);
+        const missingTargets = expectedTargets.filter((target) => !configuredTargetSet.has(target));
+        const staleTargets = configuredTargets.filter((target) => !expectedTargetSet.has(target));
+        recordCheck(missingTargets.length === 0 && staleTargets.length === 0 ? "pass" : "fail", "Workspace migration targets", missingTargets.length === 0 && staleTargets.length === 0
+            ? `${expectedTargets.length} workspace block target(s) align with migration config`
+            : [
+                missingTargets.length > 0
+                    ? `Missing from migration config: ${missingTargets.join(", ")}`
+                    : null,
+                staleTargets.length > 0
+                    ? `Not present in scripts/block-config.ts: ${staleTargets.join(", ")}`
+                    : null,
+            ]
+                .filter((detail) => typeof detail === "string")
+                .join("; "));
+    }
+    catch (error) {
+        recordCheck("fail", "Workspace migration targets", error instanceof Error ? error.message : String(error));
+    }
+}
 /**
  * Validate the migration workspace without mutating files.
  *
@@ -591,6 +635,7 @@ export function doctorProjectMigrations(projectDir, { all = false, fromMigration
     const snapshotVersions = new Set(targetVersions.length > 0
         ? [state.config.currentMigrationVersion, ...targetVersions]
         : state.config.supportedMigrationVersions);
+    recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck);
     for (const version of snapshotVersions) {
         for (const block of state.blocks) {
             const snapshotRoot = getSnapshotRoot(projectDir, block, version);

package/dist/runtime/package-managers.js

@@ -2,7 +2,7 @@ const PACKAGE_MANAGER_DATA = [
     {
         id: "bun",
         label: "Bun",
-        packageManagerField: "bun@1.3.10",
+        packageManagerField: "bun@1.3.11",
         installCommand: "bun install",
         frozenInstallCommand: "bun install --frozen-lockfile",
     },

package/dist/runtime/workspace-inventory.d.ts

@@ -0,0 +1,84 @@
+export interface WorkspaceBlockInventoryEntry {
+    apiTypesFile?: string;
+    attributeTypeName?: string;
+    openApiFile?: string;
+    slug: string;
+    typesFile: string;
+}
+export interface WorkspaceVariationInventoryEntry {
+    block: string;
+    file: string;
+    slug: string;
+}
+export interface WorkspacePatternInventoryEntry {
+    file: string;
+    slug: string;
+}
+export interface WorkspaceInventory {
+    blockConfigPath: string;
+    blocks: WorkspaceBlockInventoryEntry[];
+    hasPatternsSection: boolean;
+    hasVariationsSection: boolean;
+    patterns: WorkspacePatternInventoryEntry[];
+    source: string;
+    variations: WorkspaceVariationInventoryEntry[];
+}
+export declare const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
+export declare const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
+export declare const PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
+/**
+ * Parse workspace inventory entries from the source of `scripts/block-config.ts`.
+ *
+ * @param source Raw TypeScript source from `scripts/block-config.ts`.
+ * @returns Parsed inventory sections without the resolved `blockConfigPath`.
+ * @throws {Error} When `BLOCKS` is missing or any inventory entry is malformed.
+ */
+export declare function parseWorkspaceInventorySource(source: string): Omit<WorkspaceInventory, "blockConfigPath">;
+/**
+ * Read and parse the canonical workspace inventory file.
+ *
+ * @param projectDir Workspace root directory.
+ * @returns Parsed `WorkspaceInventory` including the resolved `blockConfigPath`.
+ * @throws {Error} When `scripts/block-config.ts` is missing or invalid.
+ */
+export declare function readWorkspaceInventory(projectDir: string): WorkspaceInventory;
+/**
+ * Return select options for the current workspace block inventory.
+ *
+ * The `description` field mirrors `block.typesFile`, while `name` and `value`
+ * both map to the block slug for use in interactive add flows.
+ *
+ * @param projectDir Workspace root directory.
+ * @returns Block options for variation-target selection.
+ */
+export declare function getWorkspaceBlockSelectOptions(projectDir: string): Array<{
+    description: string;
+    name: string;
+    value: string;
+}>;
+/**
+ * Update `scripts/block-config.ts` source text with additional inventory entries.
+ *
+ * Missing `VARIATIONS` and `PATTERNS` sections are created automatically before
+ * new entries are appended at their marker comments. When provided,
+ * `transformSource` runs before any entries are inserted.
+ *
+ * @param source Existing `scripts/block-config.ts` source.
+ * @param options Entry lists plus an optional source transformer.
+ * @returns Updated source text with all requested inventory entries appended.
+ */
+export declare function updateWorkspaceInventorySource(source: string, { blockEntries, patternEntries, variationEntries, transformSource, }?: {
+    blockEntries?: string[];
+    patternEntries?: string[];
+    transformSource?: (source: string) => string;
+    variationEntries?: string[];
+}): string;
+/**
+ * Append new entries to the canonical workspace inventory file on disk.
+ *
+ * @param projectDir Workspace root directory.
+ * @param options Entry lists and optional source transform passed through to
+ * `updateWorkspaceInventorySource`.
+ * @returns Resolves once `scripts/block-config.ts` has been updated if needed.
+ */
+export declare function appendWorkspaceInventoryEntries(projectDir: string, options: Parameters<typeof updateWorkspaceInventorySource>[1]): Promise<void>;