@wp-typia/project-tools 0.22.10 → 0.23.0

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

@@ -1,10 +1,29 @@
 import fs from "node:fs";
 import path from "node:path";
-import { EDITOR_PLUGIN_SLOT_IDS, REST_RESOURCE_METHOD_IDS, REST_RESOURCE_NAMESPACE_PATTERN, resolveEditorPluginSlotAlias, } from "./cli-add-shared.js";
-import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_ABILITY_EDITOR_ASSET, WORKSPACE_ABILITY_EDITOR_SCRIPT, WORKSPACE_ABILITY_GLOB, WORKSPACE_ADMIN_VIEW_ASSET, WORKSPACE_ADMIN_VIEW_GLOB, WORKSPACE_ADMIN_VIEW_SCRIPT, WORKSPACE_ADMIN_VIEW_STYLE, WORKSPACE_AI_FEATURE_GLOB, WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET, WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT, WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE, WORKSPACE_REST_RESOURCE_GLOB, } from "./cli-doctor-workspace-shared.js";
+import { EDITOR_PLUGIN_SLOT_IDS, MANUAL_REST_CONTRACT_AUTH_IDS, MANUAL_REST_CONTRACT_HTTP_METHOD_IDS, REST_RESOURCE_METHOD_IDS, REST_RESOURCE_NAMESPACE_PATTERN, assertValidPostMetaPostType, isGeneratedRestResourceRoutePatternCompatible, resolveEditorPluginSlotAlias, } from "./cli-add-shared.js";
+import { hasAdminViewManualSettingsRouteParameters, isAdminViewManualSettingsRestResource, } from "./cli-add-workspace-admin-view-types.js";
+import { checkExistingFiles, createDoctorCheck, resolveWorkspaceBootstrapPath, WORKSPACE_ABILITY_EDITOR_ASSET, WORKSPACE_ABILITY_EDITOR_SCRIPT, WORKSPACE_ABILITY_GLOB, WORKSPACE_ADMIN_VIEW_ASSET, WORKSPACE_ADMIN_VIEW_GLOB, WORKSPACE_ADMIN_VIEW_SCRIPT, WORKSPACE_ADMIN_VIEW_STYLE, WORKSPACE_AI_FEATURE_GLOB, WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET, WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT, WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE, WORKSPACE_POST_META_GLOB, WORKSPACE_REST_RESOURCE_GLOB, } from "./cli-doctor-workspace-shared.js";
 import { escapeRegex } from "./php-utils.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");
@@ -30,20 +49,44 @@ function getWorkspaceRestResourceRequiredFiles(restResource) {
         restResource.apiFile,
         ...Array.from(schemaNames, (schemaName) => path.join(path.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
         restResource.clientFile,
-        restResource.dataFile,
+        ...(restResource.dataFile ? [restResource.dataFile] : []),
         restResource.openApiFile,
-        restResource.phpFile,
+        ...(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));
-    return createDoctorCheck(`REST resource config ${restResource.slug}`, hasNamespace && hasMethods ? "pass" : "fail", hasNamespace && hasMethods
+    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 or methods are invalid");
+        : "REST resource namespace, methods, dataFile, phpFile, or routePattern are invalid");
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
     const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
@@ -59,6 +102,60 @@ function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix)
         ? "REST resource PHP loader hook is present"
         : "Missing REST resource PHP require glob or init hook");
 }
