@wp-typia/project-tools 0.17.0 → 0.19.0

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

@@ -10,13 +10,24 @@ import { getDefaultAnswers, scaffoldProject } from "./scaffold.js";
 import { copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, } from "./template-render.js";
 import { appendWorkspaceInventoryEntries, } from "./workspace-inventory.js";
 import { resolveWorkspaceProject, } from "./workspace-project.js";
-import { ADD_BLOCK_TEMPLATE_IDS, buildWorkspacePhpPrefix, isAddBlockTemplateId, normalizeBlockSlug, patchFile, readOptionalFile, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { ADD_BLOCK_TEMPLATE_IDS, buildWorkspacePhpPrefix, isAddBlockTemplateId, patchFile, readOptionalFile, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { resolveNonEmptyNormalizedBlockSlug, } from "./scaffold-identifiers.js";
 import { buildConfigEntries, buildMigrationBlocks, buildServerTemplateRoot, } from "./cli-add-block-config.js";
 import { COMPOUND_SHARED_SUPPORT_FILES, collectLegacyCompoundValidatorPaths, ensureBlockConfigCanAddRestManifests, ensureCompoundWorkspaceSupportFiles, } from "./cli-add-block-legacy-validator.js";
 import { parseTemplateLocator, resolveTemplateSeed, } from "./template-source.js";
 import { resolveExternalTemplateLayers, } from "./template-layers.js";
+import { formatInstallCommand, } from "./package-managers.js";
+import { parseCompoundInnerBlocksPreset } from "./compound-inner-blocks.js";
 import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
+import { parseAlternateRenderTargets } from "./alternate-render-targets.js";
+import { assertExternalLayerCompositionOptions, normalizeOptionalCliString, resolveLocalCliPathOption, } from "./cli-validation.js";
 const COLLECTION_IMPORT_LINE = "import '../../collection';";
+// This is a lightweight preflight heuristic for the common install layouts:
+// node_modules for npm/pnpm/bun/yarn-classic and Yarn PnP marker files.
+// It intentionally favors fast user guidance over exhaustive detection, so
+// stale node_modules or hoisted installs outside the workspace root can still
+// fall through to deeper resolver errors.
+const WORKSPACE_INSTALL_MARKERS = ["node_modules", ".pnp.cjs", ".pnp.loader.mjs"];
 async function ensureCollectionImport(filePath) {
     await patchFile(filePath, (source) => {
         if (source.includes(COLLECTION_IMPORT_LINE)) {
@@ -54,20 +65,14 @@ async function renderWorkspacePersistenceServerModule(projectDir, variables) {
     const templateDir = buildServerTemplateRoot(variables.persistencePolicy);
     await copyInterpolatedDirectory(templateDir, targetDir, variables);
 }
-function normalizeExternalLayerOption(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
+function hasInstalledWorkspaceDependencies(projectDir) {
+    return WORKSPACE_INSTALL_MARKERS.some((marker) => fs.existsSync(path.join(projectDir, marker)));
 }
-function resolveExternalLayerSourceFromCaller(source, callerCwd) {
-    if (typeof source !== "string" ||
-        source.length === 0 ||
-        !(path.isAbsolute(source) || source.startsWith("./") || source.startsWith("../"))) {
-        return source;
+function assertWorkspaceDependenciesInstalled(workspace) {
+    if (hasInstalledWorkspaceDependencies(workspace.projectDir)) {
+        return;
     }
-    return path.resolve(callerCwd, source);
+    throw new Error(`Workspace dependencies have not been installed yet. Run \`${formatInstallCommand(workspace.packageManager)}\` from the workspace root before using \`wp-typia add block ...\`.`);
 }
 async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir, variables, legacyValidatorPaths = []) {
     if (templateId === "compound") {
@@ -191,12 +196,14 @@ async function syncWorkspaceAddedBlockArtifacts(projectDir, templateId, variable
     }
 }
 function assertPersistenceFlagsAllowed(templateId, options) {
-    const hasPersistenceFlags = typeof options.dataStorageMode === "string" ||
+    const hasPersistenceFlags = typeof options.alternateRenderTargets === "string" ||
+        typeof options.dataStorageMode === "string" ||
         typeof options.persistencePolicy === "string";
     if (!hasPersistenceFlags) {
         return;
     }
     if (templateId === "persistence" || templateId === "compound") {
+        parseAlternateRenderTargets(options.alternateRenderTargets);
         if (typeof options.dataStorageMode === "string" &&
             options.dataStorageMode !== "custom-table" &&
             options.dataStorageMode !== "post-meta") {
@@ -207,9 +214,24 @@ function assertPersistenceFlagsAllowed(templateId, options) {
             options.persistencePolicy !== "public") {
             throw new Error(`Unsupported persistence policy "${options.persistencePolicy}". Expected one of: authenticated, public.`);
         }
+        if (templateId === "compound" &&
+            typeof options.alternateRenderTargets === "string" &&
+            !options.dataStorageMode &&
+            !options.persistencePolicy) {
+            throw new Error("`--alternate-render-targets` on `wp-typia add block --template compound` requires the persistence-enabled server render path. Add `--data-storage <post-meta|custom-table>` or `--persistence-policy <authenticated|public>` first.");
+        }
+        return;
+    }
+    throw new Error(`--data-storage, --persistence-policy, and --alternate-render-targets are supported only for \`wp-typia add block --template persistence\` or persistence-enabled \`--template compound\`.`);
+}
+function assertCompoundInnerBlocksPresetAllowed(templateId, innerBlocksPreset) {
+    if (!innerBlocksPreset) {
         return;
     }
-    throw new Error(`--data-storage and --persistence-policy are supported only for \`wp-typia add block --template persistence\` or \`--template compound\`.`);
+    if (templateId !== "compound") {
+        throw new Error("`--inner-blocks-preset` is supported only for `wp-typia add block --template compound`.");
+    }
+    parseCompoundInnerBlocksPreset(innerBlocksPreset);
 }
 /**
  * Seeds an empty official workspace migration project before any blocks are added.
@@ -239,6 +261,9 @@ export async function seedWorkspaceMigrationProject(projectDir, currentMigration
  * workspace. Defaults to `process.cwd()`.
  * @param options.dataStorageMode Optional storage mode for persistence-capable
  * templates.
+ * @param options.innerBlocksPreset Optional compound-only InnerBlocks preset
+ * (`freeform`, `ordered`, `horizontal`, or `locked-structure`) that controls
+ * the generated authoring defaults for nested compound containers.
  * @param options.persistencePolicy Optional persistence policy for
  * persistence-capable templates.
  * @param options.templateId Built-in block family to scaffold. Defaults to
@@ -248,17 +273,36 @@ export async function seedWorkspaceMigrationProject(projectDir, currentMigration
  * succeeds.
  * @throws {Error} When the template id is unknown, persistence flags are used
  * with unsupported templates, the command runs outside an official workspace,
- * or target block paths already exist.
+ * workspace dependencies have not been installed yet, or target block paths
+ * already exist.
  */
-export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataStorageMode, externalLayerId, externalLayerSource, persistencePolicy, selectExternalLayerId, templateId = "basic", }) {
+export async function runAddBlockCommand({ alternateRenderTargets, blockName, cwd = process.cwd(), dataStorageMode, externalLayerId, externalLayerSource, innerBlocksPreset, persistencePolicy, selectExternalLayerId, templateId = "basic", }) {
+    if (templateId === "query-loop") {
+        throw new Error("`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
+    }
     if (!isAddBlockTemplateId(templateId)) {
         throw new Error(`Unknown add-block template "${templateId}". Expected one of: ${ADD_BLOCK_TEMPLATE_IDS.join(", ")}`);
     }
     const resolvedTemplateId = templateId;
-    assertPersistenceFlagsAllowed(resolvedTemplateId, { dataStorageMode, persistencePolicy });
+    assertPersistenceFlagsAllowed(resolvedTemplateId, {
+        alternateRenderTargets,
+        dataStorageMode,
+        persistencePolicy,
+    });
+    assertCompoundInnerBlocksPresetAllowed(resolvedTemplateId, innerBlocksPreset);
+    const resolvedInnerBlocksPreset = parseCompoundInnerBlocksPreset(innerBlocksPreset);
     const workspace = resolveWorkspaceProject(cwd);
-    const normalizedExternalLayerId = normalizeExternalLayerOption(externalLayerId);
-    const normalizedExternalLayerSource = resolveExternalLayerSourceFromCaller(normalizeExternalLayerOption(externalLayerSource), cwd);
+    assertWorkspaceDependenciesInstalled(workspace);
+    const normalizedExternalLayerId = normalizeOptionalCliString(externalLayerId);
+    const normalizedExternalLayerSource = resolveLocalCliPathOption({
+        cwd,
+        label: "--external-layer-source",
+        value: externalLayerSource,
+    });
+    assertExternalLayerCompositionOptions({
+        externalLayerId: normalizedExternalLayerId,
+        externalLayerSource: normalizedExternalLayerSource,
+    });
     const resolvedExternalLayerSelection = await resolveOptionalInteractiveExternalLayerId({
         callerCwd: cwd,
         externalLayerId: normalizedExternalLayerId,
@@ -267,10 +311,11 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
     });
     let tempRoot = "";
     try {
-        const normalizedSlug = normalizeBlockSlug(blockName);
-        if (!normalizedSlug) {
-            throw new Error("Block name is required. Use `wp-typia add block <name> --template <family>`.");
-        }
+        const normalizedSlug = resolveNonEmptyNormalizedBlockSlug({
+            input: blockName,
+            label: "Block name",
+            usage: "wp-typia add block <name> --template <family>",
+        });
         const defaults = getDefaultAnswers(normalizedSlug, resolvedTemplateId);
         tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "wp-typia-add-block-"));
         const tempProjectDir = path.join(tempRoot, normalizedSlug);
@@ -287,9 +332,11 @@ export async function runAddBlockCommand({ blockName, cwd = process.cwd(), dataS
             : [];
         const result = await (async () => {
             const scaffoldResult = await scaffoldProject({
+                alternateRenderTargets,
                 answers: {
                     ...defaults,
                     author: workspace.author,
+                    compoundInnerBlocksPreset: resolvedInnerBlocksPreset,
                     namespace: workspace.workspace.namespace,
                     phpPrefix: blockPhpPrefix,
                     slug: normalizedSlug,

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

@@ -1,16 +1,29 @@
 import { type HookedBlockPositionId } from "./hooked-blocks.js";
 import { type WorkspaceInventory } from "./workspace-inventory.js";
 import { type WorkspaceProject } from "./workspace-project.js";
+export { normalizeBlockSlug, } from "./scaffold-identifiers.js";
 /**
  * Supported top-level `wp-typia add` kinds exposed by the canonical CLI.
  */
-export declare const ADD_KIND_IDS: readonly ["block", "variation", "pattern", "binding-source", "hooked-block"];
+export declare const ADD_KIND_IDS: readonly ["block", "variation", "pattern", "binding-source", "rest-resource", "hooked-block", "editor-plugin"];
 export type AddKindId = (typeof ADD_KIND_IDS)[number];
+/**
+ * Supported plugin-level REST resource methods accepted by
+ * `wp-typia add rest-resource --methods`.
+ */
+export declare const REST_RESOURCE_METHOD_IDS: readonly ["list", "read", "create", "update", "delete"];
+export type RestResourceMethodId = (typeof REST_RESOURCE_METHOD_IDS)[number];
+/**
+ * Supported editor-plugin shell slots accepted by `wp-typia add editor-plugin --slot`.
+ */
+export declare const EDITOR_PLUGIN_SLOT_IDS: readonly ["PluginSidebar"];
+export type EditorPluginSlotId = (typeof EDITOR_PLUGIN_SLOT_IDS)[number];
 /**
  * Supported built-in block families accepted by `wp-typia add block --template`.
  */
 export declare const ADD_BLOCK_TEMPLATE_IDS: readonly ["basic", "interactivity", "persistence", "compound"];
 export type AddBlockTemplateId = (typeof ADD_BLOCK_TEMPLATE_IDS)[number];
+export declare const REST_RESOURCE_NAMESPACE_PATTERN: RegExp;
 export interface RunAddVariationCommandOptions {
     blockName: string;
     cwd?: string;
@@ -24,18 +37,40 @@ export interface RunAddBindingSourceCommandOptions {
     bindingSourceName: string;
     cwd?: string;
 }
+export interface RunAddRestResourceCommandOptions {
+    cwd?: string;
+    methods?: string;
+    namespace?: string;
+    restResourceName: string;
+}
 export interface RunAddHookedBlockCommandOptions {
     anchorBlockName: string;
     blockName: string;
     cwd?: string;
     position: string;
 }
+/**
+ * Options for `wp-typia add editor-plugin`.
+ *
+ * @property cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @property editorPluginName Human-entered editor plugin name that will be
+ * normalized into the generated slug.
+ * @property slot Optional editor shell slot. Defaults to `PluginSidebar`.
+ */
+export interface RunAddEditorPluginCommandOptions {
+    cwd?: string;
+    editorPluginName: string;
+    slot?: string;
+}
 export interface RunAddBlockCommandOptions {
+    alternateRenderTargets?: string;
     blockName: string;
     cwd?: string;
     dataStorageMode?: string;
     externalLayerId?: string;
     externalLayerSource?: string;
+    innerBlocksPreset?: string;
     persistencePolicy?: string;
     selectExternalLayerId?: (options: Array<{
         description?: string;
@@ -57,8 +92,10 @@ export interface WorkspaceMutationSnapshot {
     /** Files or directories created by the mutation that should be removed on rollback. */
     targetPaths: string[];
 }
-export declare function normalizeBlockSlug(input: string): string;
 export declare function assertValidGeneratedSlug(label: string, slug: string, usage: string): string;
+export declare function assertValidRestResourceNamespace(namespace: string): string;
+export declare function resolveRestResourceNamespace(workspaceNamespace: string, namespace?: string): string;
+export declare function assertValidRestResourceMethods(methods?: string): RestResourceMethodId[];
 export declare function assertValidHookedBlockPosition(position: string): HookedBlockPositionId;
 export declare function getWorkspaceBootstrapPath(workspace: WorkspaceProject): string;
 export declare function buildWorkspacePhpPrefix(workspacePhpPrefix: string, slug: string): string;
@@ -86,6 +123,14 @@ export declare function snapshotWorkspaceFiles(filePaths: string[]): Promise<Wor
 export declare function rollbackWorkspaceMutation(snapshot: WorkspaceMutationSnapshot): Promise<void>;
 export declare function resolveWorkspaceBlock(inventory: WorkspaceInventory, blockSlug: string): WorkspaceInventory["blocks"][number];
 export declare function assertValidHookAnchor(anchorBlockName: string): string;
+/**
+ * Validate and normalize the editor plugin shell slot.
+ *
+ * @param slot Optional shell slot. Defaults to `PluginSidebar`.
+ * @returns The canonical editor plugin slot id.
+ * @throws {Error} When the slot is not supported by the workspace scaffold.
+ */
+export declare function assertValidEditorPluginSlot(slot?: string): EditorPluginSlotId;
 export declare function readWorkspaceBlockJson(projectDir: string, blockSlug: string): {
     blockJson: Record<string, unknown>;
     blockJsonPath: string;
@@ -94,6 +139,17 @@ export declare function getMutableBlockHooks(blockJson: Record<string, unknown>,
 export declare function assertVariationDoesNotExist(projectDir: string, blockSlug: string, variationSlug: string, inventory: WorkspaceInventory): void;
 export declare function assertPatternDoesNotExist(projectDir: string, patternSlug: string, inventory: WorkspaceInventory): void;
 export declare function assertBindingSourceDoesNotExist(projectDir: string, bindingSourceSlug: string, inventory: WorkspaceInventory): void;
+export declare function assertRestResourceDoesNotExist(projectDir: string, restResourceSlug: string, inventory: WorkspaceInventory): void;
+/**
+ * Ensure an editor plugin scaffold does not already exist on disk or in the
+ * workspace inventory.
+ *
+ * @param projectDir Workspace root directory.
+ * @param editorPluginSlug Normalized editor plugin slug.
+ * @param inventory Parsed workspace inventory.
+ * @throws {Error} When the directory or inventory entry already exists.
+ */
+export declare function assertEditorPluginDoesNotExist(projectDir: string, editorPluginSlug: string, inventory: WorkspaceInventory): void;
 /**
  * Returns help text for the canonical `wp-typia add` subcommands.
  */

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

@@ -3,12 +3,36 @@ import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
 import { HOOKED_BLOCK_ANCHOR_PATTERN, HOOKED_BLOCK_POSITION_IDS, } from "./hooked-blocks.js";
-import { toKebabCase, toSnakeCase, } from "./string-case.js";
+import { toSnakeCase, } from "./string-case.js";
 import { WORKSPACE_TEMPLATE_PACKAGE, } from "./workspace-project.js";
+export { normalizeBlockSlug, } from "./scaffold-identifiers.js";
 /**
  * Supported top-level `wp-typia add` kinds exposed by the canonical CLI.
  */
-export const ADD_KIND_IDS = ["block", "variation", "pattern", "binding-source", "hooked-block"];
+export const ADD_KIND_IDS = [
+    "block",
+    "variation",
+    "pattern",
+    "binding-source",
+    "rest-resource",
+    "hooked-block",
+    "editor-plugin",
+];
+/**
+ * Supported plugin-level REST resource methods accepted by
+ * `wp-typia add rest-resource --methods`.
+ */
+export const REST_RESOURCE_METHOD_IDS = [
+    "list",
+    "read",
+    "create",
+    "update",
+    "delete",
+];
+/**
+ * Supported editor-plugin shell slots accepted by `wp-typia add editor-plugin --slot`.
+ */
+export const EDITOR_PLUGIN_SLOT_IDS = ["PluginSidebar"];
 /**
  * Supported built-in block families accepted by `wp-typia add block --template`.
  */
@@ -19,9 +43,7 @@ export const ADD_BLOCK_TEMPLATE_IDS = [
     "compound",
 ];
 const WORKSPACE_GENERATED_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
-export function normalizeBlockSlug(input) {
-    return toKebabCase(input);
-}
+export const REST_RESOURCE_NAMESPACE_PATTERN = /^[a-z][a-z0-9-]*(?:\/[a-z0-9-]+)+$/u;
 export function assertValidGeneratedSlug(label, slug, usage) {
     if (!slug) {
         throw new Error(`${label} is required. Use \`${usage}\`.`);
@@ -31,6 +53,33 @@ export function assertValidGeneratedSlug(label, slug, usage) {
     }
     return slug;
 }
+export function assertValidRestResourceNamespace(namespace) {
+    const trimmed = namespace.trim();
+    if (!trimmed) {
+        throw new Error("REST resource namespace is required. Use `--namespace <vendor/v1>` or let the workspace default apply.");
+    }
+    if (!REST_RESOURCE_NAMESPACE_PATTERN.test(trimmed)) {
+        throw new Error("REST resource namespace must use lowercase slash-separated segments like `demo-space/v1`.");
+    }
+    return trimmed;
+}
+export function resolveRestResourceNamespace(workspaceNamespace, namespace) {
+    return assertValidRestResourceNamespace(namespace ?? `${workspaceNamespace}/v1`);
+}
+export function assertValidRestResourceMethods(methods) {
+    const rawMethods = typeof methods === "string" && methods.trim().length > 0
+        ? methods.split(",").map((value) => value.trim()).filter(Boolean)
+        : ["list", "read", "create"];
+    const normalizedMethods = Array.from(new Set(rawMethods));
+    const invalidMethods = normalizedMethods.filter((method) => !REST_RESOURCE_METHOD_IDS.includes(method));
+    if (invalidMethods.length > 0) {
+        throw new Error(`REST resource methods must be a comma-separated list of: ${REST_RESOURCE_METHOD_IDS.join(", ")}.`);
+    }
+    if (normalizedMethods.length === 0) {
+        throw new Error("REST resource methods must include at least one of: list, read, create, update, delete.");
+    }
+    return normalizedMethods;
+}
 export function assertValidHookedBlockPosition(position) {
     if (HOOKED_BLOCK_POSITION_IDS.includes(position)) {
         return position;
@@ -121,6 +170,19 @@ export function assertValidHookAnchor(anchorBlockName) {
     }
     return trimmed;
 }
+/**
+ * Validate and normalize the editor plugin shell slot.
+ *
+ * @param slot Optional shell slot. Defaults to `PluginSidebar`.
+ * @returns The canonical editor plugin slot id.
+ * @throws {Error} When the slot is not supported by the workspace scaffold.
+ */
+export function assertValidEditorPluginSlot(slot = "PluginSidebar") {
+    if (EDITOR_PLUGIN_SLOT_IDS.includes(slot)) {
+        return slot;
+    }
+    throw new Error(`Editor plugin slot must be one of: ${EDITOR_PLUGIN_SLOT_IDS.join(", ")}.`);
+}
 export function readWorkspaceBlockJson(projectDir, blockSlug) {
     const blockJsonPath = path.join(projectDir, "src", "blocks", blockSlug, "block.json");
     if (!fs.existsSync(blockJsonPath)) {
@@ -179,21 +241,58 @@ export function assertBindingSourceDoesNotExist(projectDir, bindingSourceSlug, i
         throw new Error(`A binding source inventory entry already exists for ${bindingSourceSlug}. Choose a different name.`);
     }
 }
+export function assertRestResourceDoesNotExist(projectDir, restResourceSlug, inventory) {
+    const restResourceDir = path.join(projectDir, "src", "rest", restResourceSlug);
+    const restResourcePhpPath = path.join(projectDir, "inc", "rest", `${restResourceSlug}.php`);
+    if (fs.existsSync(restResourceDir)) {
+        throw new Error(`A REST resource already exists at ${path.relative(projectDir, restResourceDir)}. Choose a different name.`);
+    }
+    if (fs.existsSync(restResourcePhpPath)) {
+        throw new Error(`A REST resource bootstrap already exists at ${path.relative(projectDir, restResourcePhpPath)}. Choose a different name.`);
+    }
+    if (inventory.restResources.some((entry) => entry.slug === restResourceSlug)) {
+        throw new Error(`A REST resource inventory entry already exists for ${restResourceSlug}. Choose a different name.`);
+    }
+}
+/**
+ * Ensure an editor plugin scaffold does not already exist on disk or in the
+ * workspace inventory.
+ *
+ * @param projectDir Workspace root directory.
+ * @param editorPluginSlug Normalized editor plugin slug.
+ * @param inventory Parsed workspace inventory.
+ * @throws {Error} When the directory or inventory entry already exists.
+ */
+export function assertEditorPluginDoesNotExist(projectDir, editorPluginSlug, inventory) {
+    const editorPluginDir = path.join(projectDir, "src", "editor-plugins", editorPluginSlug);
+    if (fs.existsSync(editorPluginDir)) {
+        throw new Error(`An editor plugin already exists at ${path.relative(projectDir, editorPluginDir)}. Choose a different name.`);
+    }
+    if (inventory.editorPlugins.some((entry) => entry.slug === editorPluginSlug)) {
+        throw new Error(`An editor plugin inventory entry already exists for ${editorPluginSlug}. Choose a different name.`);
+    }
+}
 /**
  * Returns help text for the canonical `wp-typia add` subcommands.
  */
 export function formatAddHelpText() {
     return `Usage:
-  wp-typia add block <name> --template <${ADD_BLOCK_TEMPLATE_IDS.join("|")}> [--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 hooked-block <block-slug> --anchor <anchor-block-name> --position <${HOOKED_BLOCK_POSITION_IDS.join("|")}>
+  wp-typia add block <name> --template <${ADD_BLOCK_TEMPLATE_IDS.join("|")}> [--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>] [--dry-run]
+  wp-typia add variation <name> --block <block-slug> [--dry-run]
+  wp-typia add pattern <name> [--dry-run]
+  wp-typia add binding-source <name> [--dry-run]
+  wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]
+  wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <${HOOKED_BLOCK_POSITION_IDS.join("|")}> [--dry-run]
+  wp-typia add editor-plugin <name> [--slot <${EDITOR_PLUGIN_SLOT_IDS.join("|")}>] [--dry-run]
 
 Notes:
-  \`wp-typia add\` runs only inside official ${WORKSPACE_TEMPLATE_PACKAGE} workspaces.
+  \`wp-typia add\` runs only inside official ${WORKSPACE_TEMPLATE_PACKAGE} workspaces scaffolded via \`wp-typia create <project-dir> --template workspace\`.
+  Pass \`--dry-run\` to preview the workspace files that would change without writing them.
+  \`query-loop\` is a create-time scaffold family. Use \`wp-typia create <project-dir> --template query-loop\` instead of \`wp-typia add block\`.
   \`add variation\` targets an existing block slug 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 hooked-block\` patches an existing workspace block's \`block.json\` \`blockHooks\` metadata.`;
+  \`add rest-resource\` scaffolds plugin-level TypeScript REST contracts under \`src/rest/\` and PHP route glue under \`inc/rest/\`.
+  \`add hooked-block\` patches an existing workspace block's \`block.json\` \`blockHooks\` metadata.
+  \`add editor-plugin\` scaffolds a document-level editor extension under \`src/editor-plugins/\`.`;
 }

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

@@ -1,4 +1,24 @@
-import { type RunAddBindingSourceCommandOptions, type RunAddPatternCommandOptions } from "./cli-add-shared.js";
+import { type RunAddBindingSourceCommandOptions, type RunAddEditorPluginCommandOptions, type RunAddPatternCommandOptions } from "./cli-add-shared.js";
+/**
+ * Add one document-level editor plugin scaffold to an official workspace project.
+ *
+ * @param options Command options for the editor-plugin scaffold workflow.
+ * @param options.cwd Working directory used to resolve the nearest official workspace.
+ * Defaults to `process.cwd()`.
+ * @param options.editorPluginName Human-entered editor-plugin name that will be
+ * normalized and validated before files are written.
+ * @param options.slot Optional editor plugin shell slot. Defaults to `PluginSidebar`.
+ * @returns A promise that resolves with the normalized `editorPluginSlug`, chosen
+ * `slot`, and owning `projectDir` after the scaffold files and inventory entry
+ * are written successfully.
+ * @throws {Error} When the command is run outside an official workspace, when the
+ * slug or slot is invalid, or when a conflicting file or inventory entry exists.
+ */
+export declare function runAddEditorPluginCommand({ cwd, editorPluginName, slot, }: RunAddEditorPluginCommandOptions): Promise<{
+    editorPluginSlug: string;
+    projectDir: string;
+    slot: string;
+}>;
 /**
  * Add one PHP block pattern shell to an official workspace project.
  *