@lingfan-engine/create 0.3.3 → 0.3.5

package/src/generate/project.ts

@@ -14,6 +14,7 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
+  rmSync,
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
@@ -34,6 +35,14 @@ import { restoreDotfile } from "./dotfiles.ts";
 /** 骨架目录名：占位符本身，也是模板里唯一随框架无关的目录 */
 export const SKELETON_DIR = "__PROJECT__";
 
+/**
+ * 目标目录已存在且非空时的处置方式。
+ *
+ * 三种都是使用者在生成前明确选过的，不可省略成「默认覆盖」：覆盖别人的工程
+ * 无法撤销，所以缺省仍是 `cancel`。
+ */
+export type ExistingTarget = "cancel" | "ignore" | "clear";
+
 /** 生成参数 */
 export interface GenerateOptions {
   /** 模板根目录（含 `template-meta.json` 与骨架目录） */
@@ -52,6 +61,15 @@ export interface GenerateOptions {
    * 可选是为了不破坏既有调用方——只关心框架与壳的代码不必为一个用不到的参数改签名。
    */
   readonly sources?: string;
+  /**
+   * 工程描述；写进 `package.json` 与 `Resources/project.json` 两处。
+   *
+   * 缺省与空串都表示「没有描述」，两处清单里都不出现该键。这两种状态不做区分：
+   * 调用方要么知道有描述，要么什么都没说，第三种「有但是空」没有语义。
+   */
+  readonly description?: string;
+  /** 目标目录非空时怎么办；缺省 `cancel`（报错退出，不碰磁盘） */
+  readonly existing?: ExistingTarget;
   /** 引擎包的最新版本；缺席项沿用模板记录的值 */
   readonly resolved: ReadonlyMap<string, string>;
 }
@@ -81,22 +99,35 @@ export const DEFAULT_SOURCES = "ts";
 /**
  * 生成一个工程。
  *
- * 只会新建目录：目标已存在且非空时抛错，不做覆盖也不做增量合并——覆盖别人的工程
- * 无法撤销，宁可让使用者先自己删。
+ * 目标目录已存在且非空时按 `options.existing` 处置，缺省 `cancel`——覆盖别人的工程
+ * 无法撤销，所以静默覆盖不是可选项，必须由使用者先表态（见 `ExistingTarget`）。
  */
 export function generateProject(options: GenerateOptions): GenerateResult {
   const meta = readTemplateMeta(options.templateRoot);
-  const projectDir = join(options.targetBase, options.projectName);
-  if (isOccupied(projectDir)) {
+  const projectDir = projectDirOf(options);
+  const occupied = isOccupied(projectDir);
+  const existing = options.existing ?? "cancel";
+  if (occupied && existing === "cancel") {
     throw new Error(`目标目录已存在且非空：${projectDir}`);
   }
+  if (occupied && existing === "clear") {
+    // 清空的是「目录里的内容」而不是目录本身：调用方可能已经把 shell 的 cwd
+    // 放在里面，删掉目录本身会让它指向一个不存在的 inode。
+    for (const entry of readdirSync(projectDir)) {
+      rmSync(join(projectDir, entry), { recursive: true, force: true });
+    }
+  }
   const merged = mergeLayers(layerBases(options));
-  const files = finalize(
-    merged.files,
-    merged.patch,
-    options.resolved,
-    meta.placeholder,
-    options.projectName,
+  const files = applyDescription(
+    finalize(
+      merged.files,
+      merged.patch,
+      merged.pinned,
+      options.resolved,
+      meta.placeholder,
+      options.projectName,
+    ),
+    options.description ?? "",
   );
   mkdirSync(projectDir, { recursive: true });
   for (const file of files) {
@@ -139,8 +170,15 @@ export function layerBases(options: GenerateOptions): string[] {
   return bases;
 }
 
+/** 产物目录：`<targetBase>/<projectName>`；单独抽出来供 CLI 在写盘前提示用 */
+export function projectDirOf(
+  options: Pick<GenerateOptions, "targetBase" | "projectName">,
+): string {
+  return join(options.targetBase, options.projectName);
+}
+
 /** 目标目录是否已被占用：存在且含有内容即算占用，空目录可以复用 */
-function isOccupied(dir: string): boolean {
+export function isOccupied(dir: string): boolean {
   if (!existsSync(dir)) return false;
   return readdirSync(dir).length > 0;
 }
@@ -181,10 +219,14 @@ export function collectDependencyNames(bases: readonly string[]): string[] {
  *
  * 点文件还原必须在这里发生：模板里存的是躲开 npm 改名的普通名（见 `dotfiles.ts`），
  * 产物路径要写回带点的形态，占位符替换才按产物路径判文本/二进制。
+ *
+ * `pinned` 由合并层给出而不是在这里从 `patch` 里再读一次：`pinned` 是数组，
+ * 深合并后只剩最后一层的名单，必须用逐层取并集的结果（见 `overlay` 域）。
  */
 export function finalize(
   files: readonly PendingFile[],
   patch: Readonly<Record<string, unknown>> | undefined,
+  pinned: readonly string[],
   resolved: ReadonlyMap<string, string>,
   placeholder: string,
   projectName: string,
@@ -193,7 +235,7 @@ export function finalize(
     const path = restoreDotfile(file.path);
     const content =
       file.path === "package.json"
-        ? renderManifest(file.content, patch, resolved)
+        ? renderManifest(file.content, patch, pinned, resolved)
         : file.content;
     return {
       path,
@@ -202,6 +244,47 @@ export function finalize(
   });
 }
 
+/**
+ * 把工程描述写进两份清单。
+ *
+ * 写两处是因为它们服务不同读者：`package.json` 是开发者与 npm 工具链的门面，
+ * `Resources/project.json` 跟资源一起走，运行时与构建期都读它。同源同值，
+ * 由同一个变量一次写入，不会出现两处说法不一致。
+ *
+ * 没有描述时**一个字节都不改**：模板里本就不写这个键，于是「没填描述」的产物
+ * 与引入描述之前逐字节一致，也不存在「空描述」这种中间状态。
+ */
+function applyDescription(
+  files: readonly PendingFile[],
+  description: string,
+): PendingFile[] {
+  if (description === "") return [...files];
+  return files.map((file) => {
+    if (!MANIFEST_WITH_DESCRIPTION.has(file.path)) return file;
+    const manifest = JSON.parse(file.content.toString("utf8")) as Record<
+      string,
+      unknown
+    >;
+    return {
+      path: file.path,
+      content: Buffer.from(
+        `${JSON.stringify({ ...manifest, description }, null, 2)}\n`,
+        "utf8",
+      ),
+    };
+  });
+}
+
+/**
+ * 描述落点的产物路径。
+ *
+ * 用产物路径而不是模板路径判断：点文件还原已经发生，这里的取值就是最终写盘的名字。
+ */
+const MANIFEST_WITH_DESCRIPTION: ReadonlySet<string> = new Set([
+  "package.json",
+  "Resources/project.json",
+]);
+
 /**
  * 把增量与版本号写进 `package.json`。
  *
@@ -212,6 +295,7 @@ export function finalize(
 function renderManifest(
   content: Buffer,
   patch: Readonly<Record<string, unknown>> | undefined,
+  pinned: readonly string[],
   resolved: ReadonlyMap<string, string>,
 ): Buffer {
   const manifest = JSON.parse(content.toString("utf8")) as Record<
@@ -222,13 +306,13 @@ function renderManifest(
     patch === undefined ? manifest : mergeManifest(manifest, patch);
   applyUnset(withPatch, patch);
   delete withPatch[CREATE_FIELD];
-  const pinned = new Set(pinnedNames(patch));
+  const pinnedSet = new Set(pinned);
   for (const field of ["dependencies", "devDependencies"] as const) {
     const table = withPatch[field];
     if (isStringMap(table)) {
       withPatch[field] = applyResolvedVersions(
         table,
-        withoutNames(resolved, pinned),
+        withoutNames(resolved, pinnedSet),
       );
     }
   }
@@ -282,8 +366,7 @@ const CREATE_FIELD = "create";
  *
  * 形状与 `create.remove` 并列：外层是 `package.json` 的字段名，内层是要去掉的键名。
  * 缺省项不必写它——缺省形态什么都不叠，本来就没有要减的东西。
- */
-function applyUnset(
+ */ function applyUnset(
   manifest: Record<string, unknown>,
   patch: Readonly<Record<string, unknown>> | undefined,
 ): void {
@@ -304,24 +387,6 @@ function applyUnset(
   }
 }
 
-/**
- * 读叠加层声明的「不要跟最新版」的依赖名。
- *
- * 存在的理由：模板希望依赖尽量新，但上游并非都兼容——`vue-tsc` 在 `typescript` 7 上
- * 会因 `./lib/tsc` 不再导出而直接崩，这类约束只有模板作者知道。钉住的包保留模板
- * 记录的版本区间，其余照常解析到最新。
- */
-export function pinnedNames(
-  patch: Readonly<Record<string, unknown>> | undefined,
-): string[] {
-  if (patch === undefined) return [];
-  const section = patch[CREATE_FIELD];
-  if (!isPlainRecord(section)) return [];
-  const pinned = section.pinned;
-  if (!Array.isArray(pinned)) return [];
-  return pinned.filter((item): item is string => typeof item === "string");
-}
-
 /** 只认普通对象：数组与 null 不算 */
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);

package/src/overlay/index.ts

@@ -3,6 +3,7 @@ export {
   deepMerge,
   listFiles,
   mergeLayers,
+  pinnedNames,
   readLayer,
   PATCH_SUFFIX,
   type MergedLayer,

package/src/overlay/merge.ts

@@ -132,10 +132,33 @@ function isRemoved(path: string, removes: readonly string[]): boolean {
   );
 }
 
-/** 合并结果：文件表（后写覆盖先写）+ 合并后的工程清单增量 */
+/** 合并结果：文件表（后写覆盖先写）+ 合并后的工程清单增量 + 各层钉住的依赖名并集 */
 export interface MergedLayer {
   readonly files: readonly PendingFile[];
   readonly patch: Readonly<Record<string, unknown>> | undefined;
+  readonly pinned: readonly string[];
+}
+
+/**
+ * 读本层 `create.pinned` 点名的依赖名。
+ *
+ * 与 `removeList` 同理，必须**每层各读一次**：`pinned` 是数组，深合并时由后者整体
+ * 取代，两层各钉各的包，合并后只剩最后一层的名单——`vue` 钉了 `typescript`、
+ * `tauri` 钉了 `@tauri-apps/*`，后者在后就把前者的钉法抹掉，于是 `vue-tsc` 拿到
+ * 了它不兼容的 typescript 大版本，`typecheck` 直接崩。
+ *
+ * 与 `remove` 不同的是，钉住是**累加声明**（每个层都在说「这几个包别跟最新」），
+ * 所以合并语义是并集而不是逐层施加的动作。
+ */
+export function pinnedNames(
+  patch: Readonly<Record<string, unknown>> | undefined,
+): readonly string[] {
+  if (patch === undefined) return [];
+  const section = patch[CREATE_FIELD];
+  if (!isPlainObject(section)) return [];
+  const raw = section.pinned;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((item): item is string => typeof item === "string");
 }
 
 /**
@@ -149,6 +172,7 @@ export function mergeLayers(bases: readonly string[]): MergedLayer {
   const byPath = new Map<string, PendingFile>();
   let patch: Record<string, unknown> = {};
   let hasPatch = false;
+  const pinned = new Set<string>();
   for (const base of bases) {
     if (!existsSync(base)) continue;
     const layer = readLayer(base);
@@ -158,6 +182,7 @@ export function mergeLayers(bases: readonly string[]): MergedLayer {
       }
     }
     for (const file of layer.files) byPath.set(file.path, file);
+    for (const name of pinnedNames(layer.patch)) pinned.add(name);
     if (layer.patch) {
       patch = deepMerge(patch, layer.patch);
       hasPatch = true;
@@ -166,6 +191,7 @@ export function mergeLayers(bases: readonly string[]): MergedLayer {
   return {
     files: [...byPath.values()],
     patch: hasPatch ? patch : undefined,
+    pinned: [...pinned],
   };
 }
 

package/src/registry/index.ts

@@ -1,10 +1,14 @@
 /** registry 域唯一出口：模板元数据定位 + npm 版本查询 + 引擎兼容判定。 */
 export { checkEngineCompatibility, ENGINE_SCOPE } from "./compat.ts";
 export {
+  existsLayerDirectory,
+  findConflicts,
   overlayDirOf,
   readTemplateMeta,
   resolveTemplateRoot,
+  selectableLayers,
   OVERLAY_DIR,
+  type LayerConflict,
   type TemplateMeta,
   type TemplateOption,
 } from "./template-meta.ts";

package/src/registry/template-meta.ts

@@ -41,6 +41,13 @@ export interface TemplateOption {
   readonly label: string;
   /** 一句话说明，交互问答里作为提示 */
   readonly hint: string;
+  /**
+   * 不能与本层共存的其他层 id；缺省视为空数组。
+   *
+   * 元素是**跨维度**的层 id（框架可以排斥壳），不是同一维度内的兄弟项。
+   * 单边声明即生效：只要一对层里有一方点名了另一方，这一对就是互斥的。
+   */
+  readonly excludes?: readonly string[];
 }
 
 /**
@@ -115,3 +122,69 @@ export function overlayDirOf(
   const dir = join(templateRoot, OVERLAY_DIR, optionId);
   return existsSync(dir) ? dir : undefined;
 }
+
+/**
+ * 这一层是否有自己的目录。
+ *
+ * 判据是磁盘事实而不是 id 白名单：新增一层只要建了目录就自动可选，删掉目录就自动
+ * 退出选项面，生成器不必跟着改。缺省项（`none`/`browser`/`ts`）没有目录，
+ * 因此永远不出现在「可以叠哪些层」的选项里。
+ */
+export function existsLayerDirectory(
+  templateRoot: string,
+  optionId: string,
+): boolean {
+  return existsSync(join(templateRoot, OVERLAY_DIR, optionId));
+}
+
+/**
+ * 列出可以在形态问答里勾选的层：框架与壳里有目录的那些。
+ *
+ * 故事源不是可叠加的层：TS 源、手写 `.story`、手写 `.json` 是同一棵
+ * `Resources/Stories/` 树上的三种文件形态，本来就能共存于一个工程，勾选它没有
+ * 「叠一层」的含义，所以 `sources` 维度不参与问答，只在脚本参数面（`--sources`）保留。
+ *
+ * 顺序沿用元数据里的维度顺序「框架 → 壳」，与合并顺序（骨架 → 框架 → 故事源 →
+ * 壳）不同——选项面按使用者心里的粒度排，合并顺序按覆盖关系排；维度内保持声明顺序。
+ */
+export function selectableLayers(
+  templateRoot: string,
+  meta: TemplateMeta,
+): TemplateOption[] {
+  return [...meta.frameworks, ...meta.shells].filter((option) =>
+    existsLayerDirectory(templateRoot, option.id),
+  );
+}
+
+/** 一对互斥的层 id，按选项面出现顺序排列 */
+export type LayerConflict = readonly [string, string];
+
+/**
+ * 从选中的层里找出互斥对。
+ *
+ * 只看「选中集合里同时出现了互斥的两方」，不关心是哪一方先声明的：单边声明即生效，
+ * 因此两边都声明也不会被算成两对。返回的每一对都按选项面顺序排列，便于报错文本稳定。
+ */
+export function findConflicts(
+  selected: readonly string[],
+  options: readonly TemplateOption[],
+): LayerConflict[] {
+  const order = new Map(options.map((option, index) => [option.id, index]));
+  const chosen = new Set(selected);
+  const pairs: LayerConflict[] = [];
+  const seen = new Set<string>();
+  for (const option of options) {
+    if (!chosen.has(option.id)) continue;
+    for (const excluded of option.excludes ?? []) {
+      if (!chosen.has(excluded)) continue;
+      const key = [option.id, excluded].sort().join("\u0000");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const pair = [option.id, excluded].sort(
+        (left, right) => (order.get(left) ?? 0) - (order.get(right) ?? 0),
+      ) as [string, string];
+      pairs.push(pair);
+    }
+  }
+  return pairs;
+}

package/src/shared/guards.ts

@@ -66,6 +66,20 @@ export function suggestProjectName(input: string): string {
   return collapsed.length > 0 ? collapsed : "lingfan-story";
 }
 
+/** 描述的字符上限：`package.json#description` 在 npm 生态里的通行上限 */
+export const DESCRIPTION_MAX_LENGTH = 200;
+
+/**
+ * 把自由文本收敛成可写入清单的描述。
+ *
+ * 全空白视为空，返回空串——调用方据此决定「不写这个字段」，而不是写一个空串进去。
+ * 超长直接截断而不报错：描述不影响任何路径与命令，没有理由为一个输入框拦住生成。
+ * 不校验字符集：它是给人看的自由文本，不是标识符。
+ */
+export function normalizeDescription(input: string): string {
+  return input.trim().slice(0, DESCRIPTION_MAX_LENGTH).trim();
+}
+
 /**
  * 把用户输入的版本号归一成 `^x.y.z`。
  *

package/src/shared/index.ts

@@ -1,10 +1,19 @@
-/** shared 域唯一出口：文案表、参数校验与版本运算。 */
+/** shared 域唯一出口：文案表、参数校验、包管理器识别与版本运算。 */
 export { defaultCreateTexts, type CreateTexts } from "./texts.ts";
 export {
   caretRange,
+  DESCRIPTION_MAX_LENGTH,
   isValidProjectName,
+  normalizeDescription,
   suggestProjectName,
 } from "./guards.ts";
+export {
+  currentPackageManager,
+  detectPackageManager,
+  parsePackageManager,
+  type PackageManager,
+  type PackageManagerId,
+} from "./package-manager.ts";
 export {
   compareSemver,
   floorOfRange,

package/src/shared/package-manager.ts

@@ -0,0 +1,87 @@
+/**
+ * 包管理器识别。
+ *
+ * 为什么需要识别：生成器是给**别人**用的工具，不能假定对方用 pnpm。安装依赖与
+ * 打印后续步骤都要跟随调用方的包管理器——`npm create` 就该给出 npm 的命令，
+ * `pnpm create` 给出 pnpm 的。本仓内部开发固定 pnpm 是仓库约定，不是产物约定。
+ *
+ * 识别依据是 npm 生态的既定事实 `npm_config_user_agent`（`npm create` /
+ * `pnpm create` / `yarn create` / `bun create` 都会设置它）。拿不到时退回
+ * `npm_execpath` 的文件名，再拿不到按 npm 处理——这是最不会误导人的缺省，
+ * 因为 npm 的命令形式（`npm run dev`）在 pnpm/yarn 下也基本能跑。
+ */
+
+/** 生成器认得的包管理器；不认识的都按 npm 处理 */
+export type PackageManagerId = "npm" | "pnpm" | "yarn" | "bun";
+
+/** 一个包管理器的命令写法 */
+export interface PackageManager {
+  readonly id: PackageManagerId;
+  /** 跑一个 `package.json` 脚本的写法，如 `dev` / `run dev` */
+  readonly script: string;
+  /** 安装依赖的写法（四家都是 `install`，保留字段是为了日后出现例外时有落点） */
+  readonly install: string;
+}
+
+const MANAGERS: Readonly<Record<PackageManagerId, PackageManager>> = {
+  npm: { id: "npm", script: "run dev", install: "install" },
+  pnpm: { id: "pnpm", script: "dev", install: "install" },
+  yarn: { id: "yarn", script: "dev", install: "install" },
+  bun: { id: "bun", script: "run dev", install: "install" },
+};
+
+const KNOWN = ["npm", "pnpm", "yarn", "bun"] as const;
+
+/** 把一段文本折成包管理器名：去扩展名、去版本尾缀 */
+function normalize(segment: string): PackageManagerId | undefined {
+  const name = segment
+    .toLowerCase()
+    .replace(/\.(?:c|m)?js$|\.exe$/u, "")
+    .split("@")[0];
+  return KNOWN.find((id) => id === name);
+}
+
+/**
+ * 从 `user-agent` 或可执行路径里认出包管理器。
+ *
+ * 两种输入形态不同，故首段与末段都试：`user-agent` 是
+ * `pm/版本 平台/…`（首段有名），可执行路径是 `/usr/local/bin/pm.cjs`
+ * （末段有名，首段是空串或盘符）。取第一个认得出的。
+ */
+export function parsePackageManager(
+  hint: string | undefined,
+): PackageManagerId | undefined {
+  if (hint === undefined) return undefined;
+  const segments = hint.split(/[/\\]/u).filter((part) => part !== "");
+  for (const segment of [segments[0], segments[segments.length - 1]]) {
+    if (segment === undefined) continue;
+    const found = normalize(segment);
+    if (found !== undefined) return found;
+  }
+  return undefined;
+}
+
+/**
+ * 当前进程由哪个包管理器发起。
+ *
+ * 优先级：`npm_config_user_agent`（最权威，四家都会设）→ `npm_execpath`
+ * （垫片被直接 `node` 调用时的退路）→ npm（缺省）。
+ */
+export function detectPackageManager(env: {
+  readonly userAgent?: string | undefined;
+  readonly execPath?: string | undefined;
+}): PackageManager {
+  const id =
+    parsePackageManager(env.userAgent) ??
+    parsePackageManager(env.execPath) ??
+    "npm";
+  return MANAGERS[id];
+}
+
+/** 从真实进程环境里取一个 */
+export function currentPackageManager(): PackageManager {
+  return detectPackageManager({
+    userAgent: process.env.npm_config_user_agent,
+    execPath: process.env.npm_execpath,
+  });
+}

package/src/shared/texts.ts

@@ -11,49 +11,77 @@ export const defaultCreateTexts = {
   banner: "灵泛叙事引擎 · 工程生成器",
   help: [
     "用法：",
-    "  npm create @lingfan-engine [工程名] [选项]",
-    "  pnpm create @lingfan-engine [工程名] [选项]",
+    "  npm create @lingfan-engine [工程名]",
+    "  pnpm create @lingfan-engine [工程名]",
+    "  bun create @lingfan-engine [工程名]",
     "",
+    "工程名之后按提示回答：工程名 → 描述 → 形态（可多选）。",
+    "yarn 需要 2 及以上版本（classic 没有 create 子命令）；仍用 classic 时等价写法：",
+    "  yarn dlx create-@lingfan-engine [工程名]",
+    "",
+    "包管理器不限：生成后的安装命令与后续步骤按调用方自己的包管理器给出。",
     "选项：",
-    "  -f, --framework <id>  框架（缺省取模板声明的默认值）",
-    "  -s, --shell <id>      壳（缺省取模板声明的默认值）",
-    "  -t, --sources <id>    故事源形态（缺省取模板声明的默认值）",
+    "  --description <文本>  工程描述（写进 package.json 与 Resources/project.json；可留空）",
     "  -d, --dir <路径>      生成到哪个目录下（缺省 = 当前目录）",
-    "      --no-install      生成后不自动安装依赖",
+    "      --install         生成后立即安装依赖",
+    "      --overwrite       目标目录非空时清空后继续",
     "  -y, --yes             全部取缺省值，不进入交互问答",
     "  -h, --help            显示本说明",
     "",
+    "脚本用法：CI 里可以用参数直接指定形态，跳过问答。",
+    "  -f, --framework <id>  框架（none / vue / react）",
+    "  -s, --shell <id>      壳（browser / tauri / miniprogram）",
+    "  -t, --sources <id>    故事源形态（ts / story）",
+    "  --template <id>       等价写法：框架[-壳[-故事源]]，如 vue-tauri",
+    "",
     "示例：",
-    "  npm create @lingfan-engine my-story -- --framework vue --shell browser",
-    "  npm create @lingfan-engine my-story -- --sources ts",
+    "  npm create @lingfan-engine my-story",
+    "  npm create @lingfan-engine my-story --description 试菜单的小工程",
+    "  npm create @lingfan-engine my-story --yes --install",
   ].join("\n"),
   /** 交互问答的提示语 */
   promptProjectName: "工程名",
-  promptFramework: "框架",
-  promptShell: "壳",
-  promptSources: "故事源形态",
-  promptInstall: "生成后立即安装依赖？",
+  promptDescription: "描述",
+  descriptionHint: "可留空；会写进 package.json 与 Resources/project.json",
+  promptLayers: "形态",
+  /** 非交互终端的处置 */
+  nonInteractive: "当前不是交互终端，还有未指定的项",
+  nonInteractiveHint:
+    "请补 --yes 取全部缺省，或用参数指定：--description --framework --shell --sources",
+  promptExisting: "目标目录已存在且有内容，怎么处理",
   /** 参数校验失败 */
   nameRequired: "工程名不能为空",
   nameInvalid:
     "工程名只能包含小写字母、数字、连字符与下划线，且不能以点或连字符开头",
-  dirMissing: "目标目录不存在",
   frameworkUnknown: "未知框架",
   shellUnknown: "未知壳",
   sourcesUnknown: "未知故事源形态",
-  overlayMissing: "模板缺少该选项对应的叠加层",
-  targetExists: "目标目录已存在且非空",
+  templateMalformed: "形态写法不对，应为 框架[-壳[-故事源]]",
+  /** 形态多选 */
+  layersEmptyHint: "回车 = 只用骨架（框架无关 + 浏览器）",
+  layersInvalid: "没听懂这组编号，请用空格或逗号分隔的序号",
+  layersConflict: "选中的层互相排斥",
+  layersConflictHint: "重新选择（回车 = 全部缺省）",
+  /** 目标目录已存在时的三种处置 */
+  existingIgnore: "保留现有文件，同名覆盖",
+  existingIgnoreHint: "只写本模板的文件，别的东西原地不动",
+  existingClear: "清空目录后生成",
+  existingClearHint: "删掉目录里的全部内容，不可撤销",
+  existingCancel: "取消",
+  existingCancelHint: "什么都不做，退出",
+  targetExists: "目标目录已存在且非空，未做任何改动",
   templateMissing: "找不到模板目录：本包未随附模板内容，或开发态仓库结构不完整",
   /** 生成过程 */
   stageResolve: "解析模板与版本…",
   stageCopy: "写入工程文件…",
   stageInstall: "安装依赖…",
   doneTitle: "工程已生成",
-  nextSteps: ["cd <name>", "pnpm install", "pnpm dev"].join("\n"),
+  /** 生成后的三步提示；`<install>` / `<dev>` 由调用方按包管理器替换 */
+  nextSteps: ["cd <name>", "<install>", "<dev>"].join("\n"),
   /** 非致命提示 */
   warnVersionOffline:
     "无法查询 npm registry 上的最新版本，已沿用模板记录的版本",
-  warnInstallFailed: "依赖安装失败，请在工程目录内手动执行 pnpm install",
+  warnInstallFailed: "依赖安装失败，请在工程目录内手动安装依赖",
 } as const;
 
 export type CreateTexts = typeof defaultCreateTexts;