@wp-typia/project-tools 0.16.14 → 0.18.0

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

@@ -1,6 +1,15 @@
 import type { HookedBlockPositionId } from "./hooked-blocks.js";
 import { type RunAddHookedBlockCommandOptions, type RunAddVariationCommandOptions } from "./cli-add-shared.js";
-export { runAddBindingSourceCommand, runAddPatternCommand, } from "./cli-add-workspace-assets.js";
+/**
+ * Re-export focused workspace asset scaffold commands from the companion
+ * `cli-add-workspace-assets` module.
+ */
+export { runAddEditorPluginCommand, runAddBindingSourceCommand, runAddPatternCommand, } from "./cli-add-workspace-assets.js";
+/**
+ * Re-export the plugin-level REST resource scaffold workflow from the focused
+ * rest-resource runtime helper module.
+ */
+export { runAddRestResourceCommand } from "./cli-add-workspace-rest.js";
 /**
  * Add one variation entry to an existing workspace block.
  *

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

@@ -119,7 +119,16 @@ async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
     const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
     await fsp.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
-export { runAddBindingSourceCommand, runAddPatternCommand, } from "./cli-add-workspace-assets.js";
+/**
+ * Re-export focused workspace asset scaffold commands from the companion
+ * `cli-add-workspace-assets` module.
+ */
+export { runAddEditorPluginCommand, runAddBindingSourceCommand, runAddPatternCommand, } from "./cli-add-workspace-assets.js";
+/**
+ * Re-export the plugin-level REST resource scaffold workflow from the focused
+ * rest-resource runtime helper module.
+ */
+export { runAddRestResourceCommand } from "./cli-add-workspace-rest.js";
 /**
  * Add one variation entry to an existing workspace block.
  *

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

@@ -7,8 +7,8 @@
  * - `cli-add-block` for built-in block scaffolding
  * - `cli-add-workspace` for workspace mutation commands
  */
