wp-typia 0.24.4 → 0.24.6

package/dist-bunli/cli-prompt-ncyg68rn.js

@@ -1,12 +0,0 @@
-// @bun
-import {
-  createReadlinePrompt,
-  createReadlinePromptWithInterface
-} from "./cli-rdcga1bd.js";
-import"./cli-xnn9xjcy.js";
-export {
-  createReadlinePromptWithInterface,
-  createReadlinePrompt
-};
-
-//# debugId=9AC7644B53382A7364756E2164756E21

package/dist-bunli/cli-rdcga1bd.js

@@ -1,135 +0,0 @@
-// @bun
-// ../wp-typia-project-tools/src/runtime/cli-prompt.ts
-import readline from "readline";
-function createReadlinePrompt(output = {}) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return createReadlinePromptWithInterface(rl, output);
-}
-function createReadlinePromptWithInterface(rl, output = {}) {
-  const { errorLine, printLine } = resolveReadlinePromptOutput(output);
-  const askQuestion = (query) => new Promise((resolve) => {
-    rl.question(query, resolve);
-  });
-  return {
-    async text(message, defaultValue, validate) {
-      while (true) {
-        const value = normalizePromptAnswer(await askQuestion(formatTextPrompt(message, defaultValue))) || defaultValue;
-        if (validate) {
-          const result = validate(value);
-          if (result !== true) {
-            errorLine(formatValidationError(message, result, defaultValue));
-            continue;
-          }
-        }
-        return value;
-      }
-    },
-    async select(message, options, defaultValue = 1) {
-      if (options.length === 0) {
-        throw new Error(`select() requires at least one option for prompt: ${message}`);
-      }
-      const resolvedDefaultIndex = getResolvedDefaultIndex(options, defaultValue);
-      renderSelectPrompt(message, options, resolvedDefaultIndex, printLine);
-      while (true) {
-        const answer = normalizePromptAnswer(await askQuestion(formatChoicePrompt(resolvedDefaultIndex)));
-        if (answer.length === 0) {
-          return options[resolvedDefaultIndex].value;
-        }
-        const selection = resolvePromptSelection(options, answer);
-        if (selection) {
-          return selection.value;
-        }
-        if (isPromptHelpToken(answer)) {
-          renderSelectPrompt(message, options, resolvedDefaultIndex, printLine);
-          continue;
-        }
-        errorLine(formatInvalidSelectionError(answer, options, resolvedDefaultIndex));
-      }
-    },
-    close() {
-      rl.close();
-    }
-  };
-}
-function resolveReadlinePromptOutput({
-  errorLine,
-  printLine
-}) {
-  return {
-    errorLine: errorLine ?? writePromptErrorLine,
-    printLine: printLine ?? writePromptLine
-  };
-}
-function writePromptLine(line) {
-  process.stdout.write(`${line}
-`);
-}
-function writePromptErrorLine(line) {
-  process.stderr.write(`${line}
-`);
-}
-function normalizePromptAnswer(value) {
-  return String(value).trim();
-}
-function normalizePromptToken(value) {
-  return value.trim().toLowerCase();
-}
-function getResolvedDefaultIndex(options, defaultValue) {
-  const candidateIndex = Number.isInteger(defaultValue) ? defaultValue - 1 : -1;
-  return options[candidateIndex] ? candidateIndex : 0;
-}
-function formatTextPrompt(message, defaultValue) {
-  const suffix = defaultValue.length > 0 ? ` [default: ${defaultValue}]` : "";
-  return `${message}${suffix}: `;
-}
-function formatValidationError(message, result, defaultValue) {
-  const detail = typeof result === "string" ? result : "Invalid input";
-  const retryHint = defaultValue.length > 0 ? ` Press Enter to keep "${defaultValue}".` : "";
-  return `\u274C ${message}: ${detail}.${retryHint}`;
-}
-function formatChoicePrompt(defaultIndex) {
-  return `Choice [default: ${defaultIndex + 1}, ? for options]: `;
-}
-function renderSelectPrompt(message, options, defaultIndex, printLine) {
-  printLine(message);
-  printLine("  Enter a number, option label, or option value. Press Enter to keep the default, or type ? to list choices again.");
-  options.forEach((option, index) => {
-    const defaultMarker = index === defaultIndex ? " (default)" : "";
-    const valueHint = normalizePromptToken(option.label) === normalizePromptToken(option.value) ? "" : ` [${option.value}]`;
-    printLine(`  ${index + 1}. ${option.label}${valueHint}${defaultMarker}`);
-    if (option.hint) {
-      printLine(`     ${option.hint}`);
-    }
-  });
-}
-function isPromptHelpToken(answer) {
-  const normalized = normalizePromptToken(answer);
-  return normalized === "?" || normalized === "help" || normalized === "list";
-}
-function resolvePromptSelection(options, answer) {
-  const numericChoice = Number(answer);
-  if (!Number.isNaN(numericChoice) && options[numericChoice - 1]) {
-    return options[numericChoice - 1];
-  }
-  const normalizedAnswer = normalizePromptToken(answer);
-  return options.find((option) => {
-    const normalizedLabel = normalizePromptToken(option.label);
-    const normalizedValue = normalizePromptToken(option.value);
-    return normalizedAnswer === normalizedLabel || normalizedAnswer === normalizedValue;
-  });
-}
-function formatInvalidSelectionError(answer, options, defaultIndex) {
-  const optionValues = options.map((option) => option.value).join(", ");
-  return [
-    `\u274C Invalid selection: ${answer}.`,
-    `Enter 1-${options.length}, one of: ${optionValues},`,
-    `or press Enter for "${options[defaultIndex].label}".`
-  ].join(" ");
-}
-
-export { createReadlinePrompt, createReadlinePromptWithInterface };
-
-//# debugId=44CDFE1F16A2DE6E64756E2164756E21

