@wp-typia/project-tools 0.24.4 → 0.24.6

package/dist/runtime/doctor/cli-doctor-workspace-features-ai.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 AI feature workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param aiFeatures AI feature entries parsed from the workspace inventory.
+ * @returns Ordered AI feature doctor checks.
+ */
+export declare function getWorkspaceAiFeatureDoctorChecks(workspace: WorkspaceProject, aiFeatures: WorkspaceInventory["aiFeatures"]): DoctorCheck[];

package/dist/runtime/doctor/cli-doctor-workspace-features-ai.js

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
+import { REST_RESOURCE_NAMESPACE_PATTERN } from "../add/cli-add-shared.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_AI_FEATURE_GLOB, } from "./cli-doctor-workspace-shared.js";
+function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
+    return Array.from(new Set([
+        aiFeature.aiSchemaFile,
+        aiFeature.apiFile,
+        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
+        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
+        path.join(path.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
+        aiFeature.clientFile,
+        aiFeature.dataFile,
+        aiFeature.openApiFile,
+        aiFeature.phpFile,
+        aiFeature.typesFile,
+        aiFeature.validatorsFile,
+    ]));
+}
+function checkWorkspaceAiFeatureConfig(aiFeature) {
+    const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(aiFeature.namespace);
+    return createDoctorCheck(`AI feature config ${aiFeature.slug}`, hasNamespace ? "pass" : "fail", hasNamespace
+        ? `AI feature namespace ${aiFeature.namespace} is valid`
+        : "AI feature namespace is invalid");
+}
+function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("AI feature bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const registerFunctionName = `${phpPrefix}_register_ai_features`;
+    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+    const hasServerGlob = source.includes(WORKSPACE_AI_FEATURE_GLOB);
+    const hasRegisterHook = source.includes(registerHook);
+    return createDoctorCheck("AI feature bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook
+        ? "AI feature PHP loader hook is present"
+        : "Missing AI feature PHP require glob or init hook");
+}
+/**
+ * Collect AI feature workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param aiFeatures AI feature entries parsed from the workspace inventory.
+ * @returns Ordered AI feature doctor checks.
+ */
+export function getWorkspaceAiFeatureDoctorChecks(workspace, aiFeatures) {
+    const checks = [];
+    if (aiFeatures.length > 0) {
+        checks.push(checkWorkspaceAiFeatureBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    }
+    for (const aiFeature of aiFeatures) {
+        checks.push(checkWorkspaceAiFeatureConfig(aiFeature));
+        checks.push(checkExistingFiles(workspace.projectDir, `AI feature ${aiFeature.slug}`, getWorkspaceAiFeatureRequiredFiles(aiFeature)));
+    }
+    return checks;
+}

package/dist/runtime/doctor/cli-doctor-workspace-features-editor-plugins.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 editor plugin workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param editorPlugins Editor plugin entries parsed from the workspace inventory.
+ * @returns Ordered editor plugin doctor checks.
+ */
+export declare function getWorkspaceEditorPluginDoctorChecks(workspace: WorkspaceProject, editorPlugins: WorkspaceInventory["editorPlugins"]): DoctorCheck[];

package/dist/runtime/doctor/cli-doctor-workspace-features-editor-plugins.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EDITOR_PLUGIN_SLOT_IDS, resolveEditorPluginSlotAlias, } from "../add/cli-add-shared.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET, WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT, WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE, } from "./cli-doctor-workspace-shared.js";
+import { escapeRegex } from "../shared/php-utils.js";
+function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
+    const editorPluginDir = path.join("src", "editor-plugins", editorPlugin.slug);
+    const surfaceFile = editorPlugin.slot === "PluginSidebar"
+        ? path.join(editorPluginDir, "Sidebar.tsx")
+        : path.join(editorPluginDir, "Surface.tsx");
+    return Array.from(new Set([
+        editorPlugin.file,
+        surfaceFile,
+        path.join(editorPluginDir, "data.ts"),
+        path.join(editorPluginDir, "types.ts"),
+        path.join(editorPluginDir, "style.scss"),
+    ]));
+}
+function checkWorkspaceEditorPluginConfig(editorPlugin) {
+    const normalizedSlot = resolveEditorPluginSlotAlias(editorPlugin.slot);
+    const isValidSlot = Boolean(normalizedSlot);
+    return createDoctorCheck(`Editor plugin config ${editorPlugin.slug}`, isValidSlot ? "pass" : "fail", isValidSlot
+        ? `Editor plugin slot ${editorPlugin.slot} is supported as ${normalizedSlot}`
+        : `Unsupported editor plugin slot "${editorPlugin.slot}". Expected one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")} or legacy aliases PluginSidebar, PluginDocumentSettingPanel.`);
+}
+function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Editor plugin bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
+    const enqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
+    const hasEditorEnqueueHook = source.includes(enqueueHook);
+    const hasEditorScript = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT);
+    const hasEditorAsset = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET);
+    const hasEditorStyle = source.includes(WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE);
+    return createDoctorCheck("Editor plugin bootstrap", hasEditorEnqueueHook && hasEditorScript && hasEditorAsset && hasEditorStyle ? "pass" : "fail", hasEditorEnqueueHook && hasEditorScript && hasEditorAsset && hasEditorStyle
+        ? "Editor plugin enqueue hook is present"
+        : "Missing editor plugin enqueue hook or build/editor-plugins script/style asset references");
+}
+function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
+    const indexRelativePath = [
+        path.join("src", "editor-plugins", "index.ts"),
+        path.join("src", "editor-plugins", "index.js"),
+    ].find((relativePath) => fs.existsSync(path.join(projectDir, relativePath)));
+    if (!indexRelativePath) {
+        return createDoctorCheck("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
+    }
+    const indexPath = path.join(projectDir, indexRelativePath);
+    const source = fs.readFileSync(indexPath, "utf8");
+    const missingImports = editorPlugins.filter((editorPlugin) => {
+        const importPattern = new RegExp(`['"\`]\\./${escapeRegex(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
+        return !importPattern.test(source);
+    });
+    return createDoctorCheck("Editor plugins index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0
+        ? "Editor plugin registrations are aggregated"
+        : `Missing editor plugin imports for: ${missingImports
+            .map((entry) => entry.slug)
+            .join(", ")}`);
+}
+/**
+ * Collect editor plugin workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param editorPlugins Editor plugin entries parsed from the workspace inventory.
+ * @returns Ordered editor plugin doctor checks.
+ */
+export function getWorkspaceEditorPluginDoctorChecks(workspace, editorPlugins) {
+    const checks = [];
+    if (editorPlugins.length > 0) {
+        checks.push(checkWorkspaceEditorPluginBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+        checks.push(checkWorkspaceEditorPluginIndex(workspace.projectDir, editorPlugins));
+    }
+    for (const editorPlugin of editorPlugins) {
+        checks.push(checkExistingFiles(workspace.projectDir, `Editor plugin ${editorPlugin.slug}`, getWorkspaceEditorPluginRequiredFiles(editorPlugin)));
+        checks.push(checkWorkspaceEditorPluginConfig(editorPlugin));
+    }
+    return checks;
+}

package/dist/runtime/doctor/cli-doctor-workspace-features-post-meta.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 post meta workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param postMetaEntries Post meta entries parsed from the workspace inventory.
+ * @returns Ordered post meta doctor checks.
+ */
+export declare function getWorkspacePostMetaDoctorChecks(workspace: WorkspaceProject, postMetaEntries: WorkspaceInventory["postMeta"]): DoctorCheck[];

package/dist/runtime/doctor/cli-doctor-workspace-features-post-meta.js

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import { assertValidPostMetaPostType } from "../add/cli-add-shared.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_POST_META_GLOB, } from "./cli-doctor-workspace-shared.js";
+function getWorkspacePostMetaRequiredFiles(postMeta) {
+    return Array.from(new Set([
+        postMeta.phpFile,
+        postMeta.schemaFile,
+        postMeta.typesFile,
+    ]));
+}
+function checkWorkspacePostMetaConfig(postMeta) {
+    let hasPostType = false;
+    try {
+        hasPostType = assertValidPostMetaPostType(postMeta.postType) === postMeta.postType;
+    }
+    catch {
+        hasPostType = false;
+    }
+    const hasMetaKey = typeof postMeta.metaKey === "string" &&
+        postMeta.metaKey.trim().length > 0 &&
+        !/\s/u.test(postMeta.metaKey);
+    const hasRestExposure = typeof postMeta.showInRest === "boolean";
+    return createDoctorCheck(`Post meta config ${postMeta.slug}`, hasPostType && hasMetaKey && hasRestExposure ? "pass" : "fail", hasPostType && hasMetaKey && hasRestExposure
+        ? `Post meta ${postMeta.metaKey} targets ${postMeta.postType}`
+        : "Post meta postType, metaKey, or showInRest configuration is invalid");
+}
+function checkWorkspacePostMetaBootstrap(projectDir, packageName, phpPrefix) {
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("Post meta bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const registerFunctionName = `${phpPrefix}_register_post_meta_contracts`;
+    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+    const hasServerGlob = source.includes(WORKSPACE_POST_META_GLOB);
+    const hasRegisterHook = source.includes(registerHook);
+    return createDoctorCheck("Post meta bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook
+        ? "Post meta PHP loader hook is present"
+        : "Missing post meta PHP require glob or init hook");
+}
+function checkWorkspacePostMetaPhp(projectDir, postMeta) {
+    const phpPath = path.join(projectDir, postMeta.phpFile);
+    if (!fs.existsSync(phpPath)) {
+        return createDoctorCheck(`Post meta PHP ${postMeta.slug}`, "fail", `Missing ${postMeta.phpFile}`);
+    }
+    const source = fs.readFileSync(phpPath, "utf8");
+    const hasRegisterPostMeta = source.includes("register_post_meta");
+    const hasPostType = source.includes(postMeta.postType);
+    const hasMetaKey = source.includes(postMeta.metaKey);
+    const hasSchemaFile = source.includes(postMeta.schemaFile);
+    const hasRestExposure = source.includes("'show_in_rest'");
+    return createDoctorCheck(`Post meta PHP ${postMeta.slug}`, hasRegisterPostMeta && hasPostType && hasMetaKey && hasSchemaFile && hasRestExposure
+        ? "pass"
+        : "fail", hasRegisterPostMeta && hasPostType && hasMetaKey && hasSchemaFile && hasRestExposure
+        ? "Post meta registration, schema path, and REST exposure flag are wired"
+        : "Missing register_post_meta, post type, meta key, schema path, or show_in_rest wiring");
+}
+/**
+ * Collect post meta workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param postMetaEntries Post meta entries parsed from the workspace inventory.
+ * @returns Ordered post meta doctor checks.
+ */
+export function getWorkspacePostMetaDoctorChecks(workspace, postMetaEntries) {
+    const checks = [];
+    if (postMetaEntries.length > 0) {
+        checks.push(checkWorkspacePostMetaBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    }
+    for (const postMeta of postMetaEntries) {
+        checks.push(checkWorkspacePostMetaConfig(postMeta));
+        checks.push(checkExistingFiles(workspace.projectDir, `Post meta ${postMeta.slug}`, getWorkspacePostMetaRequiredFiles(postMeta)));
+        checks.push(checkWorkspacePostMetaPhp(workspace.projectDir, postMeta));
+    }
+    return checks;
+}

package/dist/runtime/doctor/cli-doctor-workspace-features-rest.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 REST resource workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param restResources REST resources parsed from the workspace inventory.
+ * @returns Ordered REST resource doctor checks.
+ */
+export declare function getWorkspaceRestResourceDoctorChecks(workspace: WorkspaceProject, restResources: WorkspaceInventory["restResources"]): DoctorCheck[];

package/dist/runtime/doctor/cli-doctor-workspace-features-rest.js

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MANUAL_REST_CONTRACT_AUTH_IDS, MANUAL_REST_CONTRACT_HTTP_METHOD_IDS, REST_RESOURCE_METHOD_IDS, REST_RESOURCE_NAMESPACE_PATTERN, isGeneratedRestResourceRoutePatternCompatible, } from "../add/cli-add-shared.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_REST_RESOURCE_GLOB, } from "./cli-doctor-workspace-shared.js";
+function isManualRestResource(restResource) {
+    return restResource.mode === "manual";
+}
+function getWorkspaceRestResourceRequiredFiles(restResource) {
+    const schemaNames = new Set();
+    if (isManualRestResource(restResource)) {
+        schemaNames.add("query");
+        if (restResource.bodyTypeName) {
+            schemaNames.add("request");
+        }
+        schemaNames.add("response");
+        return Array.from(new Set([
+            restResource.apiFile,
+            ...Array.from(schemaNames, (schemaName) => path.join(path.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+            restResource.clientFile,
+            restResource.openApiFile,
+            restResource.typesFile,
+            restResource.validatorsFile,
+        ]));
+    }
+    if (restResource.methods.includes("list")) {
+        schemaNames.add("list-query");
+        schemaNames.add("list-response");
+    }
+    if (restResource.methods.includes("read")) {
+        schemaNames.add("read-query");
+        schemaNames.add("read-response");
+    }
+    if (restResource.methods.includes("create")) {
+        schemaNames.add("create-request");
+        schemaNames.add("create-response");
+    }
+    if (restResource.methods.includes("update")) {
+        schemaNames.add("update-query");
+        schemaNames.add("update-request");
+        schemaNames.add("update-response");
+    }
+    if (restResource.methods.includes("delete")) {
+        schemaNames.add("delete-query");
+        schemaNames.add("delete-response");
+    }
+    return Array.from(new Set([
+        restResource.apiFile,
+        ...Array.from(schemaNames, (schemaName) => path.join(path.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+        restResource.clientFile,
+        ...(restResource.dataFile ? [restResource.dataFile] : []),
+        restResource.openApiFile,
+        ...(restResource.phpFile ? [restResource.phpFile] : []),
+        restResource.typesFile,
+        restResource.validatorsFile,
+    ]));
+}
+function checkWorkspaceRestResourceConfig(restResource) {
+    const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(restResource.namespace);
+    if (isManualRestResource(restResource)) {
+        const hasAuth = restResource.auth == null ||
+            MANUAL_REST_CONTRACT_AUTH_IDS.includes(restResource.auth);
+        const hasMethod = typeof restResource.method === "string" &&
+            MANUAL_REST_CONTRACT_HTTP_METHOD_IDS.includes(restResource.method);
+        const hasPathPattern = typeof restResource.pathPattern === "string" &&
+            restResource.pathPattern.startsWith("/") &&
+            restResource.pathPattern.length > 1;
+        return createDoctorCheck(`REST resource config ${restResource.slug}`, hasNamespace && hasAuth && hasMethod && hasPathPattern ? "pass" : "fail", hasNamespace && hasAuth && hasMethod && hasPathPattern
+            ? `Manual REST contract ${restResource.method} /${restResource.namespace}${restResource.pathPattern}`
+            : "Manual REST contract namespace, auth, method, or path pattern is invalid");
+    }
+    const hasMethods = restResource.methods.length > 0 &&
+        restResource.methods.every((method) => REST_RESOURCE_METHOD_IDS.includes(method));
+    const hasGeneratedFiles = typeof restResource.dataFile === "string" &&
+        restResource.dataFile.length > 0 &&
+        typeof restResource.phpFile === "string" &&
+        restResource.phpFile.length > 0;
+    const hasRoutePattern = restResource.routePattern == null ||
+        (typeof restResource.routePattern === "string" &&
+            restResource.routePattern.startsWith("/") &&
+            restResource.routePattern.length > 1 &&
+            !/\s/u.test(restResource.routePattern) &&
+            isGeneratedRestResourceRoutePatternCompatible(restResource.routePattern));
+    return createDoctorCheck(`REST resource config ${restResource.slug}`, hasNamespace && hasMethods && hasGeneratedFiles && hasRoutePattern
+        ? "pass"
+        : "fail", hasNamespace && hasMethods && hasGeneratedFiles && hasRoutePattern
+        ? `REST resource namespace ${restResource.namespace} with methods ${restResource.methods.join(", ")}`
+        : "REST resource namespace, methods, dataFile, phpFile, or routePattern are invalid");
+}
+function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
+    const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
+    if (!fs.existsSync(bootstrapPath)) {
+        return createDoctorCheck("REST resource bootstrap", "fail", `Missing ${path.basename(bootstrapPath)}`);
+    }
+    const source = fs.readFileSync(bootstrapPath, "utf8");
+    const registerFunctionName = `${phpPrefix}_register_rest_resources`;
+    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+    const hasServerGlob = source.includes(WORKSPACE_REST_RESOURCE_GLOB);
+    const hasRegisterHook = source.includes(registerHook);
+    return createDoctorCheck("REST resource bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook
+        ? "REST resource PHP loader hook is present"
+        : "Missing REST resource PHP require glob or init hook");
+}
+/**
+ * Collect REST resource workspace doctor checks while preserving existing row order.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param restResources REST resources parsed from the workspace inventory.
+ * @returns Ordered REST resource doctor checks.
+ */
+export function getWorkspaceRestResourceDoctorChecks(workspace, restResources) {
+    const checks = [];
+    if (restResources.some((restResource) => !isManualRestResource(restResource))) {
+        checks.push(checkWorkspaceRestResourceBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    }
+    for (const restResource of restResources) {
+        checks.push(checkWorkspaceRestResourceConfig(restResource));
+        checks.push(checkExistingFiles(workspace.projectDir, `REST resource ${restResource.slug}`, getWorkspaceRestResourceRequiredFiles(restResource)));
+    }
+    return checks;
+}

package/dist/runtime/doctor/cli-doctor-workspace-features.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 REST resources, abilities, AI features, editor plugins, and admin views.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
+ * @returns Ordered `DoctorCheck[]` rows for extracted workspace feature diagnostics.
+ */
+export declare function getWorkspaceFeatureDoctorChecks(workspace: WorkspaceProject, inventory: WorkspaceInventory): DoctorCheck[];

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

@@ -0,0 +1,23 @@
+import { getWorkspaceAbilityDoctorChecks, } from "./cli-doctor-workspace-features-abilities.js";
+import { getWorkspaceAdminViewDoctorChecks, } from "./cli-doctor-workspace-features-admin-views.js";
+import { getWorkspaceAiFeatureDoctorChecks, } from "./cli-doctor-workspace-features-ai.js";
+import { getWorkspaceEditorPluginDoctorChecks, } from "./cli-doctor-workspace-features-editor-plugins.js";
+import { getWorkspacePostMetaDoctorChecks, } from "./cli-doctor-workspace-features-post-meta.js";
+import { getWorkspaceRestResourceDoctorChecks, } from "./cli-doctor-workspace-features-rest.js";
+/**
+ * Collect workspace doctor checks for REST resources, abilities, AI features, editor plugins, and admin views.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param inventory Parsed workspace inventory from `scripts/block-config.ts`.
+ * @returns Ordered `DoctorCheck[]` rows for extracted workspace feature diagnostics.
+ */
+export function getWorkspaceFeatureDoctorChecks(workspace, inventory) {
+    return [
+        ...getWorkspaceRestResourceDoctorChecks(workspace, inventory.restResources),
+        ...getWorkspacePostMetaDoctorChecks(workspace, inventory.postMeta),
+        ...getWorkspaceAbilityDoctorChecks(workspace, inventory.abilities),
+        ...getWorkspaceAiFeatureDoctorChecks(workspace, inventory.aiFeatures),
+        ...getWorkspaceEditorPluginDoctorChecks(workspace, inventory.editorPlugins),
+        ...getWorkspaceAdminViewDoctorChecks(workspace, inventory),
+    ];
+}

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

@@ -0,0 +1,40 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+import type { WorkspacePackageJson, WorkspaceProject } from "../workspace/workspace-project.js";
+/**
+ * Snapshot of package-level filesystem doctor inputs prepared asynchronously.
+ */
+export interface WorkspacePackageDoctorSnapshot {
+    /** Whether the expected workspace bootstrap PHP file exists. */
+    bootstrapExists: boolean;
+    /** Relative path to the expected workspace bootstrap PHP file. */
+    bootstrapRelativePath: string;
+    /** Whether the migration config file exists. */
+    migrationConfigExists: boolean;
+    /** Relative path to the migration config file. */
+    migrationConfigRelativePath: string;
+}
+/**
+ * Prepare package-level workspace doctor inputs without blocking the event loop.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns Snapshot values consumed by synchronous doctor row mappers.
+ */
+export declare function prepareWorkspacePackageDoctorSnapshot(workspace: WorkspaceProject, packageJson: WorkspacePackageJson): Promise<WorkspacePackageDoctorSnapshot>;
+/**
+ * Validate the package metadata that makes a project an official workspace.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
+ * @returns A `DoctorCheck` describing whether package metadata matches the workspace contract.
+ */
+export declare function getWorkspacePackageMetadataCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson, snapshot: WorkspacePackageDoctorSnapshot): DoctorCheck;
+/**
+ * Report whether a workspace configured for migrations exposes the expected doctor inputs.
+ *
+ * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
+ * @returns A migration hint row when the workspace uses migrations, otherwise `null`.
+ */
+export declare function getMigrationWorkspaceHintCheck(packageJson: WorkspacePackageJson, snapshot: WorkspacePackageDoctorSnapshot): DoctorCheck | null;

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

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { createDoctorCheck, getWorkspaceBootstrapRelativePath, } from "./cli-doctor-workspace-shared.js";
+import { pathExists } from "../shared/fs-async.js";
+import { WORKSPACE_TEMPLATE_PACKAGE } from "../workspace/workspace-project.js";
+/**
+ * Prepare package-level workspace doctor inputs without blocking the event loop.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @returns Snapshot values consumed by synchronous doctor row mappers.
+ */
+export async function prepareWorkspacePackageDoctorSnapshot(workspace, packageJson) {
+    const packageName = packageJson.name;
+    const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0
+        ? packageName
+        : workspace.packageName);
+    const migrationConfigRelativePath = path.join("src", "migrations", "config.ts");
+    const [bootstrapExists, migrationConfigExists] = await Promise.all([
+        pathExists(path.join(workspace.projectDir, bootstrapRelativePath)),
+        pathExists(path.join(workspace.projectDir, migrationConfigRelativePath)),
+    ]);
+    return {
+        bootstrapExists,
+        bootstrapRelativePath,
+        migrationConfigExists,
+        migrationConfigRelativePath,
+    };
+}
+/**
+ * Validate the package metadata that makes a project an official workspace.
+ *
+ * @param workspace Resolved workspace metadata and filesystem paths.
+ * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
+ * @returns A `DoctorCheck` describing whether package metadata matches the workspace contract.
+ */
+export function getWorkspacePackageMetadataCheck(workspace, packageJson, snapshot) {
+    const issues = [];
+    const packageName = packageJson.name;
+    const wpTypia = packageJson.wpTypia;
+    if (typeof packageName !== "string" || packageName.length === 0) {
+        issues.push("package.json must define a string name for workspace bootstrap resolution");
+    }
+    if (wpTypia?.projectType !== "workspace") {
+        issues.push('wpTypia.projectType must be "workspace"');
+    }
+    if (wpTypia?.templatePackage !== WORKSPACE_TEMPLATE_PACKAGE) {
+        issues.push(`wpTypia.templatePackage must be "${WORKSPACE_TEMPLATE_PACKAGE}"`);
+    }
+    if (wpTypia?.namespace !== workspace.workspace.namespace) {
+        issues.push(`wpTypia.namespace must equal "${workspace.workspace.namespace}"`);
+    }
+    if (wpTypia?.textDomain !== workspace.workspace.textDomain) {
+        issues.push(`wpTypia.textDomain must equal "${workspace.workspace.textDomain}"`);
+    }
+    if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
+        issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
+    }
+    if (!snapshot.bootstrapExists) {
+        issues.push(`Missing bootstrap file ${snapshot.bootstrapRelativePath}`);
+    }
+    return createDoctorCheck("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0
+        ? `package.json metadata aligns with ${workspace.packageName} and ${snapshot.bootstrapRelativePath}`
+        : issues.join("; "));
+}
+/**
+ * Report whether a workspace configured for migrations exposes the expected doctor inputs.
+ *
+ * @param packageJson Parsed workspace package manifest.
+ * @param snapshot Async filesystem snapshot for package-level doctor inputs.
+ * @returns A migration hint row when the workspace uses migrations, otherwise `null`.
+ */
+export function getMigrationWorkspaceHintCheck(packageJson, snapshot) {
+    const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
+    if (!hasMigrationScript && !snapshot.migrationConfigExists) {
+        return null;
+    }
+    return createDoctorCheck("Migration workspace", snapshot.migrationConfigExists ? "pass" : "fail", snapshot.migrationConfigExists
+        ? "Run `wp-typia migrate doctor --all` for migration target, snapshot, fixture, and generated artifact checks"
+        : `Missing ${snapshot.migrationConfigRelativePath} for the configured migration workspace`);
+}

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

@@ -0,0 +1,79 @@
+import type { DoctorCheck } from "./cli-doctor.js";
+/** Glob pattern for generated binding-source PHP entrypoints. */
+export declare const WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
+/** Relative path to the generated binding editor bundle. */
+export declare const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
+/** Relative path to the generated binding asset manifest. */
+export declare const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
+/** Glob pattern for generated REST resource PHP entrypoints. */
+export declare const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+/** Glob pattern for generated post-meta PHP entrypoints. */
+export declare const WORKSPACE_POST_META_GLOB = "/inc/post-meta/*.php";
+/** Glob pattern for generated ability PHP entrypoints. */
+export declare const WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
+/** Relative path to the generated ability editor bundle. */
+export declare const WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
+/** Relative path to the generated ability asset manifest. */
+export declare const WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
+/** Glob pattern for generated AI feature PHP entrypoints. */
+export declare const WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php";
+/** Glob pattern for generated admin view PHP entrypoints. */
+export declare const WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php";
+/** Relative path to the generated admin view editor bundle. */
+export declare const WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js";
+/** Relative path to the generated admin view asset manifest. */
+export declare const WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php";
+/** Relative path to the generated admin view stylesheet. */
+export declare const WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css";
+/** Relative path to the generated editor plugin bundle. */
+export declare const WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
+/** Relative path to the generated editor plugin asset manifest. */
+export declare const WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
+/** Relative path to the generated editor plugin stylesheet. */
+export declare const WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
+/** Canonical generated artifact filenames expected in each workspace block directory. */
+export declare const WORKSPACE_GENERATED_BLOCK_ARTIFACTS: readonly ["block.json", "typia.manifest.json", "typia.schema.json", "typia-validator.php", "typia.openapi.json"];
+/** Pattern for full block names in `namespace/slug` format. */
+export declare const WORKSPACE_FULL_BLOCK_NAME_PATTERN: RegExp;
+/**
+ * Create a doctor result row with an optional stable diagnostic code.
+ *
+ * @param label Human-readable doctor row label.
+ * @param status Pass, warn, or fail status for the row.
+ * @param detail Detailed remediation or success text for CLI output.
+ * @param code Optional stable machine-readable diagnostic code.
+ * @returns A normalized `DoctorCheck` object for CLI rendering.
+ */
+export declare function createDoctorCheck(label: string, status: DoctorCheck["status"], detail: string, code?: string): DoctorCheck;
+/**
+ * Create the standard workspace-doctor scope row.
+ *
+ * @param status Pass or fail scope status for the doctor run.
+ * @param detail Scope summary describing what diagnostics ran.
+ * @returns A `DoctorCheck` row labelled `Doctor scope`.
+ */
+export declare function createDoctorScopeCheck(status: DoctorCheck["status"], detail: string): DoctorCheck;
+/**
+ * Resolve the expected workspace bootstrap file from a package name.
+ *
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Relative PHP bootstrap filename for the workspace root.
+ */
+export declare function getWorkspaceBootstrapRelativePath(packageName: string): string;
+/**
+ * Resolve the expected workspace bootstrap file inside a project root.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param packageName Package name used to derive the plugin bootstrap basename.
+ * @returns Absolute PHP bootstrap file path for the workspace root.
+ */
+export declare function resolveWorkspaceBootstrapPath(projectDir: string, packageName: string): string;
+/**
+ * Verify that every referenced relative file exists inside a workspace.
+ *
+ * @param projectDir Absolute workspace root directory.
+ * @param label Doctor row label for the file set being checked.
+ * @param filePaths Relative file paths to validate.
+ * @returns A passing or failing `DoctorCheck` describing any missing files.
+ */
+export declare function checkExistingFiles(projectDir: string, label: string, filePaths: Array<string | undefined>): DoctorCheck;