@wp-typia/project-tools 0.22.10 → 0.23.1

package/dist/runtime/cli-doctor-workspace-features.js

@@ -1,331 +1,9 @@
-import fs from "node:fs";
-import path from "node:path";
-import { EDITOR_PLUGIN_SLOT_IDS, REST_RESOURCE_METHOD_IDS, REST_RESOURCE_NAMESPACE_PATTERN, resolveEditorPluginSlotAlias, } from "./cli-add-shared.js";
-import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_ABILITY_EDITOR_ASSET, WORKSPACE_ABILITY_EDITOR_SCRIPT, WORKSPACE_ABILITY_GLOB, WORKSPACE_ADMIN_VIEW_ASSET, WORKSPACE_ADMIN_VIEW_GLOB, WORKSPACE_ADMIN_VIEW_SCRIPT, WORKSPACE_ADMIN_VIEW_STYLE, WORKSPACE_AI_FEATURE_GLOB, WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET, WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT, WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE, WORKSPACE_REST_RESOURCE_GLOB, } from "./cli-doctor-workspace-shared.js";
-import { escapeRegex } from "./php-utils.js";
-function getWorkspaceRestResourceRequiredFiles(restResource) {
-    const schemaNames = new Set();
-    if (restResource.methods.includes("list")) {
-        schemaNames.add("list-query");
-        schemaNames.add("list-response");
-    }
-    if (restResource.methods.includes("read")) {
-        schemaNames.add("read-query");
-        schemaNames.add("read-response");
-    }
-    if (restResource.methods.includes("create")) {
-        schemaNames.add("create-request");
-        schemaNames.add("create-response");
-    }
-    if (restResource.methods.includes("update")) {
-        schemaNames.add("update-query");
-        schemaNames.add("update-request");
-        schemaNames.add("update-response");
-    }
-    if (restResource.methods.includes("delete")) {
-        schemaNames.add("delete-query");
-        schemaNames.add("delete-response");
-    }
-    return Array.from(new Set([
-        restResource.apiFile,
-        ...Array.from(schemaNames, (schemaName) => path.join(path.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
-        restResource.clientFile,
-        restResource.dataFile,
-        restResource.openApiFile,
-        restResource.phpFile,
-        restResource.typesFile,
-        restResource.validatorsFile,
-    ]));
-}
-function checkWorkspaceRestResourceConfig(restResource) {
-    const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(restResource.namespace);
-    const hasMethods = restResource.methods.length > 0 &&
-        restResource.methods.every((method) => REST_RESOURCE_METHOD_IDS.includes(method));
-    return createDoctorCheck(`REST resource config ${restResource.slug}`, hasNamespace && hasMethods ? "pass" : "fail", hasNamespace && hasMethods
-        ? `REST resource namespace ${restResource.namespace} with methods ${restResource.methods.join(", ")}`
-        : "REST resource namespace or methods are invalid");
-}
-function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
-    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-    if (!fs.existsSync(bootstrapPath)) {
-        return createDoctorCheck("REST resource bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
-    }
-    const source = fs.readFileSync(bootstrapPath, "utf8");
-    const registerFunctionName = `${phpPrefix}_register_rest_resources`;
-    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
-    const hasServerGlob = source.includes(WORKSPACE_REST_RESOURCE_GLOB);
-    const hasRegisterHook = source.includes(registerHook);
-    return createDoctorCheck("REST resource bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook
-        ? "REST resource PHP loader hook is present"
-        : "Missing REST resource PHP require glob or init hook");
-}
-function getWorkspaceAbilityRequiredFiles(ability) {
-    return Array.from(new Set([
-        ability.clientFile,
-        ability.configFile,
-        ability.dataFile,
-        ability.inputSchemaFile,
-        ability.outputSchemaFile,
-        ability.phpFile,
-        ability.typesFile,
-    ]));
-}
-function checkWorkspaceAbilityConfig(projectDir, ability) {
-    const configPath = path.join(projectDir, ability.configFile);
-    if (!fs.existsSync(configPath)) {
-        return createDoctorCheck(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
-    }
-    try {
-        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-        const abilityId = typeof config.abilityId === "string" ? config.abilityId.trim() : "";
-        const categorySlug = typeof config.category?.slug === "string"
-            ? config.category.slug.trim()
-            : "";
-        const hasValidAbilityId = /^[a-z0-9-]+\/[a-z0-9-]+$/u.test(abilityId);
-        const hasValidCategorySlug = /^[a-z0-9-]+$/u.test(categorySlug);
-        return createDoctorCheck(`Ability config ${ability.slug}`, hasValidAbilityId && hasValidCategorySlug ? "pass" : "fail", hasValidAbilityId && hasValidCategorySlug
-            ? `Ability id ${abilityId} in category ${categorySlug} is valid`
-            : "Ability config must define a valid abilityId (`namespace/ability-name`) and category.slug.");
-    }
-    catch (error) {
-        return createDoctorCheck(`Ability config ${ability.slug}`, "fail", error instanceof Error ? error.message : String(error));
-    }
-}
-function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
-    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-    if (!fs.existsSync(bootstrapPath)) {
-        return createDoctorCheck("Ability bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
-    }
-    const source = fs.readFileSync(bootstrapPath, "utf8");
-    const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
-    const enqueueFunctionName = `${phpPrefix}_enqueue_workflow_abilities`;
-    const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
-    const adminEnqueueHook = `add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );`;
-    const editorEnqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
-    const hasLoaderHook = source.includes(loadHook);
-    const hasAdminEnqueueHook = source.includes(adminEnqueueHook);
-    const hasEditorEnqueueHook = source.includes(editorEnqueueHook);
-    const hasServerGlob = source.includes(WORKSPACE_ABILITY_GLOB);
-    const hasEditorScript = source.includes(WORKSPACE_ABILITY_EDITOR_SCRIPT);
-    const hasEditorAsset = source.includes(WORKSPACE_ABILITY_EDITOR_ASSET);
-    const hasScriptModuleEnqueue = source.includes("wp_enqueue_script_module");
-    return createDoctorCheck("Ability bootstrap", hasLoaderHook &&
-        hasAdminEnqueueHook &&
-        hasEditorEnqueueHook &&
-        hasServerGlob &&
-        hasEditorScript &&
-        hasEditorAsset &&
-        hasScriptModuleEnqueue
-        ? "pass"
-        : "fail", hasLoaderHook &&
-        hasAdminEnqueueHook &&
-        hasEditorEnqueueHook &&
-        hasServerGlob &&
-        hasEditorScript &&
-        hasEditorAsset &&
-        hasScriptModuleEnqueue
-        ? "Ability loader and admin/editor script-module bootstrap hooks are present"
-        : "Missing ability loader hook, script-module enqueue, or build/abilities asset references");
-}
-function checkWorkspaceAbilityIndex(projectDir, abilities) {
-    const indexRelativePath = [
-        path.join("src", "abilities", "index.ts"),
-        path.join("src", "abilities", "index.js"),
-    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
-    if (!indexRelativePath) {
-        return createDoctorCheck("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
-    }
-    const indexPath = path.join(projectDir, indexRelativePath);
-    const source = fs.readFileSync(indexPath, "utf8");
-    const missingExports = abilities.filter((ability) => {
-        const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex(ability.slug)}\\/client['"\`]`, "mu");
-        return !exportPattern.test(source);
-    });
-    return createDoctorCheck("Abilities index", missingExports.length === 0 ? "pass" : "fail", missingExports.length === 0
-        ? "Ability client helpers are aggregated"
-        : `Missing ability exports for: ${missingExports.map((entry) => entry.slug).join(", ")}`);
-}
-function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
-    return Array.from(new Set([
-        aiFeature.aiSchemaFile,
-        aiFeature.apiFile,
-        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
-        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
-        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
-        aiFeature.clientFile,
-        aiFeature.dataFile,
-        aiFeature.openApiFile,
-        aiFeature.phpFile,
-        aiFeature.typesFile,
-        aiFeature.validatorsFile,
-    ]));
-}
-function checkWorkspaceAiFeatureConfig(aiFeature) {
-    const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(aiFeature.namespace);
-    return createDoctorCheck(`AI feature config ${aiFeature.slug}`, hasNamespace ? "pass" : "fail", hasNamespace
-        ? `AI feature namespace ${aiFeature.namespace} is valid`
-        : "AI feature namespace is invalid");
-}
-function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
-    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-    if (!fs.existsSync(bootstrapPath)) {
-        return createDoctorCheck("AI feature bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
-    }
-    const source = fs.readFileSync(bootstrapPath, "utf8");
-    const registerFunctionName = `${phpPrefix}_register_ai_features`;
-    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
-    const hasServerGlob = source.includes(WORKSPACE_AI_FEATURE_GLOB);
-    const hasRegisterHook = source.includes(registerHook);
-    return createDoctorCheck("AI feature bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook
-        ? "AI feature PHP loader hook is present"
-        : "Missing AI feature PHP require glob or init hook");
-}
-function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
-    const editorPluginDir = path.join("src", "editor-plugins", editorPlugin.slug);
-    const surfaceFile = editorPlugin.slot === "PluginSidebar"
-        ? path.join(editorPluginDir, "Sidebar.tsx")
-        : path.join(editorPluginDir, "Surface.tsx");
-    return Array.from(new Set([
-        editorPlugin.file,
-        surfaceFile,
-        path.join(editorPluginDir, "data.ts"),
-        path.join(editorPluginDir, "types.ts"),
-        path.join(editorPluginDir, "style.scss"),
-    ]));
-}
-function checkWorkspaceEditorPluginConfig(editorPlugin) {
-    const normalizedSlot = resolveEditorPluginSlotAlias(editorPlugin.slot);
-    const isValidSlot = Boolean(normalizedSlot);
-    return createDoctorCheck(`Editor plugin config ${editorPlugin.slug}`, isValidSlot ? "pass" : "fail", isValidSlot
-        ? `Editor plugin slot ${editorPlugin.slot} is supported as ${normalizedSlot}`
-        : `Unsupported editor plugin slot "${editorPlugin.slot}". Expected one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")} or legacy aliases PluginSidebar, PluginDocumentSettingPanel.`);
-}
-function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
-    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-    if (!fs.existsSync(bootstrapPath)) {
-        return createDoctorCheck("Editor plugin bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
-    }
-    const source = fs.readFileSync(bootstrapPath, "utf8");
-    const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
-    const enqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
-    const hasEditorEnqueueHook = source.includes(enqueueHook);
-    const hasEditorScript = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT);
-    const hasEditorAsset = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET);
-    const hasEditorStyle = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE);
-    return createDoctorCheck("Editor plugin bootstrap", hasEditorEnqueueHook && hasEditorScript && hasEditorAsset && hasEditorStyle ? "pass" : "fail", hasEditorEnqueueHook && hasEditorScript && hasEditorAsset && hasEditorStyle
-        ? "Editor plugin enqueue hook is present"
-        : "Missing editor plugin enqueue hook or build/editor-plugins script/style asset references");
-}
-function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
-    const indexRelativePath = [
-        path.join("src", "editor-plugins", "index.ts"),
-        path.join("src", "editor-plugins", "index.js"),
-    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
-    if (!indexRelativePath) {
-        return createDoctorCheck("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
-    }
-    const indexPath = path.join(projectDir, indexRelativePath);
-    const source = fs.readFileSync(indexPath, "utf8");
-    const missingImports = editorPlugins.filter((editorPlugin) => {
-        const importPattern = new RegExp(`['"\`]\\./${escapeRegex(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
-        return !importPattern.test(source);
-    });
-    return createDoctorCheck("Editor plugins index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0
-        ? "Editor plugin registrations are aggregated"
-        : `Missing editor plugin imports for: ${missingImports
-            .map((entry) => entry.slug)
-            .join(", ")}`);
-}
-function getWorkspaceAdminViewRequiredFiles(adminView) {
-    const adminViewDir = path.join("src", "admin-views", adminView.slug);
-    return Array.from(new Set([
-        adminView.file,
-        adminView.phpFile,
-        path.join(adminViewDir, "Screen.tsx"),
-        path.join(adminViewDir, "config.ts"),
-        path.join(adminViewDir, "data.ts"),
-        path.join(adminViewDir, "style.scss"),
-        path.join(adminViewDir, "types.ts"),
-    ]));
-}
-function checkWorkspaceAdminViewConfig(adminView, inventory) {
-    if (adminView.source === undefined) {
-        return createDoctorCheck(`Admin view config ${adminView.slug}`, "pass", "Admin view uses a replaceable local fetcher");
-    }
-    const source = adminView.source.trim();
-    const restSourceMatch = /^rest-resource:([a-z][a-z0-9-]*)$/u.exec(source);
-    const coreDataSourceMatch = /^core-data:(postType|taxonomy)\/([a-z0-9][a-z0-9_-]*)$/u.exec(source);
-    const restResourceSlug = restSourceMatch?.[1];
-    const restResource = restResourceSlug
-        ? inventory.restResources.find((entry) => entry.slug === restResourceSlug)
-        : undefined;
-    const isValid = Boolean(restResource?.methods.includes("list")) || Boolean(coreDataSourceMatch);
-    return createDoctorCheck(`Admin view config ${adminView.slug}`, isValid ? "pass" : "fail", isValid
-        ? `Admin view source ${source} is list-capable`
-        : "Admin view source must use rest-resource:<slug> with a list-capable REST resource or core-data:<postType|taxonomy>/<name>");
-}
-function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
-    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-    if (!fs.existsSync(bootstrapPath)) {
-        return createDoctorCheck("Admin view bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
-    }
-    const source = fs.readFileSync(bootstrapPath, "utf8");
-    const loadFunctionName = `${phpPrefix}_load_admin_views`;
-    const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
-    const hasLoaderHook = source.includes(loadHook);
-    const hasServerGlob = source.includes(WORKSPACE_ADMIN_VIEW_GLOB);
-    return createDoctorCheck("Admin view bootstrap", hasLoaderHook && hasServerGlob ? "pass" : "fail", hasLoaderHook && hasServerGlob
-        ? "Admin view PHP loader hook is present"
-        : "Missing admin view PHP require glob or plugins_loaded hook");
-}
-function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
-    const indexRelativePath = [
-        path.join("src", "admin-views", "index.ts"),
-        path.join("src", "admin-views", "index.js"),
-    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
-    if (!indexRelativePath) {
-        return createDoctorCheck("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
-    }
-    const indexPath = path.join(projectDir, indexRelativePath);
-    const source = fs.readFileSync(indexPath, "utf8");
-    const missingImports = adminViews.filter((adminView) => {
-        const importPattern = new RegExp(`['"\`]\\./${escapeRegex(adminView.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
-        return !importPattern.test(source);
-    });
-    return createDoctorCheck("Admin views index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0
-        ? "Admin view registrations are aggregated"
-        : `Missing admin view imports for: ${missingImports
-            .map((entry) => entry.slug)
-            .join(", ")}`);
-}
-function checkWorkspaceAdminViewPhp(projectDir, adminView) {
-    const phpPath = path.join(projectDir, adminView.phpFile);
-    if (!fs.existsSync(phpPath)) {
-        return createDoctorCheck(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
-    }
-    const source = fs.readFileSync(phpPath, "utf8");
-    const hasAdminMenu = source.includes("add_submenu_page");
-    const hasAdminEnqueue = source.includes("admin_enqueue_scripts");
-    const hasScript = source.includes(WORKSPACE_ADMIN_VIEW_SCRIPT);
-    const hasAsset = source.includes(WORKSPACE_ADMIN_VIEW_ASSET);
-    const hasStyle = source.includes(WORKSPACE_ADMIN_VIEW_STYLE);
-    const hasComponentsStyleDependency = source.includes("'wp-components'");
-    return createDoctorCheck(`Admin view PHP ${adminView.slug}`, hasAdminMenu &&
-        hasAdminEnqueue &&
-        hasScript &&
-        hasAsset &&
-        hasStyle &&
-        hasComponentsStyleDependency
-        ? "pass"
-        : "fail", hasAdminMenu &&
-        hasAdminEnqueue &&
-        hasScript &&
-        hasAsset &&
-        hasStyle &&
-        hasComponentsStyleDependency
-        ? "Admin menu, script, style, and wp-components style dependency are wired"
-        : "Missing admin menu, enqueue hook, build/admin-views asset reference, or wp-components style dependency");
-}
+import { getWorkspaceAbilityDoctorChecks, } from "./cli-doctor-workspace-features-abilities.js";
+import { getWorkspaceAdminViewDoctorChecks, } from "./cli-doctor-workspace-features-admin-views.js";
+import { getWorkspaceAiFeatureDoctorChecks, } from "./cli-doctor-workspace-features-ai.js";
+import { getWorkspaceEditorPluginDoctorChecks, } from "./cli-doctor-workspace-features-editor-plugins.js";
+import { getWorkspacePostMetaDoctorChecks, } from "./cli-doctor-workspace-features-post-meta.js";
+import { getWorkspaceRestResourceDoctorChecks, } from "./cli-doctor-workspace-features-rest.js";
 /**
  * Collect workspace doctor checks for REST resources, abilities, AI features, editor plugins, and admin views.
  *
@@ -334,45 +12,12 @@ function checkWorkspaceAdminViewPhp(projectDir, adminView) {
  * @returns Ordered `DoctorCheck[]` rows for extracted workspace feature diagnostics.
  */
 export function getWorkspaceFeatureDoctorChecks(workspace, inventory) {
-    const checks = [];
-    if (inventory.restResources.length > 0) {
-        checks.push(checkWorkspaceRestResourceBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-    }
-    for (const restResource of inventory.restResources) {
-        checks.push(checkWorkspaceRestResourceConfig(restResource));
-        checks.push(checkExistingFiles(workspace.projectDir, `REST resource ${restResource.slug}`, getWorkspaceRestResourceRequiredFiles(restResource)));
-    }
-    if (inventory.abilities.length > 0) {
-        checks.push(checkWorkspaceAbilityBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-        checks.push(checkWorkspaceAbilityIndex(workspace.projectDir, inventory.abilities));
-    }
-    for (const ability of inventory.abilities) {
-        checks.push(checkWorkspaceAbilityConfig(workspace.projectDir, ability));
-        checks.push(checkExistingFiles(workspace.projectDir, `Ability ${ability.slug}`, getWorkspaceAbilityRequiredFiles(ability)));
-    }
-    if (inventory.aiFeatures.length > 0) {
-        checks.push(checkWorkspaceAiFeatureBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-    }
-    for (const aiFeature of inventory.aiFeatures) {
-        checks.push(checkWorkspaceAiFeatureConfig(aiFeature));
-        checks.push(checkExistingFiles(workspace.projectDir, `AI feature ${aiFeature.slug}`, getWorkspaceAiFeatureRequiredFiles(aiFeature)));
-    }
-    if (inventory.editorPlugins.length > 0) {
-        checks.push(checkWorkspaceEditorPluginBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-        checks.push(checkWorkspaceEditorPluginIndex(workspace.projectDir, inventory.editorPlugins));
-    }
-    for (const editorPlugin of inventory.editorPlugins) {
-        checks.push(checkExistingFiles(workspace.projectDir, `Editor plugin ${editorPlugin.slug}`, getWorkspaceEditorPluginRequiredFiles(editorPlugin)));
-        checks.push(checkWorkspaceEditorPluginConfig(editorPlugin));
-    }
-    if (inventory.adminViews.length > 0) {
-        checks.push(checkWorkspaceAdminViewBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-        checks.push(checkWorkspaceAdminViewIndex(workspace.projectDir, inventory.adminViews));
-    }
-    for (const adminView of inventory.adminViews) {
-        checks.push(checkWorkspaceAdminViewConfig(adminView, inventory));
-        checks.push(checkExistingFiles(workspace.projectDir, `Admin view ${adminView.slug}`, getWorkspaceAdminViewRequiredFiles(adminView)));
-        checks.push(checkWorkspaceAdminViewPhp(workspace.projectDir, adminView));
-    }
-    return checks;
+    return [
+        ...getWorkspaceRestResourceDoctorChecks(workspace, inventory.restResources),
+        ...getWorkspacePostMetaDoctorChecks(workspace, inventory.postMeta),
+        ...getWorkspaceAbilityDoctorChecks(workspace, inventory.abilities),
+        ...getWorkspaceAiFeatureDoctorChecks(workspace, inventory.aiFeatures),
+        ...getWorkspaceEditorPluginDoctorChecks(workspace, inventory.editorPlugins),
+        ...getWorkspaceAdminViewDoctorChecks(workspace, inventory),
+    ];
 }

package/dist/runtime/cli-doctor-workspace-package.d.ts

@@ -1,18 +1,40 @@
 import type { DoctorCheck } from "./cli-doctor.js";
 import type { WorkspacePackageJson, WorkspaceProject } from "./workspace-project.js";
+/**
+ * Snapshot of package-level filesystem doctor inputs prepared asynchronously.
+ */
+export interface WorkspacePackageDoctorSnapshot {
+    /** Whether the expected workspace bootstrap PHP file exists. */
+    bootstrapExists: boolean;
+    /** Relative path to the expected workspace bootstrap PHP file. */
+    bootstrapRelativePath: string;
+    /** Whether the migration config file exists. */
+    migrationConfigExists: boolean;
+    /** Relative path to the migration config file. */
+    migrationConfigRelativePath: string;
+}
+/**
+ * Prepare package-level workspace doctor inputs without blocking the event loop.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns Snapshot values consumed by synchronous doctor row mappers.
+ */
+export declare function prepareWorkspacePackageDoctorSnapshot(workspace: WorkspaceProject, packageJson: WorkspacePackageJson): Promise<WorkspacePackageDoctorSnapshot>;
 /**
  * Validate the package metadata that makes a project an official workspace.
  *
  * @param workspace Resolved workspace metadata and filesystem paths.
  * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
  * @returns A `DoctorCheck` describing whether package metadata matches the workspace contract.
  */
-export declare function getWorkspacePackageMetadataCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson): DoctorCheck;
+export declare function getWorkspacePackageMetadataCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson, snapshot: WorkspacePackageDoctorSnapshot): DoctorCheck;
 /**
  * Report whether a workspace configured for migrations exposes the expected doctor inputs.
  *
- * @param workspace Resolved workspace metadata and filesystem paths.
  * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
  * @returns A migration hint row when the workspace uses migrations, otherwise `null`.
  */
-export declare function getMigrationWorkspaceHintCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson): DoctorCheck | null;
+export declare function getMigrationWorkspaceHintCheck(packageJson: WorkspacePackageJson, snapshot: WorkspacePackageDoctorSnapshot): DoctorCheck | null;

package/dist/runtime/cli-doctor-workspace-package.js

@@ -1,18 +1,42 @@
-import fs from "node:fs";
 import path from "node:path";
 import { createDoctorCheck, getWorkspaceBootstrapRelativePath, } from "./cli-doctor-workspace-shared.js";
+import { pathExists } from "./fs-async.js";
 import { WORKSPACE_TEMPLATE_PACKAGE } from "./workspace-project.js";
+/**
+ * Prepare package-level workspace doctor inputs without blocking the event loop.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns Snapshot values consumed by synchronous doctor row mappers.
+ */
+export async function prepareWorkspacePackageDoctorSnapshot(workspace, packageJson) {
+    const packageName = packageJson.name;
+    const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0
+        ? packageName
+        : workspace.packageName);
+    const migrationConfigRelativePath = path.join("src", "migrations", "config.ts");
+    const [bootstrapExists, migrationConfigExists] = await Promise.all([
+        pathExists(path.join(workspace.projectDir, bootstrapRelativePath)),
+        pathExists(path.join(workspace.projectDir, migrationConfigRelativePath)),
+    ]);
+    return {
+        bootstrapExists,
+        bootstrapRelativePath,
+        migrationConfigExists,
+        migrationConfigRelativePath,
+    };
+}
 /**
  * Validate the package metadata that makes a project an official workspace.
  *
  * @param workspace Resolved workspace metadata and filesystem paths.
  * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
  * @returns A `DoctorCheck` describing whether package metadata matches the workspace contract.
  */
-export function getWorkspacePackageMetadataCheck(workspace, packageJson) {
+export function getWorkspacePackageMetadataCheck(workspace, packageJson, snapshot) {
     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");
@@ -32,28 +56,26 @@ export function getWorkspacePackageMetadataCheck(workspace, packageJson) {
     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}`);
+    if (!snapshot.bootstrapExists) {
+        issues.push(`Missing bootstrap file ${snapshot.bootstrapRelativePath}`);
     }
     return createDoctorCheck("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0
-        ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}`
+        ? `package.json metadata aligns with ${workspace.packageName} and ${snapshot.bootstrapRelativePath}`
         : issues.join("; "));
 }
 /**
  * Report whether a workspace configured for migrations exposes the expected doctor inputs.
  *
- * @param workspace Resolved workspace metadata and filesystem paths.
  * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
  * @returns A migration hint row when the workspace uses migrations, otherwise `null`.
  */
-export function getMigrationWorkspaceHintCheck(workspace, packageJson) {
+export function getMigrationWorkspaceHintCheck(packageJson, snapshot) {
     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) {
+    if (!hasMigrationScript && !snapshot.migrationConfigExists) {
         return null;
     }
-    return createDoctorCheck("Migration workspace", hasMigrationConfig ? "pass" : "fail", hasMigrationConfig
+    return createDoctorCheck("Migration workspace", snapshot.migrationConfigExists ? "pass" : "fail", snapshot.migrationConfigExists
         ? "Run `wp-typia migrate doctor --all` for migration target, snapshot, fixture, and generated artifact checks"
-        : `Missing ${migrationConfigRelativePath} for the configured migration workspace`);
+        : `Missing ${snapshot.migrationConfigRelativePath} for the configured migration workspace`);
 }

package/dist/runtime/cli-doctor-workspace-shared.d.ts

@@ -7,6 +7,8 @@ export declare const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js"
 export declare const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
 /** Glob pattern for generated REST resource PHP entrypoints. */
 export declare const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+/** Glob pattern for generated post-meta PHP entrypoints. */
+export declare const WORKSPACE_POST_META_GLOB = "/inc/post-meta/*.php";
 /** Glob pattern for generated ability PHP entrypoints. */
 export declare const WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
 /** Relative path to the generated ability editor bundle. */

package/dist/runtime/cli-doctor-workspace-shared.js

@@ -8,6 +8,8 @@ export const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
 export const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
 /** Glob pattern for generated REST resource PHP entrypoints. */
 export const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+/** Glob pattern for generated post-meta PHP entrypoints. */
+export const WORKSPACE_POST_META_GLOB = "/inc/post-meta/*.php";
 /** Glob pattern for generated ability PHP entrypoints. */
 export const WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
 /** Relative path to the generated ability editor bundle. */

package/dist/runtime/cli-doctor-workspace.js

@@ -1,7 +1,7 @@
 import { getWorkspaceBindingDoctorChecks, } from "./cli-doctor-workspace-bindings.js";
 import { getWorkspaceBlockDoctorChecks, } from "./cli-doctor-workspace-blocks.js";
 import { getWorkspaceFeatureDoctorChecks, } from "./cli-doctor-workspace-features.js";
-import { getMigrationWorkspaceHintCheck, getWorkspacePackageMetadataCheck, } from "./cli-doctor-workspace-package.js";
+import { getMigrationWorkspaceHintCheck, getWorkspacePackageMetadataCheck, prepareWorkspacePackageDoctorSnapshot, } from "./cli-doctor-workspace-package.js";
 import { createDoctorCheck, createDoctorScopeCheck, } from "./cli-doctor-workspace-shared.js";
 import { readWorkspaceInventoryAsync, } from "./workspace-inventory.js";
 import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, tryResolveWorkspaceProject, } from "./workspace-project.js";
@@ -14,6 +14,7 @@ function formatWorkspaceInventorySummary(inventory) {
         `${inventory.patterns.length} pattern(s)`,
         `${inventory.bindingSources.length} binding source(s)`,
         `${inventory.restResources.length} REST resource(s)`,
+        `${inventory.postMeta.length} post meta contract(s)`,
         `${inventory.abilities.length} ability scaffold(s)`,
         `${inventory.aiFeatures.length} AI feature(s)`,
         `${inventory.editorPlugins.length} editor plugin(s)`,
@@ -73,14 +74,18 @@ export async function getWorkspaceDoctorChecks(cwd) {
         checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
         return checks;
     }
-    checks.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson));
+    const packageDoctorSnapshot = await prepareWorkspacePackageDoctorSnapshot(workspace, workspacePackageJson);
+    checks.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson, packageDoctorSnapshot));
     try {
         const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
         checks.push(createDoctorCheck("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
+        // The highest-impact remaining probes live in block, binding, and feature
+        // categories; keep them synchronous until broader path/content snapshots
+        // can preserve their current row ordering and diagnostics.
         checks.push(...getWorkspaceBlockDoctorChecks(workspace, inventory));
         checks.push(...getWorkspaceBindingDoctorChecks(workspace, inventory));
         checks.push(...getWorkspaceFeatureDoctorChecks(workspace, inventory));
-        const migrationWorkspaceCheck = getMigrationWorkspaceHintCheck(workspace, workspacePackageJson);
+        const migrationWorkspaceCheck = getMigrationWorkspaceHintCheck(workspacePackageJson, packageDoctorSnapshot);
         if (migrationWorkspaceCheck) {
             checks.push(migrationWorkspaceCheck);
         }