-export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, formatAddHelpText, } from "./cli-add-shared.js";
-export type { AddBlockTemplateId, AddKindId, } from "./cli-add-shared.js";
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, } from "./cli-add-shared.js";
+export type { AddBlockTemplateId, AddKindId, EditorPluginSlotId, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
-export { runAddBindingSourceCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
+export { runAddBindingSourceCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
 export { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";

package/dist/runtime/cli-add.js

@@ -7,7 +7,7 @@
  * - `cli-add-block` for built-in block scaffolding
  * - `cli-add-workspace` for workspace mutation commands
  */
-export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, formatAddHelpText, } from "./cli-add-shared.js";
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
-export { runAddBindingSourceCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
+export { runAddBindingSourceCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
 export { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";

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

@@ -11,6 +11,7 @@
  * and `HOOKED_BLOCK_POSITION_IDS`,
  * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
+ * `runAddRestResourceCommand` for plugin-level REST resource scaffolds,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
  * `createCliCommandError` and `formatCliDiagnosticError` for shared
  * non-interactive failure rendering,
@@ -25,8 +26,9 @@
 export { getDoctorChecks, runDoctor, type DoctorCheck } from "./cli-doctor.js";
 export { createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatDoctorCheckLine, formatDoctorSummaryLine, getDoctorFailureDetailLines, getFailingDoctorChecks, isCliDiagnosticError, } from "./cli-diagnostics.js";
 export type { CliDiagnosticMessage } from "./cli-diagnostics.js";
-export { formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
+export { EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
 export { HOOKED_BLOCK_POSITION_IDS } from "./hooked-blocks.js";
+export type { EditorPluginSlotId } from "./cli-add.js";
 export type { HookedBlockPositionId } from "./hooked-blocks.js";
 export { formatHelpText } from "./cli-help.js";
 export { getNextSteps, getOptionalOnboarding, runScaffoldFlow, } from "./cli-scaffold.js";

package/dist/runtime/cli-core.js

@@ -11,6 +11,7 @@
  * and `HOOKED_BLOCK_POSITION_IDS`,
  * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
+ * `runAddRestResourceCommand` for plugin-level REST resource scaffolds,
  * `getDoctorChecks`, `runDoctor`, and `DoctorCheck` for diagnostics,
  * `createCliCommandError` and `formatCliDiagnosticError` for shared
  * non-interactive failure rendering,
@@ -24,7 +25,7 @@
  */
 export { getDoctorChecks, runDoctor } from "./cli-doctor.js";
 export { createCliCommandError, CliDiagnosticError, formatCliDiagnosticError, formatDoctorCheckLine, formatDoctorSummaryLine, getDoctorFailureDetailLines, getFailingDoctorChecks, isCliDiagnosticError, } from "./cli-diagnostics.js";
-export { formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBindingSourceCommand, runAddBlockCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
+export { EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, getWorkspaceBlockSelectOptions, runAddBindingSourceCommand, runAddBlockCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
 export { HOOKED_BLOCK_POSITION_IDS } from "./hooked-blocks.js";
 export { formatHelpText } from "./cli-help.js";
 export { getNextSteps, getOptionalOnboarding, runScaffoldFlow, } from "./cli-scaffold.js";

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

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
+import { EDITOR_PLUGIN_SLOT_IDS, REST_RESOURCE_METHOD_IDS, REST_RESOURCE_NAMESPACE_PATTERN, } from "./cli-add-shared.js";
 import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_SET, } from "./hooked-blocks.js";
 import { readWorkspaceInventory } from "./workspace-inventory.js";
 import { getInvalidWorkspaceProjectReason, parseWorkspacePackageJson, WORKSPACE_TEMPLATE_PACKAGE, tryResolveWorkspaceProject, } from "./workspace-project.js";
@@ -9,6 +10,10 @@ const WORKSPACE_COLLECTION_IMPORT_PATTERN = /^\s*import\s+["']\.\.\/\.\.\/collec
 const WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php";
 const WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js";
 const WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php";
+const WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php";
+const WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js";
+const WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php";
+const WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css";
 const WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
     "block.json",
     "typia.manifest.json",
@@ -22,6 +27,9 @@ function createDoctorCheck(label, status, detail) {
 function createDoctorScopeCheck(status, detail) {
     return createDoctorCheck("Doctor scope", status, detail);
 }
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
 function getWorkspaceBootstrapRelativePath(packageName) {
     const packageBaseName = packageName.split("/").pop() ?? packageName;
     return `${packageBaseName}.php`;
@@ -184,6 +192,117 @@ function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
         ? "Binding source editor registrations are aggregated"
         : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
+function getWorkspaceRestResourceRequiredFiles(restResource) {
+    const schemaNames = new Set();
+    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.openApiFile,
+        restResource.phpFile,
+        restResource.typesFile,
+        restResource.validatorsFile,
+    ]));
+}
+function checkWorkspaceRestResourceConfig(restResource) {
+    const hasNamespace = REST_RESOURCE_NAMESPACE_PATTERN.test(restResource.namespace);
+    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
+        ? `REST resource namespace ${restResource.namespace} with methods ${restResource.methods.join(", ")}`
+        : "REST resource namespace or methods are invalid");
+}
+function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    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");
+}
+function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
+    const editorPluginDir = path.join("src", "editor-plugins", editorPlugin.slug);
+    return Array.from(new Set([
+        editorPlugin.file,
+        path.join(editorPluginDir, "Sidebar.tsx"),
+        path.join(editorPluginDir, "data.ts"),
+        path.join(editorPluginDir, "types.ts"),
+        path.join(editorPluginDir, "style.scss"),
+    ]));
+}
+function checkWorkspaceEditorPluginConfig(editorPlugin) {
+    const validSlots = new Set(EDITOR_PLUGIN_SLOT_IDS);
+    const isValidSlot = validSlots.has(editorPlugin.slot);
+    return createDoctorCheck(`Editor plugin config ${editorPlugin.slug}`, isValidSlot ? "pass" : "fail", isValidSlot
+        ? `Editor plugin slot ${editorPlugin.slot} is supported`
+        : `Unsupported editor plugin slot "${editorPlugin.slot}". Expected one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")}`);
+}
+function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
+    const packageBaseName = packageName.split("/").pop() ?? packageName;
+    const bootstrapPath = path.join(projectDir, `${packageBaseName}.php`);
+    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(", ")}`);
+}
 function checkVariationEntrypoint(projectDir, blockSlug) {
     const entryPath = path.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
     if (!fs.existsSync(entryPath)) {
@@ -258,7 +377,7 @@ export function getWorkspaceDoctorChecks(cwd) {
     checks.push(checkWorkspacePackageMetadata(workspace, workspacePackageJson));
     try {
         const inventory = readWorkspaceInventory(workspace.projectDir);
-        checks.push(createDoctorCheck("Workspace inventory", "pass", `${inventory.blocks.length} block(s), ${inventory.variations.length} variation(s), ${inventory.patterns.length} pattern(s), ${inventory.bindingSources.length} binding source(s)`));
+        checks.push(createDoctorCheck("Workspace inventory", "pass", `${inventory.blocks.length} block(s), ${inventory.variations.length} variation(s), ${inventory.patterns.length} pattern(s), ${inventory.bindingSources.length} binding source(s), ${inventory.restResources.length} REST resource(s), ${inventory.editorPlugins.length} editor plugin(s)`));
         for (const block of inventory.blocks) {
             checks.push(checkExistingFiles(workspace.projectDir, `Block ${block.slug}`, getWorkspaceBlockRequiredFiles(block)));
             checks.push(checkWorkspaceBlockMetadata(workspace.projectDir, workspace, block));
@@ -296,6 +415,21 @@ export function getWorkspaceDoctorChecks(cwd) {
                 bindingSource.editorFile,
             ]));
         }
+        if (inventory.restResources.length > 0) {
+            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.editorPlugins.length > 0) {
+            checks.push(checkWorkspaceEditorPluginBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+            checks.push(checkWorkspaceEditorPluginIndex(workspace.projectDir, inventory.editorPlugins));
+        }
+        for (const editorPlugin of inventory.editorPlugins) {
+            checks.push(checkExistingFiles(workspace.projectDir, `Editor plugin ${editorPlugin.slug}`, getWorkspaceEditorPluginRequiredFiles(editorPlugin)));
+            checks.push(checkWorkspaceEditorPluginConfig(editorPlugin));
+        }
         const migrationWorkspaceCheck = checkMigrationWorkspaceHint(workspace, workspacePackageJson);
         if (migrationWorkspaceCheck) {
             checks.push(migrationWorkspaceCheck);

package/dist/runtime/cli-help.js

@@ -10,16 +10,19 @@ import { TEMPLATE_IDS } from "./template-registry.js";
  */
 export function formatHelpText() {
     return `Usage:
-  wp-typia create <project-dir> [--template <basic|interactivity>] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
-  wp-typia create <project-dir> [--template <./path|github:owner/repo/path[#ref]>] [--variant <name>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
-  wp-typia create <project-dir> [--template <npm-package>] [--variant <name>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
-  wp-typia create <project-dir> [--template persistence] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
-  wp-typia create <project-dir> [--template compound] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template <basic|interactivity>] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--dry-run] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template query-loop] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--query-post-type <post-type>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--dry-run] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template <./path|github:owner/repo/path[#ref]>] [--variant <name>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-wp-env] [--with-test-preset] [--yes] [--dry-run] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template <npm-package>] [--variant <name>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-wp-env] [--with-test-preset] [--yes] [--dry-run] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template persistence] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--dry-run] [--no-install] [--package-manager <id>]
+  wp-typia create <project-dir> [--template compound] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--namespace <value>] [--text-domain <value>] [--php-prefix <value>] [--with-migration-ui] [--with-wp-env] [--with-test-preset] [--yes] [--dry-run] [--no-install] [--package-manager <id>]
   wp-typia <project-dir> [create flags...]
   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>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>]
   wp-typia add variation <name> --block <block-slug>
   wp-typia add pattern <name>
   wp-typia add binding-source <name>
+  wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <method[,method...]>]
+  wp-typia add editor-plugin <name> [--slot <PluginSidebar>]
   wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>
   wp-typia migrate <init|snapshot|diff|scaffold|verify|doctor|fixtures|fuzz> [...]
   wp-typia templates list
@@ -38,6 +41,8 @@ Notes:
   \`add variation\` uses an existing workspace block from \`scripts/block-config.ts\`.
   \`add pattern\` scaffolds a namespaced PHP pattern shell under \`src/patterns/\`.
   \`add binding-source\` scaffolds shared PHP and editor registration under \`src/bindings/\`.
+  \`add rest-resource\` scaffolds plugin-level TypeScript REST contracts under \`src/rest/\` and PHP route glue under \`inc/rest/\`.
+  \`add editor-plugin\` scaffolds a document-level editor extension under \`src/editor-plugins/\`.
   \`add hooked-block\` patches an existing workspace block's \`block.json\` \`blockHooks\` metadata.
   \`wp-typia doctor\` always checks environment readiness and reports when it only ran environment-level diagnostics; official workspace roots also get inventory and source-tree drift checks.
   \`wp-typia migrate doctor --all\` checks migration target alignment, snapshots, fixtures, and generated migration artifacts.

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

@@ -1,5 +1,5 @@
 import { collectScaffoldAnswers, scaffoldProject } from "./scaffold.js";
-import type { DataStorageMode, PersistencePolicy } from "./scaffold.js";
+import type { DataStorageMode, PersistencePolicy, ScaffoldProgressEvent } from "./scaffold.js";
 import type { PackageManagerId } from "./package-managers.js";
 import { type ExternalLayerSelectionOption } from "./external-layer-selection.js";
 import type { TemplateDefinition } from "./template-registry.js";
@@ -20,20 +20,27 @@ interface OptionalOnboardingGuidance {
     note: string;
     steps: string[];
 }
+export interface ScaffoldDryRunPlan {
+    dependencyInstall: "skipped-by-flag" | "would-install";
+    files: string[];
+}
 interface RunScaffoldFlowOptions {
     allowExistingDir?: boolean;
     cwd?: string;
     dataStorageMode?: string;
+    dryRun?: boolean;
     externalLayerId?: string;
     externalLayerSource?: string;
     installDependencies?: Parameters<typeof scaffoldProject>[0]["installDependencies"];
     isInteractive?: boolean;
     namespace?: string;
     noInstall?: boolean;
+    onProgress?: ((event: ScaffoldProgressEvent) => void | Promise<void>) | undefined;
     packageManager?: string;
     phpPrefix?: string;
     projectInput: string;
     promptText?: Parameters<typeof collectScaffoldAnswers>[0]["promptText"];
+    queryPostType?: string;
     selectDataStorage?: () => Promise<DataStorageMode>;
     selectExternalLayerId?: (options: ExternalLayerSelectionOption[]) => Promise<string>;
     selectPackageManager?: () => Promise<PackageManagerId>;
@@ -73,8 +80,10 @@ export declare function getOptionalOnboarding({ availableScripts, packageManager
  * project.
  * @returns The scaffold result together with next-step guidance.
  */
-export declare function runScaffoldFlow({ projectInput, cwd, templateId, dataStorageMode, externalLayerId, externalLayerSource, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, yes, noInstall, isInteractive, allowExistingDir, selectTemplate, selectDataStorage, selectExternalLayerId, selectPersistencePolicy, selectPackageManager, promptText, installDependencies, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }: RunScaffoldFlowOptions): Promise<{
+export declare function runScaffoldFlow({ projectInput, cwd, templateId, dataStorageMode, dryRun, externalLayerId, externalLayerSource, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, queryPostType, yes, noInstall, onProgress, isInteractive, allowExistingDir, selectTemplate, selectDataStorage, selectExternalLayerId, selectPersistencePolicy, selectPackageManager, promptText, installDependencies, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }: RunScaffoldFlowOptions): Promise<{
+    dryRun: boolean;
     optionalOnboarding: OptionalOnboardingGuidance;
+    plan: ScaffoldDryRunPlan | undefined;
     projectDir: string;
     projectInput: string;
     packageManager: PackageManagerId;

package/dist/runtime/cli-scaffold.js

@@ -1,11 +1,79 @@
 import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, resolvePackageManagerId, resolveTemplateId, scaffoldProject, } from "./scaffold.js";
 import { formatInstallCommand, formatRunScript, } from "./package-managers.js";
 import { getPrimaryDevelopmentScript } from "./local-dev-presets.js";
 import { getOptionalOnboardingNote, getOptionalOnboardingSteps, } from "./scaffold-onboarding.js";
+import { formatNonEmptyTargetDirectoryError } from "./scaffold-bootstrap.js";
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from "./template-registry.js";
 import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
+async function listRelativeProjectFiles(rootDir) {
+    const relativeFiles = [];
+    async function visit(currentDir) {
+        const entries = await fsp.readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const absolutePath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                await visit(absolutePath);
+                continue;
+            }
+            relativeFiles.push(path
+                .relative(rootDir, absolutePath)
+                .replace(path.sep === "\\" ? /\\/gu : /\//gu, "/"));
+        }
+    }
+    await visit(rootDir);
+    return relativeFiles.sort((left, right) => left.localeCompare(right));
+}
+async function assertDryRunTargetDirectoryReady(projectDir, allowExistingDir) {
+    if (!fs.existsSync(projectDir) || allowExistingDir) {
+        return;
+    }
+    const entries = await fsp.readdir(projectDir);
+    if (entries.length > 0) {
+        throw new Error(formatNonEmptyTargetDirectoryError(projectDir));
+    }
+}
+async function buildScaffoldDryRunPlan({ allowExistingDir, answers, cwd, dataStorageMode, externalLayerId, externalLayerSource, externalLayerSourceLabel, installDependencies, noInstall, onProgress, packageManager, persistencePolicy, projectDir, templateId, variant, withMigrationUi, withTestPreset, withWpEnv, }) {
+    await assertDryRunTargetDirectoryReady(projectDir, allowExistingDir);
+    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "wp-typia-scaffold-plan-"));
+    const previewProjectDir = path.join(tempRoot, "preview-project");
+    try {
+        const result = await scaffoldProject({
+            allowExistingDir: false,
+            answers,
+            cwd,
+            dataStorageMode,
+            externalLayerId,
+            externalLayerSource,
+            externalLayerSourceLabel,
+            installDependencies,
+            noInstall: true,
+            onProgress,
+            packageManager,
+            persistencePolicy,
+            projectDir: previewProjectDir,
+            templateId,
+            variant,
+            withMigrationUi,
+            withTestPreset,
+            withWpEnv,
+        });
+        const files = await listRelativeProjectFiles(previewProjectDir);
+        return {
+            plan: {
+                dependencyInstall: noInstall ? "skipped-by-flag" : "would-install",
+                files,
+            },
+            result,
+        };
+    }
+    finally {
+        await fsp.rm(tempRoot, { force: true, recursive: true });
+    }
+}
 function validateCreateProjectInput(projectInput) {
     const normalizedProjectInput = projectInput.trim();
     if (normalizedProjectInput.length === 0) {
@@ -135,7 +203,7 @@ export function getOptionalOnboarding({ availableScripts, packageManager, templa
  * project.
  * @returns The scaffold result together with next-step guidance.
  */
-export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templateId, dataStorageMode, externalLayerId, externalLayerSource, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, yes = false, noInstall = false, isInteractive = false, allowExistingDir = false, selectTemplate, selectDataStorage, selectExternalLayerId, selectPersistencePolicy, selectPackageManager, promptText, installDependencies = undefined, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }) {
+export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templateId, dataStorageMode, dryRun = false, externalLayerId, externalLayerSource, persistencePolicy, packageManager, namespace, textDomain, phpPrefix, queryPostType, yes = false, noInstall = false, onProgress, isInteractive = false, allowExistingDir = false, selectTemplate, selectDataStorage, selectExternalLayerId, selectPersistencePolicy, selectPackageManager, promptText, installDependencies = undefined, variant, selectWithTestPreset, selectWithWpEnv, selectWithMigrationUi, withMigrationUi, withTestPreset, withWpEnv, }) {
     const normalizedExternalLayerId = typeof externalLayerId === "string" && externalLayerId.trim().length > 0
         ? externalLayerId.trim()
         : undefined;
@@ -228,52 +296,82 @@ export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templ
             persistencePolicy: resolvedPersistencePolicy,
             phpPrefix,
             projectName,
+            queryPostType,
             templateId: resolvedTemplateId,
             textDomain,
             yes,
             promptText,
         });
-        const result = await scaffoldProject({
-            answers,
-            allowExistingDir,
-            cwd,
-            dataStorageMode: resolvedDataStorage,
-            externalLayerId: resolvedExternalLayerSelection.externalLayerId,
-            externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
-            externalLayerSourceLabel: normalizedExternalLayerSource,
-            installDependencies,
-            noInstall,
-            packageManager: resolvedPackageManager,
-            persistencePolicy: resolvedPersistencePolicy,
-            projectDir,
-            templateId: resolvedTemplateId,
-            variant,
-            withMigrationUi: resolvedWithMigrationUi,
-            withTestPreset: resolvedWithTestPreset,
-            withWpEnv: resolvedWithWpEnv,
-        });
+        const resolvedResult = dryRun
+            ? await buildScaffoldDryRunPlan({
+                allowExistingDir,
+                answers,
+                cwd,
+                dataStorageMode: resolvedDataStorage,
+                externalLayerId: resolvedExternalLayerSelection.externalLayerId,
+                externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
+                externalLayerSourceLabel: normalizedExternalLayerSource,
+                installDependencies,
+                noInstall,
+                onProgress,
+                packageManager: resolvedPackageManager,
+                persistencePolicy: resolvedPersistencePolicy,
+                projectDir,
+                templateId: resolvedTemplateId,
+                variant,
+                withMigrationUi: resolvedWithMigrationUi,
+                withTestPreset: resolvedWithTestPreset,
+                withWpEnv: resolvedWithWpEnv,
+            })
+            : {
+                plan: undefined,
+                result: await scaffoldProject({
+                    answers,
+                    allowExistingDir,
+                    cwd,
+                    dataStorageMode: resolvedDataStorage,
+                    externalLayerId: resolvedExternalLayerSelection.externalLayerId,
+                    externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
+                    externalLayerSourceLabel: normalizedExternalLayerSource,
+                    installDependencies,
+                    noInstall,
+                    onProgress,
+                    packageManager: resolvedPackageManager,
+                    persistencePolicy: resolvedPersistencePolicy,
+                    projectDir,
+                    templateId: resolvedTemplateId,
+                    variant,
+                    withMigrationUi: resolvedWithMigrationUi,
+                    withTestPreset: resolvedWithTestPreset,
+                    withWpEnv: resolvedWithWpEnv,
+                }),
+            };
         let availableScripts;
-        try {
-            const parsedPackageJson = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
-            const scripts = parsedPackageJson.scripts &&
-                typeof parsedPackageJson.scripts === "object" &&
-                !Array.isArray(parsedPackageJson.scripts)
-                ? parsedPackageJson.scripts
-                : {};
-            availableScripts = Object.entries(scripts)
-                .filter(([, value]) => typeof value === "string")
-                .map(([scriptName]) => scriptName);
-        }
-        catch {
-            availableScripts = undefined;
+        if (!dryRun) {
+            try {
+                const parsedPackageJson = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+                const scripts = parsedPackageJson.scripts &&
+                    typeof parsedPackageJson.scripts === "object" &&
+                    !Array.isArray(parsedPackageJson.scripts)
+                    ? parsedPackageJson.scripts
+                    : {};
+                availableScripts = Object.entries(scripts)
+                    .filter(([, value]) => typeof value === "string")
+                    .map(([scriptName]) => scriptName);
+            }
+            catch {
+                availableScripts = undefined;
+            }
         }
         return {
+            dryRun,
             optionalOnboarding: getOptionalOnboarding({
                 availableScripts,
                 packageManager: resolvedPackageManager,
                 templateId: resolvedTemplateId,
-                compoundPersistenceEnabled: result.variables.compoundPersistenceEnabled === "true",
+                compoundPersistenceEnabled: resolvedResult.result.variables.compoundPersistenceEnabled === "true",
             }),
+            plan: resolvedResult.plan,
             projectDir,
             projectInput,
             packageManager: resolvedPackageManager,
@@ -285,8 +383,11 @@ export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templ
                 templateId: resolvedTemplateId,
             }),
             result: {
-                ...result,
-                warnings: [...result.warnings, ...collectProjectDirectoryWarnings(projectDir)],
+                ...resolvedResult.result,
+                warnings: [
+                    ...resolvedResult.result.warnings,
+                    ...collectProjectDirectoryWarnings(projectDir),
+                ],
             },
         };
     }

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

@@ -8,18 +8,18 @@ import type { TemplateDefinition } from "./template-registry.js";
  */
 export declare function formatTemplateSummary(template: TemplateDefinition): string;
 /**
- * Format the feature hint line shown under a template summary.
+ * Format the feature and capability hint lines shown under a template summary.
  *
  * @param template Template metadata including the `features` list.
- * @returns Indented feature text for CLI list output.
+ * @returns Indented feature and capability text for CLI list output.
  */
 export declare function formatTemplateFeatures(template: TemplateDefinition): string;
 /**
  * Format the detailed template description for `templates inspect`.
  *
  * This expands special layer combinations for the `persistence` and `compound`
- * templates and returns a multi-line block including category, overlay path,
- * resolved layers, and feature labels.
+ * templates and returns a multi-line block centered on human-facing identity,
+ * capabilities, and logical layer composition.
  *
  * @param template Template metadata including `id`, `defaultCategory`,
  * `templateDir`, and `features`.