wp-typia 0.22.9 → 0.23.0

package/dist-bunli/{cli-doctor-564c43ay.js → cli-doctor-wy2yjsge.js}

@@ -1,13 +1,15 @@
 // @bun
 import {
+  hasAdminViewManualSettingsRouteParameters,
   hasExecutablePattern,
   hasUncommentedPattern,
+  isAdminViewManualSettingsRestResource,
   maskTypeScriptCommentsAndLiterals
-} from "./cli-rwjkqjhs.js";
+} from "./cli-j8et6jvr.js";
 import {
   getBuiltInTemplateLayerDirs,
   isOmittableBuiltInTemplateLayerDir
-} from "./cli-xw1wbxf3.js";
+} from "./cli-c2acv5dv.js";
 import {
   isBuiltInTemplateId,
   listTemplates
@@ -16,15 +18,20 @@ import {
   EDITOR_PLUGIN_SLOT_IDS,
   HOOKED_BLOCK_ANCHOR_PATTERN,
   HOOKED_BLOCK_POSITION_SET,
+  MANUAL_REST_CONTRACT_AUTH_IDS,
+  MANUAL_REST_CONTRACT_HTTP_METHOD_IDS,
   REST_RESOURCE_METHOD_IDS,
   REST_RESOURCE_NAMESPACE_PATTERN,
+  assertValidPostMetaPostType,
   escapeRegex,
-  readWorkspaceInventory,
+  isGeneratedRestResourceRoutePatternCompatible,
+  pathExists,
+  readWorkspaceInventoryAsync,
   resolveEditorPluginSlotAlias
-} from "./cli-regw5384.js";
+} from "./cli-ts9thts5.js";
 import"./cli-cvxvcw7c.js";
 import"./cli-t73q5aqz.js";
-import"./cli-fys8vm2t.js";
+import"./cli-43mx1vfb.js";
 import {
   CLI_DIAGNOSTIC_CODES,
   createCliCommandError,
@@ -44,9 +51,55 @@ import"./cli-xnn9xjcy.js";
 // ../wp-typia-project-tools/src/runtime/cli-doctor-environment.ts
 import { execFileSync } from "child_process";
 import { access, constants as fsConstants, rm, writeFile } from "fs/promises";
-import fs from "fs";
+import fs2 from "fs";
 import os from "os";
+import path2 from "path";
+
+// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-shared.ts
+import fs from "fs";
 import path from "path";
+var WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
+var WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
+var WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
+var WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+var WORKSPACE_POST_META_GLOB = "/inc/post-meta/*.php";
+var WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
+var WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
+var WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
+var WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php";
+var WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php";
+var WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js";
+var WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php";
+var WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css";
+var WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
+var WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
+var WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
+var WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
+  "block.json",
+  "typia.manifest.json",
+  "typia.schema.json",
+  "typia-validator.php",
+  "typia.openapi.json"
+];
+var WORKSPACE_FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+function createDoctorCheck(label, status, detail, code) {
+  return code ? { code, detail, label, status } : { detail, label, status };
+}
+function createDoctorScopeCheck(status, detail) {
+  return createDoctorCheck("Doctor scope", status, detail);
+}
+function getWorkspaceBootstrapRelativePath(packageName) {
+  return `${packageName.split("/").pop() ?? packageName}.php`;
+}
+function resolveWorkspaceBootstrapPath(projectDir, packageName) {
+  return path.join(projectDir, getWorkspaceBootstrapRelativePath(packageName));
+}
+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(", ")}`);
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-doctor-environment.ts
 function readCommandVersion(command, args = ["--version"]) {
   try {
     return execFileSync(command, args, {
@@ -70,7 +123,7 @@ async function checkWritableDirectory(directory) {
   }
 }
 async function checkTempDirectory() {
-  const tempFile = path.join(os.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+  const tempFile = path2.join(os.tmpdir(), `wp-typia-${Date.now()}.tmp`);
   try {
     await writeFile(tempFile, "ok", "utf8");
     await rm(tempFile, { force: true });
@@ -79,15 +132,12 @@ async function checkTempDirectory() {
     return false;
   }
 }
-function createDoctorCheck(label, status, detail) {
-  return { detail, label, status };
-}
 function getTemplateDoctorChecks() {
   const checks = [];
   for (const template of listTemplates()) {
     if (!isBuiltInTemplateId(template.id)) {
-      const templateDirExists = fs.existsSync(template.templateDir);
-      const hasAssets2 = templateDirExists && fs.existsSync(path.join(template.templateDir, "package.json.mustache"));
+      const templateDirExists = fs2.existsSync(template.templateDir);
+      const hasAssets2 = templateDirExists && fs2.existsSync(path2.join(template.templateDir, "package.json.mustache"));
       checks.push({
         status: !templateDirExists || hasAssets2 ? "pass" : "fail",
         label: `Template ${template.id}`,
@@ -110,9 +160,9 @@ function getTemplateDoctorChecks() {
         persistencePolicy: "public"
       })
     ])) : getBuiltInTemplateLayerDirs(builtInTemplateId);
-    const missingRequiredLayer = layerDirs.some((layerDir) => !fs.existsSync(layerDir) && !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
-    const existingLayerDirs = layerDirs.filter((layerDir) => fs.existsSync(layerDir));
-    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs.existsSync(path.join(layerDir, "src")));
+    const missingRequiredLayer = layerDirs.some((layerDir) => !fs2.existsSync(layerDir) && !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
+    const existingLayerDirs = layerDirs.filter((layerDir) => fs2.existsSync(layerDir));
+    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs2.existsSync(path2.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs2.existsSync(path2.join(layerDir, "src")));
     checks.push({
       status: hasAssets ? "pass" : "fail",
       label: `Template ${template.id}`,
@@ -141,72 +191,27 @@ async function getEnvironmentDoctorChecks(cwd) {
 import fs3 from "fs";
 import path3 from "path";
 import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
-
-// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-shared.ts
-import fs2 from "fs";
-import path2 from "path";
-var WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
-var WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
-var WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
-var WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
-var WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
-var WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
-var WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
-var WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php";
-var WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php";
-var WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js";
-var WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php";
-var WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css";
-var WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
-var WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
-var WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
-var WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
-  "block.json",
-  "typia.manifest.json",
-  "typia.schema.json",
-  "typia-validator.php",
-  "typia.openapi.json"
-];
-var WORKSPACE_FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
-function createDoctorCheck2(label, status, detail, code) {
-  return code ? { code, detail, label, status } : { detail, label, status };
-}
-function createDoctorScopeCheck(status, detail) {
-  return createDoctorCheck2("Doctor scope", status, detail);
-}
-function getWorkspaceBootstrapRelativePath(packageName) {
-  return `${packageName.split("/").pop() ?? packageName}.php`;
-}
-function resolveWorkspaceBootstrapPath(projectDir, packageName) {
-  return path2.join(projectDir, getWorkspaceBootstrapRelativePath(packageName));
-}
-function checkExistingFiles(projectDir, label, filePaths) {
-  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs2.existsSync(path2.join(projectDir, filePath)));
-  return createDoctorCheck2(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-bindings.ts
 function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
   if (!fs3.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path3.basename(bootstrapPath)}`);