package/dist-bunli/cli-scaffold-0bb6pr3w.js

@@ -1,538 +0,0 @@
-// @bun
-import {
-  DATA_STORAGE_MODES,
-  PERSISTENCE_POLICIES,
-  assertBuiltInTemplateVariantAllowed,
-  collectScaffoldAnswers,
-  formatNonEmptyTargetDirectoryError,
-  getOptionalOnboardingNote,
-  getOptionalOnboardingShortNote,
-  getOptionalOnboardingSteps,
-  getPrimaryDevelopmentScript,
-  isCompoundPersistenceEnabled,
-  isDataStorageMode,
-  isPersistencePolicy,
-  normalizeOptionalCliString,
-  parseAlternateRenderTargets,
-  parseCompoundInnerBlocksPreset,
-  resolveCreateProfileId,
-  resolveLocalCliPathOption,
-  resolveOptionalInteractiveExternalLayerId,
-  resolvePackageManagerId,
-  resolveTemplateId,
-  scaffoldProject
-} from "./cli-kfm9mm68.js";
-import"./cli-9fx0qgb7.js";
-import"./cli-377p86mf.js";
-import"./cli-84c7wff4.js";
-import {
-  OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE,
-  isBuiltInTemplateId
-} from "./cli-8hxf9qw6.js";
-import"./cli-tj7ajdvf.js";
-import"./cli-e4bwd81c.js";
-import {
-  pathExists
-} from "./cli-fv4h3ydt.js";
-import"./cli-cvxvcw7c.js";
-import {
-  createManagedTempRoot
-} from "./cli-t73q5aqz.js";
-import"./cli-bajwv85z.js";
-import"./cli-tq730sqt.js";
-import"./cli-1170yyve.js";
-import {
-  formatInstallCommand,
-  formatRunScript
-} from "./cli-am5x7tb4.js";
-import {
-  readJsonFile
-} from "./cli-ccax7s0s.js";
-import"./cli-rdcga1bd.js";
-import"./cli-xnn9xjcy.js";
-
-// ../wp-typia-project-tools/src/runtime/cli-scaffold.ts
-import path5 from "path";
-
-// ../wp-typia-project-tools/src/runtime/cli-scaffold-emission.ts
-import path2 from "path";
-
-// ../wp-typia-project-tools/src/runtime/cli-scaffold-files.ts
-import { promises as fsp } from "fs";
-import path from "path";
-async function listRelativeProjectFiles(rootDir) {
-  const relativeFiles = [];
-  async function visit(currentDir) {
-    const entries = await fsp.readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const absolutePath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await visit(absolutePath);
-        continue;
-      }
-      relativeFiles.push(path.relative(rootDir, absolutePath).replace(path.sep === "\\" ? /\\/gu : /\//gu, "/"));
-    }
-  }
-  await visit(rootDir);
-  return relativeFiles.sort((left, right) => left.localeCompare(right));
-}
-async function assertDryRunTargetDirectoryReady(projectDir, allowExistingDir) {
-  if (!await pathExists(projectDir) || allowExistingDir) {
-    return;
-  }
-  const entries = await fsp.readdir(projectDir);
-  if (entries.length > 0) {
-    throw new Error(formatNonEmptyTargetDirectoryError(projectDir));
-  }
-}
-async function readGeneratedPackageScripts(projectDir) {
-  try {
-    const parsedPackageJson = await readJsonFile(path.join(projectDir, "package.json"), {
-      context: "generated package manifest"
-    });
-    const scripts = parsedPackageJson.scripts && typeof parsedPackageJson.scripts === "object" && !Array.isArray(parsedPackageJson.scripts) ? parsedPackageJson.scripts : {};
-    return Object.entries(scripts).filter(([, value]) => typeof value === "string").map(([scriptName]) => scriptName);
-  } catch {
-    return;
-  }
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-scaffold-emission.ts
-async function emitScaffoldProject(options) {
-  return scaffoldProject(options);
-}
-async function buildScaffoldDryRunPlan(options) {
-  await assertDryRunTargetDirectoryReady(options.projectDir, options.allowExistingDir);
-  const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-scaffold-plan-");
-  const previewProjectDir = path2.join(tempRoot, "preview-project");
-  try {
-    const result = await emitScaffoldProject({
-      ...options,
-      allowExistingDir: false,
-      noInstall: true,
-      projectDir: previewProjectDir
-    });
-    const files = await listRelativeProjectFiles(previewProjectDir);
-    return {
-      plan: {
-        dependencyInstall: options.noInstall ? "skipped-by-flag" : "would-install",
-        files
-      },
-      result
-    };
-  } finally {
-    await cleanup();
-  }
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-scaffold-output.ts
-import path3 from "path";
-function quoteShellValue(value) {
-  if (!value.startsWith("-") && /^[A-Za-z0-9._/@:-]+(?:\/[A-Za-z0-9._@:-]+)*$/.test(value)) {
-    return value;
-  }
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function getNextSteps({
-  projectInput,
-  projectDir,
-  packageManager,
-  noInstall,
-  templateId
-}) {
-  const cdTarget = path3.isAbsolute(projectInput) ? projectDir : projectInput;
-  const steps = [`cd ${quoteShellValue(cdTarget)}`];
-  if (noInstall) {
-    steps.push(formatInstallCommand(packageManager));
-  }
-  steps.push(formatRunScript(packageManager, getPrimaryDevelopmentScript(templateId)));
-  return steps;
-}
-function getOptionalOnboarding({
-  availableScripts,
-  packageManager,
-  templateId,
-  compoundPersistenceEnabled = false
-}) {
-  return {
-    note: getOptionalOnboardingNote(packageManager, templateId, {
-      availableScripts,
-      compoundPersistenceEnabled
-    }),
-    shortNote: getOptionalOnboardingShortNote(packageManager, templateId, {
-      availableScripts,
-      compoundPersistenceEnabled
-    }),
-    steps: getOptionalOnboardingSteps(packageManager, templateId, {
-      availableScripts,
-      compoundPersistenceEnabled
-    })
-  };
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-scaffold-validation.ts
-import path4 from "path";
-function validateCreateProjectInput(projectInput) {
-  const normalizedProjectInput = projectInput.trim();
-  if (normalizedProjectInput.length === 0) {
-    throw new Error("Project directory is required. Usage: wp-typia create <project-dir> (or wp-typia <project-dir> when <project-dir> is the only positional argument).");
-  }
-  const normalizedProjectPath = path4.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path4.normalize(normalizedProjectInput);
-  if (normalizedProjectPath === "." || normalizedProjectPath === "..") {
-    throw new Error("`wp-typia create` requires a new project directory. Use an explicit child directory instead of `.` or `..`.");
-  }
-}
-function collectProjectDirectoryWarnings(projectDir) {
-  const warnings = [];
-  const projectName = path4.basename(projectDir);
-  if (/\s/u.test(projectName)) {
-    warnings.push(`Project directory "${projectName}" contains spaces. The generated next-step commands will be quoted, but a simple kebab-case directory name is usually easier to use with shells and downstream tooling.`);
-  }
-  const shellSensitiveCharacters = Array.from(new Set(projectName.match(/[^A-Za-z0-9._ -]/gu) ?? []));
-  if (shellSensitiveCharacters.length > 0) {
-    warnings.push(`Project directory "${projectName}" contains shell-sensitive characters (${shellSensitiveCharacters.join(", ")}). Prefer letters, numbers, ".", "_" and "-" when possible.`);
-  }
-  return warnings;
-}
-function templateUsesPersistenceSettings(templateId, options) {
-  if (templateId === "persistence") {
-    return true;
-  }
-  if (templateId !== "compound") {
-    return false;
-  }
-  return Boolean(options.dataStorageMode || options.persistencePolicy);
-}
-function templateSupportsPersistenceFlags(templateId) {
-  return templateId === "persistence" || templateId === "compound";
-}
-function templateSupportsCompoundInnerBlocksPreset(templateId) {
-  return templateId === "compound";
-}
-function createTemplateLabel(templateId) {
-  return templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE ? "`--template workspace`" : `"${templateId}"`;
-}
-function collectTemplateCapabilityWarnings(options) {
-  const warnings = [];
-  const trimmedQueryPostType = options.queryPostType?.trim();
-  if (trimmedQueryPostType && options.templateId !== "query-loop" && (isBuiltInTemplateId(options.templateId) || options.templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE)) {
-    warnings.push(`\`--query-post-type\` only applies to \`wp-typia create --template query-loop\`, which scaffolds a create-time \`core/query\` variation instead of a standalone block. ${createTemplateLabel(options.templateId)} will ignore "${trimmedQueryPostType}".`);
-  }
-  if (options.withMigrationUi === true && !isBuiltInTemplateId(options.templateId) && options.templateId !== OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE) {
-    warnings.push(`\`--with-migration-ui\` was ignored for ${createTemplateLabel(options.templateId)}. Migration UI currently scaffolds built-in templates and the official \`--template workspace\` flow; external templates still need to opt into that surface explicitly.`);
-  }
-  return warnings;
-}
-function templateSupportsAlternateRenderTargets(options) {
-  if (!options.alternateRenderTargets) {
-    return false;
-  }
-  if (options.templateId === "persistence") {
-    return true;
-  }
-  if (options.templateId !== "compound") {
-    return false;
-  }
-  return templateUsesPersistenceSettings(options.templateId, {
-    dataStorageMode: options.dataStorageMode,
-    persistencePolicy: options.persistencePolicy
-  });
-}
-function validateCreateFlagContract(options) {
-  const {
-    alternateRenderTargets,
-    dataStorageMode,
-    innerBlocksPreset,
-    persistencePolicy,
-    templateId,
-    variant
-  } = options;
-  if ((dataStorageMode || persistencePolicy) && !templateSupportsPersistenceFlags(templateId)) {
-    throw new Error("`--data-storage` and `--persistence-policy` are supported only for `wp-typia create --template persistence` or `--template compound`.");
-  }
-  if (alternateRenderTargets && !templateSupportsAlternateRenderTargets({
-    alternateRenderTargets,
-    dataStorageMode,
-    persistencePolicy,
-    templateId
-  })) {
-    if (templateId === "compound") {
-      throw new Error("`--alternate-render-targets` on `wp-typia create --template compound` requires the persistence-enabled server render path. Add `--data-storage <post-meta|custom-table>` or `--persistence-policy <authenticated|public>` first.");
-    }
-    throw new Error("`--alternate-render-targets` is supported only for `wp-typia create --template persistence` or persistence-enabled `--template compound` scaffolds.");
-  }
-  parseAlternateRenderTargets(alternateRenderTargets);
-  if (innerBlocksPreset && !templateSupportsCompoundInnerBlocksPreset(templateId)) {
-    throw new Error("`--inner-blocks-preset` is supported only for `wp-typia create --template compound`.");
-  }
-  parseCompoundInnerBlocksPreset(innerBlocksPreset);
-  if (isBuiltInTemplateId(templateId)) {
-    assertBuiltInTemplateVariantAllowed({
-      templateId,
-      variant
-    });
-  }
-}
-function parseSelectableValue(label, value, isValue, allowedValues) {
-  if (isValue(value)) {
-    return value;
-  }
-  throw new Error(`Unsupported ${label} "${value}". Expected one of: ${allowedValues.join(", ")}`);
-}
-async function resolveOptionalSelection({
-  defaultValue,
-  explicitValue,
-  isInteractive,
-  isValue,
-  label,
-  allowedValues,
-  select,
-  shouldResolve = true,
-  yes
-}) {
-  if (!shouldResolve) {
-    return;
-  }
-  if (explicitValue !== undefined) {
-    return parseSelectableValue(label, explicitValue, isValue, allowedValues);
-  }
-  if (yes) {
-    return defaultValue;
-  }
-  if (isInteractive && select) {
-    return select();
-  }
-  return defaultValue;
-}
-async function resolveOptionalBooleanFlag({
-  defaultValue = false,
-  disabled = false,
-  explicitValue,
-  isInteractive,
-  select,
-  yes
-}) {
-  if (disabled) {
-    return defaultValue;
-  }
-  if (typeof explicitValue === "boolean") {
-    return explicitValue;
-  }
-  if (yes) {
-    return defaultValue;
-  }
-  if (isInteractive && select) {
-    return select();
-  }
-  return defaultValue;
-}
-
-// ../wp-typia-project-tools/src/runtime/cli-scaffold.ts
-async function runScaffoldFlow({
-  projectInput,
-  cwd = process.cwd(),
-  templateId,
-  alternateRenderTargets,
-  dataStorageMode,
-  dryRun = false,
-  externalLayerId,
-  externalLayerSource,
-  innerBlocksPreset,
-  persistencePolicy,
-  packageManager,
-  namespace,
-  profile,
-  textDomain,
-  phpPrefix,
-  queryPostType,
-  yes = false,
-  noInstall = false,
-  onProgress,
-  isInteractive = false,
-  allowExistingDir = false,
-  selectTemplate,
-  selectDataStorage,
-  selectExternalLayerId,
-  selectPersistencePolicy,
-  selectPackageManager,
-  promptText,
-  installDependencies = undefined,
-  variant,
-  selectWithTestPreset,
-  selectWithWpEnv,
-  selectWithMigrationUi,
-  withMigrationUi,
-  withTestPreset,
-  withWpEnv
-}) {
-  const normalizedExternalLayerId = normalizeOptionalCliString(externalLayerId);
-  const normalizedExternalLayerSource = resolveLocalCliPathOption({
-    cwd,
-    label: "--external-layer-source",
-    value: externalLayerSource
-  });
-  validateCreateProjectInput(projectInput);
-  const resolvedTemplateId = await resolveTemplateId({
-    templateId,
-    yes,
-    isInteractive,
-    selectTemplate
-  });
-  const resolvedProfile = resolveCreateProfileId(profile);
-  validateCreateFlagContract({
-    alternateRenderTargets,
-    dataStorageMode,
-    innerBlocksPreset,
-    persistencePolicy,
-    templateId: resolvedTemplateId,
-    variant
-  });
-  const resolvedInnerBlocksPreset = parseCompoundInnerBlocksPreset(innerBlocksPreset);
-  const resolvedExternalLayerSelection = isBuiltInTemplateId(resolvedTemplateId) && isInteractive ? await resolveOptionalInteractiveExternalLayerId({
-    callerCwd: cwd,
-    externalLayerId: normalizedExternalLayerId,
-    externalLayerSource: normalizedExternalLayerSource,
-    selectExternalLayerId
-  }) : {
-    externalLayerId: normalizedExternalLayerId,
-    externalLayerSource: normalizedExternalLayerSource
-  };
-  try {
-    const shouldResolvePersistence = templateUsesPersistenceSettings(resolvedTemplateId, {
-      dataStorageMode,
-      persistencePolicy
-    });
-    const resolvedDataStorage = await resolveOptionalSelection({
-      allowedValues: DATA_STORAGE_MODES,
-      defaultValue: "custom-table",
-      explicitValue: dataStorageMode,
-      isInteractive,
-      isValue: isDataStorageMode,
-      label: "data storage mode",
-      select: selectDataStorage,
-      shouldResolve: shouldResolvePersistence,
-      yes
-    });
-    const resolvedPersistencePolicy = await resolveOptionalSelection({
-      allowedValues: PERSISTENCE_POLICIES,
-      defaultValue: "authenticated",
-      explicitValue: persistencePolicy,
-      isInteractive,
-      isValue: isPersistencePolicy,
-      label: "persistence policy",
-      select: selectPersistencePolicy,
-      shouldResolve: shouldResolvePersistence,
-      yes
-    });
-    const resolvedPackageManager = await resolvePackageManagerId({
-      packageManager,
-      yes,
-      isInteractive,
-      selectPackageManager
-    });
-    const resolvedWithWpEnv = resolvedProfile === "plugin-qa" ? true : await resolveOptionalBooleanFlag({
-      explicitValue: withWpEnv,
-      isInteractive,
-      select: selectWithWpEnv,
-      yes
-    });
-    const resolvedWithTestPreset = await resolveOptionalBooleanFlag({
-      explicitValue: withTestPreset,
-      isInteractive,
-      select: selectWithTestPreset,
-      yes
-    });
-    const resolvedWithMigrationUi = await resolveOptionalBooleanFlag({
-      disabled: !isBuiltInTemplateId(resolvedTemplateId) && resolvedTemplateId !== OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE,
-      explicitValue: withMigrationUi,
-      isInteractive,
-      select: selectWithMigrationUi,
-      yes
-    });
-    const projectDir = path5.resolve(cwd, projectInput);
-    const projectName = path5.basename(projectDir);
-    const answers = await collectScaffoldAnswers({
-      dataStorageMode: resolvedDataStorage,
-      namespace,
-      persistencePolicy: resolvedPersistencePolicy,
-      phpPrefix,
-      projectName,
-      queryPostType,
-      templateId: resolvedTemplateId,
-      textDomain,
-      yes,
-      promptText
-    });
-    if (resolvedTemplateId === "compound" && resolvedInnerBlocksPreset) {
-      answers.compoundInnerBlocksPreset = resolvedInnerBlocksPreset;
-    }
-    const emissionOptions = {
-      allowExistingDir,
-      alternateRenderTargets,
-      answers,
-      cwd,
-      dataStorageMode: resolvedDataStorage,
-      externalLayerId: resolvedExternalLayerSelection.externalLayerId,
-      externalLayerSource: resolvedExternalLayerSelection.externalLayerSource,
-      externalLayerSourceLabel: normalizedExternalLayerSource,
-      installDependencies,
-      noInstall,
-      onProgress,
-      packageManager: resolvedPackageManager,
-      persistencePolicy: resolvedPersistencePolicy,
-      profile: resolvedProfile,
-      projectDir,
-      templateId: resolvedTemplateId,
-      variant,
-      withMigrationUi: resolvedWithMigrationUi,
-      withTestPreset: resolvedWithTestPreset,
-      withWpEnv: resolvedWithWpEnv
-    };
-    const resolvedResult = dryRun ? await buildScaffoldDryRunPlan(emissionOptions) : {
-      plan: undefined,
-      result: await emitScaffoldProject(emissionOptions)
-    };
-    const availableScripts = dryRun ? undefined : await readGeneratedPackageScripts(projectDir);
-    return {
-      dryRun,
-      optionalOnboarding: getOptionalOnboarding({
-        availableScripts,
-        packageManager: resolvedPackageManager,
-        templateId: resolvedTemplateId,
-        compoundPersistenceEnabled: isCompoundPersistenceEnabled(resolvedResult.result.variables)
-      }),
-      plan: resolvedResult.plan,
-      projectDir,
-      projectInput,
-      packageManager: resolvedPackageManager,
-      nextSteps: getNextSteps({
-        projectInput,
-        projectDir,
-        packageManager: resolvedPackageManager,
-        noInstall,
-        templateId: resolvedTemplateId
-      }),
-      result: {
-        ...resolvedResult.result,
-        warnings: [
-          ...resolvedResult.result.warnings,
-          ...collectTemplateCapabilityWarnings({
-            queryPostType,
-            templateId: resolvedTemplateId,
-            withMigrationUi
-          }),
-          ...collectProjectDirectoryWarnings(projectDir)
-        ]
-      }
-    };
-  } finally {
-    await resolvedExternalLayerSelection.cleanup?.();
-  }
-}
-export {
-  runScaffoldFlow,
-  getOptionalOnboarding,
-  getNextSteps
-};
-
-//# debugId=3CB466F01953BF7F64756E2164756E21