wp-typia 0.20.5 → 0.22.0

package/dist-bunli/{cli-diagnostics-zecc6w1f.js → cli-diagnostics-5dvztm7q.js}

@@ -1,28 +1,34 @@
 // @bun
 import {
   CLI_DIAGNOSTIC_CODES,
+  CLI_DIAGNOSTIC_CODE_METADATA,
   CliDiagnosticError,
   createCliCommandError,
+  createCliDiagnosticCodeError,
   formatCliDiagnosticError,
   formatDoctorCheckLine,
   formatDoctorSummaryLine,
+  getCliDiagnosticCodeMetadata,
   getDoctorFailureDetailLines,
   getFailingDoctorChecks,
   isCliDiagnosticError,
   serializeCliDiagnosticError
-} from "./cli-xxzpb58s.js";
+} from "./cli-p95wr1q8.js";
 import"./cli-xnn9xjcy.js";
 export {
   serializeCliDiagnosticError,
   isCliDiagnosticError,
   getFailingDoctorChecks,
   getDoctorFailureDetailLines,
+  getCliDiagnosticCodeMetadata,
   formatDoctorSummaryLine,
   formatDoctorCheckLine,
   formatCliDiagnosticError,
+  createCliDiagnosticCodeError,
   createCliCommandError,
   CliDiagnosticError,
+  CLI_DIAGNOSTIC_CODE_METADATA,
   CLI_DIAGNOSTIC_CODES
 };
 
-//# debugId=D7A37B51FF87D98264756E2164756E21
+//# debugId=C0BB65021DB87CDD64756E2164756E21

package/dist-bunli/{cli-doctor-2bc4sq7v.js → cli-doctor-p3jxvn0k.js}

@@ -1,10 +1,4 @@
 // @bun
-import {
-  createCliCommandError,
-  formatDoctorCheckLine,
-  formatDoctorSummaryLine,
-  getDoctorFailureDetailLines
-} from "./cli-xxzpb58s.js";
 import {
   getBuiltInTemplateLayerDirs,
   isOmittableBuiltInTemplateLayerDir
@@ -19,9 +13,18 @@ import {
   HOOKED_BLOCK_POSITION_SET,
   REST_RESOURCE_METHOD_IDS,
   REST_RESOURCE_NAMESPACE_PATTERN,
-  readWorkspaceInventory
-} from "./cli-3w3qxq9w.js";
+  escapeRegex,
+  readWorkspaceInventory,
+  resolveEditorPluginSlotAlias
+} from "./cli-j180bk07.js";
 import"./cli-t73q5aqz.js";
+import {
+  CLI_DIAGNOSTIC_CODES,
+  createCliCommandError,
+  formatDoctorCheckLine,
+  formatDoctorSummaryLine,
+  getDoctorFailureDetailLines
+} from "./cli-p95wr1q8.js";
 import {
   WORKSPACE_TEMPLATE_PACKAGE,
   getInvalidWorkspaceProjectReason,
@@ -140,6 +143,10 @@ 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";
@@ -150,14 +157,244 @@ var WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
   "typia-validator.php",
   "typia.openapi.json"
 ];