+    return createDoctorCheck("Binding bootstrap", "fail", `Missing ${path3.basename(bootstrapPath)}`);
   }
   const source = fs3.readFileSync(bootstrapPath, "utf8");
   const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
   const hasEditorEnqueueHook = source.includes("enqueue_block_editor_assets");
   const hasEditorScript = source.includes(WORKSPACE_BINDING_EDITOR_SCRIPT);
   const hasEditorAsset = source.includes(WORKSPACE_BINDING_EDITOR_ASSET);
-  return createDoctorCheck2("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "Binding source PHP and editor bootstrap hooks are present" : "Missing binding source PHP require glob or editor enqueue hook");
+  return createDoctorCheck("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "Binding source PHP and editor bootstrap hooks are present" : "Missing binding source PHP require glob or editor enqueue hook");
 }
 function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
   const indexRelativePath = [path3.join("src", "bindings", "index.ts"), path3.join("src", "bindings", "index.js")].find((relativePath) => fs3.existsSync(path3.join(projectDir, relativePath)));
   if (!indexRelativePath) {
-    return createDoctorCheck2("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
+    return createDoctorCheck("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
   }
   const indexPath = path3.join(projectDir, indexRelativePath);
   const source = fs3.readFileSync(indexPath, "utf8");
   const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
-  return createDoctorCheck2("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Binding source editor registrations are aggregated" : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
+  return createDoctorCheck("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Binding source editor registrations are aggregated" : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs, bindingSource) {
   const hasBlock = bindingSource.block !== undefined;
@@ -215,10 +220,10 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
     return;
   }
   if (!bindingSource.block || !bindingSource.attribute) {
-    return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", "Binding target entries must include both block and attribute.");
+    return createDoctorCheck(`Binding target ${bindingSource.slug}`, "fail", "Binding target entries must include both block and attribute.");
   }
   if (!registeredBlockSlugs.has(bindingSource.block)) {
-    return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", `Binding target references unknown block "${bindingSource.block}".`);
+    return createDoctorCheck(`Binding target ${bindingSource.slug}`, "fail", `Binding target references unknown block "${bindingSource.block}".`);
   }
   const blockJsonRelativePath = path3.join("src", "blocks", bindingSource.block, "block.json");
   const blockJsonPath = path3.join(projectDir, blockJsonRelativePath);
@@ -271,7 +276,7 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   } else {
     issues.push(`Missing ${bindingSource.editorFile}`);
   }
-  return createDoctorCheck2(`Binding target ${bindingSource.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${bindingSource.block}.${bindingSource.attribute} is declared and supported` : issues.join("; "));
+  return createDoctorCheck(`Binding target ${bindingSource.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${bindingSource.block}.${bindingSource.attribute} is declared and supported` : issues.join("; "));
 }
 function getWorkspaceBindingDoctorChecks(workspace, inventory) {
   const checks = [];
@@ -484,13 +489,13 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
   const blockJsonRelativePath = path4.join("src", "blocks", block.slug, "block.json");
   const blockJsonPath = path4.join(projectDir, blockJsonRelativePath);
   if (!fs4.existsSync(blockJsonPath)) {
-    return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
+    return createDoctorCheck(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
   let blockJson;
   try {
     blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs4.readFileSync(blockJsonPath, "utf8")));
   } catch (error) {
-    return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", error instanceof Error ? error.message : String(error));
+    return createDoctorCheck(`Block metadata ${block.slug}`, "fail", error instanceof Error ? error.message : String(error));
   }
   const expectedName = `${workspace.workspace.namespace}/${block.slug}`;
   const issues = [];
@@ -500,46 +505,46 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
   if (blockJson.textdomain !== workspace.workspace.textDomain) {
     issues.push(`block.json textdomain must equal "${workspace.workspace.textDomain}"`);
   }
-  return createDoctorCheck2(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}` : issues.join("; "));
+  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 checkWorkspaceBlockHooks(projectDir, blockSlug) {
   const blockJsonRelativePath = path4.join("src", "blocks", blockSlug, "block.json");
   const blockJsonPath = path4.join(projectDir, blockJsonRelativePath);
   if (!fs4.existsSync(blockJsonPath)) {
-    return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
+    return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
   let blockJson;
   try {
     blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs4.readFileSync(blockJsonPath, "utf8")));
   } catch (error) {
-    return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", error instanceof Error ? error.message : String(error));
+    return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", error instanceof Error ? error.message : String(error));
   }
   const blockHooks = blockJson.blockHooks;
   if (blockHooks === undefined) {
-    return createDoctorCheck2(`Block hooks ${blockSlug}`, "pass", "No blockHooks metadata configured");
+    return createDoctorCheck(`Block hooks ${blockSlug}`, "pass", "No blockHooks metadata configured");
   }
   if (!blockHooks || typeof blockHooks !== "object" || Array.isArray(blockHooks)) {
-    return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", `${blockJsonRelativePath} must define blockHooks as an object when present.`);
+    return createDoctorCheck(`Block hooks ${blockSlug}`, "fail", `${blockJsonRelativePath} must define blockHooks as an object when present.`);
   }
   const blockName = typeof blockJson.name === "string" && blockJson.name.trim().length > 0 ? blockJson.name.trim() : null;
   const invalidEntries = Object.entries(blockHooks).filter(([anchor, position]) => blockName !== null && anchor.trim() === blockName || anchor.trim().length === 0 || anchor !== anchor.trim() || !HOOKED_BLOCK_ANCHOR_PATTERN.test(anchor) || typeof position !== "string" || !HOOKED_BLOCK_POSITION_SET.has(position));
-  return createDoctorCheck2(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0 ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0 ? ` (${Object.keys(blockHooks).join(", ")})` : ""}` : `Invalid blockHooks entries: ${invalidEntries.map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`).join(", ")}`);
+  return createDoctorCheck(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0 ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0 ? ` (${Object.keys(blockHooks).join(", ")})` : ""}` : `Invalid blockHooks entries: ${invalidEntries.map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`).join(", ")}`);
 }
 function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
   const entryRelativePath = path4.join("src", "blocks", blockSlug, "index.tsx");
   const entryPath = path4.join(projectDir, entryRelativePath);
   if (!fs4.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
+    return createDoctorCheck(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
   }
   const source = fs4.readFileSync(entryPath, "utf8");
   const hasCollectionImport = WORKSPACE_COLLECTION_IMPORT_PATTERN.test(source);
-  return createDoctorCheck2(`Block collection ${blockSlug}`, hasCollectionImport ? "pass" : "fail", hasCollectionImport ? "Shared block collection import is present" : `Missing a shared collection import like ${WORKSPACE_COLLECTION_IMPORT_LINE}`);
+  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 checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
   const metadataResult = readWorkspaceBlockIframeMetadata(projectDir, blockSlug);
   if (!metadataResult.document) {
     return [
-      createDoctorCheck2(`Block iframe/API v3 ${blockSlug}`, "warn", metadataResult.error ?? `Unable to inspect ${metadataResult.blockJsonRelativePath}`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.API_VERSION)
+      createDoctorCheck(`Block iframe/API v3 ${blockSlug}`, "warn", metadataResult.error ?? `Unable to inspect ${metadataResult.blockJsonRelativePath}`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.API_VERSION)
     ];
   }
   const blockJson = metadataResult.document;
@@ -555,51 +560,51 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
   const blockWrapperStatus = editorWrapperSources.length === 0 || hasEditorBlockPropsUsage ? "pass" : "warn";
   const blockWrapperDetail = editorSources.length === 0 ? "No editor-facing block source files found; general file checks will report missing entrypoints" : editorWrapperSources.length === 0 ? "No editor wrapper source files found; general file checks will report missing entrypoints" : hasEditorBlockPropsUsage ? "Editor-facing sources use block wrapper props" : hasBlockPropsUsage ? "Only save-facing useBlockProps.save() usage was detected. Confirm the editor wrapper also receives useBlockProps() or useInnerBlocksProps() before relying on iframe editor rendering." : "No useBlockProps(), useBlockProps.save(), or useInnerBlocksProps() usage was detected in editor-facing sources. Confirm the block wrapper receives WordPress block editor props before relying on iframe editor rendering.";
   return [
-    createDoctorCheck2(`Block iframe API version ${blockSlug}`, apiVersion !== null && apiVersion >= 3 ? "pass" : "warn", apiVersion !== null && apiVersion >= 3 ? "block.json declares apiVersion 3 for iframe editor readiness" : `Set ${metadataResult.blockJsonRelativePath} apiVersion to 3 after testing the block in iframe-enabled Post Editor and Site Editor contexts. WordPress recommends API v3 for iframe editor compatibility. See ${WORKSPACE_BLOCK_IFRAME_COMPATIBILITY_DOC_URL}`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.API_VERSION),
-    createDoctorCheck2(`Block iframe styles ${blockSlug}`, localStyleFiles.length === 0 || hasRegisteredEditorStyles ? "pass" : "warn", localStyleFiles.length === 0 ? "No local block stylesheet source files found to register" : hasRegisteredEditorStyles ? "block.json registers block styles for iframe editor loading" : `Found stylesheet source files (${localStyleFiles.join(", ")}) but block.json does not declare style or editorStyle. Register block content styles so iframe editors do not depend on parent admin styles.`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.EDITOR_STYLES),
-    createDoctorCheck2(`Block iframe globals ${blockSlug}`, globalDomAccesses.length === 0 ? "pass" : "warn", globalDomAccesses.length === 0 ? "No direct window/document/parent DOM access detected in editor-facing block sources" : `Direct global DOM access detected at ${globalDomAccesses.join(", ")}. Prefer element.ownerDocument/defaultView via refs or useRefEffect for iframe editor content.`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.EDITOR_GLOBALS),
-    createDoctorCheck2(`Block iframe wrapper ${blockSlug}`, blockWrapperStatus, blockWrapperDetail, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.BLOCK_PROPS)
+    createDoctorCheck(`Block iframe API version ${blockSlug}`, apiVersion !== null && apiVersion >= 3 ? "pass" : "warn", apiVersion !== null && apiVersion >= 3 ? "block.json declares apiVersion 3 for iframe editor readiness" : `Set ${metadataResult.blockJsonRelativePath} apiVersion to 3 after testing the block in iframe-enabled Post Editor and Site Editor contexts. WordPress recommends API v3 for iframe editor compatibility. See ${WORKSPACE_BLOCK_IFRAME_COMPATIBILITY_DOC_URL}`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.API_VERSION),
+    createDoctorCheck(`Block iframe styles ${blockSlug}`, localStyleFiles.length === 0 || hasRegisteredEditorStyles ? "pass" : "warn", localStyleFiles.length === 0 ? "No local block stylesheet source files found to register" : hasRegisteredEditorStyles ? "block.json registers block styles for iframe editor loading" : `Found stylesheet source files (${localStyleFiles.join(", ")}) but block.json does not declare style or editorStyle. Register block content styles so iframe editors do not depend on parent admin styles.`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.EDITOR_STYLES),
+    createDoctorCheck(`Block iframe globals ${blockSlug}`, globalDomAccesses.length === 0 ? "pass" : "warn", globalDomAccesses.length === 0 ? "No direct window/document/parent DOM access detected in editor-facing block sources" : `Direct global DOM access detected at ${globalDomAccesses.join(", ")}. Prefer element.ownerDocument/defaultView via refs or useRefEffect for iframe editor content.`, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.EDITOR_GLOBALS),
+    createDoctorCheck(`Block iframe wrapper ${blockSlug}`, blockWrapperStatus, blockWrapperDetail, WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES.BLOCK_PROPS)
   ];
 }
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
   if (!fs4.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path4.basename(bootstrapPath)}`);
