@wp-typia/project-tools 0.22.2 → 0.22.4

package/dist/runtime/cli-add-workspace-assets.js

@@ -8,6 +8,7 @@ import { readWorkspaceInventory, appendWorkspaceInventoryEntries, } from "./work
 import { toPascalCase, toTitleCase } from "./string-case.js";
 import { findPhpFunctionRange, hasPhpFunctionDefinition, quotePhpString, replacePhpFunctionDefinition, } from "./php-utils.js";
 import { assertBindingSourceDoesNotExist, assertEditorPluginDoesNotExist, assertPatternDoesNotExist, assertValidEditorPluginSlot, assertValidGeneratedSlug, getWorkspaceBootstrapPath, normalizeBlockSlug, patchFile, quoteTsString, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { normalizeOptionalCliString } from "./cli-validation.js";
 const PATTERN_BOOTSTRAP_CATEGORY = "register_block_pattern_category";
 const BINDING_SOURCE_SERVER_GLOB = "/src/bindings/*/server.php";
 const BINDING_SOURCE_EDITOR_SCRIPT = "build/bindings/index.js";
@@ -225,8 +226,10 @@ registerBlockBindingsSource( {
 `;
 }
 function resolveBindingTarget(options, namespace) {
-    const hasBlock = options.blockName !== undefined && options.blockName.trim().length > 0;
-    const hasAttribute = options.attributeName !== undefined && options.attributeName.trim().length > 0;
+    const blockName = normalizeOptionalCliString(options.blockName);
+    const attributeName = normalizeOptionalCliString(options.attributeName);
+    const hasBlock = blockName !== undefined;
+    const hasAttribute = attributeName !== undefined;
     if (!hasBlock && !hasAttribute) {
         return undefined;
     }
@@ -234,8 +237,8 @@ function resolveBindingTarget(options, namespace) {
         throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
     }
     return {
-        attributeName: assertValidBindingAttributeName(options.attributeName ?? ""),
-        blockSlug: resolveBindingTargetBlockSlug(options.blockName ?? "", namespace),
+        attributeName: assertValidBindingAttributeName(attributeName ?? ""),
+        blockSlug: resolveBindingTargetBlockSlug(blockName ?? "", namespace),
     };
 }
 function formatBindingAttributeTypeMember(attributeName) {

package/dist/runtime/cli-add-workspace-mutation.d.ts

@@ -0,0 +1,30 @@
+export interface WorkspaceMutationPlan<TResult> {
+    /** Files to capture before the mutation starts. Missing files are restored as absent. */
+    filePaths: string[];
+    /** Snapshot directories created by the mutation, usually migration fixtures. */
+    snapshotDirs?: string[];
+    /** Created files or directories to remove if the mutation fails. */
+    targetPaths?: string[];
+    /** Mutating work to execute after the snapshot is captured. */
+    run: () => Promise<TResult>;
+}
+/**
+ * Error thrown when the mutation and its rollback both fail.
+ */
+export declare class WorkspaceMutationRollbackError extends Error {
+    readonly mutationError: unknown;
+    readonly rollbackError: unknown;
+    constructor(mutationError: unknown, rollbackError: unknown);
+}
+/**
+ * Execute a workspace add mutation with rollback on any failure.
+ */
+export declare function executeWorkspaceMutationPlan<TResult>({ filePaths, run, snapshotDirs, targetPaths, }: WorkspaceMutationPlan<TResult>): Promise<TResult>;
+/**
+ * Insert a PHP snippet before the workspace textdomain hook or closing tag.
+ */
+export declare function insertPhpSnippetBeforeWorkspaceAnchors(source: string, snippet: string): string;
+/**
+ * Append a PHP snippet before the closing tag when one is present.
+ */
+export declare function appendPhpSnippetBeforeClosingTag(source: string, snippet: string): string;

package/dist/runtime/cli-add-workspace-mutation.js

@@ -0,0 +1,60 @@
+import { rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+const DEFAULT_PHP_SNIPPET_INSERTION_ANCHORS = [
+    /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
+    /\?>\s*$/u,
+];
+/**
+ * Error thrown when the mutation and its rollback both fail.
+ */
+export class WorkspaceMutationRollbackError extends Error {
+    constructor(mutationError, rollbackError) {
+        super("Workspace mutation failed and rollback also failed.");
+        this.name = "WorkspaceMutationRollbackError";
+        this.mutationError = mutationError;
+        this.rollbackError = rollbackError;
+    }
+}
+/**
+ * Execute a workspace add mutation with rollback on any failure.
+ */
+export async function executeWorkspaceMutationPlan({ filePaths, run, snapshotDirs = [], targetPaths = [], }) {
+    const mutationSnapshot = {
+        fileSources: await snapshotWorkspaceFiles(filePaths),
+        snapshotDirs: [...snapshotDirs],
+        targetPaths: [...targetPaths],
+    };
+    try {
+        return await run();
+    }
+    catch (error) {
+        try {
+            await rollbackWorkspaceMutation(mutationSnapshot);
+        }
+        catch (rollbackError) {
+            throw new WorkspaceMutationRollbackError(error, rollbackError);
+        }
+        throw error;
+    }
+}
+/**
+ * Insert a PHP snippet before the workspace textdomain hook or closing tag.
+ */
+export function insertPhpSnippetBeforeWorkspaceAnchors(source, snippet) {
+    for (const anchor of DEFAULT_PHP_SNIPPET_INSERTION_ANCHORS) {
+        const candidate = source.replace(anchor, (match) => `${snippet}\n${match}`);
+        if (candidate !== source) {
+            return candidate;
+        }
+    }
+    return `${source.trimEnd()}\n${snippet}\n`;
+}
+/**
+ * Append a PHP snippet before the closing tag when one is present.
+ */
+export function appendPhpSnippetBeforeClosingTag(source, snippet) {
+    const closingTagPattern = /\?>\s*$/u;
+    if (closingTagPattern.test(source)) {
+        return source.replace(closingTagPattern, `${snippet}\n?>`);
+    }
+    return `${source.trimEnd()}\n${snippet}\n`;
+}

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

@@ -4,7 +4,8 @@ import path from "node:path";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { appendWorkspaceInventoryEntries, readWorkspaceInventory } from "./workspace-inventory.js";
 import { toKebabCase, toSnakeCase, toTitleCase } from "./string-case.js";
-import { assertValidGeneratedSlug, assertValidHookAnchor, assertValidHookedBlockPosition, assertVariationDoesNotExist, getMutableBlockHooks, normalizeBlockSlug, patchFile, quoteTsString, readWorkspaceBlockJson, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { assertBlockStyleDoesNotExist, assertBlockTransformDoesNotExist, assertValidGeneratedSlug, assertValidHookAnchor, assertValidHookedBlockPosition, assertVariationDoesNotExist, getMutableBlockHooks, normalizeBlockSlug, patchFile, quoteTsString, readWorkspaceBlockJson, resolveWorkspaceBlock, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { findExecutablePatternMatch, hasExecutablePattern, hasUncommentedPattern, maskTypeScriptCommentsAndLiterals, } from "./ts-source-masking.js";
 const VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
 const VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
 const VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
@@ -19,85 +20,6 @@ const BLOCK_TRANSFORMS_CALL_LINE = "applyWorkspaceBlockTransforms(registration.s
 const BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
 const SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN = /registerScaffoldBlockType\s*\(\s*registration\s*\.\s*name\s*,\s*registration\s*\.\s*settings\s*\)\s*;?/u;
 const FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
-function maskSourceSegment(segment) {
-    return segment.replace(/[^\n\r]/gu, " ");
-}
-function maskTypeScriptComments(source) {
-    return source
-        .replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment)
-        .replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
-}
-// Preserve source offsets so executable-code match indexes still map to the original file.
-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] !== "\n" &&
-                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 hasExecutablePattern(source, pattern) {
-    return pattern.test(maskTypeScriptCommentsAndLiterals(source));
-}
-function hasUncommentedPattern(source, pattern) {
-    return pattern.test(maskTypeScriptComments(source));
-}
-function findExecutablePatternMatch(source, patterns) {
-    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
-    for (const pattern of patterns) {
-        const match = pattern.exec(maskedSource);
-        if (match && match.index !== undefined) {
-            return {
-                end: match.index + match[0].length,
-                start: match.index,
-            };
-        }
-    }
-    return undefined;
-}
 function isIdentifierBoundary(source, index) {
     if (index < 0 || index >= source.length) {
         return true;
@@ -488,24 +410,6 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
     const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
     await fsp.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
-function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-    const stylePath = path.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
-    if (fs.existsSync(stylePath)) {
-        throw new Error(`A block style already exists at ${path.relative(projectDir, stylePath)}. Choose a different name.`);
-    }
-    if (inventory.blockStyles.some((entry) => entry.block === blockSlug && entry.slug === styleSlug)) {
-        throw new Error(`A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`);
-    }
-}
-function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-    const transformPath = path.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
-    if (fs.existsSync(transformPath)) {
-        throw new Error(`A block transform already exists at ${path.relative(projectDir, transformPath)}. Choose a different name.`);
-    }
-    if (inventory.blockTransforms.some((entry) => entry.block === blockSlug && entry.slug === transformSlug)) {
-        throw new Error(`A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`);
-    }
-}
 function assertFullBlockName(blockName, flagName) {
     const trimmed = blockName.trim();
     if (!trimmed) {

package/dist/runtime/cli-add.d.ts

@@ -3,11 +3,11 @@
  *
  * The canonical CLI surface stays stable here while the implementation lives
  * in focused internal modules:
- * - `cli-add-shared` for shared validation/help/rollback helpers
+ * - `cli-add-shared` as a compatibility barrel around focused add helpers
  * - `cli-add-block` for built-in block scaffolding
  * - `cli-add-workspace` for workspace mutation commands
  */
-export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, } from "./cli-add-shared.js";
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, } from "./cli-add-shared.js";
 export type { AddBlockTemplateId, AddKindId, EditorPluginSlotId, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
 export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";

package/dist/runtime/cli-add.js

@@ -3,11 +3,11 @@
  *
  * The canonical CLI surface stays stable here while the implementation lives
  * in focused internal modules:
- * - `cli-add-shared` for shared validation/help/rollback helpers
+ * - `cli-add-shared` as a compatibility barrel around focused add helpers
  * - `cli-add-block` for built-in block scaffolding
  * - `cli-add-workspace` for workspace mutation commands
  */
-export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, } from "./cli-add-shared.js";
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
 export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
 export { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";

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

@@ -0,0 +1,11 @@
+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[];

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

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
+import { checkExistingFiles, createDoctorCheck, WORKSPACE_BINDING_EDITOR_ASSET, WORKSPACE_BINDING_EDITOR_SCRIPT, WORKSPACE_BINDING_SERVER_GLOB, } from "./cli-doctor-workspace-shared.js";
+import { escapeRegex } from "./php-utils.js";
+function checkWorkspaceBindingBootstrap(projectDir, packageName) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    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(JSON.parse(fs.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 = 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("; "));
+}
+/**
+ * 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);
+        }
+    }
+    return checks;
+}

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

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