wp-typia 0.22.7 → 0.22.9

package/dist-bunli/node-cli.js

@@ -3,7 +3,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // package.json
 var package_default = {
   name: "wp-typia",
-  version: "0.22.7",
+  version: "0.22.9",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -73,7 +73,7 @@ var package_default = {
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/project-tools": "0.22.7",
+    "@wp-typia/project-tools": "0.22.9",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -97,8 +97,8 @@ var package_default = {
 
 // src/node-cli.ts
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES8,
-  createCliCommandError as createCliCommandError3,
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES12,
+  createCliCommandError as createCliCommandError5,
   formatCliDiagnosticError,
   serializeCliDiagnosticError as serializeCliDiagnosticError2
 } from "@wp-typia/project-tools/cli-diagnostics";
@@ -754,693 +754,14 @@ import {
   listTemplates
 } from "@wp-typia/project-tools/cli-templates";
 
-// src/add-kind-registry.ts
-import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES4,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError3
-} from "@wp-typia/project-tools/cli-diagnostics";
-
-// src/add-kind-ids.ts
-import { ADD_KIND_IDS } from "@wp-typia/project-tools/cli-add-kind-ids";
-
-// src/cli-string-flags.ts
-import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES3,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError2
-} from "@wp-typia/project-tools/cli-diagnostics";
-function readOptionalCliStringFlagValue(flags, name, mode) {
-  const value = flags[name];
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value !== "string") {
-    throw createCliDiagnosticCodeError2(CLI_DIAGNOSTIC_CODES3.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    if (mode === "strict") {
-      throw createCliDiagnosticCodeError2(CLI_DIAGNOSTIC_CODES3.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-    }
-    return;
-  }
-  return mode === "strict" ? value : trimmed;
-}
-function readOptionalLooseStringFlag(flags, name) {
-  return readOptionalCliStringFlagValue(flags, name, "loose");
-}
-function readOptionalStrictStringFlag(flags, name) {
-  return readOptionalCliStringFlagValue(flags, name, "strict");
-}
-function requireStrictStringFlag(flags, name, message) {
-  const value = readOptionalStrictStringFlag(flags, name);
-  if (!value) {
-    throw createCliDiagnosticCodeError2(CLI_DIAGNOSTIC_CODES3.MISSING_ARGUMENT, message);
-  }
-  return value;
-}
-function readOptionalPairedStrictStringFlags(flags, leftName, rightName, message) {
-  const leftValue = readOptionalStrictStringFlag(flags, leftName);
-  const rightValue = readOptionalStrictStringFlag(flags, rightName);
-  if (Boolean(leftValue) !== Boolean(rightValue)) {
-    throw createCliDiagnosticCodeError2(CLI_DIAGNOSTIC_CODES3.MISSING_ARGUMENT, message);
-  }
-  return [leftValue, rightValue];
-}
-
-// src/external-layer-prompt-options.ts
-function formatExternalLayerSelectHint(option) {
-  const details = [
-    option.description,
-    option.extends.length > 0 ? `extends ${option.extends.join(", ")}` : undefined
-  ].filter((value) => typeof value === "string" && value.length > 0);
-  return details.length > 0 ? details.join(" · ") : undefined;
-}
-function toExternalLayerPromptOptions(options) {
-  return options.map((option) => ({
-    hint: formatExternalLayerSelectHint(option),
-    label: option.id,
-    value: option.id
-  }));
-}
-
-// src/add-kind-registry.ts
-var BLOCK_VISIBLE_FIELD_ORDER = [
-  "kind",
-  "name",
-  "template",
-  "alternate-render-targets",
-  "inner-blocks-preset",
-  "data-storage",
-  "persistence-policy"
-];
-var NAME_ONLY_VISIBLE_FIELDS = [
-  "kind",
-  "name"
-];
-var NAME_SOURCE_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "source"
-];
-var NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "block",
-  "attribute"
-];
-var NAME_BLOCK_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "block"
-];
-var NAME_SLOT_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "slot"
-];
-var NAME_ANCHOR_POSITION_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "anchor",
-  "position"
-];
-var NAME_FROM_TO_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "from",
-  "to"
-];
-var NAME_NAMESPACE_METHODS_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "namespace",
-  "methods"
-];
-var NAME_NAMESPACE_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "namespace"
-];
-function requireAddKindName(context, message) {
-  if (!context.name) {
-    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, message);
-  }
-  return context.name;
-}
-function defineAddKindRegistryEntry(entry) {
-  return entry;
-}
-function createNamedExecutionPlan(context, options) {
-  const name = options.name ?? requireAddKindName(context, options.missingNameMessage);
-  return {
-    execute: (cwd) => options.execute({ cwd, name }),
-    getValues: options.getValues,
-    ...options.getWarnings ? { getWarnings: options.getWarnings } : {},
-    ...options.warnLine ? { warnLine: options.warnLine } : {}
-  };
-}
-function isAddPersistenceTemplate(template) {
-  return template === "persistence" || template === "compound";
-}
-function formatAddBlockTemplateIds(addRuntime) {
-  return addRuntime.ADD_BLOCK_TEMPLATE_IDS.join(", ");
-}
-function assertAddBlockTemplateId(context, templateId) {
-  if (context.addRuntime.isAddBlockTemplateId(templateId)) {
-    return templateId;
-  }
-  if (templateId === "query-loop") {
-    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.INVALID_ARGUMENT, "`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.");
-  }
-  throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.UNKNOWN_TEMPLATE, `Unknown add-block template "${templateId}". Expected one of: ${formatAddBlockTemplateIds(context.addRuntime)}. Run \`wp-typia templates list\` to inspect available templates.`);
-}
-var ADD_KIND_REGISTRY = {
-  "admin-view": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/admin-views/${values.adminViewSlug}/ and inc/admin-views/${values.adminViewSlug}.php.`,
-        "Run your workspace build or dev command to verify the generated DataViews admin screen."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Admin view: ${values.adminViewSlug}`,
-        ...values.source ? [`Source: ${values.source}`] : [],
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added DataViews admin screen"
-    },
-    description: "Add an opt-in DataViews-powered admin screen",
-    nameLabel: "Admin view name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
-      const source = readOptionalStrictStringFlag(context.flags, "source");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAdminViewCommand({
-          adminViewName: name2,
-          cwd,
-          source
-        }),
-        getValues: (result) => ({
-          adminViewSlug: result.adminViewSlug,
-          ...result.source ? { source: result.source } : {}
-        }),
-        missingNameMessage: "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].",
-        name
-      });
-    },
-    sortOrder: 10,
-    supportsDryRun: true,
-    usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
-    visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
-  }),
-  "binding-source": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/bindings/${values.bindingSourceSlug}/server.php and src/bindings/${values.bindingSourceSlug}/editor.ts.`,
-        ...values.blockSlug && values.attributeName ? [
-          `Review src/blocks/${values.blockSlug}/block.json for the ${values.attributeName} bindable attribute.`
-        ] : [],
-        "Run your workspace build or dev command to verify the binding source hooks and editor registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Binding source: ${values.bindingSourceSlug}`,
-        ...values.blockSlug && values.attributeName ? [`Target: ${values.blockSlug}.${values.attributeName}`] : [],
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added binding source"
-    },
-    description: "Add a shared block bindings source",
-    nameLabel: "Binding source name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
-      const [blockName, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
-          attributeName,
-          bindingSourceName: name2,
-          blockName,
-          cwd
-        }),
-        getValues: (result) => ({
-          ...result.attributeName ? { attributeName: result.attributeName } : {},
-          ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
-          bindingSourceSlug: result.bindingSourceSlug
-        }),
-        missingNameMessage: "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].",
-        name
-      });
-    },
-    sortOrder: 70,
-    supportsDryRun: true,
-    usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
-  }),
-  block: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: () => [
-        "Review the generated sources under src/blocks/ and the updated scripts/block-config.ts entry.",
-        "Run your workspace build or dev command to verify the new scaffolded block family."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Blocks: ${values.blockSlugs}`,
-        `Template family: ${values.templateId}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace block"
-    },
-    description: "Add a real block slice",
-    hiddenStringSubmitFields: ["external-layer-id", "external-layer-source"],
-    nameLabel: "Block name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]");
-      const externalLayerId = readOptionalStrictStringFlag(context.flags, "external-layer-id");
-      const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
-      const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
-      const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
-      const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
-      const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
-      const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
-      const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
-      const requestedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
-      let resolvedTemplateId = requestedTemplateId ? assertAddBlockTemplateId(context, requestedTemplateId) : undefined;
-      if (!resolvedTemplateId && context.isInteractiveSession) {
-        const templatePrompt = await context.getOrCreatePrompt();
-        resolvedTemplateId = await templatePrompt.select("Select a block template", context.addRuntime.ADD_BLOCK_TEMPLATE_IDS.map((templateId) => ({
-          hint: `Scaffold the ${templateId} block family`,
-          label: templateId,
-          value: templateId
-        })), 1);
-      }
-      resolvedTemplateId ??= "basic";
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockCommand({
-          alternateRenderTargets,
-          blockName: name2,
-          cwd,
-          dataStorageMode,
-          externalLayerId,
-          externalLayerSource,
-          innerBlocksPreset,
-          persistencePolicy,
-          selectExternalLayerId: selectPrompt ? (options) => selectPrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
-          templateId: resolvedTemplateId
-        }),
-        getValues: (result) => ({
-          blockSlugs: result.blockSlugs.join(", "),
-          templateId: result.templateId
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]",
-        name,
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 20,
-    supportsDryRun: true,
-    usage: "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>] [--dry-run]",
-    visibleFieldNames: ({ template }) => BLOCK_VISIBLE_FIELD_ORDER.filter((fieldName) => {
-      if (fieldName === "alternate-render-targets") {
-        return isAddPersistenceTemplate(template);
-      }
-      if (fieldName === "inner-blocks-preset") {
-        return template === "compound";
-      }
-      if (fieldName === "data-storage" || fieldName === "persistence-policy") {
-        return isAddPersistenceTemplate(template);
-      }
-      return true;
-    })
-  }),
-  ability: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
-        "Run `wp-typia sync` or `npm run sync-abilities -- --check` and then your workspace build/dev command to verify the generated workflow ability."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Ability: ${values.abilitySlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workflow ability"
-    },
-    description: "Add a typed server/client workflow ability scaffold",
-    nameLabel: "Ability name",
-    async prepareExecution(context) {
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name }) => context.addRuntime.runAddAbilityCommand({
-          abilityName: name,
-          cwd
-        }),
-        getValues: (result) => ({
-          abilitySlug: result.abilitySlug
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.",
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 90,
-    supportsDryRun: true,
-    usage: "wp-typia add ability <name> [--dry-run]",
-    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
-  }),
-  "editor-plugin": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/editor-plugins/${values.editorPluginSlug}/.`,
-        "Run your workspace build or dev command to verify the new editor plugin registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Editor plugin: ${values.editorPluginSlug}`,
-        `Slot: ${values.slot}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added editor plugin"
-    },
-    description: "Add a slot-aware document editor extension shell",
-    nameLabel: "Editor plugin name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
-      const slot = readOptionalStrictStringFlag(context.flags, "slot");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddEditorPluginCommand({
-          cwd,
-          editorPluginName: name2,
-          slot
-        }),
-        getValues: (result) => ({
-          editorPluginSlug: result.editorPluginSlug,
-          slot: result.slot
-        }),
-        missingNameMessage: "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].",
-        name
-      });
-    },
-    sortOrder: 120,
-    supportsDryRun: true,
-    usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
-    visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
-  }),
-  "hooked-block": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/block.json for the new blockHooks entry.`,
-        "Run your workspace build or dev command to verify the updated hooked-block metadata."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Block: ${values.blockSlug}`,
-        `Anchor: ${values.anchorBlockName}`,
-        `Position: ${values.position}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added blockHooks metadata"
-    },
-    description: "Add block.json hook metadata to an existing block",
-    nameLabel: "Target block",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
-      const anchorBlockName = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-      const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddHookedBlockCommand({
-          anchorBlockName,
-          blockName: name2,
-          cwd,
-          position
-        }),
-        getValues: (result) => ({
-          anchorBlockName: result.anchorBlockName,
-          blockSlug: result.blockSlug,
-          position: result.position
-        }),
-        missingNameMessage: "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.",
-        name
-      });
-    },
-    sortOrder: 110,
-    supportsDryRun: true,
-    usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
-    visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
-  }),
-  pattern: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/patterns/${values.patternSlug}.php.`,
-        "Run your workspace build or dev command to verify the new pattern registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Pattern: ${values.patternSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace pattern"
-    },
-    description: "Add a PHP block pattern shell",
-    nameLabel: "Pattern name",
-    async prepareExecution(context) {
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name }) => context.addRuntime.runAddPatternCommand({
-          cwd,
-          patternName: name
-        }),
-        getValues: (result) => ({
-          patternSlug: result.patternSlug
-        }),
-        missingNameMessage: "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>."
-      });
-    },
-    sortOrder: 60,
-    supportsDryRun: true,
-    usage: "wp-typia add pattern <name> [--dry-run]",
-    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
-  }),
-  style: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/styles/${values.styleSlug}.ts.`,
-        "Run your workspace build or dev command to verify the new block style registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Block style: ${values.styleSlug}`,
-        `Target block: ${values.blockSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added block style"
-    },
-    description: "Add a Block Styles registration to an existing block",
-    nameLabel: "Style name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
-      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockStyleCommand({
-          blockName: blockSlug,
-          cwd,
-          styleName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          styleSlug: result.styleSlug
-        }),
-        missingNameMessage: "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.",
-        name
-      });
-    },
-    sortOrder: 40,
-    supportsDryRun: true,
-    usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
-  }),
-  transform: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/transforms/${values.transformSlug}.ts.`,
-        "Run your workspace build or dev command to verify the new block transform registration."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Block transform: ${values.transformSlug}`,
-        `From: ${values.fromBlockName}`,
-        `To: ${values.toBlockName}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added block transform"
-    },
-    description: "Add a block-to-block transform into a workspace block",
-    nameLabel: "Transform name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
-      const fromBlockName = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
-      const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockTransformCommand({
-          cwd,
-          fromBlockName,
-          toBlockName,
-          transformName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          fromBlockName: result.fromBlockName,
-          toBlockName: result.toBlockName,
-          transformSlug: result.transformSlug
-        }),
-        missingNameMessage: "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.",
-        name
-      });
-    },
-    sortOrder: 50,
-    supportsDryRun: true,
-    usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
-  }),
-  "rest-resource": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/rest/${values.restResourceSlug}/ and inc/rest/${values.restResourceSlug}.php.`,
-        "Run your workspace build or dev command to verify the generated REST resource contract."
-      ],
-      summaryLines: (values, projectDir) => [
-        `REST resource: ${values.restResourceSlug}`,
-        `Namespace: ${values.namespace}`,
-        `Methods: ${values.methods}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added plugin-level REST resource"
-    },
-    description: "Add a plugin-level typed REST resource",
-    nameLabel: "REST resource name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
-      const methods = readOptionalStrictStringFlag(context.flags, "methods");
-      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
-          cwd,
-          methods,
-          namespace,
-          restResourceName: name2
-        }),
-        getValues: (result) => ({
-          methods: result.methods.join(", "),
-          namespace: result.namespace,
-          restResourceSlug: result.restResourceSlug
-        }),
-        missingNameMessage: "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].",
-        name
-      });
-    },
-    sortOrder: 80,
-    supportsDryRun: true,
-    usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
-    visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
-  }),
-  "ai-feature": defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/ai-features/${values.aiFeatureSlug}/ and inc/ai-features/${values.aiFeatureSlug}.php.`,
-        "Run `wp-typia sync-rest` and `wp-typia sync ai` or your workspace build/dev command to verify the generated REST artifacts and AI schema."
-      ],
-      summaryLines: (values, projectDir) => [
-        `AI feature: ${values.aiFeatureSlug}`,
-        `Namespace: ${values.namespace}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added server-only AI feature"
-    },
-    description: "Add a server-owned WordPress AI feature endpoint",
-    nameLabel: "AI feature name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
-      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAiFeatureCommand({
-          aiFeatureName: name2,
-          cwd,
-          namespace
-        }),
-        getValues: (result) => ({
-          aiFeatureSlug: result.aiFeatureSlug,
-          namespace: result.namespace
-        }),
-        getWarnings: (result) => result.warnings,
-        missingNameMessage: "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].",
-        name,
-        warnLine: context.warnLine
-      });
-    },
-    sortOrder: 100,
-    supportsDryRun: true,
-    usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
-    visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
-  }),
-  variation: defineAddKindRegistryEntry({
-    completion: {
-      nextSteps: (values) => [
-        `Review src/blocks/${values.blockSlug}/variations/${values.variationSlug}.ts.`,
-        "Run your workspace build or dev command to pick up the new variation."
-      ],
-      summaryLines: (values, projectDir) => [
-        `Variation: ${values.variationSlug}`,
-        `Target block: ${values.blockSlug}`,
-        `Project directory: ${projectDir}`
-      ],
-      title: "Added workspace variation"
-    },
-    description: "Add a variation to an existing block",
-    nameLabel: "Variation name",
-    async prepareExecution(context) {
-      const name = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
-      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
-      return createNamedExecutionPlan(context, {
-        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddVariationCommand({
-          blockName: blockSlug,
-          cwd,
-          variationName: name2
-        }),
-        getValues: (result) => ({
-          blockSlug: result.blockSlug,
-          variationSlug: result.variationSlug
-        }),
-        missingNameMessage: "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
-        name
-      });
-    },
-    sortOrder: 30,
-    supportsDryRun: true,
-    usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
-  })
-};
-function isAddKindId(value) {
-  return typeof value === "string" && ADD_KIND_IDS.includes(value);
-}
-async function getAddKindExecutionPlan(kind, context) {
-  return ADD_KIND_REGISTRY[kind].prepareExecution(context);
-}
-function buildAddKindCompletionDetails(kind, options) {
-  const descriptor = ADD_KIND_REGISTRY[kind].completion;
-  return {
-    nextSteps: descriptor.nextSteps(options.values),
-    summaryLines: descriptor.summaryLines(options.values, options.projectDir),
-    title: descriptor.title
-  };
-}
-function formatAddKindList() {
-  return ADD_KIND_IDS.join(", ");
-}
-function formatAddKindUsagePlaceholder() {
-  return `<${ADD_KIND_IDS.join("|")}>`;
-}
-function supportsAddKindDryRun(kind) {
-  return ADD_KIND_REGISTRY[kind].supportsDryRun;
-}
-
 // src/config.ts
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { isPlainObject as isRecord } from "@wp-typia/api-client/runtime-primitives";
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES5,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError4
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES3,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError2
 } from "@wp-typia/project-tools/cli-diagnostics";
 import { z as z2 } from "zod";
 var WP_TYPIA_CONFIG_SOURCES = [
@@ -1514,7 +835,7 @@ function validateWpTypiaUserConfig(value, source) {
     return result.data;
   }
   const issueLines = result.error.issues.map(formatConfigValidationIssue);
-  throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.INVALID_ARGUMENT, [
+  throw createCliDiagnosticCodeError2(CLI_DIAGNOSTIC_CODES3.INVALID_ARGUMENT, [
     `Invalid wp-typia config at ${source}.`,
     ...issueLines.map((line) => `- ${line}`)
   ].join(`
@@ -1549,7 +870,7 @@ async function readJsonFile(filePath) {
     return JSON.parse(source);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.INVALID_ARGUMENT, `Unable to parse ${filePath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
+    throw createCliDiagnosticCodeError2(CLI_DIAGNOSTIC_CODES3.INVALID_ARGUMENT, `Unable to parse ${filePath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
   }
 }
 async function readWpTypiaConfigFile(filePath) {
@@ -1606,12 +927,759 @@ function extractWpTypiaConfigOverride(argv) {
   };
 }
 
-// src/runtime-bridge.ts
-import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES7,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError6
-} from "@wp-typia/project-tools/cli-diagnostics";
-
+// src/runtime-bridge.ts
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES8,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError7
+} from "@wp-typia/project-tools/cli-diagnostics";
+
+// src/add-kind-ids.ts
+import { ADD_KIND_IDS } from "@wp-typia/project-tools/cli-add-kind-ids";
+
+// src/add-kind-registry-shared.ts
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES4,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError3
+} from "@wp-typia/project-tools/cli-diagnostics";
+var BLOCK_VISIBLE_FIELD_ORDER = [
+  "kind",
+  "name",
+  "template",
+  "alternate-render-targets",
+  "inner-blocks-preset",
+  "data-storage",
+  "persistence-policy"
+];
+var NAME_ONLY_VISIBLE_FIELDS = [
+  "kind",
+  "name"
+];
+var NAME_SOURCE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "source"
+];
+var NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "block",
+  "attribute"
+];
+var NAME_BLOCK_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "block"
+];
+var NAME_SLOT_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "slot"
+];
+var NAME_ANCHOR_POSITION_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "anchor",
+  "position"
+];
+var NAME_FROM_TO_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "from",
+  "to"
+];
+var NAME_NAMESPACE_METHODS_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "namespace",
+  "methods"
+];
+var NAME_NAMESPACE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "namespace"
+];
+function requireAddKindName(context, message) {
+  if (!context.name) {
+    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, message);
+  }
+  return context.name;
+}
+function defineAddKindRegistryEntry(entry) {
+  return entry;
+}
+function createNamedExecutionPlan(context, options) {
+  const name = options.name ?? requireAddKindName(context, options.missingNameMessage);
+  return {
+    execute: (cwd) => options.execute({ cwd, name }),
+    getValues: options.getValues,
+    ...options.getWarnings ? { getWarnings: options.getWarnings } : {},
+    ...options.warnLine ? { warnLine: options.warnLine } : {}
+  };
+}
+function isAddPersistenceTemplate(template) {
+  return template === "persistence" || template === "compound";
+}
+function formatAddBlockTemplateIds(addRuntime) {
+  return addRuntime.ADD_BLOCK_TEMPLATE_IDS.join(", ");
+}
+function getMistypedAddBlockTemplateMessage(addRuntime, templateId) {
+  const suggestion = addRuntime.suggestAddBlockTemplateId(templateId);
+  if (!suggestion) {
+    return null;
+  }
+  return `Unknown add-block template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\`, or run \`wp-typia templates list\` to inspect available templates.`;
+}
+function assertAddBlockTemplateId(context, templateId) {
+  if (templateId === "query-loop") {
+    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.INVALID_ARGUMENT, "`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 (context.addRuntime.isAddBlockTemplateId(templateId)) {
+    return templateId;
+  }
+  const mistypedAddBlockTemplateMessage = getMistypedAddBlockTemplateMessage(context.addRuntime, templateId);
+  if (mistypedAddBlockTemplateMessage) {
+    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.UNKNOWN_TEMPLATE, mistypedAddBlockTemplateMessage);
+  }
+  throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES4.UNKNOWN_TEMPLATE, `Unknown add-block template "${templateId}". Expected one of: ${formatAddBlockTemplateIds(context.addRuntime)}. Run \`wp-typia templates list\` to inspect available templates.`);
+}
+
+// src/add-kinds/ability.ts
+var abilityAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
+      "Run `wp-typia sync` or `npm run sync-abilities -- --check` and then your workspace build/dev command to verify the generated workflow ability."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Ability: ${values.abilitySlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workflow ability"
+  },
+  description: "Add a typed server/client workflow ability scaffold",
+  nameLabel: "Ability name",
+  async prepareExecution(context) {
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name }) => context.addRuntime.runAddAbilityCommand({
+        abilityName: name,
+        cwd
+      }),
+      getValues: (result) => ({
+        abilitySlug: result.abilitySlug
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.",
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 90,
+  supportsDryRun: true,
+  usage: "wp-typia add ability <name> [--dry-run]",
+  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
+});
+
+// src/cli-string-flags.ts
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES5,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError4
+} from "@wp-typia/project-tools/cli-diagnostics";
+function readOptionalCliStringFlagValue(flags, name, mode) {
+  const value = flags[name];
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    if (mode === "strict") {
+      throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+    }
+    return;
+  }
+  return mode === "strict" ? value : trimmed;
+}
+function readOptionalLooseStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "loose");
+}
+function readOptionalStrictStringFlag(flags, name) {
+  return readOptionalCliStringFlagValue(flags, name, "strict");
+}
+function requireStrictStringFlag(flags, name, message) {
+  const value = readOptionalStrictStringFlag(flags, name);
+  if (!value) {
+    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, message);
+  }
+  return value;
+}
+function readOptionalPairedStrictStringFlags(flags, leftName, rightName, message) {
+  const leftValue = readOptionalStrictStringFlag(flags, leftName);
+  const rightValue = readOptionalStrictStringFlag(flags, rightName);
+  if (Boolean(leftValue) !== Boolean(rightValue)) {
+    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, message);
+  }
+  return [leftValue, rightValue];
+}
+
+// src/add-kinds/admin-view.ts
+var adminViewAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/admin-views/${values.adminViewSlug}/ and inc/admin-views/${values.adminViewSlug}.php.`,
+      "Run your workspace build or dev command to verify the generated DataViews admin screen."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Admin view: ${values.adminViewSlug}`,
+      ...values.source ? [`Source: ${values.source}`] : [],
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added DataViews admin screen"
+  },
+  description: "Add an opt-in DataViews-powered admin screen",
+  nameLabel: "Admin view name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
+    const source = readOptionalStrictStringFlag(context.flags, "source");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAdminViewCommand({
+        adminViewName: name2,
+        cwd,
+        source
+      }),
+      getValues: (result) => ({
+        adminViewSlug: result.adminViewSlug,
+        ...result.source ? { source: result.source } : {}
+      }),
+      missingNameMessage: "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].",
+      name
+    });
+  },
+  sortOrder: 10,
+  supportsDryRun: true,
+  usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
+  visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
+});
+
+// src/add-kinds/ai-feature.ts
+var aiFeatureAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/ai-features/${values.aiFeatureSlug}/ and inc/ai-features/${values.aiFeatureSlug}.php.`,
+      "Run `wp-typia sync-rest` and `wp-typia sync ai` or your workspace build/dev command to verify the generated REST artifacts and AI schema."
+    ],
+    summaryLines: (values, projectDir) => [
+      `AI feature: ${values.aiFeatureSlug}`,
+      `Namespace: ${values.namespace}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added server-only AI feature"
+  },
+  description: "Add a server-owned WordPress AI feature endpoint",
+  nameLabel: "AI feature name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
+    const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAiFeatureCommand({
+        aiFeatureName: name2,
+        cwd,
+        namespace
+      }),
+      getValues: (result) => ({
+        aiFeatureSlug: result.aiFeatureSlug,
+        namespace: result.namespace
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].",
+      name,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 100,
+  supportsDryRun: true,
+  usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
+  visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
+});
+
+// src/add-kinds/binding-source.ts
+var bindingSourceAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/bindings/${values.bindingSourceSlug}/server.php and src/bindings/${values.bindingSourceSlug}/editor.ts.`,
+      ...values.blockSlug && values.attributeName ? [
+        `Review src/blocks/${values.blockSlug}/block.json for the ${values.attributeName} bindable attribute.`
+      ] : [],
+      "Run your workspace build or dev command to verify the binding source hooks and editor registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Binding source: ${values.bindingSourceSlug}`,
+      ...values.blockSlug && values.attributeName ? [`Target: ${values.blockSlug}.${values.attributeName}`] : [],
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added binding source"
+  },
+  description: "Add a shared block bindings source",
+  nameLabel: "Binding source name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
+    const [blockName, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
+        attributeName,
+        bindingSourceName: name2,
+        blockName,
+        cwd
+      }),
+      getValues: (result) => ({
+        ...result.attributeName ? { attributeName: result.attributeName } : {},
+        ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
+        bindingSourceSlug: result.bindingSourceSlug
+      }),
+      missingNameMessage: "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].",
+      name
+    });
+  },
+  sortOrder: 70,
+  supportsDryRun: true,
+  usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
+});
+
+// src/external-layer-prompt-options.ts
+function formatExternalLayerSelectHint(option) {
+  const details = [
+    option.description,
+    option.extends.length > 0 ? `extends ${option.extends.join(", ")}` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return details.length > 0 ? details.join(" · ") : undefined;
+}
+function toExternalLayerPromptOptions(options) {
+  return options.map((option) => ({
+    hint: formatExternalLayerSelectHint(option),
+    label: option.id,
+    value: option.id
+  }));
+}
+
+// src/add-kinds/block.ts
+var blockAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: () => [
+      "Review the generated sources under src/blocks/ and the updated scripts/block-config.ts entry.",
+      "Run your workspace build or dev command to verify the new scaffolded block family."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Blocks: ${values.blockSlugs}`,
+      `Template family: ${values.templateId}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace block"
+  },
+  description: "Add a real block slice",
+  hiddenStringSubmitFields: ["external-layer-id", "external-layer-source"],
+  nameLabel: "Block name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]");
+    const externalLayerId = readOptionalStrictStringFlag(context.flags, "external-layer-id");
+    const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
+    const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
+    const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
+    const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
+    const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
+    const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
+    const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
+    const requestedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
+    let resolvedTemplateId = requestedTemplateId ? assertAddBlockTemplateId(context, requestedTemplateId) : undefined;
+    if (!resolvedTemplateId && context.isInteractiveSession) {
+      const templatePrompt = await context.getOrCreatePrompt();
+      resolvedTemplateId = await templatePrompt.select("Select a block template", context.addRuntime.ADD_BLOCK_TEMPLATE_IDS.map((templateId) => ({
+        hint: `Scaffold the ${templateId} block family`,
+        label: templateId,
+        value: templateId
+      })), 1);
+    }
+    resolvedTemplateId ??= "basic";
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockCommand({
+        alternateRenderTargets,
+        blockName: name2,
+        cwd,
+        dataStorageMode,
+        externalLayerId,
+        externalLayerSource,
+        innerBlocksPreset,
+        persistencePolicy,
+        selectExternalLayerId: selectPrompt ? (options) => selectPrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
+        templateId: resolvedTemplateId
+      }),
+      getValues: (result) => ({
+        blockSlugs: result.blockSlugs.join(", "),
+        templateId: result.templateId
+      }),
+      getWarnings: (result) => result.warnings,
+      missingNameMessage: "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]",
+      name,
+      warnLine: context.warnLine
+    });
+  },
+  sortOrder: 20,
+  supportsDryRun: true,
+  usage: "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>] [--dry-run]",
+  visibleFieldNames: ({ template }) => BLOCK_VISIBLE_FIELD_ORDER.filter((fieldName) => {
+    if (fieldName === "alternate-render-targets") {
+      return isAddPersistenceTemplate(template);
+    }
+    if (fieldName === "inner-blocks-preset") {
+      return template === "compound";
+    }
+    if (fieldName === "data-storage" || fieldName === "persistence-policy") {
+      return isAddPersistenceTemplate(template);
+    }
+    return true;
+  })
+});
+
+// src/add-kinds/editor-plugin.ts
+var editorPluginAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/editor-plugins/${values.editorPluginSlug}/.`,
+      "Run your workspace build or dev command to verify the new editor plugin registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Editor plugin: ${values.editorPluginSlug}`,
+      `Slot: ${values.slot}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added editor plugin"
+  },
+  description: "Add a slot-aware document editor extension shell",
+  nameLabel: "Editor plugin name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
+    const slot = readOptionalStrictStringFlag(context.flags, "slot");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddEditorPluginCommand({
+        cwd,
+        editorPluginName: name2,
+        slot
+      }),
+      getValues: (result) => ({
+        editorPluginSlug: result.editorPluginSlug,
+        slot: result.slot
+      }),
+      missingNameMessage: "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].",
+      name
+    });
+  },
+  sortOrder: 120,
+  supportsDryRun: true,
+  usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
+  visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
+});
+
+// src/add-kinds/hooked-block.ts
+var hookedBlockAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/block.json for the new blockHooks entry.`,
+      "Run your workspace build or dev command to verify the updated hooked-block metadata."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Block: ${values.blockSlug}`,
+      `Anchor: ${values.anchorBlockName}`,
+      `Position: ${values.position}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added blockHooks metadata"
+  },
+  description: "Add block.json hook metadata to an existing block",
+  nameLabel: "Target block",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
+    const anchorBlockName = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+    const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddHookedBlockCommand({
+        anchorBlockName,
+        blockName: name2,
+        cwd,
+        position
+      }),
+      getValues: (result) => ({
+        anchorBlockName: result.anchorBlockName,
+        blockSlug: result.blockSlug,
+        position: result.position
+      }),
+      missingNameMessage: "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.",
+      name
+    });
+  },
+  sortOrder: 110,
+  supportsDryRun: true,
+  usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
+  visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
+});
+
+// src/add-kinds/pattern.ts
+var patternAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/patterns/${values.patternSlug}.php.`,
+      "Run your workspace build or dev command to verify the new pattern registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Pattern: ${values.patternSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace pattern"
+  },
+  description: "Add a PHP block pattern shell",
+  nameLabel: "Pattern name",
+  async prepareExecution(context) {
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name }) => context.addRuntime.runAddPatternCommand({
+        cwd,
+        patternName: name
+      }),
+      getValues: (result) => ({
+        patternSlug: result.patternSlug
+      }),
+      missingNameMessage: "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>."
+    });
+  },
+  sortOrder: 60,
+  supportsDryRun: true,
+  usage: "wp-typia add pattern <name> [--dry-run]",
+  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
+});
+
+// src/add-kinds/rest-resource.ts
+var restResourceAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/rest/${values.restResourceSlug}/ and inc/rest/${values.restResourceSlug}.php.`,
+      "Run your workspace build or dev command to verify the generated REST resource contract."
+    ],
+    summaryLines: (values, projectDir) => [
+      `REST resource: ${values.restResourceSlug}`,
+      `Namespace: ${values.namespace}`,
+      `Methods: ${values.methods}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added plugin-level REST resource"
+  },
+  description: "Add a plugin-level typed REST resource",
+  nameLabel: "REST resource name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>].");
+    const methods = readOptionalStrictStringFlag(context.flags, "methods");
+    const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
+        cwd,
+        methods,
+        namespace,
+        restResourceName: name2
+      }),
+      getValues: (result) => ({
+        methods: result.methods.join(", "),
+        namespace: result.namespace,
+        restResourceSlug: result.restResourceSlug
+      }),
+      missingNameMessage: "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>].",
+      name
+    });
+  },
+  sortOrder: 80,
+  supportsDryRun: true,
+  usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
+  visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
+});
+
+// src/add-kinds/style.ts
+var styleAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/styles/${values.styleSlug}.ts.`,
+      "Run your workspace build or dev command to verify the new block style registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Block style: ${values.styleSlug}`,
+      `Target block: ${values.blockSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added block style"
+  },
+  description: "Add a Block Styles registration to an existing block",
+  nameLabel: "Style name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
+    const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockStyleCommand({
+        blockName: blockSlug,
+        cwd,
+        styleName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        styleSlug: result.styleSlug
+      }),
+      missingNameMessage: "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.",
+      name
+    });
+  },
+  sortOrder: 40,
+  supportsDryRun: true,
+  usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+});
+
+// src/add-kinds/transform.ts
+var transformAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/transforms/${values.transformSlug}.ts.`,
+      "Run your workspace build or dev command to verify the new block transform registration."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Block transform: ${values.transformSlug}`,
+      `From: ${values.fromBlockName}`,
+      `To: ${values.toBlockName}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added block transform"
+  },
+  description: "Add a block-to-block transform into a workspace block",
+  nameLabel: "Transform name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
+    const fromBlockName = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
+    const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBlockTransformCommand({
+        cwd,
+        fromBlockName,
+        toBlockName,
+        transformName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        fromBlockName: result.fromBlockName,
+        toBlockName: result.toBlockName,
+        transformSlug: result.transformSlug
+      }),
+      missingNameMessage: "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.",
+      name
+    });
+  },
+  sortOrder: 50,
+  supportsDryRun: true,
+  usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
+});
+
+// src/add-kinds/variation.ts
+var variationAddKindEntry = defineAddKindRegistryEntry({
+  completion: {
+    nextSteps: (values) => [
+      `Review src/blocks/${values.blockSlug}/variations/${values.variationSlug}.ts.`,
+      "Run your workspace build or dev command to pick up the new variation."
+    ],
+    summaryLines: (values, projectDir) => [
+      `Variation: ${values.variationSlug}`,
+      `Target block: ${values.blockSlug}`,
+      `Project directory: ${projectDir}`
+    ],
+    title: "Added workspace variation"
+  },
+  description: "Add a variation to an existing block",
+  nameLabel: "Variation name",
+  async prepareExecution(context) {
+    const name = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
+    const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
+    return createNamedExecutionPlan(context, {
+      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddVariationCommand({
+        blockName: blockSlug,
+        cwd,
+        variationName: name2
+      }),
+      getValues: (result) => ({
+        blockSlug: result.blockSlug,
+        variationSlug: result.variationSlug
+      }),
+      missingNameMessage: "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
+      name
+    });
+  },
+  sortOrder: 30,
+  supportsDryRun: true,
+  usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
+  visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
+});
+
+// src/add-kind-registry.ts
+var ADD_KIND_REGISTRY = {
+  "admin-view": adminViewAddKindEntry,
+  block: blockAddKindEntry,
+  variation: variationAddKindEntry,
+  style: styleAddKindEntry,
+  transform: transformAddKindEntry,
+  pattern: patternAddKindEntry,
+  "binding-source": bindingSourceAddKindEntry,
+  "rest-resource": restResourceAddKindEntry,
+  ability: abilityAddKindEntry,
+  "ai-feature": aiFeatureAddKindEntry,
+  "hooked-block": hookedBlockAddKindEntry,
+  "editor-plugin": editorPluginAddKindEntry
+};
+function isAddKindId(value) {
+  return typeof value === "string" && ADD_KIND_IDS.includes(value);
+}
+async function getAddKindExecutionPlan(kind, context) {
+  return ADD_KIND_REGISTRY[kind].prepareExecution(context);
+}
+function buildAddKindCompletionDetails(kind, options) {
+  const descriptor = ADD_KIND_REGISTRY[kind].completion;
+  return {
+    nextSteps: descriptor.nextSteps(options.values),
+    summaryLines: descriptor.summaryLines(options.values, options.projectDir),
+    title: descriptor.title
+  };
+}
+function formatAddKindList() {
+  return ADD_KIND_IDS.join(", ");
+}
+function formatAddKindUsagePlaceholder() {
+  return `<${ADD_KIND_IDS.join("|")}>`;
+}
+function supportsAddKindDryRun(kind) {
+  return ADD_KIND_REGISTRY[kind].supportsDryRun;
+}
+
+// src/cli-error-messages.ts
+var MISSING_CREATE_PROJECT_DIR_DETAIL_LINES = [
+  "`wp-typia create` requires <project-dir>.",
+  "`--dry-run` still needs a logical project directory name because wp-typia derives slugs, package names, and planned file paths from it."
+];
+function formatMissingAddKindDetailLine() {
+  return `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`;
+}
+function buildMissingAddKindDetailLines() {
+  return [formatMissingAddKindDetailLine()];
+}
+function shouldPrintMissingAddKindHelp(options) {
+  if (typeof options.emitOutput === "boolean") {
+    return options.emitOutput;
+  }
+  return options.format !== "json";
+}
+function buildMissingCreateProjectDirDetailLines() {
+  return [...MISSING_CREATE_PROJECT_DIR_DETAIL_LINES];
+}
+
 // src/runtime-bridge-add-dry-run.ts
 import fs2 from "node:fs";
 import { promises as fsp } from "node:fs";
