wp-typia 0.24.4 → 0.24.5

package/dist-bunli/command-list-y3g7e9rb.js

@@ -1,4013 +0,0 @@
-// @bun
-import {
-  ADD_OPTION_METADATA,
-  CREATE_OPTION_METADATA,
-  DOCTOR_OPTION_METADATA,
-  INIT_OPTION_METADATA,
-  MCP_OPTION_METADATA,
-  MIGRATE_OPTION_METADATA,
-  SYNC_OPTION_METADATA,
-  TEMPLATES_OPTION_METADATA,
-  WP_TYPIA_TOP_LEVEL_COMMAND_NAMES,
-  buildCommandOptions,
-  emitCliDiagnosticFailure,
-  formatAddKindList,
-  formatAddKindUsagePlaceholder,
-  getAddBlockDefaults,
-  getCreateDefaults,
-  getMcpSchemaSources,
-  package_default,
-  prefersStructuredCliOutput,
-  resolveCommandOptionValues
-} from "./cli-368d4cgy.js";
-import {
-  Result,
-  TaggedError,
-  createKeyMatcher,
-  defineCommand,
-  exports_external,
-  option,
-  require_jsx_dev_runtime,
-  require_react,
-  useKeyboard,
-  useRuntime
-} from "./cli-hv2yedw2.js";
-import"./cli-ac2ebaf8.js";
-import {
-  createManagedTempRoot
-} from "./cli-t73q5aqz.js";
-import {
-  ADD_KIND_IDS
-} from "./cli-bajwv85z.js";
-import {
-  CLI_DIAGNOSTIC_CODES,
-  createCliDiagnosticCodeError
-} from "./cli-tq730sqt.js";
-import {
-  PACKAGE_MANAGER_IDS,
-  formatInstallCommand,
-  formatPackageExecCommand,
-  formatRunScript,
-  inferPackageManagerId,
-  parsePackageManagerField
-} from "./cli-am5x7tb4.js";
-import"./cli-ccax7s0s.js";
-import {
-  __require,
-  __toESM
-} from "./cli-xnn9xjcy.js";
-
-// src/commands/add.ts
-var import_react34 = __toESM(require_react(), 1);
-
-// src/commands/output-adapters.ts
-var defaultPrintLine = (line) => {
-  process.stdout.write(`${line}
-`);
-};
-var defaultWarnLine = (line) => {
-  process.stderr.write(`${line}
-`);
-};
-function resolveCommandPrintLine(args) {
-  return args.printLine ?? defaultPrintLine;
-}
-function resolveCommandOutputAdapters(args) {
-  const adapters = args;
-  return {
-    printLine: adapters.printLine ?? defaultPrintLine,
-    warnLine: adapters.warnLine ?? defaultWarnLine
-  };
-}
-
-// src/render-loader.ts
-import fs from "fs";
-import { fileURLToPath } from "url";
-function resolveBundledModuleHref(baseUrl, candidates, options = {}) {
-  for (const candidate of candidates) {
-    const url = new URL(candidate, baseUrl);
-    if (fs.existsSync(fileURLToPath(url))) {
-      return url.href;
-    }
-  }
-  const missingCandidates = candidates.map((candidate) => fileURLToPath(new URL(candidate, baseUrl)));
-  const label = options.moduleLabel ?? "bundled wp-typia runtime module";
-  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}`),
-    "Run `bun run --filter wp-typia build` in a source checkout, or reinstall the published package/standalone binary if its bundled files are missing."
-  ].join(`
-`));
-}
-
-// src/add-kind-registry-shared.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 PATTERN_CATALOG_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "scope",
-  "section-role",
-  "catalog-title",
-  "tags",
-  "thumbnail-url"
-];
-var NAME_SOURCE_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "source"
-];
-var NAME_TYPE_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "type"
-];
-var NAME_BLOCK_ATTRIBUTE_POST_META_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "block",
-  "attribute",
-  "post-meta",
-  "meta-path"
-];
-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"
-];
-var NAME_POST_TYPE_TYPE_VISIBLE_FIELDS = [
-  "kind",
-  "name",
-  "post-type",
-  "type"
-];
-function requireAddKindName(context, message) {
-  if (!context.name) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 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;
-  }
-  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.`);
-}
-
-// src/add-kinds/ability.ts
-var ABILITY_MISSING_NAME_MESSAGE = "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.";
-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: ABILITY_MISSING_NAME_MESSAGE,
-      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 readOptionalDashedOrCamelStringFlag(flags, dashedName, camelName) {
-  return readOptionalStrictStringFlag(flags, dashedName) ?? readOptionalStrictStringFlag(flags, camelName);
-}
-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 ADMIN_VIEW_MISSING_NAME_MESSAGE = "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].";
-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, ADMIN_VIEW_MISSING_NAME_MESSAGE);
-    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: ADMIN_VIEW_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  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 AI_FEATURE_MISSING_NAME_MESSAGE = "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].";
-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, AI_FEATURE_MISSING_NAME_MESSAGE);
-    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: AI_FEATURE_MISSING_NAME_MESSAGE,
-      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 BINDING_SOURCE_MISSING_NAME_MESSAGE = "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--from-post-meta <post-meta> --meta-path <field>].";
-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.`
-      ] : [],
-      ...values.postMetaSlug ? [
-        `Run wp-typia sync-rest --check after editing ${values.schemaFile}.`
-      ] : [],
-      "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}`] : [],
-      ...values.postMetaSlug ? [
-        `Post meta: ${values.postMetaSlug}`,
-        `Meta field: ${values.metaPath}`
-      ] : [],
-      `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, BINDING_SOURCE_MISSING_NAME_MESSAGE);
-    const [blockName, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
-    const postMetaName = readOptionalDashedOrCamelStringFlag(context.flags, "from-post-meta", "fromPostMeta") ?? readOptionalDashedOrCamelStringFlag(context.flags, "post-meta", "postMeta");
-    const metaPath = readOptionalDashedOrCamelStringFlag(context.flags, "meta-path", "metaPath");
-    return createNamedExecutionPlan(context, {
-      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddBindingSourceCommand({
-        attributeName,
-        bindingSourceName: name2,
-        blockName,
-        cwd,
-        metaPath,
-        postMetaName
-      }),
-      getValues: (result) => ({
-        ...result.attributeName ? { attributeName: result.attributeName } : {},
-        ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
-        bindingSourceSlug: result.bindingSourceSlug,
-        ...result.metaKey ? { metaKey: result.metaKey } : {},
-        ...result.metaPath ? { metaPath: result.metaPath } : {},
-        ...result.postMetaSlug ? { postMetaSlug: result.postMetaSlug } : {},
-        ...result.postType ? { postType: result.postType } : {},
-        ...result.schemaFile ? { schemaFile: result.schemaFile } : {}
-      }),
-      missingNameMessage: BINDING_SOURCE_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  sortOrder: 70,
-  supportsDryRun: true,
-  usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--from-post-meta|--post-meta <post-meta> [--meta-path <field>]] [--dry-run]",
-  visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_POST_META_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 BLOCK_MISSING_NAME_MESSAGE = "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]";
-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, BLOCK_MISSING_NAME_MESSAGE);
-    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: BLOCK_MISSING_NAME_MESSAGE,
-      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/contract.ts
-var CONTRACT_MISSING_NAME_MESSAGE = "`wp-typia add contract` requires <name>. Usage: wp-typia add contract <name> [--type <ExportedTypeName>].";
-var contractAddKindEntry = defineAddKindRegistryEntry({
-  completion: {
-    nextSteps: (values) => [
-      `Edit ${values.typesFile} when the standalone wire shape changes.`,
-      "Run `wp-typia sync-rest` or `wp-typia sync` to refresh the generated schema artifact."
-    ],
-    summaryLines: (values, projectDir) => [
-      `Contract: ${values.contractSlug}`,
-      `Source type: ${values.sourceTypeName}`,
-      `Schema: ${values.schemaFile}`,
-      `Project directory: ${projectDir}`
-    ],
-    title: "Added standalone contract"
-  },
-  description: "Add a standalone TypeScript schema contract",
-  nameLabel: "Contract name",
-  async prepareExecution(context) {
-    const name = requireAddKindName(context, CONTRACT_MISSING_NAME_MESSAGE);
-    const typeName = readOptionalStrictStringFlag(context.flags, "type");
-    return createNamedExecutionPlan(context, {
-      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddContractCommand({
-        contractName: name2,
-        cwd,
-        typeName
-      }),
-      getValues: (result) => ({
-        contractSlug: result.contractSlug,
-        schemaFile: result.schemaFile,
-        sourceTypeName: result.sourceTypeName,
-        typesFile: result.typesFile
-      }),
-      missingNameMessage: CONTRACT_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  sortOrder: 75,
-  supportsDryRun: true,
-  usage: "wp-typia add contract <name> [--type <ExportedTypeName>] [--dry-run]",
-  visibleFieldNames: () => NAME_TYPE_VISIBLE_FIELDS
-});
-
-// src/add-kinds/core-variation.ts
-var CORE_VARIATION_MISSING_NAME_MESSAGE = "`wp-typia add core-variation` requires <name>. Usage: wp-typia add core-variation <block-name> <name> or wp-typia add core-variation <name> --block <namespace/block>.";
-var CORE_VARIATION_MISSING_BLOCK_MESSAGE = "`wp-typia add core-variation` requires <block-name>. Usage: wp-typia add core-variation <block-name> <name> or wp-typia add core-variation <name> --block <namespace/block>.";
-var CORE_VARIATION_BLOCK_NAME_PATTERN = /^[^/\s]+\/[^/\s]+$/u;
-var CORE_VARIATION_POSITIONAL_TARGET_DIAGNOSTICS = {
-  empty: () => "The first positional argument (target block name) requires a block name.",
-  invalidFormat: () => "The first positional argument (target block name) must use <namespace/block-slug> format."
-};
-function formatCoreVariationMissingPositionalNameMessage(blockName) {
-  return [
-    `\`wp-typia add core-variation ${blockName}\` is missing <name>.`,
-    "Usage: wp-typia add core-variation <block-name> <name>",
-    "Alternative: wp-typia add core-variation <name> --block <namespace/block>"
-  ].join(`
-`);
-}
-function resolveCoreVariationInputs(context) {
-  const positionalTargetBlockName = context.positionalArgs?.[1];
-  const positionalVariationName = context.positionalArgs?.[2];
-  if (positionalVariationName) {
-    if (!positionalTargetBlockName) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, CORE_VARIATION_MISSING_BLOCK_MESSAGE);
-    }
-    return {
-      targetBlockName: positionalTargetBlockName,
-      targetBlockNameDiagnostics: CORE_VARIATION_POSITIONAL_TARGET_DIAGNOSTICS,
-      variationName: positionalVariationName
-    };
-  }
-  const targetBlockFlag = readOptionalStrictStringFlag(context.flags, "block");
-  const missingPositionalNameTarget = context.name !== undefined && positionalTargetBlockName === context.name && CORE_VARIATION_BLOCK_NAME_PATTERN.test(context.name) ? context.name : undefined;
-  if (missingPositionalNameTarget && !targetBlockFlag) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, formatCoreVariationMissingPositionalNameMessage(missingPositionalNameTarget));
-  }
-  const variationName = requireAddKindName(context, CORE_VARIATION_MISSING_NAME_MESSAGE);
-  if (!targetBlockFlag) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, CORE_VARIATION_MISSING_BLOCK_MESSAGE);
-  }
-  return {
-    targetBlockName: targetBlockFlag,
-    targetBlockNameDiagnostics: "--block",
-    variationName
-  };
-}
-var coreVariationAddKindEntry = defineAddKindRegistryEntry({
-  completion: {
-    nextSteps: (values) => [
-      `Review ${values.variationFile}.`,
-      "Run your workspace build or dev command to verify the editor-side variation registration."
-    ],
-    summaryLines: (values, projectDir) => [
-      `Core variation: ${values.variationSlug}`,
-      `Target block: ${values.targetBlockName}`,
-      `Project directory: ${projectDir}`
-    ],
-    title: "Added core block variation"
-  },
-  description: "Add an editor-side variation for an existing core or external block",
-  nameLabel: "Variation name",
-  async prepareExecution(context) {
-    const { targetBlockName, targetBlockNameDiagnostics, variationName } = resolveCoreVariationInputs(context);
-    return createNamedExecutionPlan(context, {
-      execute: ({ cwd, name }) => context.addRuntime.runAddCoreVariationCommand({
-        cwd,
-        targetBlockName,
-        targetBlockNameDiagnostics,
-        variationName: name
-      }),
-      getValues: (result) => ({
-        targetBlockName: result.targetBlockName,
-        variationFile: result.variationFile,
-        variationSlug: result.variationSlug
-      }),
-      getWarnings: (result) => result.warnings,
-      missingNameMessage: CORE_VARIATION_MISSING_NAME_MESSAGE,
-      name: variationName,
-      warnLine: context.warnLine
-    });
-  },
-  sortOrder: 25,
-  supportsDryRun: true,
-  usage: `wp-typia add core-variation <block-name> <name> [--dry-run]
-Alias: wp-typia add core-variation <name> --block <namespace/block> [--dry-run]`,
-  visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
-});
-
-// src/add-kinds/editor-plugin.ts
-var EDITOR_PLUGIN_MISSING_NAME_MESSAGE = "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].";
-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, EDITOR_PLUGIN_MISSING_NAME_MESSAGE);
-    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: EDITOR_PLUGIN_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  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 HOOKED_BLOCK_MISSING_NAME_MESSAGE = "`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>.";
-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, HOOKED_BLOCK_MISSING_NAME_MESSAGE);
-    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: HOOKED_BLOCK_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  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/integration-env.ts
-var INTEGRATION_ENV_MISSING_NAME_MESSAGE = "`wp-typia add integration-env` requires <name>. Usage: wp-typia add integration-env <name> [--wp-env] [--release-zip] [--service <none|docker-compose>].";
-var integrationEnvAddKindEntry = defineAddKindRegistryEntry({
-  completion: {
-    nextSteps: (values) => [
-      `Review scripts/integration-smoke/${values.integrationEnvSlug}.mjs and docs/integration-env/${values.integrationEnvSlug}.md.`,
-      "Copy `.env.example` to `.env`, adjust local URLs or credentials, then run the generated smoke script.",
-      ...values.withWpEnv === "true" ? ["Run `npm run wp-env:start` before the smoke check when using the generated wp-env preset."] : [],
-      ...values.withReleaseZip === "true" ? ["Run `npm run release:zip` after smoke checks pass to build a distributable plugin zip."] : []
-    ],
-    summaryLines: (values, projectDir) => [
-      `Integration env: ${values.integrationEnvSlug}`,
-      `wp-env preset: ${values.withWpEnv}`,
-      `Release zip scripts: ${values.withReleaseZip}`,
-      `Service starter: ${values.service}`,
-      `Project directory: ${projectDir}`
-    ],
-    title: "Added integration environment starter"
-  },
-  description: "Add an opt-in local WordPress integration smoke environment starter",
-  nameLabel: "Integration env name",
-  async prepareExecution(context) {
-    const service = readOptionalStrictStringFlag(context.flags, "service");
-    const withReleaseZip = Boolean(context.flags["release-zip"]);
-    const withWpEnv = Boolean(context.flags["wp-env"]);
-    return createNamedExecutionPlan(context, {
-      execute: ({ cwd, name }) => context.addRuntime.runAddIntegrationEnvCommand({
-        cwd,
-        integrationEnvName: name,
-        service,
-        withReleaseZip,
-        withWpEnv
-      }),
-      getValues: (result) => ({
-        integrationEnvSlug: result.integrationEnvSlug,
-        service: result.service,
-        withReleaseZip: String(result.withReleaseZip),
-        withWpEnv: String(result.withWpEnv)
-      }),
-      getWarnings: (result) => result.warnings,
-      missingNameMessage: INTEGRATION_ENV_MISSING_NAME_MESSAGE,
-      warnLine: context.warnLine
-    });
-  },
-  sortOrder: 25,
-  supportsDryRun: true,
-  usage: "wp-typia add integration-env <name> [--wp-env] [--release-zip] [--service <none|docker-compose>] [--dry-run]",
-  visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS,
-  hiddenBooleanSubmitFields: ["wp-env", "release-zip"],
-  hiddenStringSubmitFields: ["service"]
-});
-
-// src/add-kinds/pattern.ts
-var PATTERN_MISSING_NAME_MESSAGE = "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.";
-var patternAddKindEntry = defineAddKindRegistryEntry({
-  completion: {
-    nextSteps: (values) => [
-      `Review ${values.contentFile}.`,
-      "Run your workspace build or dev command to verify the new pattern registration."
-    ],
-    summaryLines: (values, projectDir) => [
-      `Pattern: ${values.patternSlug}`,
-      `Content file: ${values.contentFile}`,
-      `Project directory: ${projectDir}`
-    ],
-    title: "Added workspace pattern"
-  },
-  description: "Add a PHP block pattern shell",
-  hiddenStringSubmitFields: ["tag"],
-  nameLabel: "Pattern name",
-  async prepareExecution(context) {
-    const name = requireAddKindName(context, PATTERN_MISSING_NAME_MESSAGE);
-    const rawScope = typeof context.flags.scope === "string" ? context.flags.scope : undefined;
-    const rawSectionRole = typeof context.flags["section-role"] === "string" ? context.flags["section-role"] : undefined;
-    const rawCatalogTitle = typeof context.flags["catalog-title"] === "string" ? context.flags["catalog-title"] : undefined;
-    const rawThumbnailUrl = typeof context.flags["thumbnail-url"] === "string" ? context.flags["thumbnail-url"] : undefined;
-    const scope = resolvePatternScopeFlag(context);
-    const sectionRole = resolvePatternSectionRoleFlag(context, scope);
-    const catalogTitle = rawCatalogTitle;
-    const tags = normalizePatternTagFlags(context.flags.tags, context.flags.tag);
-    const thumbnailUrl = rawThumbnailUrl;
-    return {
-      execute: (cwd) => context.addRuntime.runAddPatternCommand({
-        catalogTitle,
-        cwd,
-        patternScope: scope,
-        patternName: name,
-        sectionRole,
-        tags,
-        thumbnailUrl
-      }),
-      getDryRunSummaryLines: (result) => buildPatternCatalogDryRunSummaryLines(result, {
-        rawCatalogTitle,
-        rawScope,
-        rawSectionRole,
-        rawTags: tags,
-        rawThumbnailUrl
-      }),
-      getValues: (result) => ({
-        contentFile: result.contentFile,
-        patternSlug: result.patternSlug,
-        patternScope: result.patternScope,
-        ...result.sectionRole ? { sectionRole: result.sectionRole } : {}
-      }),
-      warnLine: context.warnLine
-    };
-  },
-  sortOrder: 60,
-  supportsDryRun: true,
-  usage: "wp-typia add pattern <name> [--scope <full|section>] [--section-role <role>] [--catalog-title <title>] [--tags <tag,...>] [--tag <tag>...] [--thumbnail-url <url>] [--dry-run]",
-  visibleFieldNames: () => PATTERN_CATALOG_VISIBLE_FIELDS
-});
-function createInvalidPatternArgumentError(message) {
-  return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, message);
-}
-function createMissingPatternArgumentError(message) {
-  return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-}
-function resolvePatternScopeFlag(context) {
-  const scope = readOptionalLooseStringFlag(context.flags, "scope");
-  if (!scope) {
-    return;
-  }
-  if (context.addRuntime.PATTERN_CATALOG_SCOPE_IDS.includes(scope)) {
-    return scope;
-  }
-  throw createInvalidPatternArgumentError(`\`--scope\` must be one of: ${context.addRuntime.PATTERN_CATALOG_SCOPE_IDS.join(", ")}. Usage: wp-typia add pattern <name> --scope <full|section>.`);
-}
-function resolvePatternSectionRoleFlag(context, scope) {
-  const sectionRole = readOptionalLooseStringFlag(context.flags, "section-role");
-  if (scope === "section" && sectionRole === undefined) {
-    throw createMissingPatternArgumentError("`wp-typia add pattern --scope section` requires --section-role <role> because section-scoped patterns need a typed catalog section role.");
-  }
-  if (scope !== "section" && sectionRole !== undefined) {
-    throw createInvalidPatternArgumentError("`--section-role` only applies with `--scope section`. Use `--scope section --section-role <role>` or omit `--section-role` for full patterns.");
-  }
-  const normalizedSectionRole = sectionRole === undefined ? undefined : context.addRuntime.normalizeBlockSlug(sectionRole);
-  if (normalizedSectionRole && !context.addRuntime.PATTERN_SECTION_ROLE_PATTERN.test(normalizedSectionRole)) {
-    throw createInvalidPatternArgumentError("`--section-role` must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens. Section roles apply only with `--scope section`.");
-  }
-  if (sectionRole !== undefined && !normalizedSectionRole) {
-    throw createInvalidPatternArgumentError("`--section-role` must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens. Section roles apply only with `--scope section`.");
-  }
-  return normalizedSectionRole;
-}
-function collectStringFlagValues(value) {
-  if (typeof value === "string") {
-    return [value];
-  }
-  if (Array.isArray(value)) {
-    return value.filter((item) => typeof item === "string");
-  }
-  return [];
-}
-function normalizePatternTagFlags(tagsFlag, tagFlag) {
-  const tags = [
-    ...collectStringFlagValues(tagsFlag),
-    ...collectStringFlagValues(tagFlag)
-  ];
-  return tags.length > 0 ? tags : undefined;
-}
-function quoteValue(value) {
-  return `"${value}"`;
-}
-function formatTags(tags) {
-  return tags.length > 0 ? tags.join(", ") : "no tags";
-}
-function collectPatternTagTokens(tags) {
-  return (tags ?? []).flatMap((tag) => tag.split(",")).map((tag) => tag.trim()).filter((tag) => tag.length > 0);
-}
-function valuesMatch(left, right) {
-  return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function createNormalizationNote(options) {
-  const rawValue = options.rawValue;
-  if (rawValue === undefined || rawValue.trim().length === 0 || !options.resolvedValue || rawValue === options.resolvedValue) {
-    return;
-  }
-  return `${options.fieldLabel} normalized from ${quoteValue(rawValue)} to ${quoteValue(options.resolvedValue)}.`;
-}
-function collectPatternCatalogNormalizationNotes(result, options) {
-  const notes = [
-    createNormalizationNote({
-      fieldLabel: "Scope",
-      rawValue: options.rawScope,
-      resolvedValue: result.patternScope
-    }),
-    createNormalizationNote({
-      fieldLabel: "Section role",
-      rawValue: options.rawSectionRole,
-      resolvedValue: result.sectionRole
-    }),
-    createNormalizationNote({
-      fieldLabel: "Title",
-      rawValue: options.rawCatalogTitle,
-      resolvedValue: result.title
-    }),
-    createNormalizationNote({
-      fieldLabel: "Thumbnail URL",
-      rawValue: options.rawThumbnailUrl,
-      resolvedValue: result.thumbnailUrl
-    })
-  ].filter((note) => typeof note === "string");
-  const rawTags = collectPatternTagTokens(options.rawTags);
-  if (rawTags.length > 0 && !valuesMatch(rawTags, result.tags)) {
-    notes.push(`Tags normalized from ${quoteValue(formatTags(rawTags))} to ${quoteValue(formatTags(result.tags))}.`);
-  }
-  return notes;
-}
-function buildPatternCatalogDryRunSummaryLines(result, options) {
-  const catalogLines = [
-    "",
-    "Catalog metadata:",
-    `  Scope: ${result.patternScope}`,
-    ...result.sectionRole ? [`  Section role: ${result.sectionRole}`] : [],
-    `  Title: ${result.title}`,
-    ...result.tags.length > 0 ? [`  Tags: ${formatTags(result.tags)}`] : [],
-    ...result.thumbnailUrl ? [`  Thumbnail URL: ${result.thumbnailUrl}`] : []
-  ];
-  const normalizationNotes = collectPatternCatalogNormalizationNotes(result, options);
-  if (normalizationNotes.length === 0) {
-    return catalogLines;
-  }
-  return [
-    ...catalogLines,
-    "",
-    "Normalization notes:",
-    ...normalizationNotes.map((note) => `  ${note}`)
-  ];
-}
-
-// src/add-kinds/post-meta.ts
-var POST_META_MISSING_NAME_MESSAGE = "`wp-typia add post-meta` requires <name>. Usage: wp-typia add post-meta <name> --post-type <post-type> [--type <ExportedTypeName>] [--meta-key <meta-key>].";
-var POST_META_MISSING_POST_TYPE_MESSAGE = "`wp-typia add post-meta` requires --post-type <post-type>. Usage: wp-typia add post-meta <name> --post-type <post-type>.";
-var postMetaAddKindEntry = defineAddKindRegistryEntry({
-  completion: {
-    nextSteps: (values) => [
-      `Edit ${values.typesFile} when the post meta shape changes.`,
-      "Run `wp-typia sync-rest --check` to verify the generated meta schema is current.",
-      `Smoke test ${values.metaKey} on the ${values.postType} post type in WordPress.`
-    ],
-    summaryLines: (values, projectDir) => [
-      `Post meta contract: ${values.postMetaSlug}`,
-      `Post type: ${values.postType}`,
-      `Meta key: ${values.metaKey}`,
-      `REST/editor exposure: ${values.showInRest}`,
-      `Schema: ${values.schemaFile}`,
-      `PHP: ${values.phpFile}`,
-      `Project directory: ${projectDir}`
-    ],
-    title: "Added post meta contract"
-  },
-  description: "Add a typed WordPress post meta contract",
-  hiddenBooleanSubmitFields: ["hide-from-rest"],
-  hiddenStringSubmitFields: ["meta-key"],
-  nameLabel: "Post meta name",
-  async prepareExecution(context) {
-    const name = requireAddKindName(context, POST_META_MISSING_NAME_MESSAGE);
-    const hideFromRest = Boolean(context.flags["hide-from-rest"] ?? context.flags.hideFromRest);
-    const metaKey = readOptionalDashedOrCamelStringFlag(context.flags, "meta-key", "metaKey");
-    const postType = readOptionalDashedOrCamelStringFlag(context.flags, "post-type", "postType") ?? requireStrictStringFlag(context.flags, "post-type", POST_META_MISSING_POST_TYPE_MESSAGE);
-    const typeName = readOptionalStrictStringFlag(context.flags, "type");
-    return createNamedExecutionPlan(context, {
-      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddPostMetaCommand({
-        cwd,
-        hideFromRest,
-        metaKey,
-        postMetaName: name2,
-        postType,
-        typeName
-      }),
-      getValues: (result) => ({
-        metaKey: result.metaKey,
-        phpFile: result.phpFile,
-        postMetaSlug: result.postMetaSlug,
-        postType: result.postType,
-        schemaFile: result.schemaFile,
-        showInRest: result.showInRest ? "enabled" : "disabled",
-        sourceTypeName: result.sourceTypeName,
-        typesFile: result.typesFile
-      }),
-      missingNameMessage: POST_META_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  sortOrder: 85,
-  supportsDryRun: true,
-  usage: "wp-typia add post-meta <name> --post-type <post-type> [--type <ExportedTypeName>] [--meta-key <meta-key>] [--hide-from-rest] [--dry-run]",
-  visibleFieldNames: () => NAME_POST_TYPE_TYPE_VISIBLE_FIELDS
-});
-
-// src/add-kinds/rest-resource.ts
-var REST_RESOURCE_GENERATED_USAGE = "Generated: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--route-pattern <route-pattern>] [--permission-callback <callback>] [--controller-class <ClassName>] [--controller-extends <BaseClass>] [--dry-run]";
-var REST_RESOURCE_MANUAL_USAGE = "Manual: wp-typia add rest-resource <name> --manual [--namespace <vendor/v1>] [--method <GET|POST|PUT|PATCH|DELETE>] [--auth <public|authenticated|public-write-protected>] [--path <route-pattern>|--route-pattern <route-pattern>] [--permission-callback <callback>] [--controller-class <ClassName>] [--controller-extends <BaseClass>] [--query-type <Type>] [--body-type <Type>] [--response-type <Type>] [--secret-field <field>] [--secret-state-field|--secret-has-value-field <field>] [--secret-preserve-on-empty <true|false>] [--dry-run]";
-var REST_RESOURCE_USAGE = `${REST_RESOURCE_GENERATED_USAGE}
-${REST_RESOURCE_MANUAL_USAGE}`;
-var REST_RESOURCE_MISSING_NAME_MESSAGE = [
-  "`wp-typia add rest-resource` requires <name>. Usage:",
-  `  ${REST_RESOURCE_GENERATED_USAGE}`,
-  `  ${REST_RESOURCE_MANUAL_USAGE}`
-].join(`
-`);
-var SECRET_PRESERVE_ON_EMPTY_TRUE_VALUES = new Set(["1", "true", "yes"]);
-var SECRET_PRESERVE_ON_EMPTY_FALSE_VALUES = new Set(["0", "false", "no"]);
-function readOptionalSecretPreserveOnEmptyFlag(flags) {
-  const value = flags["secret-preserve-on-empty"] ?? flags.secretPreserveOnEmpty;
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value !== "string") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`--secret-preserve-on-empty` requires a value.");
-  }
-  const normalized = value.trim().toLowerCase();
-  if (normalized.length === 0) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`--secret-preserve-on-empty` requires a value.");
-  }
-  if (SECRET_PRESERVE_ON_EMPTY_TRUE_VALUES.has(normalized)) {
-    return true;
-  }
-  if (SECRET_PRESERVE_ON_EMPTY_FALSE_VALUES.has(normalized)) {
-    return false;
-  }
-  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "Manual REST contract --secret-preserve-on-empty must be true or false.");
-}
-var restResourceAddKindEntry = defineAddKindRegistryEntry({
-  completion: {
-    nextSteps: (values) => values.mode === "manual" ? [
-      `Review src/rest/${values.restResourceSlug}/ and edit the manual contract types to match the external route owner.`,
-      "Run sync-rest --check after changing the contract types to verify schemas, OpenAPI, and client artifacts."
-    ] : [
-      `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}`,
-      `Mode: ${values.mode}`,
-      `Namespace: ${values.namespace}`,
-      ...values.mode === "manual" ? [
-        `Route: ${values.method} /${values.namespace}${values.pathPattern}`,
-        `Auth: ${values.auth}`,
-        ...values.secretFieldName ? [
-          `Secret field: ${values.secretFieldName} -> ${values.secretStateFieldName}`,
-          `Secret preserve on empty: ${values.secretPreserveOnEmpty}`
-        ] : [],
-        ...values.permissionCallback ? [`Declared permission callback: ${values.permissionCallback}`] : [],
-        ...values.controllerClass ? [`Declared controller class: ${values.controllerClass}`] : [],
-        ...values.controllerExtends ? [`Declared controller base: ${values.controllerExtends}`] : []
-      ] : [
-        `Methods: ${values.methods}`,
-        ...values.routePattern ? [`Item route: /${values.namespace}${values.routePattern}`] : [],
-        ...values.permissionCallback ? [`Permission callback: ${values.permissionCallback}`] : [],
-        ...values.controllerClass ? [`Controller class: ${values.controllerClass}`] : []
-      ],
-      `Project directory: ${projectDir}`
-    ],
-    title: "Added REST resource contract"
-  },
-  description: "Add a generated or type-only REST resource contract",
-  hiddenBooleanSubmitFields: ["manual"],
-  hiddenStringSubmitFields: [
-    "auth",
-    "body-type",
-    "controller-class",
-    "controller-extends",
-    "method",
-    "path",
-    "permission-callback",
-    "query-type",
-    "response-type",
-    "route-pattern",
-    "secret-field",
-    "secret-has-value-field",
-    "secret-masked-response-field",
-    "secret-preserve-on-empty",
-    "secret-state-field"
-  ],
-  nameLabel: "REST resource name",
-  async prepareExecution(context) {
-    const name = requireAddKindName(context, REST_RESOURCE_MISSING_NAME_MESSAGE);
-    const auth = readOptionalStrictStringFlag(context.flags, "auth");
-    const bodyTypeName = readOptionalStrictStringFlag(context.flags, "body-type");
-    const controllerClass = readOptionalDashedOrCamelStringFlag(context.flags, "controller-class", "controllerClass");
-    const controllerExtends = readOptionalDashedOrCamelStringFlag(context.flags, "controller-extends", "controllerExtends");
-    const manual = Boolean(context.flags.manual);
-    const method = readOptionalStrictStringFlag(context.flags, "method");
-    const methods = readOptionalStrictStringFlag(context.flags, "methods");
-    const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
-    const permissionCallback = readOptionalDashedOrCamelStringFlag(context.flags, "permission-callback", "permissionCallback");
-    const pathPattern = readOptionalStrictStringFlag(context.flags, "path");
-    const queryTypeName = readOptionalStrictStringFlag(context.flags, "query-type");
-    const responseTypeName = readOptionalStrictStringFlag(context.flags, "response-type");
-    const routePattern = readOptionalDashedOrCamelStringFlag(context.flags, "route-pattern", "routePattern");
-    const secretFieldName = readOptionalDashedOrCamelStringFlag(context.flags, "secret-field", "secretField");
-    const secretHasValueFieldName = readOptionalDashedOrCamelStringFlag(context.flags, "secret-has-value-field", "secretHasValueField");
-    const secretMaskedResponseFieldName = readOptionalDashedOrCamelStringFlag(context.flags, "secret-masked-response-field", "secretMaskedResponseField");
-    const secretPreserveOnEmpty = readOptionalSecretPreserveOnEmptyFlag(context.flags);
-    const secretStateFieldName = readOptionalDashedOrCamelStringFlag(context.flags, "secret-state-field", "secretStateField");
-    return createNamedExecutionPlan(context, {
-      execute: ({ cwd, name: name2 }) => context.addRuntime.runAddRestResourceCommand({
-        auth,
-        bodyTypeName,
-        controllerClass,
-        controllerExtends,
-        cwd,
-        manual,
-        method,
-        methods,
-        namespace,
-        permissionCallback,
-        pathPattern,
-        queryTypeName,
-        restResourceName: name2,
-        responseTypeName,
-        routePattern,
-        secretFieldName,
-        secretHasValueFieldName,
-        secretMaskedResponseFieldName,
-        secretPreserveOnEmpty,
-        secretStateFieldName
-      }),
-      getValues: (result) => ({
-        auth: result.auth ?? "",
-        controllerClass: result.controllerClass ?? "",
-        controllerExtends: result.controllerExtends ?? "",
-        method: result.method ?? "",
-        methods: result.methods.join(", "),
-        mode: result.mode,
-        namespace: result.namespace,
-        pathPattern: result.pathPattern ?? "",
-        permissionCallback: result.permissionCallback ?? "",
-        restResourceSlug: result.restResourceSlug,
-        routePattern: result.routePattern ?? "",
-        secretFieldName: result.secretFieldName ?? "",
-        secretPreserveOnEmpty: result.secretPreserveOnEmpty === undefined ? "" : String(result.secretPreserveOnEmpty),
-        secretStateFieldName: result.secretStateFieldName ?? ""
-      }),
-      missingNameMessage: REST_RESOURCE_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  sortOrder: 80,
-  supportsDryRun: true,
-  usage: REST_RESOURCE_USAGE,
-  visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
-});
-
-// src/add-kinds/style.ts
-var STYLE_MISSING_NAME_MESSAGE = "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.";
-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, STYLE_MISSING_NAME_MESSAGE);
-    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: STYLE_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  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 TRANSFORM_MISSING_NAME_MESSAGE = "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.";
-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, TRANSFORM_MISSING_NAME_MESSAGE);
-    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: TRANSFORM_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  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 VARIATION_MISSING_NAME_MESSAGE = "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>";
-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, VARIATION_MISSING_NAME_MESSAGE);
-    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: VARIATION_MISSING_NAME_MESSAGE,
-      name,
-      warnLine: context.warnLine
-    });
-  },
-  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,
-  "integration-env": integrationEnvAddKindEntry,
-  "core-variation": coreVariationAddKindEntry,
-  variation: variationAddKindEntry,
-  style: styleAddKindEntry,
-  transform: transformAddKindEntry,
-  pattern: patternAddKindEntry,
-  "binding-source": bindingSourceAddKindEntry,
-  contract: contractAddKindEntry,
-  "rest-resource": restResourceAddKindEntry,
-  "post-meta": postMetaAddKindEntry,
-  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 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";
-import path from "path";
-var SKIPPED_COPY_ROOT_ENTRIES = new Set([".git", "node_modules"]);
-var SKIPPED_COMPARE_ROOT_ENTRIES = new Set([
-  ".git",
-  ".pnp.cjs",
-  ".pnp.loader.mjs",
-  "node_modules"
-]);
-async function copyWorkspaceProject(sourceDir, targetDir) {
-  await fsp.cp(sourceDir, targetDir, {
-    filter: (sourcePath) => {
-      const relativePath = path.relative(sourceDir, sourcePath);
-      if (relativePath === "") {
-        return true;
-      }
-      const [rootEntry] = relativePath.split(path.sep);
-      return !SKIPPED_COPY_ROOT_ENTRIES.has(rootEntry ?? "");
-    },
-    recursive: true
-  });
-}
-function formatInstallMarkerError(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-function formatInstallMarkerFailures(failures) {
-  return failures.map((failure) => `${failure.operation}: ${failure.reason}`).join("; ");
-}
-function ensureWorkspaceInstallMarker({
-  fsAdapter = fs2,
-  sourceMarker,
-  targetMarker
-}) {
-  const failures = [];
-  try {
-    fsAdapter.symlinkSync(sourceMarker, targetMarker);
-    return;
-  } catch (error) {
-    failures.push({
-      operation: "symlink",
-      reason: formatInstallMarkerError(error)
-    });
-  }
-  try {
-    fsAdapter.linkSync(sourceMarker, targetMarker);
-    return;
-  } catch (error) {
-    failures.push({
-      operation: "hard link",
-      reason: formatInstallMarkerError(error)
-    });
-  }
-  try {
-    fsAdapter.copyFileSync(sourceMarker, targetMarker);
-    return;
-  } catch (error) {
-    failures.push({
-      operation: "copy",
-      reason: formatInstallMarkerError(error)
-    });
-  }
-  throw new Error([
-    "Failed to prepare dry-run install marker.",
-    `Source: ${sourceMarker}`,
-    `Target: ${targetMarker}`,
-    `Fallback failures: ${formatInstallMarkerFailures(failures)}`
-  ].join(" "));
-}
-function ensureWorkspaceInstallMarkers(sourceDir, targetDir) {
-  const sourceNodeModules = path.join(sourceDir, "node_modules");
-  if (fs2.existsSync(sourceNodeModules)) {
-    fs2.symlinkSync(sourceNodeModules, path.join(targetDir, "node_modules"), "junction");
-  }
-  for (const marker of [".pnp.cjs", ".pnp.loader.mjs"]) {
-    const sourceMarker = path.join(sourceDir, marker);
-    if (!fs2.existsSync(sourceMarker)) {
-      continue;
-    }
-    const targetMarker = path.join(targetDir, marker);
-    ensureWorkspaceInstallMarker({ sourceMarker, targetMarker });
-  }
-}
-async function listWorkspaceFiles(rootDir) {
-  const files = new Map;
-  async function visit(currentDir) {
-    const entries = await fsp.readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const absolutePath = path.join(currentDir, entry.name);
-      const relativePath = path.relative(rootDir, absolutePath);
-      const [rootEntry] = relativePath.split(path.sep);
-      if (SKIPPED_COMPARE_ROOT_ENTRIES.has(rootEntry ?? "")) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        await visit(absolutePath);
-        continue;
-      }
-      if (!entry.isFile()) {
-        continue;
-      }
-      files.set(relativePath.replace(path.sep === "\\" ? /\\/gu : /\//gu, "/"), await fsp.readFile(absolutePath));
-    }
-  }
-  await visit(rootDir);
-  return files;
-}
-function compareStrings(left, right) {
-  if (left < right) {
-    return -1;
-  }
-  if (left > right) {
-    return 1;
-  }
-  return 0;
-}
-async function collectWorkspaceFileOperations(sourceDir, simulatedDir) {
-  const [sourceFiles, simulatedFiles] = await Promise.all([
-    listWorkspaceFiles(sourceDir),
-    listWorkspaceFiles(simulatedDir)
-  ]);
-  const operations = [];
-  for (const [relativePath, simulatedSource] of simulatedFiles) {
-    const originalSource = sourceFiles.get(relativePath);
-    if (originalSource === undefined) {
-      operations.push(`write ${relativePath}`);
-      continue;
-    }
-    if (!originalSource.equals(simulatedSource)) {
-      operations.push(`update ${relativePath}`);
-    }
-  }
-  for (const relativePath of sourceFiles.keys()) {
-    if (!simulatedFiles.has(relativePath)) {
-      operations.push(`delete ${relativePath}`);
-    }
-  }
-  return operations.sort(compareStrings);
-}
-async function simulateWorkspaceAddDryRun({
-  cwd,
-  execute
-}) {
-  const { resolveWorkspaceProject } = await import("./workspace-project-gmv2a71z.js");
-  const workspace = resolveWorkspaceProject(cwd);
-  const relativeCwd = path.relative(workspace.projectDir, path.resolve(cwd));
-  const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-add-plan-");
-  const simulatedProjectDir = path.join(tempRoot, "workspace");
-  try {
-    await copyWorkspaceProject(workspace.projectDir, simulatedProjectDir);
-    ensureWorkspaceInstallMarkers(workspace.projectDir, simulatedProjectDir);
-    const simulatedCwd = relativeCwd.length > 0 ? path.join(simulatedProjectDir, relativeCwd) : simulatedProjectDir;
-    const result = await execute(simulatedCwd);
-    const fileOperations = await collectWorkspaceFileOperations(workspace.projectDir, simulatedProjectDir);
-    return {
-      fileOperations,
-      result
-    };
-  } finally {
-    await cleanup();
-  }
-}
-
-// src/string-utils.ts
-function escapeRegExp(source) {
-  return source.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-
-// src/output-markers.ts
-var UNICODE_OUTPUT_MARKERS = {
-  dryRun: "\uD83E\uDDEA",
-  progress: "\u23F3",
-  success: "\u2705",
-  warning: "\u26A0\uFE0F"
-};
-var ASCII_OUTPUT_MARKERS = {
-  dryRun: "[dry-run]",
-  progress: "[...]",
-  success: "[ok]",
-  warning: "[!]"
-};
-var ASCII_ENV_TRUTHY_VALUES = new Set(["1", "on", "true", "yes"]);
-var ASCII_ENV_FALSY_VALUES = new Set(["0", "off", "false", "no"]);
-function readAsciiPreferenceFromEnv(env) {
-  const rawValue = env.WP_TYPIA_ASCII;
-  if (typeof rawValue !== "string") {
-    return;
-  }
-  const normalizedValue = rawValue.trim().toLowerCase();
-  if (ASCII_ENV_TRUTHY_VALUES.has(normalizedValue)) {
-    return true;
-  }
-  if (ASCII_ENV_FALSY_VALUES.has(normalizedValue)) {
-    return false;
-  }
-  return;
-}
-function hasNoColorPreference(env) {
-  return typeof env.NO_COLOR === "string" && env.NO_COLOR.length > 0;
-}
-function prefersAsciiOutput(options = {}) {
-  if (options.forceAscii) {
-    return true;
-  }
-  const env = options.env ?? process.env;
-  const envPreference = readAsciiPreferenceFromEnv(env);
-  if (envPreference !== undefined) {
-    return envPreference;
-  }
-  if (hasNoColorPreference(env)) {
-    return true;
-  }
-  const term = options.term ?? env.TERM;
-  if (term === "dumb") {
-    return true;
-  }
-  const locale = (env.LC_ALL ?? env.LC_CTYPE ?? env.LANG ?? "").toUpperCase();
-  if (locale.includes("UTF-8") || locale.includes("UTF8")) {
-    return false;
-  }
-  if (locale === "C" || locale === "POSIX") {
-    return true;
-  }
-  if (locale.includes("ASCII") || locale.includes("ANSI_X3") || locale.includes("8859")) {
-    return true;
-  }
-  return false;
-}
-function getOutputMarker(kind, options = {}) {
-  return prefersAsciiOutput(options) ? ASCII_OUTPUT_MARKERS[kind] : UNICODE_OUTPUT_MARKERS[kind];
-}
-function formatOutputMarker(kind, text, options = {}) {
-  return `${getOutputMarker(kind, options)} ${text}`;
-}
-function stripLeadingOutputMarker(text, kind) {
-  const markers = kind ? [UNICODE_OUTPUT_MARKERS[kind], ASCII_OUTPUT_MARKERS[kind]] : Array.from(new Set([
-    ...Object.values(UNICODE_OUTPUT_MARKERS),
-    ...Object.values(ASCII_OUTPUT_MARKERS)
-  ]));
-  const markerPattern = markers.map((marker) => escapeRegExp(marker)).join("|");
-  return text.replace(new RegExp(`^(?:${markerPattern})\\s*`, "u"), "");
-}
-
-// src/runtime-output/init.ts
-function buildInitCompletionPayload(plan, markerOptions) {
-  const changeLines = [
-    ...plan.packageChanges.addDevDependencies.map((dependency) => `devDependency ${dependency.action} ${dependency.name} -> ${dependency.requiredValue}`),
-    ...plan.packageChanges.packageManagerField ? [
-      `packageManager ${plan.packageChanges.packageManagerField.action} -> ${plan.packageChanges.packageManagerField.requiredValue}`
-    ] : [],
-    ...plan.packageChanges.scripts.map((script) => `script ${script.action} ${script.name} -> ${script.requiredValue}`),
-    ...plan.plannedFiles.map((filePlan) => `file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`),
-    ...plan.commandMode === "preview-only" ? plan.generatedArtifacts.map((artifactPath) => `generated artifact ${artifactPath}`) : []
-  ];
-  const modeLine = plan.commandMode === "apply" ? plan.status === "already-initialized" ? "Mode: apply requested; no files were written because the retrofit surface already existed." : "Mode: apply; package.json and retrofit helper files were written." : "Mode: preview only; no files were written.";
-  const optionalTitle = plan.commandMode === "apply" ? `Applied adoption changes (${changeLines.length}):` : `Planned adoption changes (${changeLines.length}):`;
-  const title = plan.status === "already-initialized" ? formatOutputMarker("success", `wp-typia init: ${plan.projectName} is already initialized`, markerOptions) : plan.commandMode === "apply" ? formatOutputMarker("success", `Applied retrofit init for ${plan.projectName}`, markerOptions) : formatOutputMarker("dryRun", `Retrofit init plan for ${plan.projectName}`, markerOptions);
-  return {
-    nextSteps: plan.nextSteps,
-    optionalLines: changeLines,
-    optionalNote: plan.summary,
-    optionalTitle,
-    summaryLines: [
-      `Project directory: ${plan.projectDir}`,
-      `Detected layout: ${plan.detectedLayout.description}`,
-      ...plan.detectedLayout.blockNames.length > 0 ? [`Block targets: ${plan.detectedLayout.blockNames.join(", ")}`] : [],
-      `Package manager: ${plan.packageManager}`,
-      modeLine
-    ],
-    title,
-    warningLines: plan.notes
-  };
-}
-
-// src/runtime-output/structured.ts
-function toNonEmptyArray(values) {
-  return values && values.length > 0 ? values : undefined;
-}
-function extractPlannedFiles(payload) {
-  const files = payload.optionalLines?.map((line) => line.match(/^(?:delete|update|write)\s+(.+)$/u)?.[1]).filter((value) => typeof value === "string" && value.length > 0);
-  return toNonEmptyArray(files);
-}
-var PROJECT_DIRECTORY_SUMMARY_PREFIX = "Project directory: ";
-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;
-}
-function serializeCompletionPayload(payload) {
-  return {
-    nextSteps: toNonEmptyArray(payload.nextSteps),
-    optionalLines: toNonEmptyArray(payload.optionalLines),
-    optionalNote: payload.optionalNote,
-    optionalTitle: payload.optionalTitle,
-    preambleLines: toNonEmptyArray(payload.preambleLines),
-    summaryLines: toNonEmptyArray(payload.summaryLines),
-    title: stripLeadingOutputMarker(payload.title),
-    warningLines: toNonEmptyArray(payload.warningLines)
-  };
-}
-function buildStructuredCompletionSuccessPayload(command, completion, metadata = {}) {
-  const serializedCompletion = completion ? serializeCompletionPayload(completion) : undefined;
-  return {
-    ok: true,
-    data: {
-      ...metadata,
-      command,
-      ...serializedCompletion ? {
-        completion: serializedCompletion,
-        files: extractPlannedFiles(serializedCompletion)
-      } : {}
-    }
-  };
-}
-function buildStructuredInitSuccessPayload(plan) {
-  const completion = serializeCompletionPayload(buildInitCompletionPayload(plan));
-  const files = Array.from(new Set([
-    ...plan.plannedFiles.map((filePlan) => filePlan.path),
-    ...plan.commandMode === "preview-only" ? plan.generatedArtifacts : []
-  ]));
-  return {
-    ok: true,
-    data: {
-      command: "init",
-      completion,
-      detectedLayout: plan.detectedLayout,
-      files: toNonEmptyArray(files),
-      mode: plan.commandMode === "apply" ? "apply" : "preview",
-      packageManager: plan.packageManager,
-      plan,
-      projectDir: plan.projectDir,
-      status: plan.status,
-      summary: plan.summary
-    }
-  };
-}
-// src/runtime-output/create.ts
-var LOOSE_CREATE_COMPLETION_PACKAGE_MANAGER_PATTERN = new RegExp(`^(?:corepack\\s+)?(${PACKAGE_MANAGER_IDS.map(escapeRegExp).join("|")})(?=$|[@:/+\\s])`, "iu");
-function parseCreateCompletionPackageManager(packageManager) {
-  const normalizedPackageManager = packageManager.trim();
-  const parsedPackageManager = parsePackageManagerField(normalizedPackageManager);
-  if (parsedPackageManager) {
-    return parsedPackageManager;
-  }
-  const looseMatch = LOOSE_CREATE_COMPLETION_PACKAGE_MANAGER_PATTERN.exec(normalizedPackageManager);
-  const loosePackageManager = looseMatch?.[1]?.toLowerCase();
-  return PACKAGE_MANAGER_IDS.includes(loosePackageManager) ? loosePackageManager : null;
-}
-function resolveCreateCompletionPackageManager(packageManager) {
-  const parsedPackageManager = parseCreateCompletionPackageManager(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 formatCreateProgressLine(payload, markerOptions) {
-  return formatOutputMarker("progress", `${payload.title}: ${payload.detail}`, markerOptions);
-}
-function buildCreateCompletionPayload(flow, markerOptions) {
-  const packageManager = resolveCreateCompletionPackageManager(flow.packageManager);
-  const verificationSteps = [
-    formatPackageExecCommand(packageManager, `wp-typia@${package_default.version}`, "doctor"),
-    ...flow.optionalOnboarding.steps
-  ];
-  return {
-    nextSteps: flow.nextSteps,
-    optionalLines: verificationSteps,
-    optionalNote: flow.optionalOnboarding.shortNote ?? flow.optionalOnboarding.note,
-    optionalTitle: "Verify and sync (optional):",
-    preambleLines: flow.result.selectedVariant ? [`Template variant: ${flow.result.selectedVariant}`] : undefined,
-    summaryLines: [`Project directory: ${flow.projectDir}`],
-    title: formatOutputMarker("success", `Created ${flow.result.variables.title} in ${flow.projectDir}`, markerOptions),
-    warningLines: flow.result.warnings
-  };
-}
-function buildCreateDryRunPayload(flow, markerOptions) {
-  let dependencyInstallLine;
-  switch (flow.plan.dependencyInstall) {
-    case "skipped-by-flag":
-      dependencyInstallLine = "Dependency install: already skipped via --no-install";
-      break;
-    case "would-install":
-      dependencyInstallLine = "Dependency install: would run during a real scaffold";
-      break;
-  }
-  return {
-    optionalLines: flow.plan.files.map((relativePath) => `write ${relativePath}`),
-    optionalNote: "No files were written because --dry-run was enabled. Re-run without --dry-run to materialize this scaffold.",
-    optionalTitle: `Planned files (${flow.plan.files.length}):`,
-    preambleLines: flow.result.selectedVariant ? [`Template variant: ${flow.result.selectedVariant}`] : undefined,
-    summaryLines: [
-      `Project directory: ${flow.projectDir}`,
-      `Template: ${flow.result.templateId}`,
-      `Package manager: ${flow.packageManager}`,
-      dependencyInstallLine
-    ],
-    title: formatOutputMarker("dryRun", `Dry run for ${flow.result.variables.title} at ${flow.projectDir}`, markerOptions),
-    warningLines: flow.result.warnings
-  };
-}
-// src/runtime-output/add.ts
-function buildAddCompletionPayload(options, markerOptions) {
-  const verificationLines = [
-    formatPackageExecCommand(options.packageManager ?? inferPackageManagerId(options.projectDir), `wp-typia@${package_default.version}`, "doctor")
-  ];
-  const verificationNote = "Run doctor via your package manager for a quick inventory and generated-artifact check after the add workflow.";
-  const completion = buildAddKindCompletionDetails(options.kind, {
-    projectDir: options.projectDir,
-    values: options.values
-  });
-  return {
-    nextSteps: completion.nextSteps,
-    optionalLines: verificationLines,
-    optionalNote: verificationNote,
-    optionalTitle: "Verify workspace health (optional):",
-    summaryLines: completion.summaryLines,
-    title: formatOutputMarker("success", completion.title, markerOptions),
-    warningLines: options.warnings
-  };
-}
-function buildAddDryRunPayload(options, markerOptions) {
-  const normalizedTitle = stripLeadingOutputMarker(options.completion.title, "success").replace(/^Added\s*/u, "");
-  const summaryLines = [
-    ...options.completion.summaryLines ?? [],
-    ...options.summaryLines ?? []
-  ];
-  return {
-    optionalLines: options.fileOperations,
-    optionalNote: "No workspace files were changed because --dry-run was enabled. Re-run without --dry-run to apply this add command.",
-    optionalTitle: `Planned workspace updates (${options.fileOperations.length}):`,
-    preambleLines: options.completion.preambleLines,
-    summaryLines: summaryLines.length > 0 ? summaryLines : undefined,
-    title: formatOutputMarker("dryRun", `Dry run for ${normalizedTitle || "workspace add command"}`, markerOptions),
-    warningLines: options.completion.warningLines
-  };
-}
-// src/runtime-output/migrate.ts
-function buildMigrationCompletionPayload(options, markerOptions) {
-  const summaryLines = options.lines.filter((line) => line.trim().length > 0);
-  return {
-    summaryLines,
-    title: formatOutputMarker("success", `Completed wp-typia migrate ${options.command}`, markerOptions)
-  };
-}
-// src/runtime-output/sync.ts
-function buildSyncDryRunPayload(options, markerOptions) {
-  const targetSuffix = options.target === "ai" ? " ai" : "";
-  const targetSummary = options.target === "ai" ? "Sync target: AI artifacts only." : options.target === "default" ? "Sync target: generated project defaults." : undefined;
-  return {
-    optionalLines: options.plannedCommands.map((command) => command.displayCommand),
-    optionalNote: options.check ? `No sync scripts were executed because --dry-run was enabled. Re-run \`wp-typia sync${targetSuffix} --check\` to verify generated artifacts without rewriting them.` : `No sync scripts were executed because --dry-run was enabled. Re-run \`wp-typia sync${targetSuffix}\` without --dry-run to apply generated-file updates, or add --check to verify without rewriting.`,
-    optionalTitle: `Planned sync commands (${options.plannedCommands.length}):`,
-    summaryLines: [
-      `Project directory: ${options.projectDir}`,
-      `Package manager: ${options.packageManager}`,
-      ...targetSummary ? [targetSummary] : [],
-      options.check ? "Execution mode: would run generated sync scripts in verification mode." : "Execution mode: would run generated sync scripts in apply mode."
-    ],
-    title: formatOutputMarker("dryRun", `Dry run for wp-typia sync${targetSuffix}`, markerOptions)
-  };
-}
-// src/print-block.ts
-function printBlock(printLine, lines) {
-  for (const line of lines) {
-    printLine(line);
-  }
-}
-
-// src/runtime-output/print.ts
-function printCompletionPayload(payload, options = {}) {
-  const printLine = options.printLine ?? console.log;
-  const warnLine = options.warnLine ?? printLine;
-  for (const line of payload.preambleLines ?? []) {
-    printLine(line);
-  }
-  for (const warning of payload.warningLines ?? []) {
-    warnLine(formatOutputMarker("warning", warning, options.markerOptions));
-  }
-  const hasDetails = (payload.summaryLines?.length ?? 0) > 0 || (payload.nextSteps?.length ?? 0) > 0 || (payload.optionalLines?.length ?? 0) > 0 || Boolean(payload.optionalNote);
-  const hasLeadingContext = (payload.preambleLines?.length ?? 0) > 0 || (payload.warningLines?.length ?? 0) > 0;
-  printLine(hasLeadingContext && hasDetails ? `
-${payload.title}` : payload.title);
-  for (const line of payload.summaryLines ?? []) {
-    printLine(line);
-  }
-  if ((payload.nextSteps?.length ?? 0) > 0) {
-    printLine("Next steps:");
-    for (const step of payload.nextSteps ?? []) {
-      printLine(`  ${step}`);
-    }
-  }
-  if ((payload.optionalLines?.length ?? 0) > 0) {
-    printLine(`
-${payload.optionalTitle ?? "Optional:"}`);
-    for (const step of payload.optionalLines ?? []) {
-      printLine(`  ${step}`);
-    }
-  }
-  if (payload.optionalNote) {
-    printLine(`Note: ${payload.optionalNote}`);
-  }
-}
-// src/runtime-capabilities.ts
-function isInteractiveTerminal({
-  stdin = process.stdin,
-  stdout = process.stdout,
-  term = process.env.TERM
-} = {}) {
-  return Boolean(stdin?.isTTY) && Boolean(stdout?.isTTY) && term !== "dumb";
-}
-function supportsInteractiveTui(options = {}) {
-  const hasBunRuntime = options.hasBunRuntime ?? typeof Bun !== "undefined";
-  return hasBunRuntime && isInteractiveTerminal(options);
-}
-
-// src/runtime-bridge-shared.ts
-var loadCliDiagnosticsRuntime = () => import("./cli-diagnostics-10drxh34.js");
-async function wrapCliCommandError(command, error) {
-  const { createCliCommandError } = await loadCliDiagnosticsRuntime();
-  return createCliCommandError({ command, error });
-}
-function shouldWrapCliCommandError(options) {
-  if (options.emitOutput === false) {
-    return false;
-  }
-  if (options.renderLine) {
-    return false;
-  }
-  return true;
-}
-function emitCompletion(payload, options) {
-  if (options.emitOutput) {
-    printCompletionPayload(payload, {
-      printLine: options.printLine,
-      warnLine: options.warnLine
-    });
-  }
-  return payload;
-}
-function pushFlag(argv, name, value) {
-  if (value === undefined || value === null || value === false) {
-    return;
-  }
-  if (value === true) {
-    argv.push(`--${name}`);
-    return;
-  }
-  argv.push(`--${name}`, String(value));
-}
-
-// src/runtime-bridge-add.ts
-var loadCliAddRuntime = () => import("./cli-add-qjd3ba8j.js");
-var loadCliPromptRuntime = () => import("./cli-prompt-ncyg68rn.js");
-async function executeWorkspaceAddWithOptionalDryRun(options) {
-  const simulated = options.dryRun ? await simulateWorkspaceAddDryRun({
-    cwd: options.cwd,
-    execute: options.execute
-  }) : null;
-  const result = simulated?.result ?? await options.execute(options.cwd);
-  const completion = options.buildCompletion(result);
-  if (!options.dryRun) {
-    return emitCompletion(completion, {
-      emitOutput: options.emitOutput ?? true,
-      printLine: options.printLine,
-      warnLine: options.warnLine
-    });
-  }
-  return emitCompletion(buildAddDryRunPayload({
-    completion,
-    fileOperations: simulated.fileOperations,
-    summaryLines: options.buildDryRunSummaryLines?.(result)
-  }), {
-    emitOutput: options.emitOutput ?? true,
-    printLine: options.printLine,
-    warnLine: options.warnLine
-  });
-}
-function executePreparedAddKind(kind, context, plan) {
-  return executeWorkspaceAddWithOptionalDryRun({
-    buildCompletion: (result) => buildAddCompletionPayload({
-      kind,
-      projectDir: result.projectDir,
-      values: plan.getValues(result),
-      warnings: plan.getWarnings?.(result)
-    }),
-    buildDryRunSummaryLines: (result) => plan.getDryRunSummaryLines?.(result),
-    cwd: context.cwd,
-    dryRun: context.dryRun,
-    emitOutput: context.emitOutput,
-    execute: plan.execute,
-    printLine: context.printLine,
-    warnLine: plan.warnLine
-  });
-}
-async function executePlannedAddKind(kind, executionContext, context) {
-  const plan = await getAddKindExecutionPlan(kind, executionContext);
-  return executePreparedAddKind(kind, context, plan);
-}
-async function executeAddCommand({
-  cwd,
-  emitOutput = true,
-  flags,
-  interactive,
-  kind,
-  name,
-  positionalArgs,
-  printLine = console.log,
-  prompt,
-  warnLine = console.warn
-}) {
-  let activePrompt;
-  const dryRun = Boolean(flags["dry-run"]);
-  try {
-    const addRuntime = await loadCliAddRuntime();
-    const isInteractiveSession = interactive ?? isInteractiveTerminal();
-    if (!kind) {
-      if (shouldPrintMissingAddKindHelp({ emitOutput })) {
-        printLine(addRuntime.formatAddHelpText());
-      }
-      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()}.`);
-    }
-    if (dryRun && !supportsAddKindDryRun(kind)) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
-    }
-    const executionContext = {
-      addRuntime,
-      cwd,
-      flags,
-      getOrCreatePrompt: async () => {
-        if (activePrompt) {
-          return activePrompt;
-        }
-        const { createReadlinePrompt } = await loadCliPromptRuntime();
-        activePrompt = prompt ?? createReadlinePrompt();
-        return activePrompt;
-      },
-      isInteractiveSession,
-      name,
-      positionalArgs,
-      warnLine
-    };
-    return await executePlannedAddKind(kind, executionContext, {
-      cwd,
-      dryRun,
-      emitOutput,
-      printLine
-    });
-  } catch (error) {
-    if (!shouldWrapCliCommandError({ emitOutput })) {
-      throw error;
-    }
-    throw await wrapCliCommandError("add", error);
-  } finally {
-    if (activePrompt && activePrompt !== prompt) {
-      activePrompt.close();
-    }
-  }
-}
-// src/runtime-bridge-create.ts
-var loadCliPromptRuntime2 = () => import("./cli-prompt-ncyg68rn.js");
-var loadCliScaffoldRuntime = () => import("./cli-scaffold-0bb6pr3w.js");
-var loadCliTemplatesRuntime = () => import("./cli-templates-g8t4fm11.js");
-var loadCreateTemplateValidationRuntime = () => import("./create-template-validation-4fr851vg.js");
-var PACKAGE_MANAGER_PROMPT_OPTIONS = [
-  { label: "npm", value: "npm", hint: "Use npm" },
-  { label: "pnpm", value: "pnpm", hint: "Use pnpm" },
-  { label: "yarn", value: "yarn", hint: "Use yarn" },
-  { label: "bun", value: "bun", hint: "Use bun" }
-];
-var DATA_STORAGE_PROMPT_OPTIONS = [
-  {
-    label: "custom-table",
-    value: "custom-table",
-    hint: "Dedicated custom table storage"
-  },
-  { label: "post-meta", value: "post-meta", hint: "Persist through post meta" }
-];
-var PERSISTENCE_POLICY_PROMPT_OPTIONS = [
-  {
-    label: "authenticated",
-    value: "authenticated",
-    hint: "Authenticated write policy"
-  },
-  { label: "public", value: "public", hint: "Public token policy" }
-];
-var BOOLEAN_PROMPT_OPTIONS = [
-  { label: "Yes", value: "yes", hint: "Enable this option" },
-  { label: "No", value: "no", hint: "Keep the default disabled state" }
-];
-async function executeCreateCommand({
-  projectDir,
-  cwd,
-  emitOutput = true,
-  flags,
-  interactive,
-  onProgress,
-  printLine = console.log,
-  prompt,
-  warnLine = console.warn
-}) {
-  let activePrompt;
-  try {
-    const requestedTemplateId = readOptionalLooseStringFlag(flags, "template");
-    const resolvedTemplateId = requestedTemplateId ? (await loadCreateTemplateValidationRuntime()).validateExplicitCreateTemplateId(requestedTemplateId) : undefined;
-    const [
-      { createReadlinePrompt },
-      { runScaffoldFlow },
-      { getTemplateSelectOptions }
-    ] = await Promise.all([
-      loadCliPromptRuntime2(),
-      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,
-      dataStorageMode: readOptionalLooseStringFlag(flags, "data-storage"),
-      dryRun: Boolean(flags["dry-run"]),
-      externalLayerId: readOptionalLooseStringFlag(flags, "external-layer-id"),
-      externalLayerSource: readOptionalLooseStringFlag(flags, "external-layer-source"),
-      innerBlocksPreset: readOptionalLooseStringFlag(flags, "inner-blocks-preset"),
-      isInteractive: Boolean(scaffoldPrompt),
-      namespace: readOptionalLooseStringFlag(flags, "namespace"),
-      noInstall: Boolean(flags["no-install"]),
-      packageManager: readOptionalLooseStringFlag(flags, "package-manager"),
-      persistencePolicy: readOptionalLooseStringFlag(flags, "persistence-policy"),
-      phpPrefix: readOptionalLooseStringFlag(flags, "php-prefix"),
-      profile: readOptionalLooseStringFlag(flags, "profile"),
-      projectInput: projectDir,
-      onProgress: async (progress) => {
-        const payload2 = {
-          detail: progress.detail,
-          title: progress.title
-        };
-        onProgress?.(payload2);
-        if (emitOutput) {
-          printLine(formatCreateProgressLine(payload2));
-        }
-      },
-      promptText: scaffoldPrompt ? (message, defaultValue, validate) => scaffoldPrompt.text(message, defaultValue, validate) : undefined,
-      queryPostType: readOptionalLooseStringFlag(flags, "query-post-type"),
-      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"],
-      withTestPreset: flags["with-test-preset"],
-      withWpEnv: flags["with-wp-env"],
-      yes: effectiveYes
-    });
-    const payload = flow.dryRun && flow.plan ? buildCreateDryRunPayload({
-      packageManager: flow.packageManager,
-      plan: flow.plan,
-      projectDir: flow.projectDir,
-      result: flow.result
-    }) : buildCreateCompletionPayload(flow);
-    return emitCompletion(payload, { emitOutput, printLine, warnLine });
-  } catch (error) {
-    if (!shouldWrapCliCommandError({ emitOutput })) {
-      throw error;
-    }
-    throw await wrapCliCommandError("create", error);
-  } finally {
-    if (activePrompt && activePrompt !== prompt) {
-      activePrompt.close();
-    }
-  }
-}
-// src/runtime-bridge-doctor.ts
-var loadCliDoctorRuntime = () => import("./cli-doctor-6fyxq940.js");
-async function executeDoctorCommand(cwd, options = {}) {
-  try {
-    const { runDoctor } = await loadCliDoctorRuntime();
-    await runDoctor(cwd, { exitPolicy: options.exitPolicy });
-  } catch (error) {
-    throw await wrapCliCommandError("doctor", error);
-  }
-}
-// src/runtime-bridge-init.ts
-import path2 from "path";
-var loadCliInitRuntime = () => import("./cli-init-7avk42dh.js");
-async function executeInitCommand({ apply, cwd, packageManager, projectDir }, options = {}) {
-  try {
-    const { runInitCommand } = await loadCliInitRuntime();
-    const resolvedProjectDir = projectDir ? path2.resolve(cwd, projectDir) : cwd;
-    const plan = await runInitCommand({
-      apply,
-      packageManager,
-      projectDir: resolvedProjectDir
-    });
-    const completion = buildInitCompletionPayload(plan);
-    if (options.emitOutput ?? true) {
-      printCompletionPayload(completion, {
-        printLine: options.printLine,
-        warnLine: options.warnLine
-      });
-    }
-    return plan;
-  } catch (error) {
-    if (!shouldWrapCliCommandError({ emitOutput: options.emitOutput })) {
-      throw error;
-    }
-    throw await wrapCliCommandError("init", error);
-  }
-}
-// src/runtime-bridge-migrate.ts
-var loadMigrationsRuntime = () => import("./migrations-3vngdy51.js");
-var defaultPrintLine2 = (line) => {
-  process.stdout.write(`${line}
-`);
-};
-async function executeMigrateCommand({
-  command,
-  cwd,
-  flags,
-  printLine = defaultPrintLine2,
-  prompt,
-  renderLine
-}) {
-  try {
-    const { formatMigrationHelpText, parseMigrationArgs, runMigrationCommand } = await loadMigrationsRuntime();
-    const outputLine = renderLine ?? printLine;
-    if (!command) {
-      const helpText = formatMigrationHelpText();
-      outputLine(helpText);
-      return;
-    }
-    const argv = [command];
-    pushFlag(argv, "all", flags.all);
-    pushFlag(argv, "force", flags.force);
-    pushFlag(argv, "current-migration-version", readOptionalLooseStringFlag(flags, "current-migration-version"));
-    pushFlag(argv, "migration-version", readOptionalLooseStringFlag(flags, "migration-version"));
-    pushFlag(argv, "from-migration-version", readOptionalLooseStringFlag(flags, "from-migration-version"));
-    pushFlag(argv, "to-migration-version", readOptionalLooseStringFlag(flags, "to-migration-version"));
-    pushFlag(argv, "iterations", readOptionalLooseStringFlag(flags, "iterations"));
-    pushFlag(argv, "seed", readOptionalLooseStringFlag(flags, "seed"));
-    const parsed = parseMigrationArgs(argv);
-    const lines = renderLine ? [] : null;
-    const captureLine = (line) => {
-      lines?.push(line);
-      outputLine(line);
-    };
-    const result = await runMigrationCommand(parsed, cwd, {
-      prompt,
-      renderLine: captureLine
-    });
-    if (renderLine) {
-      return result && typeof result === "object" && "cancelled" in result && result.cancelled === true ? undefined : buildMigrationCompletionPayload({
-        command: parsed.command ?? "plan",
-        lines: lines ?? []
-      });
-    }
-    if (result && typeof result === "object" && "cancelled" in result && result.cancelled === true) {
-      return;
-    }
-  } catch (error) {
-    if (!shouldWrapCliCommandError({ renderLine })) {
-      throw error;
-    }
-    throw await wrapCliCommandError("migrate", error);
-  }
-}
-// src/runtime-bridge-templates.ts
-var loadCliTemplatesRuntime2 = () => import("./cli-templates-g8t4fm11.js");
-async function executeTemplatesCommand({ flags }, printLine = console.log) {
-  const {
-    formatTemplateDetails,
-    formatTemplateFeatures,
-    formatTemplateSummary,
-    getTemplateById,
-    listTemplates
-  } = await loadCliTemplatesRuntime2();
-  const subcommand = flags.subcommand ?? "list";
-  if (subcommand === "list") {
-    for (const template of listTemplates()) {
-      printBlock(printLine, [formatTemplateSummary(template), formatTemplateFeatures(template)]);
-    }
-    return;
-  }
-  if (subcommand === "inspect") {
-    if (!flags.id) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
-    }
-    const template = getTemplateById(flags.id);
-    if (!template) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
-    }
-    printBlock(printLine, [formatTemplateDetails(template)]);
-    return;
-  }
-  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
-}
-async function listTemplatesForRuntime() {
-  const { listTemplates } = await loadCliTemplatesRuntime2();
-  return listTemplates();
-}
-// src/runtime-bridge-sync.ts
-import { spawnSync } from "child_process";
-import fs3 from "fs";
-import path3 from "path";
-var SYNC_INSTALL_MARKERS = [
-  "node_modules",
-  ".pnp.cjs",
-  ".pnp.loader.mjs"
-];
-var LOCAL_SYNC_TOOL_PATTERN = /(^|[\s;&|()])(?:tsx|wp-scripts)(?=($|[\s;&|()]))/u;
-var CAPTURED_SYNC_OUTPUT_MAX_BUFFER = 16 * 1024 * 1024;
-function resolveSyncExecutionTarget(subcommand) {
-  if (!subcommand) {
-    return "default";
-  }
-  if (subcommand === "ai") {
-    return "ai";
-  }
-  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
-}
-function getSyncRootError(cwd) {
-  return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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 readSyncPackageJson(packageJsonPath) {
-  const source = fs3.readFileSync(packageJsonPath, "utf8");
-  try {
-    return JSON.parse(source);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to parse ${packageJsonPath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
-  }
-}
-function resolveSyncProjectContext(cwd) {
-  const packageJsonPath = path3.join(cwd, "package.json");
-  if (!fs3.existsSync(packageJsonPath)) {
-    throw getSyncRootError(cwd);
-  }
-  const packageJson = readSyncPackageJson(packageJsonPath);
-  const scripts = packageJson.scripts ?? {};
-  const syncScripts = {
-    sync: typeof scripts.sync === "string" ? {
-      command: scripts.sync,
-      scriptName: "sync"
-    } : undefined,
-    "sync-ai": typeof scripts["sync-ai"] === "string" ? {
-      command: scripts["sync-ai"],
-      scriptName: "sync-ai"
-    } : typeof scripts["sync-wordpress-ai"] === "string" ? {
-      command: scripts["sync-wordpress-ai"],
-      scriptName: "sync-wordpress-ai"
-    } : undefined,
-    "sync-rest": typeof scripts["sync-rest"] === "string" ? {
-      command: scripts["sync-rest"],
-      scriptName: "sync-rest"
-    } : undefined,
-    "sync-types": typeof scripts["sync-types"] === "string" ? {
-      command: scripts["sync-types"],
-      scriptName: "sync-types"
-    } : undefined
-  };
-  return {
-    cwd,
-    packageJsonPath,
-    packageManager: inferPackageManagerId(cwd, packageJson.packageManager),
-    scripts: syncScripts
-  };
-}
-function findInstalledDependencyMarkerDir(projectDir) {
-  let currentDir = path3.resolve(projectDir);
-  while (true) {
-    if (SYNC_INSTALL_MARKERS.some((marker) => fs3.existsSync(path3.join(currentDir, marker)))) {
-      return currentDir;
-    }
-    const parentDir = path3.dirname(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
-}
-function scriptsLikelyNeedInstalledDependencies(project, target) {
-  const candidateScripts = target === "ai" ? [project.scripts["sync-ai"]] : project.scripts.sync ? [project.scripts.sync] : [
-    project.scripts["sync-types"],
-    project.scripts["sync-rest"],
-    project.scripts["sync-ai"]
-  ];
-  return candidateScripts.some((script) => script !== undefined && LOCAL_SYNC_TOOL_PATTERN.test(script.command));
-}
-function assertSyncDependenciesInstalled(project, target) {
-  if (!scriptsLikelyNeedInstalledDependencies(project, target)) {
-    return;
-  }
-  const markerDir = findInstalledDependencyMarkerDir(project.cwd);
-  if (markerDir) {
-    return;
-  }
-  throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.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) {
-    case "bun":
-      return { args: ["run", scriptName, ...extraArgs], command: "bun" };
-    case "npm":
-      return {
-        args: [
-          "run",
-          scriptName,
-          ...extraArgs.length > 0 ? ["--", ...extraArgs] : []
-        ],
-        command: "npm"
-      };
-    case "pnpm":
-      return { args: ["run", scriptName, ...extraArgs], command: "pnpm" };
-    case "yarn":
-      return { args: ["run", scriptName, ...extraArgs], command: "yarn" };
-  }
-}
-function createSyncPlannedCommand(project, scriptName, extraArgs) {
-  const script = project.scripts[scriptName];
-  if (!script) {
-    return null;
-  }
-  const invocation = getPackageManagerRunInvocation(project.packageManager, script.scriptName, extraArgs);
-  return {
-    args: invocation.args,
-    command: invocation.command,
-    displayCommand: formatRunScript(project.packageManager, script.scriptName, extraArgs.join(" ")),
-    scriptName: script.scriptName
-  };
-}
-function buildSyncPlannedCommands(project, extraArgs, target) {
-  if (target === "ai") {
-    const syncAiCommand2 = createSyncPlannedCommand(project, "sync-ai", extraArgs);
-    if (!syncAiCommand2) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
-    }
-    return [syncAiCommand2];
-  }
-  if (project.scripts.sync) {
-    return [createSyncPlannedCommand(project, "sync", extraArgs)];
-  }
-  const syncTypesCommand = createSyncPlannedCommand(project, "sync-types", extraArgs);
-  if (!syncTypesCommand) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
-  }
-  const plannedCommands = [syncTypesCommand];
-  const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
-  if (syncRestCommand) {
-    plannedCommands.push(syncRestCommand);
-  }
-  const syncAiCommand = createSyncPlannedCommand(project, "sync-ai", extraArgs);
-  if (syncAiCommand) {
-    plannedCommands.push(syncAiCommand);
-  }
-  return plannedCommands;
-}
-function runProjectScript(project, plannedCommand, options) {
-  const result = spawnSync(plannedCommand.command, plannedCommand.args, {
-    cwd: project.cwd,
-    encoding: options.captureOutput ? "utf8" : undefined,
-    ...options.captureOutput ? { maxBuffer: CAPTURED_SYNC_OUTPUT_MAX_BUFFER } : {},
-    shell: process.platform === "win32",
-    stdio: options.captureOutput ? "pipe" : "inherit"
-  });
-  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 createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.COMMAND_EXECUTION, `\`${plannedCommand.displayCommand}\` failed.`, {
-      cause: result.error ?? (stderr ? new Error(stderr.trim()) : undefined)
-    });
-  }
-  return {
-    ...plannedCommand,
-    exitCode: result.status ?? 0,
-    ...stderr !== undefined ? { stderr } : {},
-    ...stdout !== undefined ? { stdout } : {}
-  };
-}
-async function executeSyncCommand({
-  captureOutput = false,
-  check = false,
-  cwd,
-  dryRun = false,
-  target = "default"
-}) {
-  const project = resolveSyncProjectContext(cwd);
-  const extraArgs = check ? ["--check"] : [];
-  const plannedCommands = buildSyncPlannedCommands(project, extraArgs, target);
-  const result = {
-    check,
-    dryRun,
-    packageJsonPath: project.packageJsonPath,
-    packageManager: project.packageManager,
-    plannedCommands,
-    projectDir: project.cwd,
-    target
-  };
-  if (dryRun) {
-    return result;
-  }
-  assertSyncDependenciesInstalled(project, target);
-  result.executedCommands = plannedCommands.map((plannedCommand) => runProjectScript(project, plannedCommand, {
-    captureOutput
-  }));
-  return result;
-}
-// src/ui/lazy-flow.tsx
-var import_react33 = __toESM(require_react(), 1);
-
-// src/ui/alternate-buffer-lifecycle.ts
-var import_react32 = __toESM(require_react(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/utils/format.ts
-var KEYWORDS = new Set([
-  "const",
-  "let",
-  "var",
-  "function",
-  "class",
-  "return",
-  "if",
-  "else",
-  "for",
-  "while",
-  "import",
-  "export",
-  "from",
-  "async",
-  "await",
-  "try",
-  "catch",
-  "throw",
-  "new",
-  "typeof",
-  "interface",
-  "type",
-  "enum",
-  "extends",
-  "implements",
-  "public",
-  "private",
-  "protected",
-  "def",
-  "fn",
-  "pub",
-  "use",
-  "mod",
-  "struct",
-  "impl",
-  "trait"
-]);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/form.tsx
-var import_react2 = __toESM(require_react(), 1);
-
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/form-context.tsx
-var import_react = __toESM(require_react(), 1);
-var FormContext = import_react.createContext(null);
-
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/form.tsx
-var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
-var formKeymap = createKeyMatcher({
-  cancel: ["escape"],
-  nextField: ["tab"],
-  previousField: ["shift+tab"],
-  submitShortcut: ["ctrl+s"],
-  resetShortcut: ["ctrl+r"],
-  nextError: ["f8"],
-  previousError: ["shift+f8"],
-  submit: ["enter"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/form-field.tsx
-var import_react3 = __toESM(require_react(), 1);
-var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/select-field.tsx
-var import_react4 = __toESM(require_react(), 1);
-var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/multi-select-field.tsx
-var import_react5 = __toESM(require_react(), 1);
-var jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
-var multiSelectKeymap = createKeyMatcher({
-  up: ["up", "k"],
-  down: ["down", "j"],
-  toggle: ["space"],
-  submit: ["enter"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/number-field.tsx
-var import_react6 = __toESM(require_react(), 1);
-var jsx_dev_runtime5 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/password-field.tsx
-var import_react7 = __toESM(require_react(), 1);
-var jsx_dev_runtime6 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/textarea-field.tsx
-var import_react8 = __toESM(require_react(), 1);
-var jsx_dev_runtime7 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/checkbox-field.tsx
-var import_react9 = __toESM(require_react(), 1);
-var jsx_dev_runtime8 = __toESM(require_jsx_dev_runtime(), 1);
-var checkboxKeymap = createKeyMatcher({
-  toggle: ["space", "enter"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/schema-form.tsx
-var import_react10 = __toESM(require_react(), 1);
-var jsx_dev_runtime9 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/progress-bar.tsx
-var jsx_dev_runtime10 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/stack.tsx
-var jsx_dev_runtime11 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/panel.tsx
-var jsx_dev_runtime12 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/scroll-panel.tsx
-var jsx_dev_runtime13 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/card.tsx
-var jsx_dev_runtime14 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/alert.tsx
-var jsx_dev_runtime15 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/badge.tsx
-var jsx_dev_runtime16 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/divider.tsx
-var jsx_dev_runtime17 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/key-value-list.tsx
-var import_react11 = __toESM(require_react(), 1);
-var jsx_dev_runtime18 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/stat.tsx
-var jsx_dev_runtime19 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/container.tsx
-var jsx_dev_runtime20 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/grid.tsx
-var import_react12 = __toESM(require_react(), 1);
-var jsx_dev_runtime21 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/section-header.tsx
-var jsx_dev_runtime22 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/empty-state.tsx
-var jsx_dev_runtime23 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/toast.tsx
-var jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/modal.tsx
-var import_react13 = __toESM(require_react(), 1);
-var jsx_dev_runtime25 = __toESM(require_jsx_dev_runtime(), 1);
-var modalKeymap = createKeyMatcher({
-  close: ["escape", "ctrl+c"],
-  trap: ["tab", "shift+tab"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/tabs.tsx
-var import_react15 = __toESM(require_react(), 1);
-var jsx_dev_runtime26 = __toESM(require_jsx_dev_runtime(), 1);
-var tabsKeymap = createKeyMatcher({
-  previous: ["left", "h"],
-  next: ["right", "l"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/confirm.tsx
-var import_react16 = __toESM(require_react(), 1);
-var jsx_dev_runtime27 = __toESM(require_jsx_dev_runtime(), 1);
-var confirmKeymap = createKeyMatcher({
-  toggle: ["left", "right", "h", "l", "tab"],
-  affirm: ["y"],
-  negate: ["n", "q"],
-  submit: ["enter"],
-  abort: ["escape"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/menu.tsx
-var import_react17 = __toESM(require_react(), 1);
-var jsx_dev_runtime28 = __toESM(require_jsx_dev_runtime(), 1);
-var menuKeymap = createKeyMatcher({
-  up: ["up", "k"],
-  down: ["down", "j"],
-  select: ["enter"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/nav-list.tsx
-var import_react18 = __toESM(require_react(), 1);
-var jsx_dev_runtime29 = __toESM(require_jsx_dev_runtime(), 1);
-var navKeymap = createKeyMatcher({
-  up: ["up", "k"],
-  down: ["down", "j"],
-  select: ["enter"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/command-palette.tsx
-var import_react19 = __toESM(require_react(), 1);
-var jsx_dev_runtime30 = __toESM(require_jsx_dev_runtime(), 1);
-var paletteKeymap = createKeyMatcher({
-  up: ["up", "k"],
-  down: ["down", "j"],
-  select: ["enter"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/filter.tsx
-var import_react20 = __toESM(require_react(), 1);
-var jsx_dev_runtime31 = __toESM(require_jsx_dev_runtime(), 1);
-var filterKeymap = createKeyMatcher({
-  up: ["up"],
-  down: ["down"],
-  toggle: ["tab"],
-  selectAll: ["ctrl+a"],
-  submit: ["enter"],
-  abort: ["escape"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/data-table.tsx
-var import_react21 = __toESM(require_react(), 1);
-var jsx_dev_runtime32 = __toESM(require_jsx_dev_runtime(), 1);
-var dataTableKeymap = createKeyMatcher({
-  sortPrevious: ["left", "h"],
-  sortNext: ["right", "l"],
-  rowPrevious: ["up", "k"],
-  rowNext: ["down", "j"],
-  select: ["enter"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/sidebar-layout.tsx
-var import_react22 = __toESM(require_react(), 1);
-var jsx_dev_runtime33 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/spinner.tsx
-var import_react24 = __toESM(require_react(), 1);
-var jsx_dev_runtime34 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/pager.tsx
-var import_react25 = __toESM(require_react(), 1);
-var jsx_dev_runtime35 = __toESM(require_jsx_dev_runtime(), 1);
-var pagerKeymap = createKeyMatcher({
-  scrollDown: ["down", "j"],
-  scrollUp: ["up", "k"],
-  halfPageDown: ["d"],
-  halfPageUp: ["u"],
-  top: ["g", "home"],
-  bottom: ["end"],
-  search: ["/"],
-  nextMatch: ["n"],
-  prevMatch: ["shift+n"],
-  quit: ["q", "escape"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/choose.tsx
-var import_react26 = __toESM(require_react(), 1);
-var jsx_dev_runtime36 = __toESM(require_jsx_dev_runtime(), 1);
-var chooseKeymap = createKeyMatcher({
-  up: ["up", "k"],
-  down: ["down", "j"],
-  pageUp: ["left", "h"],
-  pageDown: ["right", "l"],
-  home: ["g", "home"],
-  end: ["end", "G"],
-  toggle: ["space", "tab", "x"],
-  selectAll: ["a"],
-  submit: ["enter"],
-  abort: ["escape"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/components/file-picker.tsx
-var import_react27 = __toESM(require_react(), 1);
-var jsx_dev_runtime37 = __toESM(require_jsx_dev_runtime(), 1);
-var filePickerKeymap = createKeyMatcher({
-  up: ["up", "k"],
-  down: ["down", "j"],
-  enter: ["enter", "right", "l"],
-  back: ["backspace", "left", "h"],
-  toggleHidden: ["."],
-  quit: ["q", "escape"]
-});
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/interactive/index.tsx
-var jsx_dev_runtime38 = __toESM(require_jsx_dev_runtime(), 1);
-// ../../node_modules/.bun/@bunli+tui@0.6.0+df522c502ed1ba91/node_modules/@bunli/tui/src/charts/index.tsx
-var import_react30 = __toESM(require_react(), 1);
-var jsx_dev_runtime39 = __toESM(require_jsx_dev_runtime(), 1);
-// src/ui/alternate-buffer-lifecycle.ts
-function describeAlternateBufferFailure(context, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return `${context}: ${message}`;
-}
-function isAlternateBufferExitKey(key) {
-  return key.name === "q" || key.ctrl === true && key.name === "c";
-}
-function isAlternateBufferCompletionKey(key) {
-  return key.name === "enter" || key.sequence === "\r" || key.sequence === `
-`;
-}
-function reportAlternateBufferFailure({
-  context,
-  error,
-  exit,
-  log = console.error
-}) {
-  const message = describeAlternateBufferFailure(context, error);
-  exit();
-  log(message);
-}
-async function resolveLazyFlowComponent({
-  loader,
-  onLoaded,
-  onFailure,
-  isDisposed
-}) {
-  try {
-    const module = await loader();
-    if (!isDisposed()) {
-      onLoaded(module.default);
-    }
-  } catch (error) {
-    if (!isDisposed()) {
-      onFailure(error);
-    }
-  }
-}
-function useAlternateBufferExitKeys(options = {}) {
-  const runtime = useRuntime();
-  const exit = options.exit ?? (() => runtime.exit());
-  const enabled = options.enabled ?? true;
-  useKeyboard((key) => {
-    if (!enabled) {
-      return;
-    }
-    if (isAlternateBufferExitKey(key)) {
-      exit();
-    }
-  });
-}
-function useAlternateBufferCompletionKeys(options = {}) {
-  const runtime = useRuntime();
-  const exit = options.exit ?? (() => runtime.exit());
-  const enabled = options.enabled ?? false;
-  useKeyboard((key) => {
-    if (!enabled) {
-      return;
-    }
-    if (isAlternateBufferCompletionKey(key) || isAlternateBufferExitKey(key)) {
-      exit();
-    }
-  });
-}
-function isAlternateBufferCompletionPayload(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.title === "string" && candidate.title.trim().length > 0;
-}
-function useAlternateBufferLifecycle(context, options = {}) {
-  const runtime = useRuntime();
-  const [completion, setCompletion] = import_react32.useState(null);
-  const [progress, setProgress] = import_react32.useState(null);
-  const [status, setStatus] = import_react32.useState("editing");
-  const exit = import_react32.useCallback(() => {
-    runtime.exit();
-  }, [runtime]);
-  useAlternateBufferExitKeys({
-    enabled: (options.enableExitKeys ?? true) && status !== "completed",
-    exit
-  });
-  useAlternateBufferCompletionKeys({
-    enabled: status === "completed",
-    exit
-  });
-  const handleCancel = import_react32.useCallback(() => {
-    setCompletion(null);
-    setProgress(null);
-    setStatus("editing");
-    exit();
-  }, [exit]);
-  const handleFailure = import_react32.useCallback((error) => {
-    setCompletion(null);
-    setProgress(null);
-    setStatus("editing");
-    reportAlternateBufferFailure({
-      context,
-      error,
-      exit
-    });
-  }, [context, exit]);
-  const handleSubmit = import_react32.useCallback(async (action) => {
-    setCompletion(null);
-    setProgress(null);
-    setStatus("submitting");
-    try {
-      const result = await action();
-      if (isAlternateBufferCompletionPayload(result)) {
-        setCompletion(result);
-        setProgress(null);
-        setStatus("completed");
-        return;
-      }
-      exit();
-    } catch (error) {
-      setCompletion(null);
-      setProgress(null);
-      setStatus("editing");
-      reportAlternateBufferFailure({
-        context,
-        error,
-        exit
-      });
-    }
-  }, [context, exit]);
-  const reportProgress = import_react32.useCallback((payload) => {
-    setProgress(payload);
-  }, []);
-  return {
-    completion,
-    handleCancel,
-    handleFailure,
-    handleSubmit,
-    progress,
-    reportProgress,
-    status
-  };
-}
-
-// src/ui/lazy-flow.tsx
-function LazyFlow({ loader, props }) {
-  const [Component, setComponent] = import_react33.useState(null);
-  const { handleFailure } = useAlternateBufferLifecycle("wp-typia TUI flow failed", {
-    enableExitKeys: false
-  });
-  useAlternateBufferExitKeys({
-    enabled: Component === null
-  });
-  import_react33.useEffect(() => {
-    let disposed = false;
-    resolveLazyFlowComponent({
-      isDisposed: () => disposed,
-      loader,
-      onFailure: handleFailure,
-      onLoaded: (component) => {
-        setComponent(() => component);
-      }
-    });
-    return () => {
-      disposed = true;
-    };
-  }, [handleFailure, loader]);
-  if (!Component) {
-    return null;
-  }
-  return import_react33.createElement(Component, props);
-}
-
-// src/commands/add.ts
-function loadAddFlow() {
-  return import(resolveBundledModuleHref(import.meta.url, ["./ui/add-flow.js", "../ui/add-flow.js", "../ui/add-flow.tsx"], {
-    moduleLabel: "the add-flow UI"
-  })).then((module) => ({ default: module.AddFlow }));
-}
-var addOptions = buildCommandOptions(ADD_OPTION_METADATA);
-function resolveAddCommandName(positional) {
-  if (positional[0] === "core-variation" && positional[2]) {
-    return positional[2];
-  }
-  return positional[1];
-}
-var addCommand = defineCommand({
-  defaultFormat: "toon",
-  description: "Extend an official wp-typia workspace with blocks, integration envs, variations, block styles, transforms, patterns, binding sources, standalone contracts, plugin-level REST resources, post meta contracts, workflow abilities, server-only AI features, editor plugins, or hooked blocks.",
-  handler: async (args) => {
-    const prefersStructuredOutput = prefersStructuredCliOutput(args);
-    const { printLine, warnLine } = resolveCommandOutputAdapters(args);
-    try {
-      if (prefersStructuredOutput) {
-        const completion = await executeAddCommand({
-          cwd: args.cwd,
-          emitOutput: false,
-          flags: args.flags,
-          interactive: false,
-          kind: args.positional[0],
-          name: resolveAddCommandName(args.positional),
-          positionalArgs: args.positional,
-          printLine,
-          warnLine
-        });
-        args.output(buildStructuredCompletionSuccessPayload("add", completion, {
-          dryRun: Boolean(args.flags["dry-run"]),
-          kind: args.positional[0],
-          name: resolveAddCommandName(args.positional),
-          projectDir: extractCompletionProjectDir(completion) ?? args.cwd
-        }));
-        return;
-      }
-      await executeAddCommand({
-        cwd: args.cwd,
-        flags: args.flags,
-        kind: args.positional[0],
-        name: resolveAddCommandName(args.positional),
-        positionalArgs: args.positional,
-        printLine,
-        warnLine
-      });
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "add",
-        error
-      });
-    }
-  },
-  name: "add",
-  options: addOptions,
-  ...supportsInteractiveTui() ? {
-    render: (args) => {
-      const config = args.context?.store?.wpTypiaUserConfig && typeof args.context.store.wpTypiaUserConfig === "object" ? getAddBlockDefaults(args.context.store.wpTypiaUserConfig) : {};
-      const initialValues = resolveCommandOptionValues(ADD_OPTION_METADATA, {
-        defaults: config,
-        flags: args.flags,
-        optionNames: Object.keys(ADD_OPTION_METADATA).filter((optionName) => optionName !== "dry-run")
-      });
-      return import_react34.createElement(LazyFlow, {
-        loader: loadAddFlow,
-        props: {
-          cwd: args.cwd,
-          initialValues: {
-            ...initialValues,
-            kind: args.positional[0] ?? "block",
-            name: resolveAddCommandName(args.positional) ?? "",
-            ...args.positional[0] === "core-variation" && args.positional[2] ? { block: args.positional[1] } : {},
-            position: initialValues.position ?? "after",
-            slot: initialValues.slot ?? "sidebar"
-          }
-        }
-      });
-    },
-    tui: {
-      renderer: {
-        bufferMode: "alternate"
-      }
-    }
-  } : {}
-});
-
-// src/commands/create.ts
-var import_react35 = __toESM(require_react(), 1);
-function loadCreateFlow() {
-  return import(resolveBundledModuleHref(import.meta.url, [
-    "./ui/create-flow.js",
-    "../ui/create-flow.js",
-    "../ui/create-flow.tsx"
-  ], {
-    moduleLabel: "the create-flow UI"
-  })).then((module) => ({ default: module.CreateFlow }));
-}
-var createOptions = buildCommandOptions(CREATE_OPTION_METADATA);
-var createCommand = defineCommand({
-  defaultFormat: "toon",
-  description: "Scaffold a new wp-typia project.",
-  handler: async (args) => {
-    const prefersStructuredOutput = prefersStructuredCliOutput(args);
-    const { printLine, warnLine } = resolveCommandOutputAdapters(args);
-    const projectDir = args.positional[0];
-    if (!projectDir) {
-      emitCliDiagnosticFailure(args, {
-        code: CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT,
-        command: "create",
-        detailLines: buildMissingCreateProjectDirDetailLines()
-      });
-      return;
-    }
-    try {
-      const completion = await executeCreateCommand({
-        cwd: args.cwd,
-        emitOutput: !prefersStructuredOutput,
-        flags: args.flags,
-        interactive: prefersStructuredOutput ? false : undefined,
-        printLine,
-        projectDir,
-        warnLine
-      });
-      if (prefersStructuredOutput) {
-        args.output(buildStructuredCompletionSuccessPayload("create", completion, {
-          dryRun: Boolean(args.flags["dry-run"]),
-          projectDir: extractCompletionProjectDir(completion) ?? projectDir,
-          template: typeof args.flags.template === "string" ? args.flags.template : undefined
-        }));
-      }
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "create",
-        error
-      });
-    }
-  },
-  name: "create",
-  options: createOptions,
-  ...supportsInteractiveTui() ? {
-    render: (args) => {
-      const config = args.context?.store?.wpTypiaUserConfig && typeof args.context.store.wpTypiaUserConfig === "object" ? getCreateDefaults(args.context.store.wpTypiaUserConfig) : {};
-      const initialValues = resolveCommandOptionValues(CREATE_OPTION_METADATA, {
-        defaults: config,
-        flags: args.flags
-      });
-      return import_react35.createElement(LazyFlow, {
-        loader: loadCreateFlow,
-        props: {
-          cwd: args.cwd,
-          initialValues: {
-            ...initialValues,
-            "project-dir": args.positional[0] ?? ""
-          }
-        }
-      });
-    },
-    tui: {
-      renderer: {
-        bufferMode: "alternate"
-      }
-    }
-  } : {}
-});
-
-// src/commands/doctor.ts
-var doctorCommand = defineCommand({
-  defaultFormat: "toon",
-  description: "Run repository and project diagnostics.",
-  handler: async (args) => {
-    const prefersStructuredOutput = prefersStructuredCliOutput(args);
-    const doctorExitPolicy = args.flags["workspace-only"] ? "workspace-only" : "strict";
-    if (prefersStructuredOutput) {
-      const {
-        createDoctorRunSummary,
-        getDoctorChecks,
-        getDoctorExitFailureDetailLines
-      } = await import("./cli-doctor-6fyxq940.js");
-      const checks = await getDoctorChecks(args.cwd);
-      const summary = createDoctorRunSummary(checks, {
-        exitPolicy: doctorExitPolicy
-      });
-      if (summary.exitCode === 1) {
-        emitCliDiagnosticFailure(args, {
-          code: CLI_DIAGNOSTIC_CODES.DOCTOR_CHECK_FAILED,
-          command: "doctor",
-          detailLines: getDoctorExitFailureDetailLines(checks, {
-            exitPolicy: doctorExitPolicy
-          }),
-          extraOutput: { checks, summary },
-          summary: "One or more doctor checks failed."
-        });
-        return;
-      }
-      args.output({ checks, summary });
-      return;
-    }
-    try {
-      await executeDoctorCommand(args.cwd, { exitPolicy: doctorExitPolicy });
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "doctor",
-        error
-      });
-    }
-  },
-  name: "doctor",
-  options: buildCommandOptions(DOCTOR_OPTION_METADATA)
-});
-
-// src/commands/init.ts
-var initCommand = defineCommand({
-  defaultFormat: "toon",
-  description: "Preview or apply the minimum wp-typia retrofit plan for an existing project.",
-  handler: async (args) => {
-    const prefersStructuredOutput = prefersStructuredCliOutput(args);
-    const { printLine, warnLine } = resolveCommandOutputAdapters(args);
-    try {
-      const plan = await executeInitCommand({
-        apply: Boolean(args.flags.apply),
-        cwd: args.cwd,
-        packageManager: typeof args.flags["package-manager"] === "string" ? args.flags["package-manager"] : undefined,
-        projectDir: args.positional[0]
-      }, {
-        emitOutput: !prefersStructuredOutput,
-        printLine,
-        warnLine
-      });
-      if (prefersStructuredOutput) {
-        args.output(buildStructuredInitSuccessPayload(plan));
-      }
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "init",
-        error
-      });
-    }
-  },
-  name: "init",
-  options: buildCommandOptions(INIT_OPTION_METADATA)
-});
-
-// src/mcp.ts
-import fs4 from "fs/promises";
-import path4 from "path";
-
-// ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
-class SchemaConversionError extends TaggedError("SchemaConversionError")() {
-}
-
-class ConvertToolsError extends TaggedError("ConvertToolsError")() {
-}
-
-class GenerateMCPTypesError extends TaggedError("GenerateMCPTypesError")() {
-}
-
-class McpToolsProviderError extends TaggedError("McpToolsProviderError")() {
-}
-
-// ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/schema-to-zod.ts
-function jsonSchemaToZodSchema(schema, options = {}) {
-  return convertSchema(schema, options, "$");
-}
-function convertSchema(schema, options, path4) {
-  const { coerce = true } = options;
-  if (!schema || typeof schema !== "object") {
-    return Result.ok(exports_external.unknown());
-  }
-  if (schema.const !== undefined) {
-    return Result.ok(exports_external.literal(schema.const));
-  }
-  if (schema.enum && schema.enum.length > 0) {
-    const enumValues = schema.enum.filter((v) => v !== null);
-    if (enumValues.length > 0) {
-      if (enumValues.every((v) => typeof v === "string")) {
-        return Result.ok(exports_external.enum(enumValues));
-      }
-      const literals = enumValues.map((v) => exports_external.literal(v));
-      return unionFromSchemas(literals, path4);
-    }
-  }
-  if (schema.anyOf && schema.anyOf.length > 0) {
-    const schemas = mapSchemas(schema.anyOf, options, `${path4}.anyOf`);
-    if (Result.isError(schemas)) {
-      return schemas;
-    }
-    return unionFromSchemas(schemas.value, `${path4}.anyOf`);
-  }
-  if (schema.oneOf && schema.oneOf.length > 0) {
-    const schemas = mapSchemas(schema.oneOf, options, `${path4}.oneOf`);
-    if (Result.isError(schemas)) {
-      return schemas;
-    }
-    return unionFromSchemas(schemas.value, `${path4}.oneOf`);
-  }
-  const schemaType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
-  switch (schemaType) {
-    case "string":
-      return buildStringSchema(schema, path4);
-    case "number":
-    case "integer":
-      return Result.ok(buildNumberSchema(schema, coerce));
-    case "boolean":
-      return Result.ok(buildBooleanSchema());
-    case "array":
-      return buildArraySchema(schema, options, path4);
-    case "object":
-      return buildObjectSchema(schema, options, path4);
-    case "null":
-      return Result.ok(exports_external.null());
-    default:
-      if (schema.properties) {
-        return buildObjectSchema(schema, options, path4);
-      }
-      if (schema.items) {
-        return buildArraySchema(schema, options, path4);
-      }
-      return Result.ok(exports_external.unknown());
-  }
-}
-function buildStringSchema(schema, path4) {
-  let zodSchema = exports_external.string();
-  if (schema.minLength !== undefined) {
-    zodSchema = zodSchema.min(schema.minLength);
-  }
-  if (schema.maxLength !== undefined) {
-    zodSchema = zodSchema.max(schema.maxLength);
-  }
-  if (schema.pattern) {
-    const pattern = schema.pattern;
-    const regexResult = Result.try({
-      try: () => new RegExp(pattern),
-      catch: (cause) => new SchemaConversionError({
-        path: path4,
-        message: `Invalid regex pattern "${pattern}"`,
-        cause
-      })
-    });
-    if (Result.isError(regexResult)) {
-      return regexResult;
-    }
-    zodSchema = zodSchema.regex(regexResult.value);
-  }
-  if (schema.format) {
-    switch (schema.format) {
-      case "email":
-        zodSchema = zodSchema.email();
-        break;
-      case "uri":
-      case "url":
-        zodSchema = zodSchema.url();
-        break;
-      case "uuid":
-        zodSchema = zodSchema.uuid();
-        break;
-      case "date-time":
-        zodSchema = zodSchema.datetime();
-        break;
-      case "date":
-        zodSchema = zodSchema.date();
-        break;
-    }
-  }
-  return Result.ok(zodSchema);
-}
-function buildNumberSchema(schema, coerce) {
-  let zodSchema = coerce ? exports_external.coerce.number() : exports_external.number();
-  if (schema.type === "integer" || Array.isArray(schema.type) && schema.type.includes("integer")) {
-    zodSchema = zodSchema.int();
-  }
-  if (schema.minimum !== undefined) {
-    zodSchema = zodSchema.min(schema.minimum);
-  }
-  if (schema.maximum !== undefined) {
-    zodSchema = zodSchema.max(schema.maximum);
-  }
-  if (schema.exclusiveMinimum !== undefined) {
-    zodSchema = zodSchema.gt(schema.exclusiveMinimum);
-  }
-  if (schema.exclusiveMaximum !== undefined) {
-    zodSchema = zodSchema.lt(schema.exclusiveMaximum);
-  }
-  if (schema.multipleOf !== undefined) {
-    zodSchema = zodSchema.multipleOf(schema.multipleOf);
-  }
-  return zodSchema;
-}
-function buildBooleanSchema() {
-  return exports_external.boolean();
-}
-function buildArraySchema(schema, options, path4) {
-  let itemSchema = exports_external.unknown();
-  if (schema.items) {
-    if (Array.isArray(schema.items)) {
-      if (schema.items.length > 0) {
-        const itemResult = convertSchema(schema.items[0], options, `${path4}.items[0]`);
-        if (Result.isError(itemResult)) {
-          return itemResult;
-        }
-        itemSchema = itemResult.value;
-      }
-    } else {
-      const itemResult = convertSchema(schema.items, options, `${path4}.items`);
-      if (Result.isError(itemResult)) {
-        return itemResult;
-      }
-      itemSchema = itemResult.value;
-    }
-  }
-  let zodSchema = exports_external.array(itemSchema);
-  if (schema.minItems !== undefined) {
-    zodSchema = zodSchema.min(schema.minItems);
-  }
-  if (schema.maxItems !== undefined) {
-    zodSchema = zodSchema.max(schema.maxItems);
-  }
-  return Result.ok(zodSchema);
-}
-function buildObjectSchema(schema, options, path4) {
-  if (!schema.properties) {
-    return Result.ok(exports_external.record(exports_external.string(), exports_external.unknown()));
-  }
-  const shape = {};
-  const requiredFields = new Set(schema.required || []);
-  for (const [propName, propSchema] of Object.entries(schema.properties)) {
-    const propResult = convertSchema(propSchema, options, `${path4}.properties.${propName}`);
-    if (Result.isError(propResult)) {
-      return propResult;
-    }
-    let propZodSchema = propResult.value;
-    if (propSchema.default !== undefined) {
-      propZodSchema = propZodSchema.default(propSchema.default);
-    }
-    if (!requiredFields.has(propName)) {
-      propZodSchema = propZodSchema.optional();
-    }
-    shape[propName] = propZodSchema;
-  }
-  return Result.ok(exports_external.object(shape));
-}
-function mapSchemas(schemas, options, path4) {
-  const zodSchemas = [];
-  for (let index = 0;index < schemas.length; index += 1) {
-    const converted = convertSchema(schemas[index], options, `${path4}[${index}]`);
-    if (Result.isError(converted)) {
-      return converted;
-    }
-    zodSchemas.push(converted.value);
-  }
-  return Result.ok(zodSchemas);
-}
-function unionFromSchemas(schemas, path4) {
-  if (schemas.length === 0) {
-    return Result.err(new SchemaConversionError({
-      path: path4,
-      message: `Cannot create union from an empty schema set at ${path4}`,
-      cause: new Error("Empty schema union")
-    }));
-  }
-  if (schemas.length === 1) {
-    return Result.ok(schemas[0]);
-  }
-  let unionSchema = exports_external.union([schemas[0], schemas[1]]);
-  for (let index = 2;index < schemas.length; index += 1) {
-    unionSchema = exports_external.union([unionSchema, schemas[index]]);
-  }
-  return Result.ok(unionSchema);
-}
-
-// ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/utils.ts
-function toKebabCase(str) {
-  return str.replace(/_/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-}
-function toCommandName(toolName, namespace) {
-  const kebabName = toKebabCase(toolName);
-  return namespace ? `${namespace}:${kebabName}` : kebabName;
-}
-function toFlagName(propName) {
-  return toKebabCase(propName);
-}
-function toPascalCase(str) {
-  return str.split(/[-:_]/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
-}
-function escapeString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
-}
-
-// ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/converter.ts
-function createCommandsFromMCPTools(tools, options) {
-  const commands = [];
-  for (const tool of tools) {
-    const converted = convertToolToCommand(tool, options);
-    if (Result.isError(converted)) {
-      return converted;
-    }
-    commands.push(converted.value);
-  }
-  return Result.ok(commands);
-}
-function convertToolToCommand(tool, options) {
-  const {
-    namespace,
-    createHandler,
-    commandName: customCommandName,
-    flagName: customFlagName
-  } = options;
-  const commandName = customCommandName ? customCommandName(tool.name) : toCommandName(tool.name, namespace);
-  const bunliOptionsResult = convertInputSchemaToOptions(tool.name, tool.inputSchema, customFlagName || toFlagName);
-  if (Result.isError(bunliOptionsResult)) {
-    return bunliOptionsResult;
-  }
-  const command = {
-    name: commandName,
-    description: tool.description || `Invoke MCP tool: ${tool.name}`,
-    options: bunliOptionsResult.value,
-    handler: createHandler(tool.name)
-  };
-  return Result.ok(command);
-}
-function convertInputSchemaToOptions(toolName, inputSchema, flagNameTransform) {
-  const bunliOptions = {};
-  if (!inputSchema?.properties) {
-    return Result.ok(bunliOptions);
-  }
-  const requiredFields = new Set(inputSchema.required || []);
-  for (const [propName, propSchema] of Object.entries(inputSchema.properties)) {
-    const schemaResult = jsonSchemaToZodSchema(propSchema, { coerce: true });
-    if (Result.isError(schemaResult)) {
-      return Result.err(new ConvertToolsError({
-        toolName,
-        message: `Failed to convert input schema field "${propName}" for tool "${toolName}"`,
-        cause: schemaResult.error
-      }));
-    }
-    let zodSchema = schemaResult.value;
-    if (propSchema.default !== undefined) {
-      zodSchema = zodSchema.default(propSchema.default);
-    }
-    if (!requiredFields.has(propName)) {
-      zodSchema = zodSchema.optional();
-    }
-    const flagName = flagNameTransform(propName);
-    const shortMatch = propSchema.description?.match(/^\[-([a-zA-Z])\]\s*/);
-    const short = shortMatch ? shortMatch[1] : undefined;
-    const description = shortMatch ? propSchema.description?.slice(shortMatch[0].length) : propSchema.description;
-    bunliOptions[flagName] = option(zodSchema, {
-      description,
-      short
-    });
-  }
-  return Result.ok(bunliOptions);
-}
-function extractCommandMetadata(tool, namespace, flagNameTransform = toFlagName) {
-  const commandName = toCommandName(tool.name, namespace);
-  const optionsMeta = {};
-  if (tool.inputSchema?.properties) {
-    const requiredFields = new Set(tool.inputSchema.required || []);
-    for (const [propName, propSchema] of Object.entries(tool.inputSchema.properties)) {
-      const flagName = flagNameTransform(propName);
-      const schemaType = Array.isArray(propSchema.type) ? propSchema.type[0] : propSchema.type;
-      const shortMatch = propSchema.description?.match(/^\[-([a-zA-Z])\]\s*/);
-      const short = shortMatch ? shortMatch[1] : undefined;
-      const description = shortMatch ? propSchema.description?.slice(shortMatch[0].length) : propSchema.description;
-      optionsMeta[flagName] = {
-        type: schemaType || "unknown",
-        required: requiredFields.has(propName) && propSchema.default === undefined,
-        description,
-        short,
-        hasDefault: propSchema.default !== undefined,
-        default: propSchema.default
-      };
-      if (propSchema.enum) {
-        optionsMeta[flagName].enumValues = propSchema.enum.filter((v) => typeof v === "string" || typeof v === "number");
-      }
-      if (propSchema.minimum !== undefined) {
-        optionsMeta[flagName].minimum = propSchema.minimum;
-      }
-      if (propSchema.maximum !== undefined) {
-        optionsMeta[flagName].maximum = propSchema.maximum;
-      }
-    }
-  }
-  return {
-    name: commandName,
-    toolName: tool.name,
-    namespace,
-    description: tool.description,
-    options: optionsMeta
-  };
-}
-// ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/codegen.ts
-import { mkdir, writeFile } from "fs/promises";
-import { join as join2 } from "path";
-async function generateMCPTypes(options) {
-  const { tools, outputDir } = options;
-  return await Result.tryPromise({
-    try: async () => {
-      await mkdir(outputDir, { recursive: true });
-      for (const { namespace, tools: toolList } of tools) {
-        if (!toolList || toolList.length === 0)
-          continue;
-        const content = generateNamespaceTypes(namespace, toolList);
-        const fileName = `mcp-${namespace}.gen.ts`;
-        const filePath = join2(outputDir, fileName);
-        await writeFile(filePath, content, "utf-8");
-      }
-      const indexContent = generateIndexFile(tools);
-      await writeFile(join2(outputDir, "mcp-index.gen.ts"), indexContent, "utf-8");
-    },
-    catch: (cause) => new GenerateMCPTypesError({
-      outputDir,
-      message: `Failed to generate MCP types in ${outputDir}`,
-      cause
-    })
-  });
-}
-function generateNamespaceTypes(namespace, tools) {
-  const lines = [];
-  lines.push(`// This file was automatically generated by @bunli/plugin-mcp`);
-  lines.push(`// DO NOT EDIT - changes will be overwritten`);
-  lines.push(``);
-  lines.push(`import type { Command, Options, CLIOption } from '@bunli/core'`);
-  lines.push(`import { option } from '@bunli/core'`);
-  lines.push(`import { z } from 'zod'`);
-  lines.push(``);
-  const metadata = tools.map((tool) => extractCommandMetadata(tool, namespace));
-  for (const cmd of metadata) {
-    lines.push(generateCommandSchema(cmd));
-    lines.push(``);
-  }
-  lines.push(generateModuleAugmentation(namespace, metadata));
-  return lines.join(`
-`);
-}
-function generateCommandSchema(cmd) {
-  const lines = [];
-  const baseName = toPascalCase(cmd.name);
-  lines.push(`// ${cmd.description || cmd.toolName}`);
-  lines.push(`export const ${baseName}Options = {`);
-  for (const [flagName, opt] of Object.entries(cmd.options)) {
-    const zodSchema = generateZodSchemaString(opt);
-    const metadata = [];
-    if (opt.description) {
-      metadata.push(`description: '${escapeString(opt.description)}'`);
-    }
-    if (opt.short) {
-      metadata.push(`short: '${opt.short}'`);
-    }
-    const metadataStr = metadata.length > 0 ? `, { ${metadata.join(", ")} }` : "";
-    lines.push(`  '${flagName}': option(${zodSchema}${metadataStr}),`);
-  }
-  lines.push(`} as const`);
-  lines.push(``);
-  lines.push(`export type ${baseName}Flags = {`);
-  for (const [flagName, opt] of Object.entries(cmd.options)) {
-    const tsType = jsonSchemaTypeToTS(opt.type, opt.enumValues);
-    const optional = !opt.required ? "?" : "";
-    lines.push(`  '${flagName}'${optional}: ${tsType}`);
-  }
-  lines.push(`}`);
-  return lines.join(`
-`);
-}
-function generateZodSchemaString(opt) {
-  let schema;
-  if (opt.enumValues && opt.enumValues.length > 0) {
-    if (opt.enumValues.every((v) => typeof v === "string")) {
-      const values = opt.enumValues.map((v) => `'${escapeString(v)}'`).join(", ");
-      schema = `z.enum([${values}])`;
-    } else {
-      const literals = opt.enumValues.map((v) => typeof v === "string" ? `z.literal('${escapeString(v)}')` : `z.literal(${v})`).join(", ");
-      schema = `z.union([${literals}])`;
-    }
-  } else {
-    switch (opt.type) {
-      case "string":
-        schema = "z.string()";
-        break;
-      case "number":
-        schema = "z.coerce.number()";
-        break;
-      case "integer":
-        schema = "z.coerce.number().int()";
-        break;
-      case "boolean":
-        schema = "z.boolean()";
-        break;
-      case "array":
-        schema = "z.array(z.unknown())";
-        break;
-      case "object":
-        schema = "z.record(z.unknown())";
-        break;
-      default:
-        schema = "z.unknown()";
-    }
-  }
-  if (opt.minimum !== undefined) {
-    schema += `.min(${opt.minimum})`;
-  }
-  if (opt.maximum !== undefined) {
-    schema += `.max(${opt.maximum})`;
-  }
-  if (opt.hasDefault && opt.default !== undefined) {
-    const defaultVal = typeof opt.default === "string" ? `'${escapeString(opt.default)}'` : JSON.stringify(opt.default);
-    schema += `.default(${defaultVal})`;
-  }
-  if (!opt.required && !opt.hasDefault) {
-    schema += ".optional()";
-  }
-  return schema;
-}
-function jsonSchemaTypeToTS(type, enumValues) {
-  if (enumValues && enumValues.length > 0) {
-    return enumValues.map((v) => typeof v === "string" ? `'${escapeString(v)}'` : String(v)).join(" | ");
-  }
-  switch (type) {
-    case "string":
-      return "string";
-    case "number":
-    case "integer":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "array":
-      return "unknown[]";
-    case "object":
-      return "Record<string, unknown>";
-    case "null":
-      return "null";
-    default:
-      return "unknown";
-  }
-}
-function generateModuleAugmentation(namespace, metadata) {
-  const lines = [];
-  lines.push(`// Module augmentation for type-safe execute()`);
-  lines.push(`declare module '@bunli/core' {`);
-  lines.push(`  interface RegisteredCommands {`);
-  for (const cmd of metadata) {
-    const baseName = toPascalCase(cmd.name);
-    lines.push(`    '${cmd.name}': Command<typeof ${baseName}Options>`);
-  }
-  lines.push(`  }`);
-  lines.push(`}`);
-  return lines.join(`
-`);
-}
-function generateIndexFile(toolGroups) {
-  const lines = [];
-  lines.push(`// This file was automatically generated by @bunli/plugin-mcp`);
-  lines.push(`// DO NOT EDIT - changes will be overwritten`);
-  lines.push(``);
-  for (const { namespace } of toolGroups) {
-    if (!namespace)
-      continue;
-    lines.push(`export * from './mcp-${namespace}.gen.js'`);
-  }
-  return lines.join(`
-`);
-}
-// src/mcp.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isTool(value) {
-  return isObject(value) && typeof value.name === "string" && (value.description === undefined || typeof value.description === "string");
-}
-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 = path4.resolve(cwd, source.path);
-  const raw = await fs4.readFile(schemaPath, "utf8");
-  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;
-  }
-  if (Array.isArray(parsed) && parsed.every(isTool)) {
-    return {
-      namespace: source.namespace,
-      tools: parsed
-    };
-  }
-  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)));
-}
-async function syncMcpSchemas(cwd, schemaSources, outputDir = path4.join(cwd, ".bunli", "mcp")) {
-  const groups = await loadMcpToolGroups(cwd, schemaSources);
-  const result = await generateMCPTypes({
-    outputDir,
-    tools: groups
-  });
-  if (Result.isError(result)) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, getErrorMessage(result.error), getErrorCauseOptions(result.error));
-  }
-  const registry = groups.map((group) => ({
-    namespace: group.namespace,
-    tools: group.tools.map((tool) => extractCommandMetadata(tool, group.namespace))
-  }));
-  for (const group of groups) {
-    const convert = createCommandsFromMCPTools(group.tools, {
-      createHandler: () => async () => {},
-      namespace: group.namespace
-    });
-    if (Result.isError(convert)) {
-      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, getErrorMessage(convert.error), getErrorCauseOptions(convert.error));
-    }
-  }
-  await fs4.mkdir(outputDir, { recursive: true });
-  await fs4.writeFile(path4.join(outputDir, "registry.json"), `${JSON.stringify(registry, null, 2)}
-`, "utf8");
-  return {
-    commandCount: registry.reduce((count, group) => count + group.tools.length, 0),
-    groups,
-    outputDir
-  };
-}
-
-// src/commands/mcp.ts
-function printMcpToolGroupSummary(summary, printLine) {
-  for (const group of summary) {
-    printLine(`${group.namespace} (${group.toolCount})`);
-    for (const tool of group.tools) {
-      printLine(`  - ${tool}`);
-    }
-  }
-}
-function printMcpSyncSummary(result, printLine) {
-  printLine(`Synced ${result.commandCount} MCP tools across ${result.groups.length} namespaces into ${result.outputDir}.`);
-}
-var mcpCommand = defineCommand({
-  defaultFormat: "json",
-  description: "Inspect or sync schema-driven MCP metadata for wp-typia.",
-  handler: async (args) => {
-    const subcommand = args.positional[0] ?? "list";
-    const prefersStructuredOutput = prefersStructuredCliOutput(args);
-    const printLine = resolveCommandPrintLine(args);
-    const userConfig = args.context?.store?.wpTypiaUserConfig && typeof args.context.store.wpTypiaUserConfig === "object" ? args.context.store.wpTypiaUserConfig : {};
-    const schemaSources = getMcpSchemaSources(userConfig);
-    if (schemaSources.length === 0) {
-      emitCliDiagnosticFailure(args, {
-        code: CLI_DIAGNOSTIC_CODES.CONFIGURATION_MISSING,
-        command: "mcp",
-        detailLines: [
-          "No MCP schema sources are configured. Add `mcp.schemaSources` in ~/.config/wp-typia/config.json, .wp-typiarc(.json), or package.json#wp-typia."
-        ]
-      });
-      return;
-    }
-    try {
-      if (subcommand === "list") {
-        const groups = await loadMcpToolGroups(args.cwd, schemaSources);
-        const summary = groups.map((group) => ({
-          namespace: group.namespace,
-          toolCount: group.tools.length,
-          tools: group.tools.map((tool) => tool.name)
-        }));
-        if (prefersStructuredOutput) {
-          args.output({ groups: summary });
-          return;
-        }
-        printMcpToolGroupSummary(summary, printLine);
-        return;
-      }
-      if (subcommand === "sync") {
-        const outputDir = args.flags["output-dir"] ?? `${args.cwd}/.bunli/mcp`;
-        const result = await syncMcpSchemas(args.cwd, schemaSources, outputDir);
-        if (prefersStructuredOutput) {
-          args.output({ sync: result });
-          return;
-        }
-        printMcpSyncSummary(result, printLine);
-        return;
-      }
-      emitCliDiagnosticFailure(args, {
-        code: CLI_DIAGNOSTIC_CODES.INVALID_COMMAND,
-        command: "mcp",
-        detailLines: [
-          `Unknown mcp subcommand "${subcommand}". Expected list or sync.`
-        ]
-      });
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "mcp",
-        error
-      });
-    }
-  },
-  name: "mcp",
-  options: buildCommandOptions(MCP_OPTION_METADATA)
-});
-
-// src/commands/migrate.ts
-var import_react36 = __toESM(require_react(), 1);
-function loadMigrateFlow() {
-  return import(resolveBundledModuleHref(import.meta.url, [
-    "./ui/migrate-flow.js",
-    "../ui/migrate-flow.js",
-    "../ui/migrate-flow.tsx"
-  ], {
-    moduleLabel: "the migrate-flow UI"
-  })).then((module) => ({ default: module.MigrateFlow }));
-}
-var migrateOptions = buildCommandOptions(MIGRATE_OPTION_METADATA);
-var migrateCommand = defineCommand({
-  defaultFormat: "toon",
-  description: "Run migration workflows for migration-capable wp-typia projects.",
-  handler: async (args) => {
-    const printLine = resolveCommandPrintLine(args);
-    try {
-      await executeMigrateCommand({
-        command: args.positional[0],
-        cwd: args.cwd,
-        flags: args.flags,
-        printLine
-      });
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "migrate",
-        error
-      });
-    }
-  },
-  name: "migrate",
-  options: migrateOptions,
-  ...supportsInteractiveTui() ? {
-    render: (args) => {
-      const initialValues = resolveCommandOptionValues(MIGRATE_OPTION_METADATA, {
-        flags: args.flags
-      });
-      return import_react36.createElement(LazyFlow, {
-        loader: loadMigrateFlow,
-        props: {
-          cwd: args.cwd,
-          initialValues: {
-            ...initialValues,
-            command: args.positional[0] ?? "plan",
-            "to-migration-version": initialValues["to-migration-version"] ?? "current"
-          }
-        }
-      });
-    },
-    tui: {
-      renderer: {
-        bufferMode: "alternate"
-      }
-    }
-  } : {}
-});
-
-// src/commands/sync.ts
-var syncCommand = defineCommand({
-  description: "Run the generated-project sync workflow from a scaffolded project or official workspace root.",
-  handler: async (args) => {
-    const check = Boolean(args.flags.check);
-    const dryRun = Boolean(args.flags["dry-run"]);
-    const prefersStructuredOutput = prefersStructuredCliOutput(args);
-    try {
-      const target = resolveSyncExecutionTarget(args.positional[0]);
-      const sync = await executeSyncCommand({
-        captureOutput: prefersStructuredOutput && !dryRun,
-        check,
-        cwd: args.cwd,
-        dryRun,
-        target
-      });
-      if (prefersStructuredOutput) {
-        args.output({ sync });
-        return;
-      }
-      if (dryRun) {
-        printCompletionPayload(buildSyncDryRunPayload({
-          check: sync.check,
-          packageManager: sync.packageManager,
-          plannedCommands: sync.plannedCommands,
-          projectDir: sync.projectDir,
-          target: sync.target
-        }));
-      }
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "sync",
-        error
-      });
-    }
-  },
-  name: "sync",
-  options: buildCommandOptions(SYNC_OPTION_METADATA)
-});
-
-// src/commands/templates.ts
-var templatesCommand = defineCommand({
-  defaultFormat: "json",
-  description: "Inspect built-in and external scaffold templates.",
-  handler: async (args) => {
-    const subcommand = args.positional[0] ?? "list";
-    const id = args.positional[1] ?? args.flags.id;
-    const effectiveSubcommand = subcommand === "list" && typeof id === "string" && id.length > 0 ? "inspect" : subcommand;
-    const prefersStructuredOutput = prefersStructuredCliOutput(args);
-    const printLine = resolveCommandPrintLine(args);
-    try {
-      if (prefersStructuredOutput) {
-        const templates = await listTemplatesForRuntime();
-        if (effectiveSubcommand === "list") {
-          args.output({ templates });
-          return;
-        }
-        if (effectiveSubcommand === "inspect" && id) {
-          const { getTemplateById } = await import("./cli-templates-g8t4fm11.js");
-          let template;
-          try {
-            template = getTemplateById(id);
-          } catch (lookupError) {
-            const message = lookupError instanceof Error ? lookupError.message : String(lookupError);
-            if (!message.startsWith("Unknown template")) {
-              throw lookupError;
-            }
-            emitCliDiagnosticFailure(args, {
-              code: CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT,
-              command: "templates",
-              detailLines: [`Unknown template "${id}".`]
-            });
-            return;
-          }
-          args.output({ template });
-          return;
-        }
-      }
-      await executeTemplatesCommand({
-        flags: { id, subcommand: effectiveSubcommand }
-      }, printLine);
-    } catch (error) {
-      emitCliDiagnosticFailure(args, {
-        command: "templates",
-        error
-      });
-    }
-  },
-  name: "templates",
-  options: buildCommandOptions(TEMPLATES_OPTION_METADATA)
-});
-
-// src/command-list.ts
-var WP_TYPIA_COMMANDS_BY_NAME = {
-  add: addCommand,
-  create: createCommand,
-  doctor: doctorCommand,
-  init: initCommand,
-  mcp: mcpCommand,
-  migrate: migrateCommand,
-  sync: syncCommand,
-  templates: templatesCommand
-};
-var wpTypiaCommands = WP_TYPIA_TOP_LEVEL_COMMAND_NAMES.map((commandName) => WP_TYPIA_COMMANDS_BY_NAME[commandName]);
-export {
-  wpTypiaCommands
-};
-
-//# debugId=3C2BF11DC520694164756E2164756E21