+    return createDoctorCheck("Pattern bootstrap", "fail", `Missing ${path4.basename(bootstrapPath)}`);
   }
   const source = fs4.readFileSync(bootstrapPath, "utf8");
   const hasCategoryAnchor = source.includes("register_block_pattern_category");
   const hasPatternGlob = source.includes("/src/patterns/*.php");
-  return createDoctorCheck2("Pattern bootstrap", hasCategoryAnchor && hasPatternGlob ? "pass" : "fail", hasCategoryAnchor && hasPatternGlob ? "Pattern category and loader hooks are present" : "Missing pattern category registration or src/patterns loader hook");
+  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 = path4.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs4.existsSync(entryPath)) {
-    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path4.relative(projectDir, entryPath)}`);
+    return createDoctorCheck(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path4.relative(projectDir, entryPath)}`);
   }
   const source = fs4.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern(source, WORKSPACE_VARIATIONS_IMPORT_PATTERN);
   const hasCall = hasExecutablePattern(source, WORKSPACE_VARIATIONS_CALL_PATTERN);
-  return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Variations registration hook is present" : "Missing ./variations import or registerWorkspaceVariations() call");
+  return createDoctorCheck(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Variations registration hook is present" : "Missing ./variations import or registerWorkspaceVariations() call");
 }
 function checkBlockStyleEntrypoint(projectDir, blockSlug) {
   const entryPath = path4.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs4.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path4.relative(projectDir, entryPath)}`);
+    return createDoctorCheck(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path4.relative(projectDir, entryPath)}`);
   }
   const source = fs4.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern(source, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN);
   const hasCall = hasExecutablePattern(source, WORKSPACE_BLOCK_STYLES_CALL_PATTERN);