-function createDoctorCheck2(label, status, detail) {
-  return { detail, label, status };
+var WORKSPACE_FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+var WORKSPACE_VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
+var WORKSPACE_VARIATIONS_CALL_PATTERN = /registerWorkspaceVariations\s*\(\s*\)\s*;?/u;
+var WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceBlockStyles\s*\}\s*from\s*["']\.\/styles["']\s*;?\s*$/mu;
+var WORKSPACE_BLOCK_STYLES_CALL_PATTERN = /registerWorkspaceBlockStyles\s*\(\s*\)\s*;?/u;
+var WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN = /^\s*import\s*\{\s*applyWorkspaceBlockTransforms\s*\}\s*from\s*["']\.\/transforms["']\s*;?\s*$/mu;
+var WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+var WORKSPACE_BLOCK_IFRAME_COMPATIBILITY_DOC_URL = "https://developer.wordpress.org/block-editor/reference-guides/block-api/block-api-versions/block-migration-for-iframe-editor-compatibility/";
+var WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES = {
+  API_VERSION: "wp-typia.workspace.block.iframe.api-version",
+  BLOCK_PROPS: "wp-typia.workspace.block.iframe.block-props",
+  EDITOR_GLOBALS: "wp-typia.workspace.block.iframe.editor-globals",
+  EDITOR_STYLES: "wp-typia.workspace.block.iframe.editor-styles"
+};
+var WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN = /\.[cm]?[jt]sx?$/u;
+var WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES = new Set([
+  "edit",
+  "editor",
+  "index",
+  "save"
+]);
+var WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES = new Set([
+  "components",
+  "controls",
+  "editor",
+  "inspector"
+]);
+var WORKSPACE_BLOCK_LOCAL_STYLE_FILES = [
+  "editor.css",
+  "editor.scss",
+  "index.css",
+  "style.css",
+  "style.scss"
+];
+var WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN = /\b(?:document|window)\b|\b(?:parent|top)\b(?!\s*:)/gu;
+var WORKSPACE_BLOCK_PROPS_PATTERN = /\buse(?:Block|InnerBlocks)Props(?:\.save)?\s*\(/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 escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+function maskSourceSegment(segment) {
+  return segment.replace(/[^\n\r]/gu, " ");
+}
+function maskTypeScriptComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment).replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
+}
+function maskTypeScriptCommentsAndLiterals(source) {
+  let maskedSource = "";
+  let index = 0;
+  while (index < source.length) {
+    const current = source[index];
+    const next = source[index + 1];
+    if (current === "/" && next === "/") {
+      const start = index;
+      index += 2;
+      while (index < source.length && source[index] !== `
+` && source[index] !== "\r") {
+        index += 1;
+      }
+      maskedSource += maskSourceSegment(source.slice(start, index));
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      const start = index;
+      index += 2;
+      while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
+        index += 1;
+      }
+      index = Math.min(index + 2, source.length);
+      maskedSource += maskSourceSegment(source.slice(start, index));
+      continue;
+    }
+    if (current === "'" || current === '"' || current === "`") {
+      const start = index;
+      const quote = current;
+      index += 1;
+      while (index < source.length) {
+        const char = source[index];
+        if (char === "\\") {
+          index += 2;
+          continue;
+        }
+        index += 1;
+        if (char === quote) {
+          break;
+        }
+      }
+      maskedSource += maskSourceSegment(source.slice(start, index));
+      continue;
+    }
+    maskedSource += current;
+    index += 1;
+  }
+  return maskedSource;
+}
+function hasUncommentedPattern(source, pattern) {
+  return pattern.test(maskTypeScriptComments(source));
+}
+function hasExecutablePattern(source, pattern) {
+  return pattern.test(maskTypeScriptCommentsAndLiterals(source));
+}
+function normalizePathSeparators(relativePath) {
+  return relativePath.split(path2.sep).join("/");
+}
+function hasRegisteredBlockAsset(value) {
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.some((entry) => hasRegisteredBlockAsset(entry));
+  }
+  return false;
+}
+function readWorkspaceBlockIframeMetadata(projectDir, blockSlug) {
+  const blockJsonRelativePath = path2.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path2.join(projectDir, blockJsonRelativePath);
+  if (!fs2.existsSync(blockJsonPath)) {
+    return {
+      blockJsonRelativePath,
+      error: `Missing ${blockJsonRelativePath}`
+    };
+  }
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(blockJsonPath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        blockJsonRelativePath,
+        error: `${blockJsonRelativePath} must contain a JSON object`
+      };
+    }
+    return {
+      blockJsonRelativePath,
+      document: parsed
+    };
+  } catch (error) {
+    return {
+      blockJsonRelativePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function isWorkspaceBlockEditorSource(relativePath) {
+  const normalizedPath = normalizePathSeparators(relativePath);
+  const normalizedLowerPath = normalizedPath.toLowerCase();
+  if (!WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN.test(normalizedLowerPath) || /\.d\.[cm]?[jt]s$/u.test(normalizedLowerPath)) {
+    return false;
+  }
+  const segments = normalizedLowerPath.split("/");
+  const fileName = segments[segments.length - 1] ?? "";
+  const baseName = fileName.replace(/\.[^.]+$/u, "");
+  if (WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES.has(baseName)) {
+    return true;
+  }
+  return segments.slice(0, -1).some((segment) => WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES.has(segment));
+}
+function isWorkspaceBlockSaveSource(relativePath) {
+  const fileName = normalizePathSeparators(relativePath).split("/").pop() ?? "";
+  return fileName.replace(/\.[^.]+$/u, "").toLowerCase() === "save";
+}
+function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
+  const blockDir = path2.join(projectDir, "src", "blocks", blockSlug);
+  if (!fs2.existsSync(blockDir)) {
+    return [];
+  }
+  const sources = [];
+  const visitDirectory = (directory) => {
+    for (const entry of fs2.readdirSync(directory, { withFileTypes: true })) {
+      const entryPath = path2.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        visitDirectory(entryPath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const relativePath = normalizePathSeparators(path2.relative(projectDir, entryPath));
+      const blockRelativePath = path2.relative(blockDir, entryPath);
+      if (!isWorkspaceBlockEditorSource(blockRelativePath)) {
+        continue;
+      }
+      sources.push({
+        relativePath,
+        source: fs2.readFileSync(entryPath, "utf8")
+      });
+    }
+  };
+  visitDirectory(blockDir);
+  return sources;
+}
+function getSourceLineNumber(source, index) {
+  let lineNumber = 1;
+  for (let cursor = 0;cursor < index; cursor += 1) {
+    if (source[cursor] === `
+`) {
+      lineNumber += 1;
+    }
+  }
+  return lineNumber;
+}
+function isGlobalDomAccessCandidate(maskedSource, index, token) {
+  if (token === "document" || token === "window") {
+    return true;
+  }
+  const before = maskedSource.slice(0, index);
+  const after = maskedSource.slice(index + token.length);
+  const previousNonWhitespace = before.match(/\S(?=\s*$)/u)?.[0] ?? "";
+  const nextNonWhitespace = after.match(/^\s*(\S)/u)?.[1] ?? "";
+  if (previousNonWhitespace === "." || previousNonWhitespace === "{" || previousNonWhitespace === ",") {
+    return false;
+  }
+  if (nextNonWhitespace === ":") {
+    return false;
+  }
+  if (/\b(?:const|function|let|var)\s+$/u.test(before)) {
+    return false;
+  }
+  return true;
+}
+function findWorkspaceBlockGlobalDomAccesses(sources) {
+  const findings = [];
+  for (const { relativePath, source } of sources) {
+    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
+    const matches = maskedSource.matchAll(WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN);
+    for (const match of matches) {
+      const index = match.index ?? 0;
+      const matchedToken = match[0].replace(/\W+/gu, "");
+      if (!isGlobalDomAccessCandidate(maskedSource, index, matchedToken)) {
+        continue;
+      }
+      findings.push(`${relativePath}:${getSourceLineNumber(source, index)} (${matchedToken})`);
+      if (findings.length >= 5) {
+        return findings;
+      }
+    }
+  }
+  return findings;
 }
 function getWorkspaceBootstrapRelativePath(packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
@@ -260,6 +497,32 @@ function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
   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}`);
 }
+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)
+    ];
+  }
+  const blockJson = metadataResult.document;
+  const apiVersion = typeof blockJson.apiVersion === "number" && Number.isFinite(blockJson.apiVersion) ? blockJson.apiVersion : null;
+  const blockDir = path2.join(projectDir, "src", "blocks", blockSlug);
+  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs2.existsSync(path2.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path2.join("src", "blocks", blockSlug, fileName)));
+  const hasRegisteredEditorStyles = hasRegisteredBlockAsset(blockJson.style) || hasRegisteredBlockAsset(blockJson.editorStyle);
+  const editorSources = collectWorkspaceBlockEditorSources(projectDir, blockSlug);
+  const editorWrapperSources = editorSources.filter((source) => !isWorkspaceBlockSaveSource(source.relativePath));
+  const globalDomAccesses = findWorkspaceBlockGlobalDomAccesses(editorSources);
+  const hasBlockPropsUsage = editorSources.some(({ source }) => hasExecutablePattern(source, WORKSPACE_BLOCK_PROPS_PATTERN));
+  const hasEditorBlockPropsUsage = editorWrapperSources.some(({ source }) => hasExecutablePattern(source, WORKSPACE_BLOCK_PROPS_PATTERN));
+  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)
+  ];
+}
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
   const bootstrapPath = path2.join(projectDir, `${packageBaseName}.php`);
@@ -294,6 +557,71 @@ function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
   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(", ")}`);
 }
