wp-typia 0.22.7 → 0.22.9

package/dist-bunli/{command-list-6zr1tj96.js → command-list-g3qhb3y4.js}

@@ -17,7 +17,7 @@ import {
   package_default,
   prefersStructuredCliOutput,
   resolveCommandOptionValues
-} from "./cli-cjygr56g.js";
+} from "./cli-y934dq2k.js";
 import {
   Result,
   TaggedError,
@@ -42,10 +42,12 @@ import {
   createCliDiagnosticCodeError
 } from "./cli-p95wr1q8.js";
 import {
+  PACKAGE_MANAGER_IDS,
   formatInstallCommand,
   formatPackageExecCommand,
   formatRunScript,
-  inferPackageManagerId
+  inferPackageManagerId,
+  parsePackageManagerField
 } from "./cli-52ke0ptp.js";
 import {
   __require,
@@ -67,7 +69,7 @@ function resolveBundledModuleHref(baseUrl, candidates, options = {}) {
   }
   const missingCandidates = candidates.map((candidate) => fileURLToPath(new URL(candidate, baseUrl)));
   const label = options.moduleLabel ?? "bundled wp-typia runtime module";
-  throw new Error([
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_BUILD_ARTIFACT, [
     `Missing bundled build artifacts for ${label}.`,
     "None of the expected files were found:",
     ...missingCandidates.map((candidatePath) => `- ${candidatePath}`),
@@ -76,63 +78,7 @@ function resolveBundledModuleHref(baseUrl, candidates, options = {}) {
 `));
 }
 
-// src/cli-string-flags.ts
-function readOptionalCliStringFlagValue(flags, name, mode) {
-  const value = flags[name];
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value !== "string") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    if (mode === "strict") {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-  }
-  return [leftValue, rightValue];
-}
-
-// src/external-layer-prompt-options.ts
-function formatExternalLayerSelectHint(option2) {
-  const details = [
-    option2.description,
-    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
-  ].filter((value) => typeof value === "string" && value.length > 0);
-  return details.length > 0 ? details.join(" \xB7 ") : undefined;
-}
-function toExternalLayerPromptOptions(options) {
-  return options.map((option2) => ({
-    hint: formatExternalLayerSelectHint(option2),
-    label: option2.id,
-    value: option2.id
-  }));
-}
-
-// src/add-kind-registry.ts
+// src/add-kind-registry-shared.ts
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
   "name",
@@ -214,509 +160,614 @@ function isAddPersistenceTemplate(template) {
 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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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;
   }
-  if (templateId === "query-loop") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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.");
+  const mistypedAddBlockTemplateMessage = getMistypedAddBlockTemplateMessage(context.addRuntime, templateId);
+  if (mistypedAddBlockTemplateMessage) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE, mistypedAddBlockTemplateMessage);
   }
   throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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
+
+// 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
+function readOptionalCliStringFlagValue(flags, name, mode) {
+  const value = flags[name];
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    if (mode === "strict") {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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(option2) {
+  const details = [
+    option2.description,
+    option2.extends.length > 0 ? `extends ${option2.extends.join(", ")}` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return details.length > 0 ? details.join(" \xB7 ") : undefined;
+}
+function toExternalLayerPromptOptions(options) {
+  return options.map((option2) => ({
+    hint: formatExternalLayerSelectHint(option2),
+    label: option2.id,
+    value: option2.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);
@@ -742,6 +793,24 @@ 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 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 "fs";
 import { promises as fsp } from "fs";
@@ -946,6 +1015,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;
@@ -988,6 +1064,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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;
@@ -1044,8 +1127,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 {
@@ -1167,11 +1251,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({
@@ -1343,7 +1422,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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.COMMAND_EXECUTION, `\`${plannedCommand.displayCommand}\` failed.`, {
       cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
     });
   }
@@ -1384,14 +1463,15 @@ async function executeSyncCommand({
 }
 
 // src/runtime-bridge.ts
-var loadCliAddRuntime = () => import("./cli-add-8jpdnz1r.js");
+var loadCliAddRuntime = () => import("./cli-add-6dn9h94t.js");
 var loadCliDiagnosticsRuntime = () => import("./cli-diagnostics-5dvztm7q.js");
-var loadCliDoctorRuntime = () => import("./cli-doctor-h5tq4ztr.js");
-var loadCliInitRuntime = () => import("./cli-init-w9p558th.js");
+var loadCliDoctorRuntime = () => import("./cli-doctor-564c43ay.js");
+var loadCliInitRuntime = () => import("./cli-init-znhqp8tr.js");
 var loadCliPromptRuntime = () => import("./cli-prompt-614tq57c.js");
-var loadCliScaffoldRuntime = () => import("./cli-scaffold-qve8rqja.js");
-var loadCliTemplatesRuntime = () => import("./cli-templates-9t2a7zqd.js");
-var loadMigrationsRuntime = () => import("./migrations-v0avgyg6.js");
+var loadCliScaffoldRuntime = () => import("./cli-scaffold-6trxyyk6.js");
+var loadCliTemplatesRuntime = () => import("./cli-templates-hc71dfc2.js");
+var loadCreateTemplateValidationRuntime = () => import("./create-template-validation-rtec5sng.js");
+var loadMigrationsRuntime = () => import("./migrations-qc1r0yqe.js");
 async function wrapCliCommandError(command, error) {
   const { createCliCommandError } = await loadCliDiagnosticsRuntime();
   return createCliCommandError({ command, error });
@@ -1504,20 +1584,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,
@@ -1526,7 +1610,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"),
@@ -1543,17 +1627,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"],
@@ -1596,10 +1680,10 @@ async function executeAddCommand({
     const addRuntime = await loadCliAddRuntime();
     const isInteractiveSession = interactive ?? isInteractiveTerminal();
     if (!kind) {
-      if (emitOutput) {
+      if (shouldPrintMissingAddKindHelp({ emitOutput })) {
         printLine(addRuntime.formatAddHelpText());
       }
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, formatMissingAddKindDetailLine());
     }
     if (!isAddKindId(kind)) {
       throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
@@ -1651,7 +1735,7 @@ 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;
   }
@@ -1663,7 +1747,7 @@ async function executeTemplatesCommand({ flags }, printLine = console.log) {
     if (!template) {
       throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
     }
-    printBlock([formatTemplateDetails(template)], printLine);
+    printBlock(printLine, [formatTemplateDetails(template)]);
     return;
   }
   throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
@@ -2274,10 +2358,7 @@ var createCommand = defineCommand({
       emitCliDiagnosticFailure(args, {
         code: CLI_DIAGNOSTIC_CODES.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."
-        ]
+        detailLines: buildMissingCreateProjectDirDetailLines()
       });
       return;
     }
@@ -2339,7 +2420,7 @@ var doctorCommand = defineCommand({
     const prefersStructuredOutput = prefersStructuredCliOutput(args);
     if (prefersStructuredOutput) {
       const [{ getDoctorChecks }, { getDoctorFailureDetailLines }] = await Promise.all([
-        import("./cli-doctor-h5tq4ztr.js"),
+        import("./cli-doctor-564c43ay.js"),
         import("./cli-diagnostics-5dvztm7q.js")
       ]);
       const checks = await getDoctorChecks(args.cwd);
@@ -2925,10 +3006,21 @@ function isTool(value) {
 function isToolGroup(value) {
   return isObject(value) && typeof value.namespace === "string" && Array.isArray(value.tools) && value.tools.every(isTool);
 }
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function getErrorCauseOptions(error) {
+  return error instanceof Error ? { cause: error } : undefined;
+}
 async function readSchemaSource(cwd, source) {
   const schemaPath = path3.resolve(cwd, source.path);
   const raw = await fs4.readFile(schemaPath, "utf8");
-  const parsed = JSON.parse(raw);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Schema source "${source.path}" must contain valid JSON. ${getErrorMessage(error)}`, getErrorCauseOptions(error));
+  }
   if (isToolGroup(parsed)) {
     return parsed;
   }
@@ -2938,7 +3030,7 @@ async function readSchemaSource(cwd, source) {
       tools: parsed
     };
   }
-  throw new Error(`Schema source "${source.path}" must contain either one MCPToolGroup object or an array of MCP tools.`);
+  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Schema source "${source.path}" must contain either one MCPToolGroup object or an array of MCP tools.`);
 }
 async function loadMcpToolGroups(cwd, schemaSources) {
   return Promise.all(schemaSources.map((source) => readSchemaSource(cwd, source)));
@@ -2950,7 +3042,7 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path3.join(cwd, ".
     tools: groups
   });
   if (Result.isError(result)) {
-    throw result.error;
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, getErrorMessage(result.error), getErrorCauseOptions(result.error));
   }
   const registry = groups.map((group) => ({
     namespace: group.namespace,
@@ -2962,7 +3054,7 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path3.join(cwd, ".
       namespace: group.namespace
     });
     if (Result.isError(convert)) {
-      throw convert.error;
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, getErrorMessage(convert.error), getErrorCauseOptions(convert.error));
     }
   }
   await fs4.mkdir(outputDir, { recursive: true });
@@ -3155,7 +3247,7 @@ var templatesCommand = defineCommand({
           return;
         }
         if (effectiveSubcommand === "inspect" && id) {
-          const { getTemplateById } = await import("./cli-templates-9t2a7zqd.js");
+          const { getTemplateById } = await import("./cli-templates-hc71dfc2.js");
           let template;
           try {
             template = getTemplateById(id);
@@ -3205,4 +3297,4 @@ export {
   wpTypiaCommands
 };
 
-//# debugId=2AA06F030398E13464756E2164756E21
+//# debugId=1A737B9B812DF37F64756E2164756E21