@wp-typia/project-tools 0.24.4 → 0.24.6

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

@@ -1,121 +1 @@
-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 "./template-builtins.js";
-import { createDoctorCheck } from "./cli-doctor-workspace-shared.js";
-import { isBuiltInTemplateId, listTemplates } from "./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(),
-    ];
-}
+export * from "./doctor/cli-doctor-environment.js";

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

@@ -1,11 +1 @@
-import type { DoctorCheck } from "./cli-doctor.js";
-import type { WorkspaceInventory } from "./workspace-inventory.js";
-import type { WorkspaceProject } from "./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[];
+export * from "./doctor/cli-doctor-workspace-bindings.js";

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

@@ -1,195 +1 @@
-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 "./json-utils.js";
-import { escapeRegex } from "./php-utils.js";
-import { assertPostMetaBindingPath, loadPostMetaBindingFieldsSync, } from "./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;
-}
+export * from "./doctor/cli-doctor-workspace-bindings.js";

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

@@ -1,12 +1 @@
-import type { DoctorCheck } from "./cli-doctor.js";
-import type { WorkspaceInventory } from "./workspace-inventory.js";
-import type { WorkspaceProject } from "./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[];
+export * from "./doctor/cli-doctor-workspace-block-addons.js";

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

@@ -1,162 +1 @@
-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 "./pattern-catalog.js";
-import { hasExecutablePattern, hasUncommentedPattern, } from "./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;
-}
+export * from "./doctor/cli-doctor-workspace-block-addons.js";

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

@@ -1,9 +1 @@
-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[];
+export * from "./doctor/cli-doctor-workspace-block-iframe.js";