+function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs, bindingSource) {
+  const hasBlock = bindingSource.block !== undefined;
+  const hasAttribute = bindingSource.attribute !== undefined;
+  if (!hasBlock && !hasAttribute) {
+    return;
+  }
+  if (!bindingSource.block || !bindingSource.attribute) {
+    return createDoctorCheck2(`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}".`);
+  }
+  const blockJsonRelativePath = path2.join("src", "blocks", bindingSource.block, "block.json");
+  const blockJsonPath = path2.join(projectDir, blockJsonRelativePath);
+  const issues = [];
+  try {
+    const blockJson = parseScaffoldBlockMetadata(JSON.parse(fs2.readFileSync(blockJsonPath, "utf8")));
+    const attributes = blockJson.attributes;
+    if (!attributes || typeof attributes !== "object" || Array.isArray(attributes)) {
+      issues.push(`${blockJsonRelativePath} must define an attributes object`);
+    } else {
+      const attributeConfig = attributes[bindingSource.attribute];
+      if (!attributeConfig || typeof attributeConfig !== "object" || Array.isArray(attributeConfig)) {
+        issues.push(`${blockJsonRelativePath} must declare attribute "${bindingSource.attribute}"`);
+      }
+    }
+  } catch (error) {
+    issues.push(error instanceof Error ? `Unable to read ${blockJsonRelativePath}: ${error.message}` : `Unable to read ${blockJsonRelativePath}.`);
+  }
+  const serverPath = path2.join(projectDir, bindingSource.serverFile);
+  if (fs2.existsSync(serverPath)) {
+    const serverSource = fs2.readFileSync(serverPath, "utf8");
+    const supportedAttributesFilter = `block_bindings_supported_attributes_${workspace.workspace.namespace}/${bindingSource.block}`;
+    if (!serverSource.includes(supportedAttributesFilter)) {
+      issues.push(`${bindingSource.serverFile} must register ${supportedAttributesFilter}`);
+    }
+    if (!new RegExp(`'${escapeRegex(bindingSource.attribute)}'`, "u").test(serverSource)) {
+      issues.push(`${bindingSource.serverFile} must expose attribute "${bindingSource.attribute}"`);
+    }
+  } else {
+    issues.push(`Missing ${bindingSource.serverFile}`);
+  }
+  const editorPath = path2.join(projectDir, bindingSource.editorFile);
+  if (fs2.existsSync(editorPath)) {
+    const editorSource = fs2.readFileSync(editorPath, "utf8");
+    const blockName = `${workspace.workspace.namespace}/${bindingSource.block}`;
+    const bindingSourceTargetMatch = editorSource.match(/export\s+const\s+BINDING_SOURCE_TARGET\s*=\s*\{([\s\S]*?)\}\s+as\s+const\s*;/u);
+    if (!bindingSourceTargetMatch) {
+      issues.push(`${bindingSource.editorFile} must export BINDING_SOURCE_TARGET`);
+    } else {
+      const targetSource = bindingSourceTargetMatch[1] ?? "";
+      const attributePattern = new RegExp(`\\battribute\\s*:\\s*["']${escapeRegex(bindingSource.attribute)}["']`, "u");
+      const blockPattern = new RegExp(`\\bblock\\s*:\\s*["']${escapeRegex(blockName)}["']`, "u");
+      if (!attributePattern.test(targetSource)) {
+        issues.push(`${bindingSource.editorFile} must document target attribute "${bindingSource.attribute}"`);
+      }
+      if (!blockPattern.test(targetSource)) {
+        issues.push(`${bindingSource.editorFile} must document target block "${blockName}"`);
+      }
+    }
+  } 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("; "));
+}
 function getWorkspaceRestResourceRequiredFiles(restResource) {
   const schemaNames = new Set;
   if (restResource.methods.includes("list")) {
@@ -444,18 +772,19 @@ function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
 }
 function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
   const editorPluginDir = path2.join("src", "editor-plugins", editorPlugin.slug);
+  const surfaceFile = editorPlugin.slot === "PluginSidebar" ? path2.join(editorPluginDir, "Sidebar.tsx") : path2.join(editorPluginDir, "Surface.tsx");
   return Array.from(new Set([
     editorPlugin.file,
-    path2.join(editorPluginDir, "Sidebar.tsx"),
+    surfaceFile,
     path2.join(editorPluginDir, "data.ts"),
     path2.join(editorPluginDir, "types.ts"),
     path2.join(editorPluginDir, "style.scss")
   ]));
 }
 function checkWorkspaceEditorPluginConfig(editorPlugin) {
-  const validSlots = new Set(EDITOR_PLUGIN_SLOT_IDS);
-  const isValidSlot = validSlots.has(editorPlugin.slot);
-  return createDoctorCheck2(`Editor plugin config ${editorPlugin.slug}`, isValidSlot ? "pass" : "fail", isValidSlot ? `Editor plugin slot ${editorPlugin.slot} is supported` : `Unsupported editor plugin slot "${editorPlugin.slot}". Expected one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")}`);
+  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.`);
 }
 function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
@@ -488,16 +817,114 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   });
   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(", ")}`);
 }