-  return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block style registration hook is present" : "Missing ./styles import or registerWorkspaceBlockStyles() call");
+  return createDoctorCheck(`Block style entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block style registration hook is present" : "Missing ./styles import or registerWorkspaceBlockStyles() call");
 }
 function checkBlockTransformEntrypoint(projectDir, blockSlug) {
   const entryPath = path4.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs4.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path4.relative(projectDir, entryPath)}`);
+    return createDoctorCheck(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path4.relative(projectDir, entryPath)}`);
   }
   const source = fs4.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern(source, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN);
   const hasCall = hasExecutablePattern(source, WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN);
-  return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block transform registration hook is present" : "Missing ./transforms import or applyWorkspaceBlockTransforms(registration.settings) call");
+  return createDoctorCheck(`Block transform entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block transform registration hook is present" : "Missing ./transforms import or applyWorkspaceBlockTransforms(registration.settings) call");
 }
 function checkBlockTransformConfig(workspace, transform) {
   const expectedTo = `${workspace.workspace.namespace}/${transform.block}`;
@@ -610,7 +615,7 @@ function checkBlockTransformConfig(workspace, transform) {
   if (transform.to !== expectedTo) {
     issues.push(`to must equal "${expectedTo}" for workspace block "${transform.block}"`);
   }
-  return createDoctorCheck2(`Block transform config ${transform.block}/${transform.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${transform.from} transforms into ${transform.to}` : issues.join("; "));
+  return createDoctorCheck(`Block transform config ${transform.block}/${transform.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${transform.from} transforms into ${transform.to}` : issues.join("; "));
 }
 function getWorkspaceBlockDoctorChecks(workspace, inventory) {
   const checks = [];
@@ -625,7 +630,7 @@ function getWorkspaceBlockDoctorChecks(workspace, inventory) {
   const variationTargetBlocks = new Set;
   for (const variation of inventory.variations) {
     if (!registeredBlockSlugs.has(variation.block)) {
-      checks.push(createDoctorCheck2(`Variation ${variation.block}/${variation.slug}`, "fail", `Variation references unknown block "${variation.block}"`));
+      checks.push(createDoctorCheck(`Variation ${variation.block}/${variation.slug}`, "fail", `Variation references unknown block "${variation.block}"`));
       continue;
     }
     variationTargetBlocks.add(variation.block);
@@ -637,7 +642,7 @@ function getWorkspaceBlockDoctorChecks(workspace, inventory) {
   const blockStyleTargetBlocks = new Set;
   for (const blockStyle of inventory.blockStyles) {
     if (!registeredBlockSlugs.has(blockStyle.block)) {
-      checks.push(createDoctorCheck2(`Block style ${blockStyle.block}/${blockStyle.slug}`, "fail", `Block style references unknown block "${blockStyle.block}"`));
+      checks.push(createDoctorCheck(`Block style ${blockStyle.block}/${blockStyle.slug}`, "fail", `Block style references unknown block "${blockStyle.block}"`));
       continue;
     }
     blockStyleTargetBlocks.add(blockStyle.block);
@@ -652,7 +657,7 @@ function getWorkspaceBlockDoctorChecks(workspace, inventory) {
   const blockTransformTargetBlocks = new Set;
   for (const blockTransform of inventory.blockTransforms) {
     if (!registeredBlockSlugs.has(blockTransform.block)) {
-      checks.push(createDoctorCheck2(`Block transform ${blockTransform.block}/${blockTransform.slug}`, "fail", `Block transform references unknown block "${blockTransform.block}"`));
+      checks.push(createDoctorCheck(`Block transform ${blockTransform.block}/${blockTransform.slug}`, "fail", `Block transform references unknown block "${blockTransform.block}"`));
       continue;
     }
     blockTransformTargetBlocks.add(blockTransform.block);
@@ -678,8 +683,26 @@ function getWorkspaceBlockDoctorChecks(workspace, inventory) {
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-features.ts
 import fs5 from "fs";
 import path5 from "path";
+function isManualRestResource(restResource) {
+  return restResource.mode === "manual";
+}
 function getWorkspaceRestResourceRequiredFiles(restResource) {
   const schemaNames = new Set;
+  if (isManualRestResource(restResource)) {
+    schemaNames.add("query");
+    if (restResource.bodyTypeName) {
+      schemaNames.add("request");
+    }
+    schemaNames.add("response");
+    return Array.from(new Set([
+      restResource.apiFile,
+      ...Array.from(schemaNames, (schemaName) => path5.join(path5.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+      restResource.clientFile,
+      restResource.openApiFile,
+      restResource.typesFile,
+      restResource.validatorsFile
+    ]));
+  }
   if (restResource.methods.includes("list")) {
     schemaNames.add("list-query");
     schemaNames.add("list-response");
@@ -705,29 +728,80 @@ function getWorkspaceRestResourceRequiredFiles(restResource) {
     restResource.apiFile,
     ...Array.from(schemaNames, (schemaName) => path5.join(path5.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
     restResource.clientFile,
-    restResource.dataFile,
+    ...restResource.dataFile ? [restResource.dataFile] : [],
     restResource.openApiFile,
-    restResource.phpFile,
+    ...restResource.phpFile ? [restResource.phpFile] : [],
     restResource.typesFile,
     restResource.validatorsFile
   ]));
 }
 function checkWorkspaceRestResourceConfig(restResource) {
   const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(restResource.namespace);
+  if (isManualRestResource(restResource)) {
+    const hasAuth = restResource.auth == null || MANUAL_REST_CONTRACT_AUTH_IDS.includes(restResource.auth);
+    const hasMethod = typeof restResource.method === "string" && MANUAL_REST_CONTRACT_HTTP_METHOD_IDS.includes(restResource.method);
+    const hasPathPattern = typeof restResource.pathPattern === "string" && restResource.pathPattern.startsWith("/") && restResource.pathPattern.length > 1;
+    return createDoctorCheck(`REST resource config ${restResource.slug}`, hasNamespace && hasAuth && hasMethod && hasPathPattern ? "pass" : "fail", hasNamespace && hasAuth && hasMethod && hasPathPattern ? `Manual REST contract ${restResource.method} /${restResource.namespace}${restResource.pathPattern}` : "Manual REST contract namespace, auth, method, or path pattern is invalid");
+  }
   const hasMethods = restResource.methods.length > 0 && restResource.methods.every((method) => REST_RESOURCE_METHOD_IDS.includes(method));
-  return createDoctorCheck2(`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");
+  const hasGeneratedFiles = typeof restResource.dataFile === "string" && restResource.dataFile.length > 0 && typeof restResource.phpFile === "string" && restResource.phpFile.length > 0;
+  const hasRoutePattern = restResource.routePattern == null || typeof restResource.routePattern === "string" && restResource.routePattern.startsWith("/") && restResource.routePattern.length > 1 && !/\s/u.test(restResource.routePattern) && isGeneratedRestResourceRoutePatternCompatible(restResource.routePattern);
+  return createDoctorCheck(`REST resource config ${restResource.slug}`, hasNamespace && hasMethods && hasGeneratedFiles && hasRoutePattern ? "pass" : "fail", hasNamespace && hasMethods && hasGeneratedFiles && hasRoutePattern ? `REST resource namespace ${restResource.namespace} with methods ${restResource.methods.join(", ")}` : "REST resource namespace, methods, dataFile, phpFile, or routePattern are invalid");
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
   if (!fs5.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
+    return createDoctorCheck("REST resource bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
   }
   const source = fs5.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 createDoctorCheck2("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");
+  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 getWorkspacePostMetaRequiredFiles(postMeta) {
+  return Array.from(new Set([
+    postMeta.phpFile,
+    postMeta.schemaFile,
+    postMeta.typesFile
+  ]));
+}
+function checkWorkspacePostMetaConfig(postMeta) {
+  let hasPostType = false;
+  try {
+    hasPostType = assertValidPostMetaPostType(postMeta.postType) === postMeta.postType;
+  } catch {
+    hasPostType = false;
+  }
+  const hasMetaKey = typeof postMeta.metaKey === "string" && postMeta.metaKey.trim().length > 0 && !/\s/u.test(postMeta.metaKey);
+  const hasRestExposure = typeof postMeta.showInRest === "boolean";
+  return createDoctorCheck(`Post meta config ${postMeta.slug}`, hasPostType && hasMetaKey && hasRestExposure ? "pass" : "fail", hasPostType && hasMetaKey && hasRestExposure ? `Post meta ${postMeta.metaKey} targets ${postMeta.postType}` : "Post meta postType, metaKey, or showInRest configuration is invalid");
+}
+function checkWorkspacePostMetaBootstrap(projectDir, packageName, phpPrefix) {
+  const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
+  if (!fs5.existsSync(bootstrapPath)) {
+    return createDoctorCheck("Post meta bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
+  }
+  const source = fs5.readFileSync(bootstrapPath, "utf8");
+  const registerFunctionName = `${phpPrefix}_register_post_meta_contracts`;
+  const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+  const hasServerGlob = source.includes(WORKSPACE_POST_META_GLOB);
+  const hasRegisterHook = source.includes(registerHook);
+  return createDoctorCheck("Post meta bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook ? "Post meta PHP loader hook is present" : "Missing post meta PHP require glob or init hook");
+}
+function checkWorkspacePostMetaPhp(projectDir, postMeta) {
+  const phpPath = path5.join(projectDir, postMeta.phpFile);
+  if (!fs5.existsSync(phpPath)) {
+    return createDoctorCheck(`Post meta PHP ${postMeta.slug}`, "fail", `Missing ${postMeta.phpFile}`);
+  }
+  const source = fs5.readFileSync(phpPath, "utf8");
+  const hasRegisterPostMeta = source.includes("register_post_meta");
+  const hasPostType = source.includes(postMeta.postType);
+  const hasMetaKey = source.includes(postMeta.metaKey);
+  const hasSchemaFile = source.includes(postMeta.schemaFile);
+  const hasRestExposure = source.includes("'show_in_rest'");
+  return createDoctorCheck(`Post meta PHP ${postMeta.slug}`, hasRegisterPostMeta && hasPostType && hasMetaKey && hasSchemaFile && hasRestExposure ? "pass" : "fail", hasRegisterPostMeta && hasPostType && hasMetaKey && hasSchemaFile && hasRestExposure ? "Post meta registration, schema path, and REST exposure flag are wired" : "Missing register_post_meta, post type, meta key, schema path, or show_in_rest wiring");
 }
 function getWorkspaceAbilityRequiredFiles(ability) {
   return Array.from(new Set([
@@ -743,7 +817,7 @@ function getWorkspaceAbilityRequiredFiles(ability) {
 function checkWorkspaceAbilityConfig(projectDir, ability) {
   const configPath = path5.join(projectDir, ability.configFile);
   if (!fs5.existsSync(configPath)) {
-    return createDoctorCheck2(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
+    return createDoctorCheck(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
   }
   try {
     const config = JSON.parse(fs5.readFileSync(configPath, "utf8"));
@@ -751,15 +825,15 @@ function checkWorkspaceAbilityConfig(projectDir, ability) {
     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 createDoctorCheck2(`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.");
+    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 createDoctorCheck2(`Ability config ${ability.slug}`, "fail", error instanceof Error ? error.message : String(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 (!fs5.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
+    return createDoctorCheck("Ability bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
   }
   const source = fs5.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
@@ -774,7 +848,7 @@ function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
   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 createDoctorCheck2("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");
+  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 = [
@@ -782,7 +856,7 @@ function checkWorkspaceAbilityIndex(projectDir, abilities) {
     path5.join("src", "abilities", "index.js")
   ].find((relativePath) => fs5.existsSync(path5.join(projectDir, relativePath)));
   if (!indexRelativePath) {
-    return createDoctorCheck2("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
+    return createDoctorCheck("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
   }
   const indexPath = path5.join(projectDir, indexRelativePath);
   const source = fs5.readFileSync(indexPath, "utf8");
@@ -790,7 +864,7 @@ function checkWorkspaceAbilityIndex(projectDir, abilities) {
     const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex(ability.slug)}\\/client['"\`]`, "mu");
     return !exportPattern.test(source);
   });
-  return createDoctorCheck2("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(", ")}`);
+  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([
@@ -809,19 +883,19 @@ function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
 }
 function checkWorkspaceAiFeatureConfig(aiFeature) {
   const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(aiFeature.namespace);
-  return createDoctorCheck2(`AI feature config ${aiFeature.slug}`, hasNamespace ? "pass" : "fail", hasNamespace ? `AI feature namespace ${aiFeature.namespace} is valid` : "AI feature namespace is invalid");
+  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 (!fs5.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
+    return createDoctorCheck("AI feature bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
   }
   const source = fs5.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 createDoctorCheck2("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");
+  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 = path5.join("src", "editor-plugins", editorPlugin.slug);
@@ -837,12 +911,12 @@ function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
 function checkWorkspaceEditorPluginConfig(editorPlugin) {
   const normalizedSlot = resolveEditorPluginSlotAlias(editorPlugin.slot);
   const isValidSlot = Boolean(normalizedSlot);
-  return createDoctorCheck2(`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.`);
+  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 (!fs5.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
+    return createDoctorCheck("Editor plugin bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
   }
   const source = fs5.readFileSync(bootstrapPath, "utf8");
   const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
@@ -851,7 +925,7 @@ function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix)
   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 createDoctorCheck2("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");
+  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 = [
@@ -859,7 +933,7 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
     path5.join("src", "editor-plugins", "index.js")
   ].find((relativePath) => fs5.existsSync(path5.join(projectDir, relativePath)));
   if (!indexRelativePath) {
-    return createDoctorCheck2("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
+    return createDoctorCheck("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
   }
   const indexPath = path5.join(projectDir, indexRelativePath);
   const source = fs5.readFileSync(indexPath, "utf8");
@@ -867,7 +941,7 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
     return !importPattern.test(source);
   });
-  return createDoctorCheck2("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(", ")}`);
+  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 = path5.join("src", "admin-views", adminView.slug);
@@ -883,27 +957,31 @@ function getWorkspaceAdminViewRequiredFiles(adminView) {
 }
 function checkWorkspaceAdminViewConfig(adminView, inventory) {
   if (adminView.source === undefined) {
-    return createDoctorCheck2(`Admin view config ${adminView.slug}`, "pass", "Admin view uses a replaceable local fetcher");
+    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 createDoctorCheck2(`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>");
+  const isListCapableRestResource = Boolean(restResource?.methods.includes("list"));
+  const isManualSettingsRestResource = isAdminViewManualSettingsRestResource(restResource);
+  const hasManualSettingsRouteParameters = isManualSettingsRestResource && hasAdminViewManualSettingsRouteParameters(restResource);
+  const isValid = isListCapableRestResource || isManualSettingsRestResource && !hasManualSettingsRouteParameters || Boolean(coreDataSourceMatch);
+  const failDetail = hasManualSettingsRouteParameters ? `Admin view source ${source} uses route parameters or regex groups and cannot scaffold a singleton settings form` : "Admin view source must use rest-resource:<slug> with a list-capable REST resource, a manual settings contract with a body type, or core-data:<postType|taxonomy>/<name>";
+  return createDoctorCheck(`Admin view config ${adminView.slug}`, isValid ? "pass" : "fail", isValid ? `Admin view source ${source} is ${isManualSettingsRestResource ? "settings-form capable" : coreDataSourceMatch ? "core-data capable" : "list-capable"}` : failDetail);
 }
 function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
   if (!fs5.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
+    return createDoctorCheck("Admin view bootstrap", "fail", `Missing ${path5.basename(bootstrapPath)}`);
   }
   const source = fs5.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 createDoctorCheck2("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");
+  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 = [
@@ -911,7 +989,7 @@ function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
     path5.join("src", "admin-views", "index.js")
   ].find((relativePath) => fs5.existsSync(path5.join(projectDir, relativePath)));
   if (!indexRelativePath) {
-    return createDoctorCheck2("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
+    return createDoctorCheck("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
   }
   const indexPath = path5.join(projectDir, indexRelativePath);
   const source = fs5.readFileSync(indexPath, "utf8");
@@ -919,12 +997,12 @@ function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex(adminView.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
     return !importPattern.test(source);
   });
-  return createDoctorCheck2("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(", ")}`);
+  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 = path5.join(projectDir, adminView.phpFile);
   if (!fs5.existsSync(phpPath)) {
-    return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
+    return createDoctorCheck(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
   }
   const source = fs5.readFileSync(phpPath, "utf8");
   const hasAdminMenu = source.includes("add_submenu_page");
@@ -933,17 +1011,25 @@ function checkWorkspaceAdminViewPhp(projectDir, adminView) {
   const hasAsset = source.includes(WORKSPACE_ADMIN_VIEW_ASSET);
   const hasStyle = source.includes(WORKSPACE_ADMIN_VIEW_STYLE);
   const hasComponentsStyleDependency = source.includes("'wp-components'");
-  return createDoctorCheck2(`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");
+  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");
 }
 function getWorkspaceFeatureDoctorChecks(workspace, inventory) {
   const checks = [];
-  if (inventory.restResources.length > 0) {
+  if (inventory.restResources.some((restResource) => !isManualRestResource(restResource))) {
     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.postMeta.length > 0) {
+    checks.push(checkWorkspacePostMetaBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+  }
+  for (const postMeta of inventory.postMeta) {
+    checks.push(checkWorkspacePostMetaConfig(postMeta));
+    checks.push(checkExistingFiles(workspace.projectDir, `Post meta ${postMeta.slug}`, getWorkspacePostMetaRequiredFiles(postMeta)));
+    checks.push(checkWorkspacePostMetaPhp(workspace.projectDir, postMeta));
+  }
   if (inventory.abilities.length > 0) {
     checks.push(checkWorkspaceAbilityBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
     checks.push(checkWorkspaceAbilityIndex(workspace.projectDir, inventory.abilities));
@@ -980,12 +1066,25 @@ function getWorkspaceFeatureDoctorChecks(workspace, inventory) {
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-package.ts
-import fs6 from "fs";
 import path6 from "path";
-function getWorkspacePackageMetadataCheck(workspace, packageJson) {
-  const issues = [];
+async function prepareWorkspacePackageDoctorSnapshot(workspace, packageJson) {
   const packageName = packageJson.name;
   const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0 ? packageName : workspace.packageName);
+  const migrationConfigRelativePath = path6.join("src", "migrations", "config.ts");
+  const [bootstrapExists, migrationConfigExists] = await Promise.all([
+    pathExists(path6.join(workspace.projectDir, bootstrapRelativePath)),
+    pathExists(path6.join(workspace.projectDir, migrationConfigRelativePath))
+  ]);
+  return {
+    bootstrapExists,
+    bootstrapRelativePath,
+    migrationConfigExists,
+    migrationConfigRelativePath
+  };
+}
+function getWorkspacePackageMetadataCheck(workspace, packageJson, snapshot) {
+  const issues = [];
+  const packageName = packageJson.name;
   const wpTypia = packageJson.wpTypia;
   if (typeof packageName !== "string" || packageName.length === 0) {
     issues.push("package.json must define a string name for workspace bootstrap resolution");
@@ -1005,19 +1104,17 @@ function getWorkspacePackageMetadataCheck(workspace, packageJson) {
   if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
     issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
   }
-  if (!fs6.existsSync(path6.join(workspace.projectDir, bootstrapRelativePath))) {
-    issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
+  if (!snapshot.bootstrapExists) {
+    issues.push(`Missing bootstrap file ${snapshot.bootstrapRelativePath}`);
   }
-  return createDoctorCheck2("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}` : issues.join("; "));
+  return createDoctorCheck("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `package.json metadata aligns with ${workspace.packageName} and ${snapshot.bootstrapRelativePath}` : issues.join("; "));
 }
-function getMigrationWorkspaceHintCheck(workspace, packageJson) {
+function getMigrationWorkspaceHintCheck(packageJson, snapshot) {
   const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
-  const migrationConfigRelativePath = path6.join("src", "migrations", "config.ts");
-  const hasMigrationConfig = fs6.existsSync(path6.join(workspace.projectDir, migrationConfigRelativePath));
-  if (!hasMigrationScript && !hasMigrationConfig) {
+  if (!hasMigrationScript && !snapshot.migrationConfigExists) {
     return null;
   }
-  return createDoctorCheck2("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`);
+  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 ${snapshot.migrationConfigRelativePath} for the configured migration workspace`);
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace.ts
@@ -1030,13 +1127,14 @@ 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)`,
     `${inventory.adminViews.length} admin view(s)`
   ].join(", ");
 }
-function getWorkspaceDoctorChecks(cwd) {
+async function getWorkspaceDoctorChecks(cwd) {
   const checks = [];
   let workspace = null;
   let invalidWorkspaceReason = null;
@@ -1045,13 +1143,13 @@ function getWorkspaceDoctorChecks(cwd) {
     workspace = tryResolveWorkspaceProject(cwd);
   } catch (error) {
     checks.push(createDoctorScopeCheck("fail", "Scope: blocked before workspace checks. Environment checks ran, but workspace discovery could not continue. Fix the nearby workspace package metadata and rerun `wp-typia doctor`."));
-    checks.push(createDoctorCheck2("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+    checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
     return checks;
   }
   if (!workspace) {
     if (invalidWorkspaceReason) {
       checks.push(createDoctorScopeCheck("fail", "Scope: blocked before workspace checks. Environment checks ran, but workspace diagnostics could not continue because a nearby wp-typia workspace candidate is invalid. Fix the workspace package metadata and rerun `wp-typia doctor`."));
-      checks.push(createDoctorCheck2("Workspace package metadata", "fail", invalidWorkspaceReason));
+      checks.push(createDoctorCheck("Workspace package metadata", "fail", invalidWorkspaceReason));
     } else {
       checks.push(createDoctorScopeCheck("pass", "Scope: environment-only. No official wp-typia workspace root was detected, so this run only covered environment readiness. Re-run `wp-typia doctor` from a workspace root if you expected package metadata, inventory, or generated artifact checks."));
     }
@@ -1062,22 +1160,23 @@ function getWorkspaceDoctorChecks(cwd) {
   try {
     workspacePackageJson = parseWorkspacePackageJson(workspace.projectDir);
   } catch (error) {
-    checks.push(createDoctorCheck2("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
+    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 = readWorkspaceInventory(workspace.projectDir);
-    checks.push(createDoctorCheck2("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
+    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
+    checks.push(createDoctorCheck("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
     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);
     }
   } catch (error) {
-    checks.push(createDoctorCheck2("Workspace inventory", "fail", error instanceof Error ? error.message : String(error)));
+    checks.push(createDoctorCheck("Workspace inventory", "fail", error instanceof Error ? error.message : String(error)));
   }
   return checks;
 }
@@ -1086,7 +1185,7 @@ function getWorkspaceDoctorChecks(cwd) {
 async function getDoctorChecks(cwd) {
   return [
     ...await getEnvironmentDoctorChecks(cwd),
-    ...getWorkspaceDoctorChecks(cwd)
+    ...await getWorkspaceDoctorChecks(cwd)
   ];
 }
 async function runDoctor(cwd, options = {}) {
@@ -1115,4 +1214,4 @@ export {
   getDoctorChecks
 };
 
-//# debugId=C5B6D0A40DB5B07664756E2164756E21
+//# debugId=A0E15D6F99F87A7464756E2164756E21