@@ -1741,9 +1809,15 @@ async function simulateWorkspaceAddDryRun({
 
 // src/runtime-bridge-output.ts
 import {
+  PACKAGE_MANAGER_IDS,
   formatPackageExecCommand,
-  inferPackageManagerId
+  inferPackageManagerId,
+  parsePackageManagerField
 } from "@wp-typia/project-tools/package-managers";
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES6,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError5
+} from "@wp-typia/project-tools/cli-diagnostics";
 
 // src/output-markers.ts
 var UNICODE_OUTPUT_MARKERS = {
@@ -1823,6 +1897,13 @@ function stripLeadingOutputMarker(text, kind) {
   return text.replace(new RegExp(`^(?:${markerPattern})\\s*`, "u"), "");
 }
 
+// src/print-block.ts
+function printBlock(printLine, lines) {
+  for (const line of lines) {
+    printLine(line);
+  }
+}
+
 // src/runtime-bridge-output.ts
 function printCompletionPayload(payload, options = {}) {
   const printLine = options.printLine ?? console.log;
@@ -1865,6 +1946,13 @@ function extractPlannedFiles(payload) {
   return toNonEmptyArray(files);
 }
 var PROJECT_DIRECTORY_SUMMARY_PREFIX = "Project directory: ";
+function resolveCreateCompletionPackageManager(packageManager) {
+  const parsedPackageManager = parsePackageManagerField(packageManager);
+  if (parsedPackageManager) {
+    return parsedPackageManager;
+  }
+  throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.INVALID_ARGUMENT, `Unsupported package manager "${packageManager}" in create completion payload. Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}.`);
+}
 function extractCompletionProjectDir(completion) {
   const projectDir = completion?.summaryLines?.find((line) => line.startsWith(PROJECT_DIRECTORY_SUMMARY_PREFIX))?.slice(PROJECT_DIRECTORY_SUMMARY_PREFIX.length).trim();
   return projectDir && projectDir.length > 0 ? projectDir : undefined;
@@ -1921,8 +2009,9 @@ function formatCreateProgressLine(payload, markerOptions) {
   return formatOutputMarker("progress", `${payload.title}: ${payload.detail}`, markerOptions);
 }
 function buildCreateCompletionPayload(flow, markerOptions) {
+  const packageManager = resolveCreateCompletionPackageManager(flow.packageManager);
   const verificationSteps = [
-    formatPackageExecCommand(flow.packageManager, `wp-typia@${package_default.version}`, "doctor"),
+    formatPackageExecCommand(packageManager, `wp-typia@${package_default.version}`, "doctor"),
     ...flow.optionalOnboarding.steps
   ];
   return {
@@ -2044,11 +2133,6 @@ function buildSyncDryRunPayload(options, markerOptions) {
     title: formatOutputMarker("dryRun", `Dry run for wp-typia sync${targetSuffix}`, markerOptions)
   };
 }
-function printBlock(lines, printLine) {
-  for (const line of lines) {
-    printLine(line);
-  }
-}
 
 // src/runtime-capabilities.ts
 function isInteractiveTerminal({
@@ -2063,8 +2147,8 @@ import { spawnSync } from "node:child_process";
 import fs3 from "node:fs";
 import path3 from "node:path";
 import {
-  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES6,
-  createCliDiagnosticCodeError as createCliDiagnosticCodeError5
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES7,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError6
 } from "@wp-typia/project-tools/cli-diagnostics";
 import {
   formatInstallCommand,
@@ -2085,10 +2169,10 @@ function resolveSyncExecutionTarget(subcommand) {
   if (subcommand === "ai") {
     return "ai";
   }
-  throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
+  throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
 }
 function getSyncRootError(cwd) {
-  return createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.OUTSIDE_PROJECT_ROOT, `No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root that already contains generated sync scripts. If you expected this directory to work, cd into the scaffold root first or rerun the scaffold before syncing.`);
+  return createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.OUTSIDE_PROJECT_ROOT, `No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root that already contains generated sync scripts. If you expected this directory to work, cd into the scaffold root first or rerun the scaffold before syncing.`);
 }
 function resolveSyncProjectContext(cwd) {
   const packageJsonPath = path3.join(cwd, "package.json");
@@ -2154,7 +2238,7 @@ function assertSyncDependenciesInstalled(project, target) {
   if (markerDir) {
     return;
   }
-  throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.DEPENDENCIES_NOT_INSTALLED, `Project dependencies have not been installed yet. Run \`${formatInstallCommand(project.packageManager)}\` from the project root before \`wp-typia sync\`. The generated sync scripts rely on local tools such as \`tsx\`.`);
+  throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.DEPENDENCIES_NOT_INSTALLED, `Project dependencies have not been installed yet. Run \`${formatInstallCommand(project.packageManager)}\` from the project root before \`wp-typia sync\`. The generated sync scripts rely on local tools such as \`tsx\`.`);
 }
 function getPackageManagerRunInvocation(packageManager, scriptName, extraArgs) {
   switch (packageManager) {
@@ -2192,7 +2276,7 @@ function buildSyncPlannedCommands(project, extraArgs, target) {
   if (target === "ai") {
     const syncAiCommand2 = createSyncPlannedCommand(project, "sync-ai", extraArgs);
     if (!syncAiCommand2) {
-      throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
+      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
     }
     return [syncAiCommand2];
   }
@@ -2201,7 +2285,7 @@ function buildSyncPlannedCommands(project, extraArgs, target) {
   }
   const syncTypesCommand = createSyncPlannedCommand(project, "sync-types", extraArgs);
   if (!syncTypesCommand) {
-    throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES6.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
+    throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
   }
   const plannedCommands = [syncTypesCommand];
   const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
@@ -2225,7 +2309,7 @@ function runProjectScript(project, plannedCommand, options) {
   const stderr = options.captureOutput && typeof result.stderr === "string" ? result.stderr : undefined;
   const stdout = options.captureOutput && typeof result.stdout === "string" ? result.stdout : undefined;
   if (result.error || result.status !== 0) {
-    throw new Error(`\`${plannedCommand.displayCommand}\` failed.`, {
+    throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.COMMAND_EXECUTION, `\`${plannedCommand.displayCommand}\` failed.`, {
       cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
     });
   }
@@ -2273,6 +2357,7 @@ var loadCliInitRuntime = () => import("@wp-typia/project-tools/cli-init");
 var loadCliPromptRuntime = () => import("@wp-typia/project-tools/cli-prompt");
 var loadCliScaffoldRuntime = () => import("@wp-typia/project-tools/cli-scaffold");
 var loadCliTemplatesRuntime = () => import("@wp-typia/project-tools/cli-templates");
+var loadCreateTemplateValidationRuntime = () => import("@wp-typia/project-tools/create-template-validation");
 var loadMigrationsRuntime = () => import("@wp-typia/project-tools/migrations");
 async function wrapCliCommandError(command, error) {
   const { createCliCommandError: createCliCommandError3 } = await loadCliDiagnosticsRuntime();
@@ -2386,20 +2471,24 @@ async function executeCreateCommand({
   prompt,
   warnLine = console.warn
 }) {
-  const [
-    { createReadlinePrompt },
-    { runScaffoldFlow },
-    { getTemplateSelectOptions }
-  ] = await Promise.all([
-    loadCliPromptRuntime(),
-    loadCliScaffoldRuntime(),
-    loadCliTemplatesRuntime()
-  ]);
-  const shouldPrompt = interactive ?? (!Boolean(flags.yes) && isInteractiveTerminal());
-  const activePrompt = shouldPrompt ? prompt ?? createReadlinePrompt() : undefined;
-  const shouldPromptForExternalLayerSelection = Boolean(activePrompt) && activePrompt !== prompt;
-  const effectiveYes = Boolean(flags.yes) || Boolean(flags["dry-run"]) && !Boolean(activePrompt);
+  let activePrompt;
   try {
+    const requestedTemplateId = readOptionalLooseStringFlag(flags, "template");
+    const resolvedTemplateId = requestedTemplateId ? (await loadCreateTemplateValidationRuntime()).validateExplicitCreateTemplateId(requestedTemplateId) : undefined;
+    const [
+      { createReadlinePrompt },
+      { runScaffoldFlow },
+      { getTemplateSelectOptions }
+    ] = await Promise.all([
+      loadCliPromptRuntime(),
+      loadCliScaffoldRuntime(),
+      loadCliTemplatesRuntime()
+    ]);
+    const shouldPrompt = interactive ?? (!Boolean(flags.yes) && isInteractiveTerminal());
+    activePrompt = shouldPrompt ? prompt ?? createReadlinePrompt() : undefined;
+    const scaffoldPrompt = activePrompt;
+    const shouldPromptForExternalLayerSelection = Boolean(scaffoldPrompt) && scaffoldPrompt !== prompt;
+    const effectiveYes = Boolean(flags.yes) || Boolean(flags["dry-run"]) && !Boolean(scaffoldPrompt);
     const flow = await runScaffoldFlow({
       alternateRenderTargets: readOptionalLooseStringFlag(flags, "alternate-render-targets"),
       cwd,
@@ -2408,7 +2497,7 @@ async function executeCreateCommand({
       externalLayerId: readOptionalLooseStringFlag(flags, "external-layer-id"),
       externalLayerSource: readOptionalLooseStringFlag(flags, "external-layer-source"),
       innerBlocksPreset: readOptionalLooseStringFlag(flags, "inner-blocks-preset"),
-      isInteractive: Boolean(activePrompt),
+      isInteractive: Boolean(scaffoldPrompt),
       namespace: readOptionalLooseStringFlag(flags, "namespace"),
       noInstall: Boolean(flags["no-install"]),
       packageManager: readOptionalLooseStringFlag(flags, "package-manager"),
@@ -2425,17 +2514,17 @@ async function executeCreateCommand({
           printLine(formatCreateProgressLine(payload2));
         }
       },
-      promptText: activePrompt ? (message, defaultValue, validate) => activePrompt.text(message, defaultValue, validate) : undefined,
+      promptText: scaffoldPrompt ? (message, defaultValue, validate) => scaffoldPrompt.text(message, defaultValue, validate) : undefined,
       queryPostType: readOptionalLooseStringFlag(flags, "query-post-type"),
-      selectDataStorage: activePrompt ? () => activePrompt.select("Select a data storage mode", [...DATA_STORAGE_PROMPT_OPTIONS], 1) : undefined,
-      selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt ? (options) => activePrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
-      selectPackageManager: activePrompt ? () => activePrompt.select("Select a package manager", [...PACKAGE_MANAGER_PROMPT_OPTIONS], 1) : undefined,
-      selectPersistencePolicy: activePrompt ? () => activePrompt.select("Select a persistence policy", [...PERSISTENCE_POLICY_PROMPT_OPTIONS], 1) : undefined,
-      selectTemplate: activePrompt ? () => activePrompt.select("Select a template", getTemplateSelectOptions(), 1) : undefined,
-      selectWithMigrationUi: activePrompt ? async () => await activePrompt.select("Enable migration UI support?", [...BOOLEAN_PROMPT_OPTIONS], 2) === "yes" : undefined,
-      selectWithTestPreset: activePrompt ? async () => await activePrompt.select("Include the Playwright test preset?", [...BOOLEAN_PROMPT_OPTIONS], 2) === "yes" : undefined,
-      selectWithWpEnv: activePrompt ? async () => await activePrompt.select("Include a local wp-env preset?", [...BOOLEAN_PROMPT_OPTIONS], 2) === "yes" : undefined,
-      templateId: readOptionalLooseStringFlag(flags, "template"),
+      selectDataStorage: scaffoldPrompt ? () => scaffoldPrompt.select("Select a data storage mode", [...DATA_STORAGE_PROMPT_OPTIONS], 1) : undefined,
+      selectExternalLayerId: shouldPromptForExternalLayerSelection && scaffoldPrompt ? (options) => scaffoldPrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
+      selectPackageManager: scaffoldPrompt ? () => scaffoldPrompt.select("Select a package manager", [...PACKAGE_MANAGER_PROMPT_OPTIONS], 1) : undefined,
+      selectPersistencePolicy: scaffoldPrompt ? () => scaffoldPrompt.select("Select a persistence policy", [...PERSISTENCE_POLICY_PROMPT_OPTIONS], 1) : undefined,
+      selectTemplate: scaffoldPrompt ? () => scaffoldPrompt.select("Select a template", getTemplateSelectOptions(), 1) : undefined,
+      selectWithMigrationUi: scaffoldPrompt ? async () => await scaffoldPrompt.select("Enable migration UI support?", [...BOOLEAN_PROMPT_OPTIONS], 2) === "yes" : undefined,
+      selectWithTestPreset: scaffoldPrompt ? async () => await scaffoldPrompt.select("Include the Playwright test preset?", [...BOOLEAN_PROMPT_OPTIONS], 2) === "yes" : undefined,
+      selectWithWpEnv: scaffoldPrompt ? async () => await scaffoldPrompt.select("Include a local wp-env preset?", [...BOOLEAN_PROMPT_OPTIONS], 2) === "yes" : undefined,
+      templateId: resolvedTemplateId,
       textDomain: readOptionalLooseStringFlag(flags, "text-domain"),
       variant: readOptionalLooseStringFlag(flags, "variant"),
       withMigrationUi: flags["with-migration-ui"],
@@ -2478,16 +2567,16 @@ async function executeAddCommand({
     const addRuntime = await loadCliAddRuntime();
     const isInteractiveSession = interactive ?? isInteractiveTerminal();
     if (!kind) {
-      if (emitOutput) {
+      if (shouldPrintMissingAddKindHelp({ emitOutput })) {
         printLine(addRuntime.formatAddHelpText());
       }
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.MISSING_ARGUMENT, `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT, formatMissingAddKindDetailLine());
     }
     if (!isAddKindId(kind)) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
     }
     if (dryRun && !supportsAddKindDryRun(kind)) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
     }
     const executionContext = {
       addRuntime,
@@ -2533,22 +2622,22 @@ async function executeTemplatesCommand({ flags }, printLine = console.log) {
   const subcommand = flags.subcommand ?? "list";
   if (subcommand === "list") {
     for (const template of listTemplates()) {
-      printBlock([formatTemplateSummary(template), formatTemplateFeatures(template)], printLine);
+      printBlock(printLine, [formatTemplateSummary(template), formatTemplateFeatures(template)]);
     }
     return;
   }
   if (subcommand === "inspect") {
     if (!flags.id) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
     }
     const template = getTemplateById(flags.id);
     if (!template) {
-      throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
+      throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
     }
-    printBlock([formatTemplateDetails(template)], printLine);
+    printBlock(printLine, [formatTemplateDetails(template)]);
     return;
   }
-  throw createCliDiagnosticCodeError6(CLI_DIAGNOSTIC_CODES7.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
+  throw createCliDiagnosticCodeError7(CLI_DIAGNOSTIC_CODES8.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
 }
 async function executeInitCommand({ apply, cwd, packageManager, projectDir }, options = {}) {
   try {
@@ -2637,6 +2726,10 @@ async function executeMigrateCommand({
 
 // src/command-contract.ts
 import path4 from "node:path";
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES9,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError8
+} from "@wp-typia/project-tools/cli-diagnostics";
 
 // src/command-registry.ts
 var WP_TYPIA_CANONICAL_CREATE_USAGE = "wp-typia create <project-dir>";
@@ -2906,10 +2999,10 @@ function looksLikeStructuredProjectInput(value) {
 function assertPositionalAliasProjectDir(projectDir) {
   const normalizedProjectDir = path4.normalize(projectDir).replace(/[\\/]+$/u, "") || path4.normalize(projectDir);
   if (normalizedProjectDir === "." || normalizedProjectDir === "..") {
-    throw new Error(`The positional alias does not scaffold into \`${projectDir}\`. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` with an explicit child directory instead.`);
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, `The positional alias does not scaffold into \`${projectDir}\`. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` with an explicit child directory instead.`);
   }
   if (looksLikeStructuredProjectInput(projectDir)) {
-    throw new Error(`The positional alias only accepts unambiguous local project directories. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for \`${projectDir}\`.`);
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, `The positional alias only accepts unambiguous local project directories. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for \`${projectDir}\`.`);
   }
 }
 function normalizeWpTypiaArgv(argv) {
@@ -2923,7 +3016,7 @@ function normalizeWpTypiaArgv(argv) {
     return argv;
   }
   if (firstPositional === "migrations") {
-    throw new Error("`wp-typia migrations` was removed in favor of `wp-typia migrate`. Use `wp-typia migrate <subcommand>` instead.");
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, "`wp-typia migrations` was removed in favor of `wp-typia migrate`. Use `wp-typia migrate <subcommand>` instead.");
   }
   if (isReservedTopLevelCommandName(firstPositional)) {
     assertStringOptionValues(argv);
@@ -2931,7 +3024,7 @@ function normalizeWpTypiaArgv(argv) {
   }
   if (positionalIndexes.length > 1) {
     const extraPositionals = positionalIndexes.slice(1).map((index) => argv[index]).filter((value) => typeof value === "string" && value.length > 0);
-    throw new Error(`The positional alias only accepts a single project directory. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for scaffold invocations with additional positional arguments, or check the command spelling if you meant another top-level command. Extra positional arguments: ${extraPositionals.map((value) => `\`${value}\``).join(", ")}.`);
+    throw createCliDiagnosticCodeError8(CLI_DIAGNOSTIC_CODES9.INVALID_ARGUMENT, `The positional alias only accepts a single project directory. Use \`${WP_TYPIA_CANONICAL_CREATE_USAGE}\` for scaffold invocations with additional positional arguments, or check the command spelling if you meant another top-level command. Extra positional arguments: ${extraPositionals.map((value) => `\`${value}\``).join(", ")}.`);
   }
   assertPositionalAliasProjectDir(firstPositional);
   const normalizedArgv = [
@@ -2943,82 +3036,115 @@ function normalizeWpTypiaArgv(argv) {
   return normalizedArgv;
 }
 
-// src/node-cli.ts
-var NODE_FALLBACK_OPTION_PARSER = buildCommandOptionParser(ALL_COMMAND_OPTION_METADATA);
-var NODE_FALLBACK_BOOLEAN_OPTION_NAMES = ["help", "version"];
-var STANDALONE_GUIDANCE_LINE = "Prefer not to install Bun? Use the standalone wp-typia binary from the GitHub release assets.";
-var NODE_FALLBACK_RUNTIME_SUMMARY_LINES = [
-  "Runtime: Node fallback",
-  "Human-readable fallback for common non-interactive create/init/add/migrate flows, doctor, sync, templates, --help, and --version when Bun is unavailable.",
-  `Install Bun 1.3.11+ or use \`bunx wp-typia ...\` for the full Bunli/OpenTUI runtime and Bun-only command surfaces such as \`skills\`, \`completions\`, and \`mcp\`. ${STANDALONE_GUIDANCE_LINE}`,
-  "Output markers: WP_TYPIA_ASCII=1 forces ASCII markers, WP_TYPIA_ASCII=0 opts back into Unicode markers, and non-empty NO_COLOR requests ASCII markers when WP_TYPIA_ASCII is unset."
-];
-var printLine = (line) => {
-  console.log(line);
-};
-function printBlock2(lines) {
-  for (const line of lines) {
-    printLine(line);
-  }
-}
-function hasFlagBeforeTerminator(argv, flag) {
-  for (const arg of argv) {
-    if (arg === "--") {
-      return false;
+// src/node-fallback/dispatchers/add.ts
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES10,
+  createCliCommandError as createCliCommandError3
+} from "@wp-typia/project-tools/cli-diagnostics";
+async function dispatchNodeFallbackAdd({
+  cwd,
+  mergedFlags,
+  positionals,
+  printLine
+}) {
+  if (!positionals[1]) {
+    if (shouldPrintMissingAddKindHelp({ format: mergedFlags.format })) {
+      const { formatAddHelpText } = await import("@wp-typia/project-tools/cli-add");
+      printLine(formatAddHelpText());
     }
-    if (arg === flag) {
-      return true;
+    throw createCliCommandError3({
+      code: CLI_DIAGNOSTIC_CODES10.MISSING_ARGUMENT,
+      command: "add",
+      detailLines: buildMissingAddKindDetailLines()
+    });
+  }
+  if (mergedFlags.format === "json") {
+    let completion;
+    try {
+      completion = await executeAddCommand({
+        cwd,
+        emitOutput: false,
+        flags: mergedFlags,
+        interactive: false,
+        kind: positionals[1],
+        name: positionals[2]
+      });
+    } catch (error) {
+      throw createCliCommandError3({
+        command: "add",
+        error
+      });
     }
+    printLine(JSON.stringify(buildStructuredCompletionSuccessPayload("add", completion, {
+      dryRun: Boolean(mergedFlags["dry-run"]),
+      kind: positionals[1],
+      name: positionals[2],
+      projectDir: extractCompletionProjectDir(completion) ?? cwd
+    }), null, 2));
+    return;
   }
-  return false;
-}
-function parseGlobalFlags(argv) {
-  const { argv: nextArgv, flags } = extractKnownOptionValuesFromArgv(argv, {
-    optionNames: ["format", "id"],
-    parser: NODE_FALLBACK_OPTION_PARSER
+  await executeAddCommand({
+    cwd,
+    flags: mergedFlags,
+    interactive: undefined,
+    kind: positionals[1],
+    name: positionals[2]
   });
-  return {
-    argv: nextArgv,
-    flags: {
-      format: typeof flags.format === "string" ? flags.format : undefined,
-      id: typeof flags.id === "string" ? flags.id : undefined
-    }
-  };
 }
-async function applyNodeFallbackConfigDefaults(command, subcommand, flags, configOverridePath, cwd) {
-  let config = await loadWpTypiaUserConfig(cwd);
-  if (configOverridePath) {
-    const overrideConfig = await loadWpTypiaUserConfigFromSource(cwd, configOverridePath);
-    config = mergeWpTypiaUserConfig(config, overrideConfig);
+
+// src/node-fallback/dispatchers/create.ts
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES11,
+  createCliCommandError as createCliCommandError4
+} from "@wp-typia/project-tools/cli-diagnostics";
+async function dispatchNodeFallbackCreate({
+  cwd,
+  mergedFlags,
+  positionals,
+  printLine
+}) {
+  const projectDir = positionals[1];
+  if (!projectDir) {
+    throw createCliCommandError4({
+      code: CLI_DIAGNOSTIC_CODES11.MISSING_ARGUMENT,
+      command: "create",
+      detailLines: buildMissingCreateProjectDirDetailLines()
+    });
   }
-  if (command === "create") {
-    return {
-      ...flags,
-      ...resolveCommandOptionValues(CREATE_OPTION_METADATA, {
-        defaults: getCreateDefaults(config),
-        flags
-      })
-    };
+  let completion;
+  try {
+    completion = await executeCreateCommand({
+      cwd,
+      emitOutput: mergedFlags.format !== "json",
+      flags: mergedFlags,
+      interactive: mergedFlags.format === "json" ? false : undefined,
+      projectDir
+    });
+  } catch (error) {
+    throw createCliCommandError4({
+      command: "create",
+      error
+    });
   }
-  if (command === "add" && subcommand === "block") {
-    return {
-      ...flags,
-      ...resolveCommandOptionValues(ADD_OPTION_METADATA, {
-        defaults: getAddBlockDefaults(config),
-        flags
-      })
-    };
+  if (mergedFlags.format === "json") {
+    printLine(JSON.stringify(buildStructuredCompletionSuccessPayload("create", completion, {
+      dryRun: Boolean(mergedFlags["dry-run"]),
+      projectDir: extractCompletionProjectDir(completion) ?? projectDir,
+      template: typeof mergedFlags.template === "string" ? mergedFlags.template : undefined
+    }), null, 2));
   }
-  return flags;
-}
-function parseArgv(argv) {
-  return parseCommandArgvWithMetadata(argv, {
-    extraBooleanOptionNames: NODE_FALLBACK_BOOLEAN_OPTION_NAMES,
-    parser: NODE_FALLBACK_OPTION_PARSER
-  });
 }
-function renderGeneralHelp() {
-  printBlock2([
+
+// src/node-fallback/help.ts
+var STANDALONE_GUIDANCE_LINE = "Prefer not to install Bun? Use the standalone wp-typia binary from the GitHub release assets.";
+var NODE_FALLBACK_RUNTIME_SUMMARY_LINES = [
+  "Runtime: Node fallback",
+  "Human-readable fallback for common non-interactive create/init/add/migrate flows, doctor, sync, templates, --help, and --version when Bun is unavailable.",
+  `Install Bun 1.3.11+ or use \`bunx wp-typia ...\` for the full Bunli/OpenTUI runtime and Bun-only command surfaces such as \`skills\`, \`completions\`, and \`mcp\`. ${STANDALONE_GUIDANCE_LINE}`,
+  "Output markers: WP_TYPIA_ASCII=1 forces ASCII markers, WP_TYPIA_ASCII=0 opts back into Unicode markers, and non-empty NO_COLOR requests ASCII markers when WP_TYPIA_ASCII is unset."
+];
+function renderGeneralHelp(printLine) {
+  printBlock(printLine, [
     `wp-typia ${package_default.version}`,
     "",
     "Canonical CLI package for wp-typia scaffolding and project workflows.",
@@ -3035,8 +3161,8 @@ function renderGeneralHelp() {
     `- ${WP_TYPIA_POSITIONAL_ALIAS_USAGE}`
   ]);
 }
-function renderNodeFallbackCommandHelp(config) {
-  printBlock2([
+function renderNodeFallbackCommandHelp(printLine, config) {
+  printBlock(printLine, [
     config.heading,
     "",
     ...NODE_FALLBACK_RUNTIME_SUMMARY_LINES,
@@ -3085,8 +3211,71 @@ var NODE_FALLBACK_COMMAND_HELP_CONFIG = {
 };
 var NODE_FALLBACK_HELP_RENDERERS = Object.fromEntries(Object.entries(NODE_FALLBACK_COMMAND_HELP_CONFIG).map(([command, config]) => [
   command,
-  () => renderNodeFallbackCommandHelp(config)
+  (printLine) => renderNodeFallbackCommandHelp(printLine, config)
 ]));
+
+// src/node-cli.ts
+var NODE_FALLBACK_OPTION_PARSER = buildCommandOptionParser(ALL_COMMAND_OPTION_METADATA);
+var NODE_FALLBACK_BOOLEAN_OPTION_NAMES = ["help", "version"];
+var printLine = (line) => {
+  console.log(line);
+};
+function hasFlagBeforeTerminator(argv, flag) {
+  for (const arg of argv) {
+    if (arg === "--") {
+      return false;
+    }
+    if (arg === flag) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseGlobalFlags(argv) {
+  const { argv: nextArgv, flags } = extractKnownOptionValuesFromArgv(argv, {
+    optionNames: ["format", "id"],
+    parser: NODE_FALLBACK_OPTION_PARSER
+  });
+  return {
+    argv: nextArgv,
+    flags: {
+      format: typeof flags.format === "string" ? flags.format : undefined,
+      id: typeof flags.id === "string" ? flags.id : undefined
+    }
+  };
+}
+async function applyNodeFallbackConfigDefaults(command, subcommand, flags, configOverridePath, cwd) {
+  let config = await loadWpTypiaUserConfig(cwd);
+  if (configOverridePath) {
+    const overrideConfig = await loadWpTypiaUserConfigFromSource(cwd, configOverridePath);
+    config = mergeWpTypiaUserConfig(config, overrideConfig);
+  }
+  if (command === "create") {
+    return {
+      ...flags,
+      ...resolveCommandOptionValues(CREATE_OPTION_METADATA, {
+        defaults: getCreateDefaults(config),
+        flags
+      })
+    };
+  }
+  if (command === "add" && subcommand === "block") {
+    return {
+      ...flags,
+      ...resolveCommandOptionValues(ADD_OPTION_METADATA, {
+        defaults: getAddBlockDefaults(config),
+        flags
+      })
+    };
+  }
+  return flags;
+}
+function parseArgv(argv) {
+  return parseCommandArgvWithMetadata(argv, {
+    extraBooleanOptionNames: NODE_FALLBACK_BOOLEAN_OPTION_NAMES,
+    parser: NODE_FALLBACK_OPTION_PARSER
+  });
+}
 function renderVersion(options = {}) {
   if (options.format === "json") {
     printLine(JSON.stringify({
@@ -3110,16 +3299,16 @@ function renderTemplatesJson(flags, subcommand) {
   }
   const templateId = flags.id;
   if (!templateId) {
-    throw createCliCommandError3({
-      code: CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT,
+    throw createCliCommandError5({
+      code: CLI_DIAGNOSTIC_CODES12.MISSING_ARGUMENT,
       command: "templates",
       detailLines: ["`wp-typia templates inspect` requires <template-id>."]
     });
   }
   const template = getTemplateById(templateId);
   if (!template) {
-    throw createCliCommandError3({
-      code: CLI_DIAGNOSTIC_CODES8.INVALID_ARGUMENT,
+    throw createCliCommandError5({
+      code: CLI_DIAGNOSTIC_CODES12.INVALID_ARGUMENT,
       command: "templates",
       detailLines: [`Unknown template "${templateId}".`]
     });
@@ -3129,8 +3318,8 @@ function renderTemplatesJson(flags, subcommand) {
   }, null, 2));
 }
 function renderUnsupportedCommand(command) {
-  throw createCliCommandError3({
-    code: CLI_DIAGNOSTIC_CODES8.UNSUPPORTED_COMMAND,
+  throw createCliCommandError5({
+    code: CLI_DIAGNOSTIC_CODES12.UNSUPPORTED_COMMAND,
     command,
     detailLines: [
       [
@@ -3145,7 +3334,7 @@ function renderUnsupportedCommand(command) {
 async function renderDoctorJson() {
   const [
     { getDoctorChecks },
-    { createCliCommandError: createCliCommandError4, getDoctorFailureDetailLines }
+    { createCliCommandError: createCliCommandError6, getDoctorFailureDetailLines }
   ] = await Promise.all([
     import("@wp-typia/project-tools/cli-doctor"),
     import("@wp-typia/project-tools/cli-diagnostics")
@@ -3155,8 +3344,8 @@ async function renderDoctorJson() {
     checks
   }, null, 2));
   if (checks.some((check) => check.status === "fail")) {
-    throw createCliCommandError4({
-      code: CLI_DIAGNOSTIC_CODES8.DOCTOR_CHECK_FAILED,
+    throw createCliCommandError6({
+      code: CLI_DIAGNOSTIC_CODES12.DOCTOR_CHECK_FAILED,
       command: "doctor",
       detailLines: getDoctorFailureDetailLines(checks),
       summary: "One or more doctor checks failed."
@@ -3164,94 +3353,8 @@ async function renderDoctorJson() {
   }
 }
 var NODE_FALLBACK_COMMAND_DISPATCHERS = {
-  add: async ({
-    cwd,
-    mergedFlags,
-    positionals
-  }) => {
-    if (!positionals[1]) {
-      const { formatAddHelpText } = await import("@wp-typia/project-tools/cli-add");
-      printLine(formatAddHelpText());
-      throw createCliCommandError3({
-        code: CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT,
-        command: "add",
-        detailLines: [
-          `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`
-        ]
-      });
-    }
-    if (mergedFlags.format === "json") {
-      let completion;
-      try {
-        completion = await executeAddCommand({
-          cwd,
-          emitOutput: false,
-          flags: mergedFlags,
-          interactive: false,
-          kind: positionals[1],
-          name: positionals[2]
-        });
-      } catch (error) {
-        throw createCliCommandError3({
-          command: "add",
-          error
-        });
-      }
-      printLine(JSON.stringify(buildStructuredCompletionSuccessPayload("add", completion, {
-        dryRun: Boolean(mergedFlags["dry-run"]),
-        kind: positionals[1],
-        name: positionals[2],
-        projectDir: extractCompletionProjectDir(completion) ?? cwd
-      }), null, 2));
-      return;
-    }
-    await executeAddCommand({
-      cwd,
-      flags: mergedFlags,
-      interactive: undefined,
-      kind: positionals[1],
-      name: positionals[2]
-    });
-  },
-  create: async ({
-    cwd,
-    mergedFlags,
-    positionals
-  }) => {
-    const projectDir = positionals[1];
-    if (!projectDir) {
-      throw createCliCommandError3({
-        code: CLI_DIAGNOSTIC_CODES8.MISSING_ARGUMENT,
-        command: "create",
-        detailLines: [
-          "`wp-typia create` requires <project-dir>.",
-          "`--dry-run` still needs a logical project directory name because wp-typia derives slugs, package names, and planned file paths from it."
-        ]
-      });
-    }
-    let completion;
-    try {
-      completion = await executeCreateCommand({
-        cwd,
-        emitOutput: mergedFlags.format !== "json",
-        flags: mergedFlags,
-        interactive: mergedFlags.format === "json" ? false : undefined,
-        projectDir
-      });
-    } catch (error) {
-      throw createCliCommandError3({
-        command: "create",
-        error
-      });
-    }
-    if (mergedFlags.format === "json") {
-      printLine(JSON.stringify(buildStructuredCompletionSuccessPayload("create", completion, {
-        dryRun: Boolean(mergedFlags["dry-run"]),
-        projectDir: extractCompletionProjectDir(completion) ?? projectDir,
-        template: typeof mergedFlags.template === "string" ? mergedFlags.template : undefined
-      }), null, 2));
-    }
-  },
+  add: dispatchNodeFallbackAdd,
+  create: dispatchNodeFallbackCreate,
   doctor: async ({ cwd, mergedFlags }) => {
     if (mergedFlags.format === "json") {
       await renderDoctorJson();
@@ -3317,7 +3420,7 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
         }));
       }
     } catch (error) {
-      throw createCliCommandError3({
+      throw createCliCommandError5({
         command: "sync",
         error
       });
@@ -3331,8 +3434,8 @@ var NODE_FALLBACK_COMMAND_DISPATCHERS = {
     const templateId = typeof mergedFlags.id === "string" ? mergedFlags.id : positionals[2];
     const resolvedSubcommand = templateId ? "inspect" : subcommand ?? "list";
     if (resolvedSubcommand !== "list" && resolvedSubcommand !== "inspect") {
-      throw createCliCommandError3({
-        code: CLI_DIAGNOSTIC_CODES8.INVALID_COMMAND,
+      throw createCliCommandError5({
+        code: CLI_DIAGNOSTIC_CODES12.INVALID_COMMAND,
         command: "templates",
         detailLines: [
           `Unknown templates subcommand "${resolvedSubcommand}". Expected list or inspect.`
@@ -3370,7 +3473,7 @@ async function runNodeCli(argv = process.argv.slice(2)) {
   const helpTarget = command === "help" ? subcommand : command;
   const versionRequested = hasFlagBeforeTerminator(cliArgv, "--version") || command === "version";
   if (cliArgv.length === 0) {
-    renderGeneralHelp();
+    renderGeneralHelp(printLine);
     process.exitCode = 1;
     return;
   }
@@ -3378,18 +3481,18 @@ async function runNodeCli(argv = process.argv.slice(2)) {
     if (helpTarget) {
       const helpRenderer = NODE_FALLBACK_HELP_RENDERERS[helpTarget];
       if (helpRenderer) {
-        helpRenderer();
+        helpRenderer(printLine);
         return;
       }
       if (helpTarget === "help" || helpTarget === "version") {
-        renderGeneralHelp();
+        renderGeneralHelp(printLine);
         return;
       }
     } else {
-      renderGeneralHelp();
+      renderGeneralHelp(printLine);
       return;
     }
-    renderGeneralHelp();
+    renderGeneralHelp(printLine);
     return;
   }
   if (versionRequested) {
@@ -3404,7 +3507,8 @@ async function runNodeCli(argv = process.argv.slice(2)) {
     await commandDispatcher({
       cwd: process.cwd(),
       mergedFlags,
-      positionals
+      positionals,
+      printLine
     });
     return;
   }
@@ -3416,7 +3520,7 @@ async function runNodeCliEntrypoint(argv = process.argv.slice(2)) {
     await runNodeCli(argv);
   } catch (error) {
     if (prefersStructuredErrorOutput) {
-      const diagnostic = createCliCommandError3({
+      const diagnostic = createCliCommandError5({
         command: resolveCanonicalCommandContext(argv),
         error
       });
@@ -3439,4 +3543,4 @@ export {
   hasFlagBeforeTerminator
 };
 
-//# debugId=5D4E56BAE8A1432964756E2164756E21
+//# debugId=B5CA87A93189F22464756E2164756E21