+function getWorkspaceAdminViewRequiredFiles(adminView) {
+  const adminViewDir = path2.join("src", "admin-views", adminView.slug);
+  return Array.from(new Set([
+    adminView.file,
+    adminView.phpFile,
+    path2.join(adminViewDir, "Screen.tsx"),
+    path2.join(adminViewDir, "config.ts"),
+    path2.join(adminViewDir, "data.ts"),
+    path2.join(adminViewDir, "style.scss"),
+    path2.join(adminViewDir, "types.ts")
+  ]));
+}
+function checkWorkspaceAdminViewConfig(adminView, inventory) {
+  if (adminView.source === undefined) {
+    return createDoctorCheck2(`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>");
+}
+function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
+  const packageBaseName = packageName.split("/").pop() ?? packageName;
+  const bootstrapPath = path2.join(projectDir, `${packageBaseName}.php`);
+  if (!fs2.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path2.basename(bootstrapPath)}`);
+  }
+  const source = fs2.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");
+}
+function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
+  const indexRelativePath = [
+    path2.join("src", "admin-views", "index.ts"),
+    path2.join("src", "admin-views", "index.js")
+  ].find((relativePath) => fs2.existsSync(path2.join(projectDir, relativePath)));
+  if (!indexRelativePath) {
+    return createDoctorCheck2("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
+  }
+  const indexPath = path2.join(projectDir, indexRelativePath);
+  const source = fs2.readFileSync(indexPath, "utf8");
+  const missingImports = adminViews.filter((adminView) => {
+    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(", ")}`);
+}
+function checkWorkspaceAdminViewPhp(projectDir, adminView) {
+  const phpPath = path2.join(projectDir, adminView.phpFile);
+  if (!fs2.existsSync(phpPath)) {
+    return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
+  }
+  const source = fs2.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 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");
+}
 function checkVariationEntrypoint(projectDir, blockSlug) {
   const entryPath = path2.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs2.existsSync(entryPath)) {
     return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path2.relative(projectDir, entryPath)}`);
   }
   const source = fs2.readFileSync(entryPath, "utf8");