+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");
+}
 function getWorkspaceAbilityRequiredFiles(ability) {
     return Array.from(new Set([
         ability.clientFile,
@@ -259,10 +356,23 @@ function checkWorkspaceAdminViewConfig(adminView, inventory) {
     const restResource = restResourceSlug
         ? inventory.restResources.find((entry) => entry.slug === restResourceSlug)
         : undefined;
-    const isValid = Boolean(restResource?.methods.includes("list")) || Boolean(coreDataSourceMatch);
+    const isListCapableRestResource = Boolean(restResource?.methods.includes("list"));
+    const isManualSettingsRestResource = isAdminViewManualSettingsRestResource(restResource);
+    const hasManualSettingsRouteParameters = isManualSettingsRestResource &&
+        hasAdminViewManualSettingsRouteParameters(restResource);
+    const isValid = isListCapableRestResource ||
+        (isManualSettingsRestResource && !hasManualSettingsRouteParameters) ||
+        Boolean(coreDataSourceMatch);
+    const failDetail = hasManualSettingsRouteParameters
+        ? `Admin view source ${source} uses route parameters or regex groups and cannot scaffold a singleton settings form`
+        : "Admin view source must use rest-resource:<slug> with a list-capable REST resource, a manual settings contract with a body type, or core-data:<postType|taxonomy>/<name>";
     return createDoctorCheck(`Admin view config ${adminView.slug}`, isValid ? "pass" : "fail", isValid
-        ? `Admin view source ${source} is list-capable`
-        : "Admin view source must use rest-resource:<slug> with a list-capable REST resource or core-data:<postType|taxonomy>/<name>");
+        ? `Admin view source ${source} is ${isManualSettingsRestResource
+            ? "settings-form capable"
+            : coreDataSourceMatch
+                ? "core-data capable"
+                : "list-capable"}`
+        : failDetail);
 }
 function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
     const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
@@ -335,13 +445,21 @@ function checkWorkspaceAdminViewPhp(projectDir, adminView) {
  */
 export function getWorkspaceFeatureDoctorChecks(workspace, inventory) {
     const checks = [];
-    if (inventory.restResources.length > 0) {
+    if (inventory.restResources.some((restResource) => !isManualRestResource(restResource))) {
         checks.push(checkWorkspaceRestResourceBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
     }
     for (const restResource of inventory.restResources) {
         checks.push(checkWorkspaceRestResourceConfig(restResource));
         checks.push(checkExistingFiles(workspace.projectDir, `REST resource ${restResource.slug}`, getWorkspaceRestResourceRequiredFiles(restResource)));
     }
+    if (inventory.postMeta.length > 0) {
+        checks.push(checkWorkspacePostMetaBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    }
+    for (const postMeta of inventory.postMeta) {
+        checks.push(checkWorkspacePostMetaConfig(postMeta));
+        checks.push(checkExistingFiles(workspace.projectDir, `Post meta ${postMeta.slug}`, getWorkspacePostMetaRequiredFiles(postMeta)));
+        checks.push(checkWorkspacePostMetaPhp(workspace.projectDir, postMeta));
+    }
     if (inventory.abilities.length > 0) {
         checks.push(checkWorkspaceAbilityBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
         checks.push(checkWorkspaceAbilityIndex(workspace.projectDir, inventory.abilities));

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

@@ -1,18 +1,40 @@
 import type { DoctorCheck } from "./cli-doctor.js";
 import type { WorkspacePackageJson, WorkspaceProject } from "./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): DoctorCheck;
+export declare function getWorkspacePackageMetadataCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson, snapshot: WorkspacePackageDoctorSnapshot): DoctorCheck;
 /**
  * Report whether a workspace configured for migrations exposes the expected doctor inputs.
  *
- * @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 migration hint row when the workspace uses migrations, otherwise `null`.
  */
-export declare function getMigrationWorkspaceHintCheck(workspace: WorkspaceProject, packageJson: WorkspacePackageJson): DoctorCheck | null;
+export declare function getMigrationWorkspaceHintCheck(packageJson: WorkspacePackageJson, snapshot: WorkspacePackageDoctorSnapshot): DoctorCheck | null;

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

@@ -1,18 +1,42 @@
-import fs from "node:fs";
 import path from "node:path";
 import { createDoctorCheck, getWorkspaceBootstrapRelativePath, } from "./cli-doctor-workspace-shared.js";
+import { pathExists } from "./fs-async.js";
 import { WORKSPACE_TEMPLATE_PACKAGE } from "./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) {
+export function getWorkspacePackageMetadataCheck(workspace, packageJson, snapshot) {
     const issues = [];
     const packageName = packageJson.name;
-    const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0 ? packageName : workspace.packageName);
     const wpTypia = packageJson.wpTypia;
     if (typeof packageName !== "string" || packageName.length === 0) {
         issues.push("package.json must define a string name for workspace bootstrap resolution");
@@ -32,28 +56,26 @@ export function getWorkspacePackageMetadataCheck(workspace, packageJson) {
     if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
         issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
     }
-    if (!fs.existsSync(path.join(workspace.projectDir, bootstrapRelativePath))) {
-        issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
+    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 ${bootstrapRelativePath}`
+        ? `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 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 migration hint row when the workspace uses migrations, otherwise `null`.
  */
-export function getMigrationWorkspaceHintCheck(workspace, packageJson) {
+export function getMigrationWorkspaceHintCheck(packageJson, snapshot) {
     const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
-    const migrationConfigRelativePath = path.join("src", "migrations", "config.ts");
-    const hasMigrationConfig = fs.existsSync(path.join(workspace.projectDir, migrationConfigRelativePath));
-    if (!hasMigrationScript && !hasMigrationConfig) {
+    if (!hasMigrationScript && !snapshot.migrationConfigExists) {
         return null;
     }
-    return createDoctorCheck("Migration workspace", hasMigrationConfig ? "pass" : "fail", hasMigrationConfig
+    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 ${migrationConfigRelativePath} for the configured migration workspace`);
+        : `Missing ${snapshot.migrationConfigRelativePath} for the configured migration workspace`);
 }

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

@@ -7,6 +7,8 @@ export declare const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js"
 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. */

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

@@ -8,6 +8,8 @@ export const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
 export const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
 /** Glob pattern for generated REST resource PHP entrypoints. */
 export const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+/** Glob pattern for generated post-meta PHP entrypoints. */
+export const WORKSPACE_POST_META_GLOB = "/inc/post-meta/*.php";
 /** Glob pattern for generated ability PHP entrypoints. */
 export const WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php";
 /** Relative path to the generated ability editor bundle. */

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

@@ -1,7 +1,7 @@
 import { getWorkspaceBindingDoctorChecks, } from "./cli-doctor-workspace-bindings.js";
 import { getWorkspaceBlockDoctorChecks, } from "./cli-doctor-workspace-blocks.js";
 import { getWorkspaceFeatureDoctorChecks, } from "./cli-doctor-workspace-features.js";
-import { getMigrationWorkspaceHintCheck, getWorkspacePackageMetadataCheck, } from "./cli-doctor-workspace-package.js";
+import { getMigrationWorkspaceHintCheck, getWorkspacePackageMetadataCheck, prepareWorkspacePackageDoctorSnapshot, } from "./cli-doctor-workspace-package.js";
 import { createDoctorCheck, createDoctorScopeCheck, } from "./cli-doctor-workspace-shared.js";
 import { readWorkspaceInventoryAsync, } from "./workspace-inventory.js";
 import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, tryResolveWorkspaceProject, } from "./workspace-project.js";
@@ -14,6 +14,7 @@ function formatWorkspaceInventorySummary(inventory) {
         `${inventory.patterns.length} pattern(s)`,
         `${inventory.bindingSources.length} binding source(s)`,
         `${inventory.restResources.length} REST resource(s)`,
+        `${inventory.postMeta.length} post meta contract(s)`,
         `${inventory.abilities.length} ability scaffold(s)`,
         `${inventory.aiFeatures.length} AI feature(s)`,
         `${inventory.editorPlugins.length} editor plugin(s)`,
@@ -73,14 +74,18 @@ export async function getWorkspaceDoctorChecks(cwd) {
         checks.push(createDoctorCheck("Workspace package metadata", "fail", error instanceof Error ? error.message : String(error)));
         return checks;
     }
-    checks.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson));
+    const packageDoctorSnapshot = await prepareWorkspacePackageDoctorSnapshot(workspace, workspacePackageJson);
+    checks.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson, packageDoctorSnapshot));
     try {
         const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
         checks.push(createDoctorCheck("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
+        // The highest-impact remaining probes live in block, binding, and feature
+        // categories; keep them synchronous until broader path/content snapshots
+        // can preserve their current row ordering and diagnostics.
         checks.push(...getWorkspaceBlockDoctorChecks(workspace, inventory));
         checks.push(...getWorkspaceBindingDoctorChecks(workspace, inventory));
         checks.push(...getWorkspaceFeatureDoctorChecks(workspace, inventory));
-        const migrationWorkspaceCheck = getMigrationWorkspaceHintCheck(workspace, workspacePackageJson);
+        const migrationWorkspaceCheck = getMigrationWorkspaceHintCheck(workspacePackageJson, packageDoctorSnapshot);
         if (migrationWorkspaceCheck) {
             checks.push(migrationWorkspaceCheck);
         }

package/dist/runtime/cli-help.js

@@ -20,12 +20,15 @@ export function formatHelpText() {
   wp-typia init [project-dir] [--apply] [--package-manager <id>]
   wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]
   wp-typia add block <name> [--template <basic|interactivity|persistence|compound>] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--inner-blocks-preset <freeform|ordered|horizontal|locked-structure>] [--alternate-render-targets <email,mjml,plain-text>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
+  wp-typia add integration-env <name> [--wp-env] [--service <none|docker-compose>]
   wp-typia add variation <name> --block <block-slug>
   wp-typia add style <name> --block <block-slug>
   wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>
   wp-typia add pattern <name>
   wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>]
   wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <method[,method...]>]
+  wp-typia add rest-resource <name> --manual [--namespace <vendor/v1>] [--method <GET|POST|PUT|PATCH|DELETE>] [--auth <public|authenticated|public-write-protected>] [--path <route-pattern>] [--query-type <Type>] [--body-type <Type>] [--response-type <Type>]
+  wp-typia add post-meta <name> --post-type <post-type> [--type <ExportedTypeName>] [--meta-key <meta-key>] [--hide-from-rest]
   wp-typia add ability <name>
   wp-typia add ai-feature <name> [--namespace <vendor/v1>]
   wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>]
@@ -53,6 +56,8 @@ Notes:
   Pass \`--source rest-resource:<slug>\` to reuse a list-capable REST resource.
   Pass \`--source core-data:postType/post\` or \`--source core-data:taxonomy/category\` to bind a WordPress-owned entity collection.
   Generated admin-view workspaces add \`@wp-typia/dataviews\` and the needed WordPress DataViews packages as opt-in dependencies.
+  \`add integration-env\` generates an opt-in local smoke starter under \`scripts/integration-smoke/\`, updates \`.env.example\`, and can add \`@wordpress/env\` plus \`.wp-env.json\` when \`--wp-env\` is passed.
+  Pass \`--service docker-compose\` to include a placeholder local service stack that can be adapted to project-specific dependencies.
   \`query-loop\` is create-only. Use \`wp-typia create <project-dir> --template query-loop\`; \`wp-typia add block\` accepts only basic, interactivity, persistence, and compound families.
   \`add variation\` uses an existing workspace block from \`scripts/block-config.ts\`.
   \`add style\` registers a Block Styles option for an existing generated block.
@@ -60,6 +65,8 @@ Notes:
   \`add pattern\` scaffolds a namespaced PHP pattern shell under \`src/patterns/\`.
   \`add binding-source\` scaffolds shared PHP and editor registration under \`src/bindings/\`; pass \`--block\` and \`--attribute\` together to declare a bindable generated-block attribute.
   \`add rest-resource\` scaffolds plugin-level TypeScript REST contracts under \`src/rest/\` and PHP route glue under \`inc/rest/\`.
+  \`add rest-resource --manual\` tracks an external REST route with typed schemas, OpenAPI, clients, and drift checks without generating PHP route/controller files.
+  \`add post-meta\` scaffolds typed post meta contracts under \`src/post-meta/\`, emits schema artifacts, and wires generated \`register_post_meta()\` helpers under \`inc/post-meta/\`.
   \`add ability\` scaffolds typed workflow abilities under \`src/abilities/\` and server registration under \`inc/abilities/\`.
   \`add ai-feature\` scaffolds server-owned AI feature endpoints under \`src/ai-features/\` and PHP route glue under \`inc/ai-features/\`.
   \`add editor-plugin\` scaffolds a document-level editor extension under \`src/editor-plugins/\`; legacy aliases \`PluginSidebar\` and \`PluginDocumentSettingPanel\` resolve to \`sidebar\` and \`document-setting-panel\`.

package/dist/runtime/cli-init-templates.js

@@ -182,6 +182,16 @@ function getSyncScriptEnv() {
 \treturn env;
 }
 
+function getOptionalNodeErrorCode( error: unknown ): string | undefined {
+\treturn typeof error === 'object' && error !== null && 'code' in error
+\t\t? String( ( error as { code: unknown } ).code )
+\t\t: undefined;
+}
+
+function isFileNotFoundError( error: unknown ): boolean {
+\treturn getOptionalNodeErrorCode( error ) === 'ENOENT';
+}
+
 function runSyncScript( scriptPath: string, options: SyncCliOptions ) {
 \tconst args = [ scriptPath ];
 \tif ( options.check ) {
@@ -196,7 +206,7 @@ function runSyncScript( scriptPath: string, options: SyncCliOptions ) {
 \t} );
 
 \tif ( result.error ) {
-\t\tif ( ( result.error as NodeJS.ErrnoException ).code === 'ENOENT' ) {
+\t\tif ( isFileNotFoundError( result.error ) ) {
 \t\t\tthrow new Error(
 \t\t\t\t'Unable to resolve \`tsx\` for project sync. Install project dependencies or rerun the command through your package manager.'
 \t\t\t);

package/dist/runtime/contract-artifacts.d.ts

@@ -0,0 +1,14 @@
+interface SyncStandaloneContractArtifactsOptions {
+    projectDir: string;
+    schemaFile: string;
+    sourceTypeName: string;
+    typesFile: string;
+}
+/**
+ * Generate the JSON Schema artifact for a standalone TypeScript contract.
+ *
+ * @param options Workspace-relative type/schema paths plus the exported source
+ * type name.
+ */
+export declare function syncStandaloneContractArtifacts({ projectDir, schemaFile, sourceTypeName, typesFile, }: SyncStandaloneContractArtifactsOptions): Promise<void>;
+export {};

package/dist/runtime/contract-artifacts.js

@@ -0,0 +1,15 @@
+import { syncTypeSchemas, } from "@wp-typia/block-runtime/metadata-core";
+/**
+ * Generate the JSON Schema artifact for a standalone TypeScript contract.
+ *
+ * @param options Workspace-relative type/schema paths plus the exported source
+ * type name.
+ */
+export async function syncStandaloneContractArtifacts({ projectDir, schemaFile, sourceTypeName, typesFile, }) {
+    await syncTypeSchemas({
+        jsonSchemaFile: schemaFile,
+        projectRoot: projectDir,
+        sourceTypeName,
+        typesFile,
+    });
+}

package/dist/runtime/index.d.ts

@@ -38,5 +38,5 @@ export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOpti
 export { EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, pruneExternalTemplateCache, } from "./template-source-cache.js";
 export type { ExternalTemplateCachePruneOptions, ExternalTemplateCachePruneResult, } from "./template-source-cache.js";
 export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
-export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddPostMetaCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
 export type { CliDiagnosticCode, CliDiagnosticCodeError, CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, WorkspaceBlockSelectOption, } from "./cli-core.js";

package/dist/runtime/index.js

@@ -29,4 +29,4 @@ export { clearPackageVersionsCache, getPackageVersions, invalidatePackageVersion
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
 export { EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, pruneExternalTemplateCache, } from "./template-source-cache.js";
 export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
-export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddPostMetaCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/rest-resource-artifacts.d.ts

@@ -1,7 +1,8 @@
-import type { RestResourceMethodId } from "./cli-add-shared.js";
+import type { ManualRestContractAuthId, ManualRestContractHttpMethodId, RestResourceMethodId } from "./cli-add-shared.js";
 interface RestResourceTemplateVariablesLike {
     namespace: string;
     pascalCase: string;
+    routePattern?: string;
     slugKebabCase: string;
     title: string;
 }
@@ -14,6 +15,26 @@ interface SyncRestResourceArtifactsOptions {
     validatorsFile: string;
     variables: RestResourceTemplateVariablesLike;
 }
+interface ManualRestContractTemplateVariablesLike {
+    auth: ManualRestContractAuthId;
+    bodyTypeName?: string;
+    method: ManualRestContractHttpMethodId;
+    namespace: string;
+    pascalCase: string;
+    pathPattern: string;
+    queryTypeName: string;
+    responseTypeName: string;
+    slugKebabCase: string;
+    title: string;
+}
+interface SyncManualRestContractArtifactsOptions {
+    clientFile: string;
+    outputDir: string;
+    projectDir: string;
+    typesFile: string;
+    validatorsFile: string;
+    variables: ManualRestContractTemplateVariablesLike;
+}
 /**
  * Build the endpoint manifest for a workspace-level REST resource scaffold.
  *
@@ -24,6 +45,33 @@ interface SyncRestResourceArtifactsOptions {
 export declare function buildRestResourceEndpointManifest(variables: RestResourceTemplateVariablesLike, methods: RestResourceMethodId[]): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
     sourceTypeName: string;
 }>, import("@wp-typia/block-runtime/schema-core").EndpointOpenApiEndpointDefinition[]>;
+/**
+ * Build the endpoint manifest for a type-only manual REST contract. Manual
+ * contracts describe routes owned by another integration without generating PHP
+ * route glue in the workspace.
+ *
+ * @param variables Template naming data used for contract names, route path,
+ * and OpenAPI info.
+ * @returns Endpoint manifest consumed by schema, OpenAPI, and client generators.
+ */
+export declare function buildManualRestContractEndpointManifest(variables: ManualRestContractTemplateVariablesLike): import("@wp-typia/block-runtime/metadata-core").EndpointManifestDefinition<Record<string, {
+    sourceTypeName: string;
+}>, readonly [{
+    readonly wordpressAuth?: {
+        mechanism: "rest-nonce";
+    } | {
+        mechanism: "public-signed-token";
+    } | undefined;
+    readonly method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    readonly operationId: `call${string}ManualRestContract`;
+    readonly path: `/${string}${string}`;
+    readonly queryContract: "query";
+    readonly responseContract: "response";
+    readonly summary: `Call external ${string} REST route.`;
+    readonly tags: readonly [string];
+    readonly bodyContract?: string | undefined;
+    readonly auth: "authenticated" | "public" | "public-write-protected";
+}]>;
 /**
  * Synchronize generated schemas, OpenAPI output, and endpoint client code for
  * a workspace-level REST resource scaffold.
@@ -32,4 +80,12 @@ export declare function buildRestResourceEndpointManifest(variables: RestResourc
  * @returns A promise that resolves after every generated REST artifact has been refreshed.
  */
 export declare function syncRestResourceArtifacts({ clientFile, methods, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncRestResourceArtifactsOptions): Promise<void>;
+/**
+ * Synchronize generated schemas, OpenAPI output, and endpoint client code for a
+ * type-only manual REST contract.
+ *
+ * @param options Contract file paths and naming variables.
+ * @returns A promise that resolves after every generated artifact has refreshed.
+ */
+export declare function syncManualRestContractArtifacts({ clientFile, outputDir, projectDir, typesFile, validatorsFile, variables, }: SyncManualRestContractArtifactsOptions): Promise<void>;
 export {};