create-krispya 0.13.0 → 0.14.0

package/dist/cli.cjs

@@ -4,17 +4,18 @@
 const p = require('@clack/prompts');
 const color = require('chalk');
 const commander = require('commander');
-const promises$1 = require('node:fs/promises');
+const promises = require('node:fs/promises');
 const node_module = require('node:module');
 const node_path = require('node:path');
 const node_process = require('node:process');
 const undici = require('undici');
-const workspace = require('./shared/create-krispya.CiGwBdQ3.cjs');
-const Conf = require('conf');
-const promises = require('fs/promises');
+const workspace = require('./shared/create-krispya.Wf4wp5cQ.cjs');
+const promises$1 = require('fs/promises');
 const fs = require('fs');
 const path = require('path');
 const node_fs = require('node:fs');
+const node_child_process = require('node:child_process');
+require('conf');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -33,7 +34,6 @@ function _interopNamespaceCompat(e) {
 
 const p__namespace = /*#__PURE__*/_interopNamespaceCompat(p);
 const color__default = /*#__PURE__*/_interopDefaultCompat(color);
-const Conf__default = /*#__PURE__*/_interopDefaultCompat(Conf);
 
 function formatConfigSummary(options, inherited) {
   const lines = [];
@@ -134,8 +134,9 @@ function formatMonorepoConfigSummary(options) {
   lines.push(
     formatRow("Engine", `${workspace.getEngineName(options.engine)}@${options.engine.version ?? "latest"}`)
   );
-  lines.push(formatRow("Package manager", options.packageManager));
-  if (options.packageManager === "pnpm") {
+  const packageManagerName = workspace.getPackageManagerName(options.packageManager);
+  lines.push(formatRow("Package manager", packageManagerName));
+  if (packageManagerName === "pnpm") {
     const versionManaged = options.pnpmManageVersions ? "yes" : "no";
     lines.push(formatRow("\u21B3 Version managed", versionManaged, ""));
   }
@@ -145,22 +146,6 @@ function formatMonorepoConfigSummary(options) {
   return lines.join("\n");
 }
 
-const config = new Conf__default({
-  projectName: "create-krispya"
-});
-function getAiPlatforms() {
-  return config.get("aiPlatforms");
-}
-function getConfigStrategy() {
-  return config.get("configStrategy") ?? "stealth";
-}
-function clearConfig() {
-  config.clear();
-}
-function getConfigPath() {
-  return config.path;
-}
-
 const R3F_INTEGRATION_OPTIONS = [
   { value: "drei", label: "Drei" },
   { value: "handle", label: "Handle" },
@@ -224,7 +209,7 @@ function getDefaultOptions(template, name, projectType = "app", libraryBundler,
     formatter: inheritedSettings?.formatter ?? "prettier",
     // Libraries get vitest by default, apps don't
     testing: projectType === "library" ? "vitest" : "none",
-    configStrategy: getConfigStrategy(),
+    configStrategy: workspace.getConfigStrategy(),
     ide: "vscode"
   };
   return {
@@ -274,7 +259,7 @@ async function promptForCustomization(template, name, projectType, features, inh
     libraryBundler = bundler;
   }
   let engine = inheritedSettings?.engine ?? presets?.engine ?? { name: "node", version: "latest" };
-  let finalPackageManager = inheritedSettings?.packageManager?.name ?? presets?.packageManager ?? "pnpm";
+  let finalPackageManager = inheritedSettings?.packageManager?.name ?? presets?.packageManager?.name ?? "pnpm";
   let pnpmManageVersions = inheritedSettings?.pnpmManageVersions ?? presets?.pnpmManageVersions ?? true;
   if (!inheritedSettings?.engine?.version) {
     const nodeVersionInput = await p__namespace.text({
@@ -282,7 +267,7 @@ async function promptForCustomization(template, name, projectType, features, inh
       placeholder: presets?.engine?.version ?? "latest",
       defaultValue: presets?.engine?.version ?? "latest",
       validate: (value) => {
-        if (!value.length) return "Required";
+        if (!value?.length) return "Required";
         if (value !== "latest" && !/^\d+(\.\d+(\.\d+)?)?$/.test(value)) {
           return 'Must be "latest" or a valid semver (e.g., "22" or "22.13.0")';
         }
@@ -302,7 +287,7 @@ async function promptForCustomization(template, name, projectType, features, inh
         { value: "npm", label: "npm" },
         { value: "yarn", label: "yarn" }
       ],
-      initialValue: presets?.packageManager ?? "pnpm"
+      initialValue: presets?.packageManager?.name ?? "pnpm"
     });
     if (p__namespace.isCancel(packageManager)) {
       p__namespace.cancel("Operation cancelled.");
@@ -385,7 +370,7 @@ async function promptForCustomization(template, name, projectType, features, inh
       { value: "stealth", label: "stealth", hint: "configs in .config/" },
       { value: "root", label: "root", hint: "configs at project root" }
     ],
-    initialValue: getConfigStrategy()
+    initialValue: workspace.getConfigStrategy()
   });
   if (p__namespace.isCancel(configStrategyChoice)) {
     p__namespace.cancel("Operation cancelled.");
@@ -411,7 +396,7 @@ async function promptForCustomization(template, name, projectType, features, inh
     projectType,
     libraryBundler: projectType === "library" ? libraryBundler : void 0,
     engine,
-    packageManager: { name: finalPackageManager },
+    packageManager: presets?.packageManager?.name === finalPackageManager ? presets.packageManager : { name: finalPackageManager },
     pnpmManageVersions,
     linter,
     formatter,
@@ -458,7 +443,7 @@ async function promptForMonorepoCustomization(name, presets) {
     placeholder: presets?.engine?.version ?? "latest",
     defaultValue: presets?.engine?.version ?? "latest",
     validate: (value) => {
-      if (!value.length) return "Required";
+      if (!value?.length) return "Required";
       if (value !== "latest" && !/^\d+(\.\d+(\.\d+)?)?$/.test(value)) {
         return 'Must be "latest" or a valid semver (e.g., "22" or "22.13.0")';
       }
@@ -539,7 +524,7 @@ async function promptForMonorepo(workspaceName, presets) {
     formatMonorepoConfigSummary({
       name: defaultOptions.name,
       engine: defaultOptions.engine ?? { name: "node", version: "latest" },
-      packageManager: workspace.getPackageManagerName(defaultOptions.packageManager),
+      packageManager: defaultOptions.packageManager ?? { name: "pnpm" },
       pnpmManageVersions: defaultOptions.pnpmManageVersions,
       linter: defaultOptions.linter ?? "oxlint",
       formatter: defaultOptions.formatter ?? "prettier",
@@ -560,7 +545,7 @@ async function promptForOptions(name, presets) {
       placeholder: workspace.generateRandomName(),
       defaultValue: workspace.generateRandomName(),
       validate: (value) => {
-        if (!value.length) return "Project name is required";
+        if (!value?.length) return "Project name is required";
       }
     });
     if (p__namespace.isCancel(nameResult)) {
@@ -592,7 +577,7 @@ function presetsToInheritedSettings(presets) {
   return {
     linter: presets.linter,
     formatter: presets.formatter,
-    packageManager: presets.packageManager ? { name: presets.packageManager } : void 0,
+    packageManager: presets.packageManager,
     engine: presets.engine,
     pnpmManageVersions: presets.pnpmManageVersions
   };
@@ -644,7 +629,7 @@ async function promptForPackageOptions(projectName, projectType, inheritedSettin
 }
 
 async function promptForAiAgentPlatforms(isNonInteractive) {
-  const savedPlatforms = getAiPlatforms();
+  const savedPlatforms = workspace.getAiPlatforms();
   if (isNonInteractive) {
     return savedPlatforms ?? workspace.ALL_AI_PLATFORMS;
   }
@@ -677,54 +662,9 @@ async function promptForAiAgentPlatforms(isNonInteractive) {
   return selected;
 }
 
-async function checkAnyExists(paths) {
-  for (const path of paths) {
-    try {
-      await promises.access(path, promises.constants.F_OK);
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function validateWorkspace(monorepoRoot) {
-  const errors = [];
-  const tsConfigPath = path.join(monorepoRoot, ".config/typescript/package.json");
-  try {
-    await promises.access(tsConfigPath, promises.constants.F_OK);
-  } catch {
-    errors.push("Missing .config/typescript package");
-  }
-  const linterPaths = [
-    path.join(monorepoRoot, ".config/oxlint/package.json"),
-    path.join(monorepoRoot, ".config/eslint/package.json"),
-    path.join(monorepoRoot, "eslint.config.js"),
-    path.join(monorepoRoot, "biome.json")
-  ];
-  const hasLinter = await checkAnyExists(linterPaths);
-  if (!hasLinter) {
-    errors.push(
-      "Missing linter config (.config/oxlint, .config/eslint, eslint.config.js, or biome.json)"
-    );
-  }
-  const formatterPaths = [
-    path.join(monorepoRoot, ".config/oxfmt/package.json"),
-    path.join(monorepoRoot, ".config/prettier/package.json"),
-    path.join(monorepoRoot, ".prettierrc.json"),
-    path.join(monorepoRoot, "biome.json")
-  ];
-  const hasFormatter = await checkAnyExists(formatterPaths);
-  if (!hasFormatter) {
-    errors.push(
-      "Missing formatter config (.config/oxfmt, .config/prettier, .prettierrc.json, or biome.json)"
-    );
-  }
-  return { valid: errors.length === 0, errors };
-}
-
 async function fileExists$1(path) {
   try {
-    await promises$1.access(path, node_fs.constants.F_OK);
+    await promises.access(path, node_fs.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -740,8 +680,8 @@ async function detectMonorepoRoot() {
   while (currentDir !== root) {
     const workspaceFile = node_path.join(currentDir, "pnpm-workspace.yaml");
     try {
-      await promises$1.access(workspaceFile, node_fs.constants.F_OK);
-      const content = await promises$1.readFile(workspaceFile, "utf-8");
+      await promises.access(workspaceFile, node_fs.constants.F_OK);
+      const content = await promises.readFile(workspaceFile, "utf-8");
       if (content.includes("packages:")) {
         return currentDir;
       }
@@ -765,7 +705,7 @@ async function detectPackageRoot() {
 async function parseWorkspaceDirectories(monorepoRoot) {
   try {
     const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
-    const content = await promises$1.readFile(workspaceFile, "utf-8");
+    const content = await promises.readFile(workspaceFile, "utf-8");
     return workspace.parseWorkspaceYamlContent(content);
   } catch {
     return [];
@@ -775,14 +715,14 @@ async function detectWorkspaceSettings(monorepoRoot) {
   try {
     const tooling = await workspace.detectTooling(monorepoRoot);
     const pkgPath = node_path.join(monorepoRoot, "package.json");
-    const content = await promises$1.readFile(pkgPath, "utf-8");
+    const content = await promises.readFile(pkgPath, "utf-8");
     const pkgJson = JSON.parse(content);
-    const packageManager = workspace.parsePackageManager(pkgJson.packageManager);
+    const packageManager = workspace.parsePackageManagerSpec(pkgJson.packageManager);
     const engine = workspace.parseEngine(pkgJson.engines);
     let pnpmManageVersions;
     try {
       const workspaceFile = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
-      const workspaceContent = await promises$1.readFile(workspaceFile, "utf-8");
+      const workspaceContent = await promises.readFile(workspaceFile, "utf-8");
       pnpmManageVersions = workspaceContent.includes("manage-package-manager-versions: true");
     } catch {
     }
@@ -820,7 +760,7 @@ async function detectExistingConfigs(monorepoRoot) {
 async function getMonorepoScope(monorepoRoot) {
   try {
     const pkgPath = node_path.join(monorepoRoot, "package.json");
-    const content = await promises$1.readFile(pkgPath, "utf-8");
+    const content = await promises.readFile(pkgPath, "utf-8");
     const pkgJson = JSON.parse(content);
     if (pkgJson.name) {
       return pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
@@ -832,12 +772,12 @@ async function getMonorepoScope(monorepoRoot) {
 async function getWorkspacePackages(monorepoRoot) {
   const packagesDir = node_path.join(monorepoRoot, "packages");
   try {
-    const entries = await promises$1.readdir(packagesDir, { withFileTypes: true });
+    const entries = await promises.readdir(packagesDir, { withFileTypes: true });
     const names = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       try {
-        const content = await promises$1.readFile(node_path.join(packagesDir, entry.name, "package.json"), "utf-8");
+        const content = await promises.readFile(node_path.join(packagesDir, entry.name, "package.json"), "utf-8");
         const pkg = JSON.parse(content);
         if (pkg.name) names.push(pkg.name);
       } catch {
@@ -852,13 +792,13 @@ async function ensureConfigInWorkspace(monorepoRoot) {
   const workspacePath = node_path.join(monorepoRoot, "pnpm-workspace.yaml");
   let content;
   try {
-    content = await promises$1.readFile(workspacePath, "utf-8");
+    content = await promises.readFile(workspacePath, "utf-8");
   } catch {
     content = `packages:
   - '.config/*'
   - 'packages/*'
 `;
-    await promises$1.writeFile(workspacePath, content);
+    await promises.writeFile(workspacePath, content);
     return;
   }
   if (content.includes(".config/*")) {
@@ -874,7 +814,7 @@ ${content}`;
     lines.splice(packagesIndex + 1, 0, "  - '.config/*'");
     content = lines.join("\n");
   }
-  await promises$1.writeFile(workspacePath, content);
+  await promises.writeFile(workspacePath, content);
 }
 
 async function handleCheckCommand() {
@@ -883,7 +823,7 @@ async function handleCheckCommand() {
     console.log(color__default.red("\u2717") + " Not a monorepo workspace");
     process.exit(1);
   }
-  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  const { valid, errors } = await workspace.validateWorkspace(monorepoRoot);
   if (valid) {
     console.log(color__default.green("\u2713") + " Valid monorepo workspace");
     console.log(color__default.dim(`  ${monorepoRoot}`));
@@ -902,7 +842,7 @@ async function migrateEslintConfig(monorepoRoot, files) {
   const existingConfigPath = node_path.join(monorepoRoot, "eslint.config.js");
   let existingContent;
   try {
-    existingContent = await promises$1.readFile(existingConfigPath, "utf-8");
+    existingContent = await promises.readFile(existingConfigPath, "utf-8");
   } catch {
     workspace.renderEslintConfigPackage(files);
     return;
@@ -981,7 +921,7 @@ async function migratePrettierConfig(monorepoRoot, files) {
   const existingConfigPath = node_path.join(monorepoRoot, ".prettierrc.json");
   let existingContent;
   try {
-    existingContent = await promises$1.readFile(existingConfigPath, "utf-8");
+    existingContent = await promises.readFile(existingConfigPath, "utf-8");
   } catch {
     workspace.renderPrettierConfigPackage(files);
     return;
@@ -1040,7 +980,7 @@ async function handleFixCommand(options) {
     console.log(color__default.dim("  Run this command from within a monorepo"));
     process.exit(1);
   }
-  const { valid, errors } = await validateWorkspace(monorepoRoot);
+  const { valid, errors } = await workspace.validateWorkspace(monorepoRoot);
   if (valid) {
     console.log(color__default.green("\u2713") + " Workspace is already valid");
     console.log(color__default.dim(`  ${monorepoRoot}`));
@@ -1174,19 +1114,19 @@ async function handleFixCommand(options) {
     }
     for (const [filePath, file] of Object.entries(files)) {
       const fullPath = node_path.join(monorepoRoot, filePath);
-      await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
-      await promises$1.writeFile(fullPath, file.content);
+      await promises.mkdir(node_path.dirname(fullPath), { recursive: true });
+      await promises.writeFile(fullPath, file.content);
     }
     await ensureConfigInWorkspace(monorepoRoot);
     if (existingConfigs.eslintConfigPath && linter === "eslint") {
       try {
-        await promises$1.unlink(existingConfigs.eslintConfigPath);
+        await promises.unlink(existingConfigs.eslintConfigPath);
       } catch {
       }
     }
     if (existingConfigs.prettierConfigPath && formatter === "prettier") {
       try {
-        await promises$1.unlink(existingConfigs.prettierConfigPath);
+        await promises.unlink(existingConfigs.prettierConfigPath);
       } catch {
       }
     }
@@ -1215,8 +1155,8 @@ async function handleFixCommand(options) {
         workspace.renderVscodeFiles(vscodeFiles, linter, formatter);
         for (const [filePath, file] of Object.entries(vscodeFiles)) {
           const fullPath = node_path.join(monorepoRoot, filePath);
-          await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
-          await promises$1.writeFile(fullPath, file.content);
+          await promises.mkdir(node_path.dirname(fullPath), { recursive: true });
+          await promises.writeFile(fullPath, file.content);
         }
         console.log(color__default.dim("  Generated .vscode/settings.json"));
         console.log(color__default.dim("  Generated .vscode/extensions.json"));
@@ -1239,8 +1179,8 @@ async function handleFixCommand(options) {
         });
         for (const [filePath, file] of Object.entries(aiFilesOutput)) {
           const fullPath = node_path.join(monorepoRoot, filePath);
-          await promises$1.mkdir(node_path.dirname(fullPath), { recursive: true });
-          await promises$1.writeFile(fullPath, file.content);
+          await promises.mkdir(node_path.dirname(fullPath), { recursive: true });
+          await promises.writeFile(fullPath, file.content);
           console.log(color__default.dim(`  Generated ${filePath}`));
         }
       }
@@ -1282,18 +1222,22 @@ function renderExpectedViteConfig(template) {
 async function detectCurrentConfig(root, isMonorepo = true) {
   let name = root.split(/[/\\]/).pop() ?? "workspace";
   let packageManager = "pnpm";
+  let packageManagerSpec = { name: "pnpm" };
+  let engine;
   let hasTypecheck = false;
   let viteTemplate;
   try {
     const pkgPath = path.join(root, "package.json");
-    const content = await promises.readFile(pkgPath, "utf-8");
+    const content = await promises$1.readFile(pkgPath, "utf-8");
     const pkgJson = JSON.parse(content);
     if (pkgJson.name) {
       name = pkgJson.name.replace(/^@/, "").replace(/\/.*$/, "");
     }
     if (pkgJson.packageManager) {
-      packageManager = pkgJson.packageManager.split("@")[0] ?? packageManager;
+      packageManagerSpec = workspace.parsePackageManagerSpec(pkgJson.packageManager) ?? packageManagerSpec;
+      packageManager = packageManagerSpec.name;
     }
+    engine = workspace.parseEngine(pkgJson.engines);
     hasTypecheck = pkgJson.scripts?.typecheck != null;
     viteTemplate = detectViteTemplate(pkgJson);
   } catch {
@@ -1305,6 +1249,8 @@ async function detectCurrentConfig(root, isMonorepo = true) {
     linter: tooling.linter ?? "oxlint",
     formatter: tooling.formatter ?? "prettier",
     packageManager,
+    packageManagerSpec,
+    engine,
     isMonorepo,
     configStrategy,
     hasTypecheck,
@@ -1411,7 +1357,7 @@ async function planExpectedFiles(config) {
 }
 async function fileExists(path) {
   try {
-    await promises.access(path, fs.constants.F_OK);
+    await promises$1.access(path, fs.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -1553,7 +1499,7 @@ async function compareWithDisk(expected, root) {
       const fullPath = path.join(root, filePath);
       const newContent = file.content;
       if (await fileExists(fullPath)) {
-        const currentContent = await promises.readFile(fullPath, "utf-8");
+        const currentContent = await promises$1.readFile(fullPath, "utf-8");
         if (fileContentsEqual(filePath, currentContent, newContent)) {
           changes.push({
             path: filePath,
@@ -1631,7 +1577,7 @@ function detectLibraryPackage(pkg) {
   return pkg.exports != null || pkg.main?.includes("dist") === true || pkg.module?.includes("dist") === true || Array.isArray(pkg.files) && pkg.files.includes("dist");
 }
 function getPackageManagerForScripts(config, pkg) {
-  const packageManager = pkg.packageManager?.split("@")[0] ?? config.packageManager;
+  const packageManager = workspace.parsePackageManagerSpec(pkg.packageManager)?.name ?? config.packageManager;
   return isPackageManagerName(packageManager) ? packageManager : "pnpm";
 }
 function getSinglePackageToolScripts(config) {
@@ -1661,6 +1607,35 @@ function scriptsEqual(left, right) {
   if (leftEntries.length !== Object.keys(right).length) return false;
   return leftEntries.every(([key, value]) => right[key] === value);
 }
+function packageManagerFieldsEqual(pkg, packageManagerSpec, targetNodeVersion) {
+  if (packageManagerSpec == null || packageManagerSpec.version == null) {
+    return targetNodeVersion == null || pkg.engines?.node === `>=${targetNodeVersion}`;
+  }
+  const majorVersion = workspace.getSemverMajorString(packageManagerSpec.version);
+  return pkg.packageManager === workspace.formatPackageManager(packageManagerSpec) && pkg.engines?.[packageManagerSpec.name] === `>=${majorVersion}.0.0` && (targetNodeVersion == null || pkg.engines?.node === `>=${targetNodeVersion}`);
+}
+function applyPackageManagerFields(pkg, packageManagerSpec, targetNodeVersion) {
+  if (packageManagerSpec == null || packageManagerSpec.version == null) {
+    if (targetNodeVersion == null) return pkg;
+    return {
+      ...pkg,
+      engines: {
+        ...pkg.engines,
+        node: `>=${targetNodeVersion}`
+      }
+    };
+  }
+  const majorVersion = workspace.getSemverMajorString(packageManagerSpec.version);
+  return {
+    ...pkg,
+    packageManager: workspace.formatPackageManager(packageManagerSpec),
+    engines: {
+      ...pkg.engines,
+      [packageManagerSpec.name]: `>=${majorVersion}.0.0`,
+      ...targetNodeVersion == null ? {} : { node: `>=${targetNodeVersion}` }
+    }
+  };
+}
 async function getExpectedPackageScripts(root, config, pkg) {
   if (config.isMonorepo) {
     return workspace.packageJsonScripts.monorepoRoot(config.linter, config.formatter);
@@ -1702,7 +1677,7 @@ async function getPackageJsonScriptUpdates(root, config) {
   const packageJsonPath = path.join(root, "package.json");
   let currentContent;
   try {
-    currentContent = await promises.readFile(packageJsonPath, "utf-8");
+    currentContent = await promises$1.readFile(packageJsonPath, "utf-8");
   } catch {
     return [];
   }
@@ -1712,7 +1687,9 @@ async function getPackageJsonScriptUpdates(root, config) {
   const nextScripts = workspace.mergePackageJsonScripts(currentScripts, expectedScripts);
   const currentDevDependencies = pkg.devDependencies ?? {};
   const nextDevDependencies = await getExpectedPackageDevDependencies(root, config, pkg);
-  if (scriptsEqual(currentScripts, nextScripts) && scriptsEqual(currentDevDependencies, nextDevDependencies)) {
+  const targetPackageManagerSpec = config.targetPackageManagerSpec;
+  const targetNodeVersion = config.targetNodeVersion;
+  if (scriptsEqual(currentScripts, nextScripts) && scriptsEqual(currentDevDependencies, nextDevDependencies) && packageManagerFieldsEqual(pkg, targetPackageManagerSpec, targetNodeVersion)) {
     return [
       {
         path: "package.json",
@@ -1722,10 +1699,14 @@ async function getPackageJsonScriptUpdates(root, config) {
       }
     ];
   }
-  const nextPackageJson = {
-    ...pkg,
-    scripts: nextScripts
-  };
+  const nextPackageJson = applyPackageManagerFields(
+    {
+      ...pkg,
+      scripts: nextScripts
+    },
+    targetPackageManagerSpec,
+    targetNodeVersion
+  );
   if (Object.keys(nextDevDependencies).length > 0 || pkg.devDependencies != null) {
     nextPackageJson.devDependencies = nextDevDependencies;
   }
@@ -1740,6 +1721,41 @@ async function getPackageJsonScriptUpdates(root, config) {
     }
   ];
 }
+async function getPackageManagerConfigUpdates(root, config) {
+  if (config.targetPackageManagerSpec == null && config.targetNodeVersion == null) return [];
+  const packageJsonPath = path.join(root, "package.json");
+  let currentContent;
+  try {
+    currentContent = await promises$1.readFile(packageJsonPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const pkg = JSON.parse(currentContent);
+  if (packageManagerFieldsEqual(pkg, config.targetPackageManagerSpec, config.targetNodeVersion)) {
+    return [
+      {
+        path: "package.json",
+        status: "unchanged",
+        currentContent,
+        newContent: currentContent
+      }
+    ];
+  }
+  const nextPackageJson = applyPackageManagerFields(
+    pkg,
+    config.targetPackageManagerSpec,
+    config.targetNodeVersion
+  );
+  return [
+    {
+      path: "package.json",
+      status: "modified",
+      currentContent,
+      newContent: `${JSON.stringify(nextPackageJson, null, 2)}
+`
+    }
+  ];
+}
 function planSinglePackageOxlintConfig(config) {
   if (config.linter !== "oxlint" || config.isMonorepo) return void 0;
   const isStealth = (config.configStrategy ?? "stealth") === "stealth";
@@ -1763,7 +1779,7 @@ async function getOxlintConfigReplacementUpdates(root, config) {
   const fullPath = path.join(root, expected.path);
   let currentContent;
   try {
-    currentContent = await promises.readFile(fullPath, "utf-8");
+    currentContent = await promises$1.readFile(fullPath, "utf-8");
   } catch {
     return [expected];
   }
@@ -1785,26 +1801,118 @@ async function getOxlintConfigReplacementUpdates(root, config) {
     }
   ];
 }
-async function getWorkspaceConfigUpdates(root) {
+function extractBuildDependencies(content) {
+  const buildDependencies = {};
+  let section;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "onlyBuiltDependencies:") {
+      section = "onlyBuiltDependencies";
+      continue;
+    }
+    if (trimmed === "allowBuilds:") {
+      section = "allowBuilds";
+      continue;
+    }
+    if (section != null && trimmed && !line.startsWith(" ") && !line.startsWith("	")) {
+      section = void 0;
+    }
+    if (section === "onlyBuiltDependencies" && trimmed.startsWith("-")) {
+      const dependency = trimmed.slice(1).trim().replace(/^["']|["']$/g, "");
+      if (dependency.length > 0) {
+        buildDependencies[dependency] = true;
+      }
+    }
+    if (section === "allowBuilds") {
+      const match = trimmed.match(/^([^:]+):\s*(true|false)$/);
+      if (match == null) continue;
+      const dependency = match[1].trim().replace(/^["']|["']$/g, "");
+      if (dependency.length > 0) {
+        buildDependencies[dependency] = match[2] === "true";
+      }
+    }
+  }
+  return buildDependencies;
+}
+function withDefaultBuildDependencies(buildDependencies) {
+  return Object.keys(buildDependencies).length > 0 ? buildDependencies : { esbuild: true };
+}
+function isPnpmWorkspaceManagedScalarKey(trimmed) {
+  return trimmed.startsWith("manage-package-manager-versions:") || trimmed.startsWith("pmOnFail:");
+}
+function isPnpmWorkspaceManagedBlockKey(trimmed) {
+  return trimmed === "onlyBuiltDependencies:" || trimmed === "allowBuilds:";
+}
+function isIndentedWorkspaceLine(line) {
+  return line.startsWith(" ") || line.startsWith("	");
+}
+function removePnpmWorkspaceManagedKeys(content) {
+  const sourceLines = content.split("\n");
+  const lines = [];
+  let insertionIndex = 0;
+  let foundManagedKey = false;
+  for (let index = 0; index < sourceLines.length; index++) {
+    const line = sourceLines[index];
+    const trimmed = line.trim();
+    if (isPnpmWorkspaceManagedScalarKey(trimmed)) {
+      if (!foundManagedKey) {
+        insertionIndex = lines.length;
+        foundManagedKey = true;
+      }
+      continue;
+    }
+    if (isPnpmWorkspaceManagedBlockKey(trimmed)) {
+      if (!foundManagedKey) {
+        insertionIndex = lines.length;
+        foundManagedKey = true;
+      }
+      while (index + 1 < sourceLines.length) {
+        const nextLine = sourceLines[index + 1];
+        const nextTrimmed = nextLine.trim();
+        if (nextTrimmed !== "" && !isIndentedWorkspaceLine(nextLine)) break;
+        index++;
+      }
+      continue;
+    }
+    lines.push(line);
+  }
+  return {
+    content: lines.join("\n").trim(),
+    insertionIndex
+  };
+}
+function patchPnpmWorkspaceManagedKeys(content, profile, buildDependencies) {
+  const managedContent = workspace.renderPnpmWorkspaceConfig({
+    profile,
+    manageVersions: true,
+    buildDependencies
+  });
+  const existing = removePnpmWorkspaceManagedKeys(content);
+  const preservedLines = existing.content.length > 0 ? existing.content.split("\n") : [];
+  const insertionIndex = Math.min(existing.insertionIndex, preservedLines.length);
+  const managedLines = managedContent.split("\n");
+  preservedLines.splice(insertionIndex, 0, ...managedLines);
+  return preservedLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+async function getWorkspaceConfigUpdates(root, config) {
   const workspacePath = path.join(root, "pnpm-workspace.yaml");
   const changes = [];
+  const packageManagerSpec = config?.targetPackageManagerSpec ?? config?.packageManagerSpec ?? { name: "pnpm" };
+  const profile = workspace.getPackageManagerProfile(packageManagerSpec);
+  const defaultPackages = [".config/*", "apps/*", "packages/*"];
   let currentContent = "";
   let exists = false;
   try {
-    currentContent = await promises.readFile(workspacePath, "utf-8");
+    currentContent = await promises$1.readFile(workspacePath, "utf-8");
     exists = true;
   } catch {
   }
   if (!exists) {
-    const newContent = `manage-package-manager-versions: true
-
-packages:
-  - '.config/*'
-  - 'apps/*'
-  - 'packages/*'
-
-onlyBuiltDependencies:
-  - esbuild
+    const newContent = `${workspace.renderPnpmWorkspaceConfig({
+      profile,
+      manageVersions: true,
+      packages: defaultPackages
+    })}
 `;
     changes.push({
       path: "pnpm-workspace.yaml",
@@ -1813,32 +1921,14 @@ onlyBuiltDependencies:
     });
     return changes;
   }
-  let updatedContent = currentContent;
-  let needsUpdate = false;
-  if (!currentContent.includes("manage-package-manager-versions")) {
-    updatedContent = `manage-package-manager-versions: true
-
-${updatedContent}`;
-    needsUpdate = true;
-  }
-  if (!currentContent.includes("onlyBuiltDependencies")) {
-    updatedContent = `${updatedContent.trimEnd()}
-
-onlyBuiltDependencies:
-  - esbuild
+  const buildDependencies = withDefaultBuildDependencies(extractBuildDependencies(currentContent));
+  const updatedContent = `${patchPnpmWorkspaceManagedKeys(
+    currentContent,
+    profile,
+    buildDependencies
+  )}
 `;
-    needsUpdate = true;
-  }
-  if (!currentContent.includes(".config/*")) {
-    const lines = updatedContent.split("\n");
-    const packagesIndex = lines.findIndex((line) => line.trim().startsWith("packages:"));
-    if (packagesIndex !== -1) {
-      lines.splice(packagesIndex + 1, 0, "  - '.config/*'");
-      updatedContent = lines.join("\n");
-      needsUpdate = true;
-    }
-  }
-  if (needsUpdate) {
+  if (updatedContent !== currentContent) {
     changes.push({
       path: "pnpm-workspace.yaml",
       status: "modified",
@@ -1859,8 +1949,8 @@ async function applyUpdates(changes, root) {
   for (const change of changes) {
     if (change.status === "unchanged") continue;
     const fullPath = path.join(root, change.path);
-    await promises.mkdir(path.dirname(fullPath), { recursive: true });
-    await promises.writeFile(fullPath, change.newContent);
+    await promises$1.mkdir(path.dirname(fullPath), { recursive: true });
+    await promises$1.writeFile(fullPath, change.newContent);
   }
 }
 function formatFileChange(change) {
@@ -1936,6 +2026,96 @@ function orderUpdateCategories(categories) {
     (left, right) => getCategoryOrder(left.category) - getCategoryOrder(right.category)
   );
 }
+function isPnpmMajorMigration(config) {
+  const currentPackageManager = config.packageManagerSpec;
+  const targetPackageManager = config.targetPackageManagerSpec;
+  if (currentPackageManager?.name !== "pnpm" || targetPackageManager?.name !== "pnpm") {
+    return false;
+  }
+  const currentMajor = workspace.getSemverMajor(currentPackageManager.version);
+  const targetMajor = workspace.getSemverMajor(targetPackageManager.version);
+  return currentMajor != null && targetMajor != null && currentMajor !== targetMajor;
+}
+function getPackageUpdateCommand(config) {
+  const packageManagerName = config.packageManager.split("@")[0] ?? config.packageManager;
+  if (packageManagerName === "pnpm") {
+    if (isPnpmMajorMigration(config)) {
+      return {
+        command: "pnpm",
+        args: ["install"],
+        displayCommand: "pnpm install",
+        promptMessage: "Install dependencies?",
+        successMessage: "Dependencies installed",
+        failureLabel: "Dependency install"
+      };
+    }
+    return {
+      command: "pnpm",
+      args: ["update"],
+      displayCommand: "pnpm update",
+      promptMessage: "Update packages?",
+      successMessage: "Packages updated",
+      failureLabel: "Package update"
+    };
+  }
+  if (packageManagerName === "npm") {
+    return {
+      command: "npm",
+      args: ["update"],
+      displayCommand: "npm update",
+      promptMessage: "Update packages?",
+      successMessage: "Packages updated",
+      failureLabel: "Package update"
+    };
+  }
+  return void 0;
+}
+async function runPackageUpdate(projectRoot, updateCommand) {
+  await new Promise((resolve, reject) => {
+    const child = node_child_process.spawn(updateCommand.command, updateCommand.args, {
+      cwd: projectRoot,
+      shell: process.platform === "win32",
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${updateCommand.displayCommand} exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+async function promptForPackageUpdate(projectRoot, config, options) {
+  const updateCommand = getPackageUpdateCommand(config);
+  if (!updateCommand) {
+    console.log(color__default.dim(`  Package updates are not supported for ${config.packageManager}`));
+    return;
+  }
+  const shouldUpdatePackages = options.yes || await p__namespace.confirm({
+    message: updateCommand.promptMessage,
+    initialValue: true
+  });
+  if (p__namespace.isCancel(shouldUpdatePackages)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  if (!shouldUpdatePackages) {
+    console.log(color__default.dim("  Skipped package updates"));
+    return;
+  }
+  console.log();
+  console.log(color__default.cyan(`Running ${updateCommand.displayCommand}...`));
+  try {
+    await runPackageUpdate(projectRoot, updateCommand);
+    console.log(color__default.green("\u2713") + ` ${updateCommand.successMessage}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(color__default.red("\u2717") + ` ${updateCommand.failureLabel} failed: ${message}`);
+    process.exit(1);
+  }
+}
 async function collectUpdateCategories(projectRoot, config, isMonorepo) {
   const expected = await planExpectedFiles(config);
   const categories = await compareWithDisk(expected, projectRoot);
@@ -1959,7 +2139,7 @@ async function collectUpdateCategories(projectRoot, config, isMonorepo) {
     });
   }
   if (isMonorepo) {
-    const workspaceConfigChanges = await getWorkspaceConfigUpdates(projectRoot);
+    const workspaceConfigChanges = await getWorkspaceConfigUpdates(projectRoot, config);
     if (workspaceConfigChanges.length > 0) {
       allCategories.push({
         category: "workspace-config",
@@ -1971,6 +2151,110 @@ async function collectUpdateCategories(projectRoot, config, isMonorepo) {
   }
   return orderUpdateCategories(allCategories);
 }
+async function resolveTargetPackageManagerSpec(options, config) {
+  if (options.packageManager == null) return void 0;
+  const packageManager = workspace.parsePackageManagerSpec(options.packageManager);
+  if (packageManager == null) {
+    console.log(color__default.red("\u2717") + ` Unsupported package manager: ${options.packageManager}`);
+    process.exit(1);
+  }
+  return workspace.resolvePackageManager({
+    name: config.name,
+    packageManager
+  });
+}
+function getPackageManagerMajorUpdateTarget(currentPackageManager, latestPackageManager) {
+  if (currentPackageManager?.version == null) return void 0;
+  const currentMajor = workspace.getSemverMajor(currentPackageManager.version);
+  const latestMajor = workspace.getSemverMajor(latestPackageManager.version);
+  if (currentMajor == null || latestMajor == null || latestMajor <= currentMajor) {
+    return void 0;
+  }
+  return latestPackageManager;
+}
+function getRequiredNodeUpdateTarget(currentNodeVersion, requiredNodeVersion) {
+  if (requiredNodeVersion == null) return void 0;
+  if (currentNodeVersion == null) return requiredNodeVersion;
+  return workspace.compareNumericSemver(currentNodeVersion, requiredNodeVersion) < 0 ? requiredNodeVersion : void 0;
+}
+function formatPackageManagerMajor(packageManager) {
+  const major = workspace.getSemverMajor(packageManager.version);
+  return major == null ? packageManager.name : `${packageManager.name}@${major}`;
+}
+async function promptForNodeRequirementUpdate(options, config, targetPackageManagerSpec) {
+  if (targetPackageManagerSpec == null) return void 0;
+  const profile = workspace.getPackageManagerProfile(targetPackageManagerSpec);
+  const requiredNodeVersion = profile.requirements.node;
+  const currentNodeVersion = config.engine?.version;
+  const targetNodeVersion = getRequiredNodeUpdateTarget(currentNodeVersion, requiredNodeVersion);
+  if (targetNodeVersion == null) return void 0;
+  const currentNodeLabel = currentNodeVersion == null ? "not set" : `>=${currentNodeVersion}`;
+  p__namespace.log.warn(
+    `${workspace.formatPackageManager(targetPackageManagerSpec)} requires Node >=${targetNodeVersion}; current engines.node is ${currentNodeLabel}.`
+  );
+  const shouldUpdate = options.yes || await p__namespace.confirm({
+    message: `Update engines.node to >=${targetNodeVersion} too?`,
+    initialValue: true
+  });
+  if (p__namespace.isCancel(shouldUpdate)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return shouldUpdate ? targetNodeVersion : void 0;
+}
+async function promptForPackageManagerMajorUpdate(options, config) {
+  if (options.packageManager != null || config.packageManagerSpec == null) return void 0;
+  const currentPackageManager = config.packageManagerSpec;
+  if (currentPackageManager.version == null) return void 0;
+  const latestPackageManager = await workspace.resolvePackageManager({
+    name: config.name,
+    packageManager: { name: currentPackageManager.name }
+  });
+  const updateTarget = getPackageManagerMajorUpdateTarget(
+    currentPackageManager,
+    latestPackageManager
+  );
+  if (updateTarget == null) return void 0;
+  const shouldUpdate = options.yes || await p__namespace.confirm({
+    message: `Update ${currentPackageManager.name} from ${formatPackageManagerMajor(
+      currentPackageManager
+    )} to ${formatPackageManagerMajor(latestPackageManager)}?`,
+    initialValue: true
+  });
+  if (p__namespace.isCancel(shouldUpdate)) {
+    p__namespace.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  return shouldUpdate ? updateTarget : void 0;
+}
+async function applyPackageManagerMigration(projectRoot, isMonorepo, options, detectedConfig) {
+  const targetPackageManagerSpec = await resolveTargetPackageManagerSpec(options, detectedConfig) ?? await promptForPackageManagerMajorUpdate(options, detectedConfig);
+  if (targetPackageManagerSpec == null) return detectedConfig;
+  const targetNodeVersion = await promptForNodeRequirementUpdate(
+    options,
+    detectedConfig,
+    targetPackageManagerSpec
+  );
+  const migrationConfig = {
+    ...detectedConfig,
+    packageManager: targetPackageManagerSpec.name,
+    targetPackageManagerSpec,
+    targetNodeVersion
+  };
+  const changes = [
+    ...await getPackageManagerConfigUpdates(projectRoot, migrationConfig),
+    ...isMonorepo || targetPackageManagerSpec.name === "pnpm" ? await getWorkspaceConfigUpdates(projectRoot, migrationConfig) : []
+  ].filter((change) => change.status === "added" || change.status === "modified");
+  if (changes.length === 0) return migrationConfig;
+  console.log();
+  console.log(color__default.cyan("Package Manager:"));
+  for (const change of changes) {
+    console.log(formatFileChange(change));
+  }
+  await applyUpdates(changes, projectRoot);
+  console.log(color__default.green("\u2713") + ` Package Manager: updated ${changes.length}`);
+  return migrationConfig;
+}
 async function processUpdateCategory(category, projectRoot, options) {
   const newChanges = category.changes.filter((change) => change.status === "added");
   const modifiedChanges = category.changes.filter((change) => change.status === "modified");
@@ -2010,11 +2294,8 @@ async function processUpdateCategory(category, projectRoot, options) {
     if (addedCount > 0) parts.push(`added ${addedCount}`);
     if (updatedFilesCount > 0) parts.push(`updated ${updatedFilesCount}`);
     console.log(color__default.green("\u2713") + ` ${category.label}: ${parts.join(", ")}`);
-    console.log();
     return "updated";
   }
-  console.log(color__default.dim(`  Skipped ${category.label}`));
-  console.log();
   return "skipped";
 }
 async function handleUpdateCommand(options, handleFixCommand) {
@@ -2027,7 +2308,7 @@ async function handleUpdateCommand(options, handleFixCommand) {
   }
   const isMonorepo = monorepoRoot != null;
   if (isMonorepo) {
-    const { valid, errors } = await validateWorkspace(projectRoot);
+    const { valid, errors } = await workspace.validateWorkspace(projectRoot);
     if (!valid) {
       console.log(color__default.yellow("!") + " Workspace has issues:");
       for (const error of errors) {
@@ -2080,6 +2361,8 @@ async function handleUpdateCommand(options, handleFixCommand) {
       console.log(color__default.dim(`  Skipped ${skippedCount}`));
     }
   }
+  const finalConfig = await applyPackageManagerMigration(projectRoot, isMonorepo, options, config);
+  await promptForPackageUpdate(projectRoot, finalConfig, options);
   process.exit(0);
 }
 
@@ -2097,9 +2380,10 @@ async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedS
     message: "Package name?",
     initialValue: `@${scope}/`,
     validate: (value) => {
-      const validationError = workspace.validatePackageName(value);
+      const packageName = value ?? "";
+      const validationError = workspace.validatePackageName(packageName);
       if (validationError) return validationError;
-      const dirName = value.includes("/") ? value.split("/").pop() : value;
+      const dirName = workspace.getPackageDirectoryName(packageName);
       if (!dirName) return "Package name is required";
       if (!hasCustomDirectories) {
         const targetPath = node_path.join(monorepoRoot, defaultDir, dirName);
@@ -2116,7 +2400,7 @@ async function createPackageInWorkspace(monorepoRoot, packageManager, inheritedS
     return false;
   }
   const scopedName = packageNameInput;
-  const shortName = scopedName.includes("/") ? scopedName.split("/").pop() : scopedName;
+  const shortName = workspace.getPackageDirectoryName(scopedName);
   const packageOptions = await promptForPackageOptions(scopedName, packageType, inheritedSettings);
   let targetDir = defaultDir;
   if (hasCustomDirectories && workspaceDirectories.length > 0) {
@@ -2197,10 +2481,11 @@ async function handleWorkspaceCommand(name, options, writeGeneratedFiles) {
   const template = options.template ?? "vanilla";
   const baseTemplate = workspace.getBaseTemplate(template);
   const scopedName = name.startsWith("@") ? name : `@${scope}/${name}`;
-  const fullPackagePath = node_path.join(monorepoRoot, targetDir, name);
+  const packageDirName = workspace.getPackageDirectoryName(name);
+  const fullPackagePath = node_path.join(monorepoRoot, targetDir, packageDirName);
   try {
-    await promises$1.access(fullPackagePath, node_fs.constants.F_OK);
-    console.error(color__default.red("Error:") + ` Directory ${targetDir}/${name} already exists`);
+    await promises.access(fullPackagePath, node_fs.constants.F_OK);
+    console.error(color__default.red("Error:") + ` Directory ${targetDir}/${packageDirName} already exists`);
     process.exit(1);
   } catch {
   }
@@ -2213,7 +2498,7 @@ async function handleWorkspaceCommand(name, options, writeGeneratedFiles) {
   };
   const pnpmManageVersions = inheritedSettings.pnpmManageVersions ?? true;
   const isLibrary = projectType === "library";
-  const relativePkgPath = node_path.join(targetDir, name);
+  const relativePkgPath = node_path.join(targetDir, packageDirName);
   const workspaceRoot = calculateWorkspaceRoot(relativePkgPath);
   const projectOptions = {
     name: scopedName,
@@ -2241,11 +2526,11 @@ async function handleWorkspaceCommand(name, options, writeGeneratedFiles) {
       triplex: options.triplex ? {} : void 0
     }
   };
-  console.log(color__default.cyan("Creating") + ` ${scopedName} in ${targetDir}/${name}...`);
+  console.log(color__default.cyan("Creating") + ` ${scopedName} in ${targetDir}/${packageDirName}...`);
   try {
     const { files } = await workspace.planProject(workspace.resolveProjectPlanInput(projectOptions));
     await writeGeneratedFiles(fullPackagePath, files);
-    console.log(color__default.green("\u2713") + ` Created ${scopedName} at ${targetDir}/${name}`);
+    console.log(color__default.green("\u2713") + ` Created ${scopedName} at ${targetDir}/${packageDirName}`);
     process.exit(0);
   } catch (error) {
     console.error(color__default.red("Error:") + " Failed to create package");
@@ -2316,13 +2601,13 @@ async function writeGeneratedFiles(basePath, files) {
   const filePaths = Object.keys(files).sort();
   for (const filePath of filePaths) {
     const fullFilePath = node_path.join(basePath, filePath);
-    await promises$1.mkdir(node_path.dirname(fullFilePath), { recursive: true });
+    await promises.mkdir(node_path.dirname(fullFilePath), { recursive: true });
     const file = files[filePath];
     if (file.type === "text") {
-      await promises$1.writeFile(fullFilePath, file.content);
+      await promises.writeFile(fullFilePath, file.content);
     } else {
       const response = await undici.fetch(file.url);
-      await promises$1.writeFile(fullFilePath, response.body);
+      await promises.writeFile(fullFilePath, response.body);
     }
   }
 }
@@ -2390,7 +2675,8 @@ async function handleSingleWorkspaceCreation(projectOptions, isNonInteractive) {
   const defaultFallbackName = base === "vanilla" ? "vanilla-app" : base === "react" ? "react-app" : "react-three-app";
   projectOptions.name ??= defaultFallbackName;
   const packageManager = workspace.getPackageManagerName(projectOptions.packageManager);
-  const projectPath = node_path.join(node_process.cwd(), projectOptions.name);
+  const projectDirName = workspace.getPackageDirectoryName(projectOptions.name);
+  const projectPath = node_path.join(node_process.cwd(), projectDirName);
   const spinner = p__namespace.spinner();
   spinner.start("Creating project...");
   try {
@@ -2399,15 +2685,11 @@ async function handleSingleWorkspaceCreation(projectOptions, isNonInteractive) {
     await writeGeneratedFiles(projectPath, files);
     spinner.stop(color__default.green.inverse(" \u2713 Project created! "));
     if (isNonInteractive) process.exit(0);
-    const nextSteps = projectOptions.projectType === "library" ? [
-      `cd ${projectOptions.name}`,
-      `${packageManager} install`,
-      `${packageManager} run build`
-    ].join("\n") : [
-      `cd ${projectOptions.name}`,
-      `${packageManager} install`,
-      `${packageManager} run dev`
-    ].join("\n");
+    const nextSteps = projectOptions.projectType === "library" ? [`cd ${projectDirName}`, `${packageManager} install`, `${packageManager} run build`].join(
+      "\n"
+    ) : [`cd ${projectDirName}`, `${packageManager} install`, `${packageManager} run dev`].join(
+      "\n"
+    );
     p__namespace.note(nextSteps, "Next steps");
     p__namespace.outro(color__default.green("Happy coding! \u2728"));
   } catch (error) {
@@ -2423,7 +2705,7 @@ async function main() {
   ).option(
     "--template <type>",
     "project template: vanilla, vanilla-js, react, react-js, r3f, r3f-js (default: vanilla)"
-  ).option("--linter <type>", "linter: eslint, oxlint, or biome (default: oxlint)").option("--formatter <type>", "formatter: prettier, oxfmt, or biome (default: prettier)").option("--drei", "add @react-three/drei (r3f only)").option("--handle", "add @react-three/handle (r3f only)").option("--leva", "add leva (r3f only)").option("--postprocessing", "add @react-three/postprocessing (r3f only)").option("--rapier", "add @react-three/rapier (r3f only)").option("--xr", "add @react-three/xr (r3f only)").option("--uikit", "add @react-three/uikit (r3f only)").option("--offscreen", "add @react-three/offscreen (r3f only)").option("--zustand", "add zustand (r3f only)").option("--koota", "add koota (r3f only)").option("--triplex", "set up triplex development environment (r3f only)").option("--viverse", "set up viverse deployment (r3f only)").option("--package-manager <manager>", "specify package manager (e.g. npm, yarn, pnpm)").option("--ide <ide>", "IDE files: vscode or none (default: vscode)").option(
+  ).option("--linter <type>", "linter: eslint, oxlint, or biome (default: oxlint)").option("--formatter <type>", "formatter: prettier, oxfmt, or biome (default: prettier)").option("--drei", "add @react-three/drei (r3f only)").option("--handle", "add @react-three/handle (r3f only)").option("--leva", "add leva (r3f only)").option("--postprocessing", "add @react-three/postprocessing (r3f only)").option("--rapier", "add @react-three/rapier (r3f only)").option("--xr", "add @react-three/xr (r3f only)").option("--uikit", "add @react-three/uikit (r3f only)").option("--offscreen", "add @react-three/offscreen (r3f only)").option("--zustand", "add zustand (r3f only)").option("--koota", "add koota (r3f only)").option("--triplex", "set up triplex development environment (r3f only)").option("--viverse", "set up viverse deployment (r3f only)").option("--package-manager <manager>", "specify package manager (e.g. npm, yarn, pnpm@11)").option("--ide <ide>", "IDE files: vscode or none (default: vscode)").option(
     "--pnpm-manage-versions",
     "enable manage-package-manager-versions in pnpm-workspace.yaml (default: true)"
   ).option(
@@ -2437,18 +2719,24 @@ async function main() {
       process.chdir(options.path);
     }
     if (options.clearConfig) {
-      clearConfig();
+      workspace.clearConfig();
       console.log("Configuration cleared.");
       process.exit(0);
     }
     if (options.configPath) {
-      console.log(getConfigPath());
+      console.log(workspace.getConfigPath());
       process.exit(0);
     }
     if (options.ide && !["vscode", "none"].includes(options.ide)) {
       console.error(color__default.red("Error:") + ' --ide must be "vscode" or "none"');
       process.exit(1);
     }
+    const packageManagerSpec = workspace.parsePackageManagerSpec(options.packageManager);
+    if (options.packageManager && packageManagerSpec == null) {
+      console.error(color__default.red("Error:") + " --package-manager must be npm, yarn, or pnpm");
+      console.log(color__default.dim("  Version specs are allowed, e.g. pnpm@10 or pnpm@11"));
+      process.exit(1);
+    }
     if (name?.startsWith("-")) {
       switch (name) {
         case "--version":
@@ -2460,11 +2748,11 @@ async function main() {
           program.help();
           break;
         case "--clear-config":
-          clearConfig();
+          workspace.clearConfig();
           console.log("Configuration cleared.");
           process.exit(0);
         case "--config-path":
-          console.log(getConfigPath());
+          console.log(workspace.getConfigPath());
           process.exit(0);
         case "--check":
           await handleCheckCommand();
@@ -2534,7 +2822,7 @@ async function main() {
           viverse: options.viverse ? {} : void 0,
           triplex: options.triplex ? {} : void 0
         },
-        packageManager: options.packageManager ? { name: options.packageManager } : void 0,
+        packageManager: packageManagerSpec,
         pnpmManageVersions: options.pnpmManageVersions,
         engine: { name: "node", version: options.nodeVersion ?? "latest" }
       };
@@ -2545,7 +2833,7 @@ async function main() {
         bundler: options.bundler,
         linter: options.linter,
         formatter: options.formatter,
-        packageManager: options.packageManager,
+        packageManager: packageManagerSpec,
         ide: options.ide,
         engine: options.nodeVersion ? { name: "node", version: options.nodeVersion } : void 0,
         pnpmManageVersions: options.pnpmManageVersions,