-  const hasImport = source.includes("./variations");
-  const hasCall = source.includes("registerWorkspaceVariations()");
+  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");
 }
+function checkBlockStyleEntrypoint(projectDir, blockSlug) {
+  const entryPath = path2.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  if (!fs2.existsSync(entryPath)) {
+    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path2.relative(projectDir, entryPath)}`);
+  }
+  const source = fs2.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");
+}
+function checkBlockTransformEntrypoint(projectDir, blockSlug) {
+  const entryPath = path2.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  if (!fs2.existsSync(entryPath)) {
+    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path2.relative(projectDir, entryPath)}`);
+  }
+  const source = fs2.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");
+}
+function checkBlockTransformConfig(workspace, transform) {
+  const expectedTo = `${workspace.workspace.namespace}/${transform.block}`;
+  const issues = [];
+  if (!WORKSPACE_FULL_BLOCK_NAME_PATTERN.test(transform.from)) {
+    issues.push("from must use full namespace/block format");
+  }
+  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("; "));
+}
 function checkMigrationWorkspaceHint(workspace, packageJson) {
   const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
   const migrationConfigRelativePath = path2.join("src", "migrations", "config.ts");
@@ -539,12 +966,13 @@ function getWorkspaceDoctorChecks(cwd) {
   checks.push(checkWorkspacePackageMetadata(workspace, workspacePackageJson));
   try {
     const inventory = readWorkspaceInventory(workspace.projectDir);
-    checks.push(createDoctorCheck2("Workspace inventory", "pass", `${inventory.blocks.length} block(s), ${inventory.variations.length} variation(s), ${inventory.patterns.length} pattern(s), ${inventory.bindingSources.length} binding source(s), ${inventory.restResources.length} REST resource(s), ${inventory.abilities.length} ability scaffold(s), ${inventory.aiFeatures.length} AI feature(s), ${inventory.editorPlugins.length} editor plugin(s)`));
+    checks.push(createDoctorCheck2("Workspace inventory", "pass", `${inventory.blocks.length} block(s), ${inventory.variations.length} variation(s), ${inventory.blockStyles.length} block style(s), ${inventory.blockTransforms.length} block transform(s), ${inventory.patterns.length} pattern(s), ${inventory.bindingSources.length} binding source(s), ${inventory.restResources.length} REST resource(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)`));
     for (const block of inventory.blocks) {
       checks.push(checkExistingFiles(workspace.projectDir, `Block ${block.slug}`, getWorkspaceBlockRequiredFiles(block)));
       checks.push(checkWorkspaceBlockMetadata(workspace.projectDir, workspace, block));
       checks.push(checkWorkspaceBlockHooks(workspace.projectDir, block.slug));
       checks.push(checkWorkspaceBlockCollectionImport(workspace.projectDir, block.slug));
+      checks.push(...checkWorkspaceBlockIframeCompatibility(workspace.projectDir, block.slug));
     }
     const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
     const variationTargetBlocks = new Set;
@@ -559,6 +987,37 @@ function getWorkspaceDoctorChecks(cwd) {
     for (const blockSlug of variationTargetBlocks) {
       checks.push(checkVariationEntrypoint(workspace.projectDir, blockSlug));
     }
+    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}"`));
+        continue;
+      }
+      blockStyleTargetBlocks.add(blockStyle.block);
+      checks.push(checkExistingFiles(workspace.projectDir, `Block style ${blockStyle.block}/${blockStyle.slug}`, [blockStyle.file]));
+    }
+    for (const blockSlug of blockStyleTargetBlocks) {
+      checks.push(checkExistingFiles(workspace.projectDir, `Block style registry ${blockSlug}`, [
+        path2.join("src", "blocks", blockSlug, "styles", "index.ts")
+      ]));
+      checks.push(checkBlockStyleEntrypoint(workspace.projectDir, blockSlug));
+    }
+    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}"`));
+        continue;
+      }
+      blockTransformTargetBlocks.add(blockTransform.block);
+      checks.push(checkBlockTransformConfig(workspace, blockTransform));
+      checks.push(checkExistingFiles(workspace.projectDir, `Block transform ${blockTransform.block}/${blockTransform.slug}`, [blockTransform.file]));
+    }
+    for (const blockSlug of blockTransformTargetBlocks) {
+      checks.push(checkExistingFiles(workspace.projectDir, `Block transform registry ${blockSlug}`, [
+        path2.join("src", "blocks", blockSlug, "transforms", "index.ts")
+      ]));
+      checks.push(checkBlockTransformEntrypoint(workspace.projectDir, blockSlug));
+    }
     const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs2.existsSync(path2.join(workspace.projectDir, "src", "patterns"));
     if (shouldCheckPatternBootstrap) {
       checks.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
@@ -575,6 +1034,10 @@ function getWorkspaceDoctorChecks(cwd) {
         bindingSource.serverFile,
         bindingSource.editorFile
       ]));
