@wp-typia/project-tools 0.24.3 → 0.24.5

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

@@ -0,0 +1,121 @@
+import { execFileSync } from "node:child_process";
+import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getBuiltInTemplateLayerDirs, isOmittableBuiltInTemplateLayerDir, } from "../templates/template-builtins.js";
+import { createDoctorCheck } from "./cli-doctor-workspace-shared.js";
+import { isBuiltInTemplateId, listTemplates } from "../templates/template-registry.js";
+function readCommandVersion(command, args = ["--version"]) {
+    try {
+        return execFileSync(command, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function compareMajorVersion(actualVersion, minimumMajor) {
+    const parsed = Number.parseInt(actualVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
+    return Number.isFinite(parsed) && parsed >= minimumMajor;
+}
+async function checkWritableDirectory(directory) {
+    try {
+        await access(directory, fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkTempDirectory() {
+    const tempFile = path.join(os.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+    try {
+        await writeFile(tempFile, "ok", "utf8");
+        await rm(tempFile, { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getTemplateDoctorChecks() {
+    const checks = [];
+    for (const template of listTemplates()) {
+        if (!isBuiltInTemplateId(template.id)) {
+            const templateDirExists = fs.existsSync(template.templateDir);
+            const hasAssets = templateDirExists &&
+                fs.existsSync(path.join(template.templateDir, "package.json.mustache"));
+            checks.push({
+                status: !templateDirExists || hasAssets ? "pass" : "fail",
+                label: `Template ${template.id}`,
+                detail: !templateDirExists
+                    ? "External template metadata only; local overlay package is not installed."
+                    : hasAssets
+                        ? template.templateDir
+                        : "Missing core template assets",
+            });
+            continue;
+        }
+        const builtInTemplateId = template.id;
+        const layerDirs = builtInTemplateId === "persistence"
+            ? Array.from(new Set([
+                ...getBuiltInTemplateLayerDirs(builtInTemplateId, { persistencePolicy: "authenticated" }),
+                ...getBuiltInTemplateLayerDirs(builtInTemplateId, { persistencePolicy: "public" }),
+            ]))
+            : builtInTemplateId === "compound"
+                ? Array.from(new Set([
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId),
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId, {
+                        persistenceEnabled: true,
+                        persistencePolicy: "authenticated",
+                    }),
+                    ...getBuiltInTemplateLayerDirs(builtInTemplateId, {
+                        persistenceEnabled: true,
+                        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")));
+        checks.push({
+            status: hasAssets ? "pass" : "fail",
+            label: `Template ${template.id}`,
+            detail: hasAssets
+                ? existingLayerDirs.join(" + ")
+                : "Missing core template assets",
+        });
+    }
+    return checks;
+}
+/**
+ * Collect environment-scoped doctor checks for the current working directory.
+ *
+ * The returned rows cover Bun/Node/git availability, writability of the
+ * current working directory and OS temp directory, and built-in or external
+ * template asset integrity in display order.
+ *
+ * @param cwd Working directory validated for writability.
+ * @returns Ordered environment check rows ready for CLI rendering.
+ */
+export async function getEnvironmentDoctorChecks(cwd) {
+    const bunVersion = readCommandVersion("bun");
+    const nodeVersion = readCommandVersion("node");
+    const gitVersion = readCommandVersion("git");
+    const cwdWritable = await checkWritableDirectory(cwd);
+    const tempWritable = await checkTempDirectory();
+    return [
+        createDoctorCheck("Bun", bunVersion && compareMajorVersion(bunVersion, 1) ? "pass" : "fail", bunVersion ? `Detected ${bunVersion}` : "Not available"),
+        createDoctorCheck("Node", nodeVersion && compareMajorVersion(nodeVersion, 20) ? "pass" : "fail", nodeVersion ? `Detected ${nodeVersion}` : "Not available"),
+        createDoctorCheck("git", gitVersion ? "pass" : "fail", gitVersion ?? "Not available"),
+        createDoctorCheck("Current directory", cwdWritable ? "pass" : "fail", cwdWritable ? "Writable" : "Not writable"),
+        createDoctorCheck("Temp directory", tempWritable ? "pass" : "fail", tempWritable ? "Writable" : "Not writable"),
+        ...getTemplateDoctorChecks(),
+    ];
+}

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

@@ -0,0 +1,11 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+import type { WorkspaceInventory } from "../workspace/workspace-inventory.js";
+import type { WorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Collect workspace doctor checks for extracted binding-source diagnostics.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
+ * @returns Ordered `DoctorCheck[]` rows for binding bootstrap, index, and target checks.
+ */
+export declare function getWorkspaceBindingDoctorChecks(workspace: WorkspaceProject, inventory: WorkspaceInventory): DoctorCheck[];

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

@@ -0,0 +1,195 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_BINDING_EDITOR_ASSET, WORKSPACE_BINDING_EDITOR_SCRIPT, WORKSPACE_BINDING_SERVER_GLOB, } from "./cli-doctor-workspace-shared.js";
+import { readJsonFileSync } from "../shared/json-utils.js";
+import { escapeRegex } from "../shared/php-utils.js";
+import { assertPostMetaBindingPath, loadPostMetaBindingFieldsSync, } from "../add/post-meta-binding-fields.js";
+function checkWorkspaceBindingBootstrap(projectDir, packageName) {
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Binding bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.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 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 = [path.join("src", "bindings", "index.ts"), path.join("src", "bindings", "index.js")].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+    if (!indexRelativePath) {
+        return createDoctorCheck("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
+    }
+    const indexPath = path.join(projectDir, indexRelativePath);
+    const source = fs.readFileSync(indexPath, "utf8");
+    const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
+    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;
+    const hasAttribute = bindingSource.attribute !== undefined;
+    if (!hasBlock && !hasAttribute) {
+        return undefined;
+    }
+    if (!bindingSource.block || !bindingSource.attribute) {
+        return createDoctorCheck(`Binding target ${bindingSource.slug}`, "fail", "Binding target entries must include both block and attribute.");
+    }
+    if (!registeredBlockSlugs.has(bindingSource.block)) {
+        return createDoctorCheck(`Binding target ${bindingSource.slug}`, "fail", `Binding target references unknown block "${bindingSource.block}".`);
+    }
+    const blockJsonRelativePath = path.join("src", "blocks", bindingSource.block, "block.json");
+    const blockJsonPath = path.join(projectDir, blockJsonRelativePath);
+    const issues = [];
+    try {
+        const blockJson = parseScaffoldBlockMetadata(readJsonFileSync(blockJsonPath, {
+            context: "workspace block metadata",
+        }));
+        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 = path.join(projectDir, bindingSource.serverFile);
+    if (fs.existsSync(serverPath)) {
+        const serverSource = fs.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)}\\1`, "u").test(serverSource)) {
+            issues.push(`${bindingSource.serverFile} must expose attribute "${bindingSource.attribute}"`);
+        }
+    }
+    else {
+        issues.push(`Missing ${bindingSource.serverFile}`);
+    }
+    const editorPath = path.join(projectDir, bindingSource.editorFile);
+    if (fs.existsSync(editorPath)) {
+        const editorSource = fs.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 createDoctorCheck(`Binding target ${bindingSource.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `${bindingSource.block}.${bindingSource.attribute} is declared and supported`
+        : issues.join("; "));
+}
+function checkWorkspaceBindingPostMeta(projectDir, inventory, bindingSource) {
+    if (!bindingSource.postMeta) {
+        return undefined;
+    }
+    const postMeta = inventory.postMeta.find((entry) => entry.slug === bindingSource.postMeta);
+    if (!postMeta) {
+        return createDoctorCheck(`Binding post meta ${bindingSource.slug}`, "fail", `Binding source references unknown post meta contract "${bindingSource.postMeta}".`);
+    }
+    const issues = [];
+    try {
+        const fields = loadPostMetaBindingFieldsSync(projectDir, postMeta);
+        if (bindingSource.metaPath) {
+            assertPostMetaBindingPath(fields, postMeta.slug, bindingSource.metaPath);
+        }
+    }
+    catch (error) {
+        issues.push(error instanceof Error ? error.message : String(error));
+    }
+    const serverPath = path.join(projectDir, bindingSource.serverFile);
+    if (fs.existsSync(serverPath)) {
+        const serverSource = fs.readFileSync(serverPath, "utf8");
+        if (!serverSource.includes("get_post_meta")) {
+            issues.push(`${bindingSource.serverFile} must read post meta values`);
+        }
+        if (!serverSource.includes(postMeta.metaKey)) {
+            issues.push(`${bindingSource.serverFile} must reference ${postMeta.metaKey}`);
+        }
+        if (!serverSource.includes(postMeta.schemaFile)) {
+            issues.push(`${bindingSource.serverFile} must reference ${postMeta.schemaFile}`);
+        }
+    }
+    else {
+        issues.push(`Missing ${bindingSource.serverFile}`);
+    }
+    const editorPath = path.join(projectDir, bindingSource.editorFile);
+    if (fs.existsSync(editorPath)) {
+        const editorSource = fs.readFileSync(editorPath, "utf8");
+        if (!editorSource.includes("POST_META_BINDING_FIELDS")) {
+            issues.push(`${bindingSource.editorFile} must define post meta binding fields`);
+        }
+        if (!editorSource.includes(postMeta.schemaFile)) {
+            issues.push(`${bindingSource.editorFile} must reference ${postMeta.schemaFile}`);
+        }
+        if (bindingSource.metaPath && !editorSource.includes(bindingSource.metaPath)) {
+            issues.push(`${bindingSource.editorFile} must reference default meta path "${bindingSource.metaPath}"`);
+        }
+    }
+    else {
+        issues.push(`Missing ${bindingSource.editorFile}`);
+    }
+    return createDoctorCheck(`Binding post meta ${bindingSource.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `${bindingSource.slug} reads ${postMeta.slug} via ${postMeta.schemaFile}`
+        : issues.join("; "));
+}
+/**
+ * Collect workspace doctor checks for extracted binding-source diagnostics.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
+ * @returns Ordered `DoctorCheck[]` rows for binding bootstrap, index, and target checks.
+ */
+export function getWorkspaceBindingDoctorChecks(workspace, inventory) {
+    const checks = [];
+    if (inventory.bindingSources.length > 0) {
+        checks.push(checkWorkspaceBindingBootstrap(workspace.projectDir, workspace.packageName));
+        checks.push(checkWorkspaceBindingSourcesIndex(workspace.projectDir, inventory.bindingSources));
+    }
+    const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
+    for (const bindingSource of inventory.bindingSources) {
+        checks.push(checkExistingFiles(workspace.projectDir, `Binding source ${bindingSource.slug}`, [
+            bindingSource.serverFile,
+            bindingSource.editorFile,
+        ]));
+        const bindingTargetCheck = checkWorkspaceBindingTarget(workspace.projectDir, workspace, registeredBlockSlugs, bindingSource);
+        if (bindingTargetCheck) {
+            checks.push(bindingTargetCheck);
+        }
+        const bindingPostMetaCheck = checkWorkspaceBindingPostMeta(workspace.projectDir, inventory, bindingSource);
+        if (bindingPostMetaCheck) {
+            checks.push(bindingPostMetaCheck);
+        }
+    }
+    return checks;
+}

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

@@ -0,0 +1,12 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+import type { WorkspaceInventory } from "../workspace/workspace-inventory.js";
+import type { WorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Collect variation, block style, transform, and pattern doctor checks.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
+ * @param registeredBlockSlugs Block slugs already declared in the inventory.
+ * @returns Ordered add-on and pattern doctor checks.
+ */
+export declare function getWorkspaceBlockAddonDoctorChecks(workspace: WorkspaceProject, inventory: WorkspaceInventory, registeredBlockSlugs: ReadonlySet<string>): DoctorCheck[];

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

@@ -0,0 +1,162 @@
+import fs from "node:fs";
+import path from "node:path";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_FULL_BLOCK_NAME_PATTERN, } from "./cli-doctor-workspace-shared.js";
+import { formatPatternCatalogDiagnostics, resolvePatternCatalogContentFile, validatePatternCatalog, } from "../add/pattern-catalog.js";
+import { hasExecutablePattern, hasUncommentedPattern, } from "../shared/ts-source-masking.js";
+const WORKSPACE_VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
+const WORKSPACE_VARIATIONS_CALL_PATTERN = /registerWorkspaceVariations\s*\(\s*\)\s*;?/u;
+const WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceBlockStyles\s*\}\s*from\s*["']\.\/styles["']\s*;?\s*$/mu;
+const WORKSPACE_BLOCK_STYLES_CALL_PATTERN = /registerWorkspaceBlockStyles\s*\(\s*\)\s*;?/u;
+const WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN = /^\s*import\s*\{\s*applyWorkspaceBlockTransforms\s*\}\s*from\s*["']\.\/transforms["']\s*;?\s*$/mu;
+const WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+function isNestedPatternContentFile(patternFile) {
+    if (!patternFile) {
+        return false;
+    }
+    const normalizedPath = patternFile.replace(/\\/gu, "/");
+    return (normalizedPath.startsWith("src/patterns/") &&
+        normalizedPath.slice("src/patterns/".length).includes("/"));
+}
+function checkWorkspacePatternBootstrap(projectDir, packageName, requiresNestedPatternGlob) {
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Pattern bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const hasCategoryAnchor = source.includes("register_block_pattern_category");
+    const hasPatternGlob = source.includes("/src/patterns/*.php");
+    const hasNestedPatternGlob = source.includes("/src/patterns/*/*.php");
+    const hasRequiredPatternGlobs = hasPatternGlob && (!requiresNestedPatternGlob || hasNestedPatternGlob);
+    return createDoctorCheck("Pattern bootstrap", hasCategoryAnchor && hasRequiredPatternGlobs ? "pass" : "fail", hasCategoryAnchor && hasRequiredPatternGlobs
+        ? "Pattern category and loader hooks are present"
+        : requiresNestedPatternGlob
+            ? "Missing pattern category registration or nested src/patterns loader hook"
+            : "Missing pattern category registration or src/patterns loader hook");
+}
+function checkVariationEntrypoint(projectDir, blockSlug) {
+    const entryPath = path.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+    if (!fs.existsSync(entryPath)) {
+        return createDoctorCheck(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path.relative(projectDir, entryPath)}`);
+    }
+    const source = fs.readFileSync(entryPath, "utf8");
+    const hasImport = hasUncommentedPattern(source, WORKSPACE_VARIATIONS_IMPORT_PATTERN);
+    const hasCall = hasExecutablePattern(source, WORKSPACE_VARIATIONS_CALL_PATTERN);
+    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 = path.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+    if (!fs.existsSync(entryPath)) {
+        return createDoctorCheck(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path.relative(projectDir, entryPath)}`);
+    }
+    const source = fs.readFileSync(entryPath, "utf8");
+    const hasImport = hasUncommentedPattern(source, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN);
+    const hasCall = hasExecutablePattern(source, WORKSPACE_BLOCK_STYLES_CALL_PATTERN);
+    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 = path.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+    if (!fs.existsSync(entryPath)) {
+        return createDoctorCheck(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path.relative(projectDir, entryPath)}`);
+    }
+    const source = fs.readFileSync(entryPath, "utf8");
+    const hasImport = hasUncommentedPattern(source, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN);
+    const hasCall = hasExecutablePattern(source, WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN);
+    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}`;
+    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 createDoctorCheck(`Block transform config ${transform.block}/${transform.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `${transform.from} transforms into ${transform.to}`
+        : issues.join("; "));
+}
+/**
+ * Collect variation, block style, transform, and pattern doctor checks.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
+ * @param registeredBlockSlugs Block slugs already declared in the inventory.
+ * @returns Ordered add-on and pattern doctor checks.
+ */
+export function getWorkspaceBlockAddonDoctorChecks(workspace, inventory, registeredBlockSlugs) {
+    const checks = [];
+    const variationTargetBlocks = new Set();
+    for (const variation of inventory.variations) {
+        if (!registeredBlockSlugs.has(variation.block)) {
+            checks.push(createDoctorCheck(`Variation ${variation.block}/${variation.slug}`, "fail", `Variation references unknown block "${variation.block}"`));
+            continue;
+        }
+        variationTargetBlocks.add(variation.block);
+        checks.push(checkExistingFiles(workspace.projectDir, `Variation ${variation.block}/${variation.slug}`, [variation.file]));
+    }
+    for (const blockSlug of variationTargetBlocks) {
+        checks.push(checkVariationEntrypoint(workspace.projectDir, blockSlug));
+    }
+    const blockStyleTargetBlocks = new Set();
+    for (const blockStyle of inventory.blockStyles) {
+        if (!registeredBlockSlugs.has(blockStyle.block)) {
+            checks.push(createDoctorCheck(`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}`, [
+            path.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(createDoctorCheck(`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}`, [
+            path.join("src", "blocks", blockSlug, "transforms", "index.ts"),
+        ]));
+        checks.push(checkBlockTransformEntrypoint(workspace.projectDir, blockSlug));
+    }
+    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 ||
+        fs.existsSync(path.join(workspace.projectDir, "src", "patterns"));
+    if (shouldCheckPatternBootstrap) {
+        const requiresNestedPatternGlob = inventory.patterns.some((pattern) => isNestedPatternContentFile(resolvePatternCatalogContentFile(pattern)));
+        checks.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName, requiresNestedPatternGlob));
+    }
+    if (inventory.patterns.length > 0) {
+        const catalogValidation = validatePatternCatalog(inventory.patterns, {
+            projectDir: workspace.projectDir,
+        });
+        checks.push(createDoctorCheck("Pattern catalog", catalogValidation.errors.length > 0
+            ? "fail"
+            : catalogValidation.warnings.length > 0
+                ? "warn"
+                : "pass", catalogValidation.diagnostics.length > 0
+            ? formatPatternCatalogDiagnostics(catalogValidation.diagnostics)
+            : "Pattern catalog metadata is valid"));
+    }
+    for (const pattern of inventory.patterns) {
+        checks.push(checkExistingFiles(workspace.projectDir, `Pattern ${pattern.slug}`, [
+            resolvePatternCatalogContentFile(pattern),
+        ]));
+    }
+    return checks;
+}

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

@@ -0,0 +1,9 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+/**
+ * Collect iframe/API v3 compatibility checks for one workspace block.
+ *
+ * @param projectDir Absolute workspace project root.
+ * @param blockSlug Block slug from the workspace inventory.
+ * @returns Ordered iframe compatibility doctor checks.
+ */
+export declare function getWorkspaceBlockIframeCompatibilityChecks(projectDir: string, blockSlug: string): DoctorCheck[];