+      const bindingTargetCheck = checkWorkspaceBindingTarget(workspace.projectDir, workspace, registeredBlockSlugs, bindingSource);
+      if (bindingTargetCheck) {
+        checks.push(bindingTargetCheck);
+      }
     }
     if (inventory.restResources.length > 0) {
       checks.push(checkWorkspaceRestResourceBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
@@ -606,6 +1069,15 @@ function getWorkspaceDoctorChecks(cwd) {
       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));
+    }
     const migrationWorkspaceCheck = checkMigrationWorkspaceHint(workspace, workspacePackageJson);
     if (migrationWorkspaceCheck) {
       checks.push(migrationWorkspaceCheck);
@@ -636,6 +1108,7 @@ async function runDoctor(cwd, options = {}) {
   const failureDetailLines = getDoctorFailureDetailLines(checks);
   if (failureDetailLines.length > 0) {
     throw createCliCommandError({
+      code: CLI_DIAGNOSTIC_CODES.DOCTOR_CHECK_FAILED,
       command: "doctor",
       detailLines: failureDetailLines,
       summary: "One or more doctor checks failed."
@@ -648,4 +1121,4 @@ export {
   getDoctorChecks
 };
 
-//# debugId=DA7EC2F06C52A22464756E2164756E21
+//# debugId=0A56FB55109F0ECC64756E2164756E21