create-krispya 0.6.0 → 0.8.0

package/dist/chunks/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-const color = require('chalk');
 const promises = require('fs/promises');
 const fs = require('fs');
 const path = require('path');
+const color = require('chalk');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -91,7 +91,7 @@ const GitAttributes = [
 ].join("\n");
 const defaultFormatterConfig = {
   printWidth: 102,
-  tabWidth: 4,
+  tabWidth: 2,
   useTabs: false,
   semi: true,
   singleQuote: true,
@@ -103,17 +103,13 @@ const defaultPrettierConfig = {
   $schema: "https://json.schemastore.org/prettierrc",
   ...defaultFormatterConfig,
   overrides: [
-    {
-      files: ["*.json", "**/*.json"],
-      options: { tabWidth: 2 }
-    },
     {
       files: ["*.md", "**/*.md"],
-      options: { tabWidth: 2, semi: false }
+      options: { semi: false }
     },
     {
       files: ["*.yml", "*.yaml", "**/*.yml", "**/*.yaml"],
-      options: { tabWidth: 2, semi: false }
+      options: { semi: false }
     }
   ]
 };
@@ -155,22 +151,24 @@ const AI_PLATFORM_HINTS = {
 function generateAiFiles(files, params) {
   const { platforms, isMonorepo, configStrategy, ...rest } = params;
   if (platforms.length === 0) return;
-  files[".ai/workspace.md"] = {
-    type: "text",
-    content: generateWorkspace({
-      ...rest,
-      isMonorepo: !!isMonorepo,
-      configStrategy: configStrategy ?? "stealth"
-    })
-  };
-  const pointer = "See `.ai/` for project rules.\n";
-  for (const platform of platforms) {
-    const path = platform === "agents" ? "AGENTS.md" : "CLAUDE.md";
-    files[path] = { type: "text", content: pointer };
+  const content = generateWorkspace({
+    ...rest,
+    isMonorepo: !!isMonorepo});
+  const pointer = "See [`AGENTS.md`](./Agents.md) for agent context.\n";
+  const hasAgents = platforms.includes("agents");
+  const hasClaude = platforms.includes("claude");
+  const isSingleton = platforms.length === 1;
+  if (hasAgents) files["AGENTS.md"] = { type: "text", content };
+  if (hasClaude) {
+    if (isSingleton) {
+      files["CLAUDE.md"] = { type: "text", content };
+    } else {
+      files["CLAUDE.md"] = { type: "text", content: pointer };
+    }
   }
 }
 function generateWorkspace(ctx) {
-  const { name, packageManager, linter, formatter, isMonorepo, configStrategy } = ctx;
+  const { name, packageManager, linter, formatter, isMonorepo} = ctx;
   const sections = [
     `# ${name}`,
     "",
@@ -187,54 +185,572 @@ function generateWorkspace(ctx) {
   ];
   if (isMonorepo) {
     sections.push(
-      "",
-      "## Structure",
-      "",
-      "- `apps/` \u2014 applications",
-      "- `packages/` \u2014 shared libraries",
-      "- `.config/` \u2014 shared config packages",
-      "",
-      "## Monorepo",
       "",
       "- Use `workspace:*` for internal dependencies",
       `- New packages: \`${packageManager} create krispya <name> --workspace\``
     );
-  } else if (configStrategy === "root") {
-    sections.push(
-      "",
-      "## Structure",
-      "",
-      "- `src/` \u2014 source code",
-      "- `dist/` \u2014 generated, don't edit",
-      "- Config files (`tsconfig.json`, etc.) are at project root"
-    );
-  } else {
-    sections.push(
-      "",
-      "## Structure",
-      "",
-      "- `src/` \u2014 source code",
-      "- `.config/` \u2014 configs, don't move",
-      "- `dist/` \u2014 generated, don't edit"
-    );
   }
   sections.push("");
   return sections.join("\n");
 }
 
+function getLanguageFromTemplate(template) {
+  return template.endsWith("-js") ? "javascript" : "typescript";
+}
+function getBaseTemplate(template) {
+  return template.replace("-js", "");
+}
+
+async function getLatestNpmVersion(packageName, fallback) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+    const data = await response.json();
+    return data.version;
+  } catch {
+    return fallback;
+  }
+}
+async function getLatestPnpmVersion() {
+  return getLatestNpmVersion("pnpm", "10.11.0");
+}
+async function getLatestYarnVersion() {
+  return getLatestNpmVersion("yarn", "4.6.0");
+}
+async function getLatestNpmCliVersion() {
+  return getLatestNpmVersion("npm", "11.0.0");
+}
+async function getLatestNodeVersion() {
+  try {
+    const response = await fetch("https://nodejs.org/dist/index.json");
+    const data = await response.json();
+    const latestVersion = data[0];
+    if (latestVersion) {
+      return latestVersion.version.replace(/^v/, "");
+    }
+    return "25.0.0";
+  } catch {
+    return "25.0.0";
+  }
+}
+function validateNameSegment(segment, label) {
+  if (!segment.length) {
+    return `${label} is required`;
+  }
+  if (!/^[a-z0-9-]+$/.test(segment)) {
+    return `${label} must be lowercase and contain only letters, numbers, and hyphens`;
+  }
+  if (segment.startsWith("-") || segment.endsWith("-")) {
+    return `${label} cannot start or end with a hyphen`;
+  }
+  if (segment.includes("--")) {
+    return `${label} cannot contain consecutive hyphens`;
+  }
+  return void 0;
+}
+function validatePackageName(name) {
+  if (!name.length) {
+    return "Package name is required";
+  }
+  if (name.includes("..") || name.includes("\\")) {
+    return "Package name cannot contain path traversal sequences";
+  }
+  if (name.startsWith("@")) {
+    const slashIndex = name.indexOf("/");
+    if (slashIndex === -1) {
+      return "Scoped package name must include a package name after the scope (e.g., @scope/name)";
+    }
+    if (name.indexOf("/", slashIndex + 1) !== -1) {
+      return "Package name can only have one slash for scoped packages";
+    }
+    const scope = name.slice(1, slashIndex);
+    const packageName = name.slice(slashIndex + 1);
+    const scopeError = validateNameSegment(scope, "Scope");
+    if (scopeError) return scopeError;
+    const nameError = validateNameSegment(packageName, "Package name");
+    if (nameError) return nameError;
+    return void 0;
+  }
+  if (name.includes("/")) {
+    return "Unscoped package name cannot contain slashes. Use @scope/name format for scoped packages";
+  }
+  return validateNameSegment(name, "Package name");
+}
+function parseWorkspaceYamlContent(content) {
+  const directories = [];
+  let inPackagesSection = false;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "packages:") {
+      inPackagesSection = true;
+      continue;
+    }
+    if (inPackagesSection && trimmed && !line.startsWith(" ") && !line.startsWith("	") && !trimmed.startsWith("-")) {
+      break;
+    }
+    if (inPackagesSection && trimmed.startsWith("-")) {
+      const entry = trimmed.slice(1).trim().replace(/^["']|["']$/g, "").replace(/^\.\//, "").replace(/\/\*.*$/, "");
+      if (entry && !entry.startsWith(".")) {
+        directories.push(entry);
+      }
+    }
+  }
+  return directories;
+}
+async function pathExists(path) {
+  try {
+    await promises.access(path, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectLinterFromScript(script) {
+  if (!script) return void 0;
+  if (script.includes("oxlint")) return "oxlint";
+  if (script.includes("eslint")) return "eslint";
+  if (script.includes("biome check") || script.includes("biome lint")) return "biome";
+  return void 0;
+}
+function detectFormatterFromScript(script) {
+  if (!script) return void 0;
+  if (script.includes("prettier")) return "prettier";
+  if (script.includes("oxfmt")) return "oxfmt";
+  if (script.includes("biome format")) return "biome";
+  return void 0;
+}
+async function detectLinterFromConfig(root) {
+  if (await pathExists(path.join(root, ".config/oxlint"))) return "oxlint";
+  if (await pathExists(path.join(root, ".config/eslint"))) return "eslint";
+  if (await pathExists(path.join(root, "biome.json"))) {
+    try {
+      const content = await promises.readFile(path.join(root, "biome.json"), "utf-8");
+      const config = JSON.parse(content);
+      if (config.linter?.enabled !== false) return "biome";
+    } catch {
+      return "biome";
+    }
+  }
+  return void 0;
+}
+async function detectFormatterFromConfig(root) {
+  if (await pathExists(path.join(root, ".config/prettier"))) return "prettier";
+  if (await pathExists(path.join(root, ".config/oxfmt"))) return "oxfmt";
+  if (await pathExists(path.join(root, "biome.json"))) {
+    try {
+      const content = await promises.readFile(path.join(root, "biome.json"), "utf-8");
+      const config = JSON.parse(content);
+      if (config.formatter?.enabled !== false) return "biome";
+    } catch {
+      return "biome";
+    }
+  }
+  return void 0;
+}
+function detectLinterFromDeps(devDeps) {
+  if (!devDeps) return void 0;
+  if (devDeps["@biomejs/biome"]) return "biome";
+  if (devDeps.eslint) return "eslint";
+  if (devDeps.oxlint) return "oxlint";
+  return void 0;
+}
+function detectFormatterFromDeps(devDeps) {
+  if (!devDeps) return void 0;
+  if (devDeps["@biomejs/biome"]) return "biome";
+  if (devDeps.prettier) return "prettier";
+  if (devDeps.oxfmt) return "oxfmt";
+  return void 0;
+}
+async function detectTooling(root) {
+  try {
+    const pkgPath = path.join(root, "package.json");
+    const content = await promises.readFile(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const linter = detectLinterFromScript(pkg.scripts?.lint) ?? await detectLinterFromConfig(root) ?? detectLinterFromDeps(pkg.devDependencies);
+    const formatter = detectFormatterFromScript(pkg.scripts?.format) ?? await detectFormatterFromConfig(root) ?? detectFormatterFromDeps(pkg.devDependencies);
+    return { linter, formatter };
+  } catch {
+    return { linter: void 0, formatter: void 0 };
+  }
+}
+function generateRandomName() {
+  const adjectives = [
+    "red",
+    "blue",
+    "green",
+    "yellow",
+    "purple",
+    "orange",
+    "pink",
+    "black",
+    "white",
+    "tiny",
+    "big",
+    "small",
+    "large",
+    "huge",
+    "giant",
+    "mini",
+    "mega",
+    "super",
+    "happy",
+    "sad",
+    "angry",
+    "calm",
+    "quiet",
+    "loud",
+    "silent",
+    "noisy",
+    "shiny",
+    "dull",
+    "bright",
+    "dark",
+    "fuzzy",
+    "smooth",
+    "rough",
+    "soft"
+  ];
+  const nouns = [
+    "apple",
+    "banana",
+    "cherry",
+    "date",
+    "elderberry",
+    "fig",
+    "grape",
+    "honeydew",
+    "cat",
+    "dog",
+    "elephant",
+    "fox",
+    "giraffe",
+    "horse",
+    "iguana",
+    "jaguar",
+    "mountain",
+    "river",
+    "ocean",
+    "desert",
+    "forest",
+    "jungle",
+    "meadow",
+    "valley",
+    "star",
+    "moon",
+    "sun",
+    "planet",
+    "comet",
+    "asteroid",
+    "galaxy",
+    "universe"
+  ];
+  const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
+  return `${randomAdjective}-${randomNoun}`;
+}
+
+const PACKAGE_VERSION_DEFINITIONS = {
+  "@biomejs/biome": { fallbackVersion: "2.0.0" },
+  "@react-three/drei": { fallbackVersion: "10.0.0" },
+  "@react-three/fiber": { fallbackVersion: "9.0.0" },
+  "@react-three/handle": { fallbackVersion: "6.6.16" },
+  "@react-three/offscreen": { fallbackVersion: "0.0.8" },
+  "@react-three/postprocessing": { fallbackVersion: "3.0.4" },
+  "@react-three/rapier": { fallbackVersion: "2.1.0" },
+  "@react-three/uikit": { fallbackVersion: "0.8.15" },
+  "@react-three/xr": { fallbackVersion: "6.6.16" },
+  "@testing-library/dom": { fallbackVersion: "10.4.0" },
+  "@testing-library/react": { fallbackVersion: "16.2.0" },
+  "@types/react": { fallbackVersion: "19.0.0" },
+  "@types/react-dom": { fallbackVersion: "19.0.0" },
+  "@types/three": { fallbackVersion: "0.175.0", prefix: "~" },
+  "@vitejs/plugin-basic-ssl": { fallbackVersion: "2.0.0" },
+  "@vitejs/plugin-react": { fallbackVersion: "4.4.1" },
+  "@viverse/cli": { fallbackVersion: "0.9.5-beta.8" },
+  eslint: { fallbackVersion: "9.17.0" },
+  "eslint-plugin-react-hooks": { fallbackVersion: "5.1.0" },
+  jsdom: { fallbackVersion: "26.0.0" },
+  koota: { fallbackVersion: "0.4.0" },
+  leva: { fallbackVersion: "0.10.0" },
+  oxfmt: { fallbackVersion: "0.21.0" },
+  oxlint: { fallbackVersion: "1.36.0" },
+  prettier: { fallbackVersion: "3.4.2" },
+  react: { fallbackVersion: "19.0.0" },
+  "react-dom": { fallbackVersion: "19.0.0" },
+  three: { fallbackVersion: "0.175.0", prefix: "~" },
+  tsdown: { fallbackVersion: "0.12.0" },
+  "typescript-eslint": { fallbackVersion: "8.18.0" },
+  unbuild: { fallbackVersion: "3.5.0" },
+  vite: { fallbackVersion: "6.3.4" },
+  vitest: { fallbackVersion: "4.0.0" },
+  zustand: { fallbackVersion: "5.0.3" }
+};
+function addPackageName(packageNames, explicitVersions, packageName) {
+  if (!explicitVersions.has(packageName)) {
+    packageNames.add(packageName);
+  }
+}
+function getExplicitVersionPackages(options) {
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(options.dependencies ?? {}),
+    ...Object.keys(options.versions ?? {})
+  ]);
+}
+function getPackageFallbackVersion(packageName) {
+  const definition = PACKAGE_VERSION_DEFINITIONS[packageName];
+  if (definition == null) {
+    throw new Error(`Missing package version definition for ${packageName}`);
+  }
+  return definition.fallbackVersion;
+}
+function getResolvedPackageVersion(versions, packageName) {
+  return versions[packageName] ?? getPackageFallbackVersion(packageName);
+}
+function formatResolvedPackageVersion(versions, packageName, prefix) {
+  const resolvedPrefix = prefix ?? PACKAGE_VERSION_DEFINITIONS[packageName]?.prefix ?? "^";
+  return `${resolvedPrefix}${getResolvedPackageVersion(versions, packageName)}`;
+}
+function assignResolvedPackageVersion(target, versions, packageName, prefix) {
+  target[packageName] = formatResolvedPackageVersion(versions, packageName, prefix);
+}
+function getPackageManagerSpec(packageManager) {
+  return packageManager ?? { name: "pnpm" };
+}
+function getPackageManagerName(packageManager) {
+  return getPackageManagerSpec(packageManager).name;
+}
+function formatPackageManager(packageManager) {
+  const spec = getPackageManagerSpec(packageManager);
+  return spec.version ? `${spec.name}@${spec.version}` : spec.name;
+}
+function parsePackageManager(packageManager) {
+  if (packageManager == null || packageManager.length === 0) {
+    return void 0;
+  }
+  const atIndex = packageManager.indexOf("@");
+  if (atIndex === -1) {
+    return { name: packageManager };
+  }
+  return {
+    name: packageManager.slice(0, atIndex),
+    version: packageManager.slice(atIndex + 1)
+  };
+}
+function getEngineSpec(engine) {
+  return engine ?? { name: "node" };
+}
+function getEngineName(engine) {
+  return getEngineSpec(engine).name;
+}
+function parseEngine(engines) {
+  if (engines == null) {
+    return void 0;
+  }
+  const [name, range] = Object.entries(engines).find(
+    ([engineName]) => engineName !== "npm" && engineName !== "pnpm" && engineName !== "yarn"
+  ) ?? [];
+  if (name == null) {
+    return void 0;
+  }
+  const version = range?.match(/(\d+(?:\.\d+(?:\.\d+)?)?)/)?.[1];
+  return { name, version };
+}
+async function resolvePackageManager(options) {
+  const packageManager = getPackageManagerSpec(options.packageManager);
+  if (packageManager.version == null) {
+    if (packageManager.name === "pnpm") {
+      packageManager.version = await getLatestPnpmVersion();
+    } else if (packageManager.name === "yarn") {
+      packageManager.version = await getLatestYarnVersion();
+    } else if (packageManager.name === "npm") {
+      packageManager.version = await getLatestNpmCliVersion();
+    }
+  }
+  return packageManager;
+}
+async function resolveEngine(options) {
+  const engine = getEngineSpec(options.engine);
+  if (engine.version == null && engine.name === "node") {
+    engine.version = await getLatestNodeVersion();
+  }
+  return engine;
+}
+async function resolvePackageVersions(packageNames, existingVersions = {}) {
+  const versions = { ...existingVersions };
+  const uniquePackageNames = [...new Set(packageNames)];
+  await Promise.all(
+    uniquePackageNames.map(async (packageName) => {
+      if (versions[packageName] != null) return;
+      versions[packageName] = await getLatestNpmVersion(
+        packageName,
+        getPackageFallbackVersion(packageName)
+      );
+    })
+  );
+  return versions;
+}
+async function resolveProjectPackageVersions(options) {
+  return resolvePackageVersions(collectProjectPackageNames(options), options.versions);
+}
+async function resolveMonorepoRootPackageVersions(params) {
+  const packageNames = /* @__PURE__ */ new Set();
+  const explicitVersions = new Set(Object.keys(params.versions ?? {}));
+  addPackageName(packageNames, explicitVersions, getLinterPackage(params.linter));
+  if (params.formatter !== "biome" || params.linter !== "biome") {
+    addPackageName(packageNames, explicitVersions, getFormatterPackage(params.formatter));
+  }
+  return resolvePackageVersions(packageNames, params.versions);
+}
+function collectProjectPackageNames(options) {
+  const packageNames = /* @__PURE__ */ new Set();
+  const explicitVersions = getExplicitVersionPackages(options);
+  const template = options.template ?? "vanilla";
+  const baseTemplate = getBaseTemplate(template);
+  const language = getLanguageFromTemplate(template);
+  const isLibrary = options.projectType === "library";
+  const isReact = baseTemplate === "react" || baseTemplate === "r3f";
+  const isR3f = baseTemplate === "r3f";
+  const isTypescript = language === "typescript";
+  const inWorkspace = options.workspaceRoot != null;
+  const testing = options.testing ?? (isLibrary ? "vitest" : "none");
+  const linter = options.linter ?? "oxlint";
+  const formatter = options.formatter ?? "prettier";
+  const bundler = options.libraryBundler ?? "unbuild";
+  const packageManager = getPackageManagerName(options.packageManager);
+  if (!isLibrary) {
+    addPackageName(packageNames, explicitVersions, "vite");
+  }
+  if (isReact) {
+    if (!isLibrary) {
+      addPackageName(packageNames, explicitVersions, "react");
+      addPackageName(packageNames, explicitVersions, "react-dom");
+      addPackageName(packageNames, explicitVersions, "@vitejs/plugin-react");
+    }
+    if (isTypescript) {
+      addPackageName(packageNames, explicitVersions, "@types/react");
+      addPackageName(packageNames, explicitVersions, "@types/react-dom");
+    }
+  }
+  if (isR3f) {
+    if (!isLibrary) {
+      addPackageName(packageNames, explicitVersions, "three");
+      addPackageName(packageNames, explicitVersions, "@react-three/fiber");
+    }
+    if (isTypescript) {
+      addPackageName(packageNames, explicitVersions, "@types/three");
+    }
+    if (isEnabledOption(options.drei)) {
+      addPackageName(packageNames, explicitVersions, "@react-three/drei");
+    }
+    if (isEnabledOption(options.handle)) {
+      addPackageName(packageNames, explicitVersions, "@react-three/handle");
+    }
+    if (isEnabledOption(options.koota)) {
+      addPackageName(packageNames, explicitVersions, "koota");
+    }
+    if (isEnabledOption(options.leva)) {
+      addPackageName(packageNames, explicitVersions, "leva");
+    }
+    if (isEnabledOption(options.rapier)) {
+      addPackageName(packageNames, explicitVersions, "@react-three/rapier");
+    }
+    if (isEnabledOption(options.uikit)) {
+      addPackageName(packageNames, explicitVersions, "@react-three/uikit");
+    }
+    if (isEnabledOption(options.zustand)) {
+      addPackageName(packageNames, explicitVersions, "zustand");
+    }
+    if (isEnabledOption(options.xr)) {
+      addPackageName(packageNames, explicitVersions, "@react-three/xr");
+      addPackageName(packageNames, explicitVersions, "@vitejs/plugin-basic-ssl");
+    }
+    if (!isEnabledOption(options.xr) && isEnabledOption(options.offscreen)) {
+      addPackageName(packageNames, explicitVersions, "@react-three/offscreen");
+    }
+    if (!isEnabledOption(options.xr) && isEnabledOption(options.postprocessing)) {
+      addPackageName(packageNames, explicitVersions, "@react-three/postprocessing");
+    }
+    if (isEnabledOption(options.viverse) && packageManager === "npm") {
+      addPackageName(packageNames, explicitVersions, "@viverse/cli");
+    }
+  }
+  if (testing === "vitest") {
+    addPackageName(packageNames, explicitVersions, "vitest");
+    if (isReact) {
+      addPackageName(packageNames, explicitVersions, "@testing-library/react");
+      addPackageName(packageNames, explicitVersions, "@testing-library/dom");
+      addPackageName(packageNames, explicitVersions, "jsdom");
+    }
+  }
+  if (linter === "eslint") {
+    addPackageName(packageNames, explicitVersions, "eslint");
+    if (isTypescript) {
+      addPackageName(packageNames, explicitVersions, "typescript-eslint");
+    }
+    if (isReact) {
+      addPackageName(packageNames, explicitVersions, "eslint-plugin-react-hooks");
+    }
+  } else if (linter === "oxlint") {
+    if (!inWorkspace) {
+      addPackageName(packageNames, explicitVersions, "oxlint");
+    }
+  } else if (linter === "biome") {
+    addPackageName(packageNames, explicitVersions, "@biomejs/biome");
+  }
+  if (formatter === "prettier") {
+    addPackageName(packageNames, explicitVersions, "prettier");
+  } else if (formatter === "oxfmt") {
+    if (!inWorkspace) {
+      addPackageName(packageNames, explicitVersions, "oxfmt");
+    }
+  } else if (formatter === "biome") {
+    addPackageName(packageNames, explicitVersions, "@biomejs/biome");
+  }
+  if (isLibrary) {
+    addPackageName(packageNames, explicitVersions, bundler === "unbuild" ? "unbuild" : "tsdown");
+  }
+  return [...packageNames];
+}
+function getLinterPackage(linter) {
+  if (linter === "biome") {
+    return "@biomejs/biome";
+  }
+  return linter;
+}
+function getFormatterPackage(formatter) {
+  if (formatter === "biome") {
+    return "@biomejs/biome";
+  }
+  return formatter;
+}
+function isEnabledOption(option) {
+  return option != null && option !== false;
+}
+
 function generateTypescriptConfig(baseTemplateOrParams) {
   const params = typeof baseTemplateOrParams === "string" ? { baseTemplate: baseTemplateOrParams } : baseTemplateOrParams;
-  const { baseTemplate, useConfigPackage, configStrategy = "stealth" } = params;
+  const {
+    baseTemplate,
+    useConfigPackage,
+    configStrategy = "stealth",
+    engine,
+    versions = {}
+  } = params;
   const isReact = baseTemplate === "react";
   const isR3f = baseTemplate === "r3f";
   const files = {};
   const devDependencies = {};
+  if (getEngineName(engine) === "node" && getEngineSpec(engine).version) {
+    const majorVersion = getEngineSpec(engine).version.split(".")[0];
+    devDependencies["@types/node"] = `^${majorVersion}.0.0`;
+  } else {
+    devDependencies["@types/node"] = "^22.0.0";
+  }
   if (isReact || isR3f) {
-    devDependencies["@types/react"] = "^19.0.0";
-    devDependencies["@types/react-dom"] = "^19.0.0";
+    assignResolvedPackageVersion(devDependencies, versions, "@types/react");
+    assignResolvedPackageVersion(devDependencies, versions, "@types/react-dom");
   }
   if (isR3f) {
-    devDependencies["@types/three"] = "~0.175.0";
+    assignResolvedPackageVersion(devDependencies, versions, "@types/three", "~");
   }
   if (useConfigPackage) {
     devDependencies["@config/typescript"] = "workspace:*";
@@ -257,7 +773,10 @@ function generateTypescriptConfig(baseTemplateOrParams) {
     const tsConfig = {
       $schema: "https://json.schemastore.org/tsconfig",
       files: [],
-      references: [{ path: "./.config/tsconfig.app.json" }, { path: "./.config/tsconfig.node.json" }]
+      references: [
+        { path: "./.config/tsconfig.app.json" },
+        { path: "./.config/tsconfig.node.json" }
+      ]
     };
     files["tsconfig.json"] = {
       type: "text",
@@ -363,6 +882,7 @@ function generateTypescriptConfig(baseTemplateOrParams) {
   return { files, devDependencies };
 }
 
+const DEFAULT_LIBRARY_VERSION = "0.1.0";
 function generatePackageJson(params) {
   const {
     name,
@@ -376,14 +896,15 @@ function generatePackageJson(params) {
     workspaceDependencies
   } = params;
   const files = {};
-  const packageManager = options.packageManager ?? "pnpm";
-  const isPnpm = packageManager === "pnpm";
+  const packageManager = getPackageManagerSpec(options.packageManager);
+  const isPnpm = packageManager.name === "pnpm";
   const packageJson = {
     name,
     description: "Built with \u{1F339} create-krispya",
     type: "module"
   };
   if (isLibrary) {
+    packageJson.version = DEFAULT_LIBRARY_VERSION;
     packageJson.main = "./dist/index.mjs";
     packageJson.module = "./dist/index.mjs";
     if (language === "typescript") {
@@ -405,10 +926,16 @@ function generatePackageJson(params) {
       allDependencies[pkgName] = "workspace:*";
     }
   }
+  const allDevDependencies = { ...devDependencies };
+  const engine = getEngineSpec(options.engine);
+  if (getEngineName(engine) === "node" && engine.version) {
+    const majorVersion = engine.version.split(".")[0];
+    allDevDependencies["@types/node"] ??= `^${majorVersion}.0.0`;
+  }
   packageJson.scripts = scripts;
   packageJson.dependencies = sortKeys(allDependencies);
-  if (Object.keys(devDependencies).length > 0) {
-    packageJson.devDependencies = sortKeys(devDependencies);
+  if (Object.keys(allDevDependencies).length > 0) {
+    packageJson.devDependencies = sortKeys(allDevDependencies);
   }
   if (isLibrary && Object.keys(peerDependencies).length > 0) {
     packageJson.peerDependencies = sortKeys(peerDependencies);
@@ -416,25 +943,14 @@ function generatePackageJson(params) {
   const isMonorepoPackage = options.workspaceRoot != null;
   if (!isMonorepoPackage) {
     const engines = {};
-    if (isPnpm) {
-      const pnpmVersion = options.pnpmVersion ?? "10.11.0";
-      const majorVersion = pnpmVersion.split(".")[0];
-      engines.pnpm = `>=${majorVersion}.0.0`;
-      packageJson.packageManager = `pnpm@${pnpmVersion}`;
-    } else if (packageManager === "yarn") {
-      const yarnVersion = options.yarnVersion ?? "4.6.0";
-      const majorVersion = yarnVersion.split(".")[0];
-      engines.yarn = `>=${majorVersion}.0.0`;
-      packageJson.packageManager = `yarn@${yarnVersion}`;
-    } else if (packageManager === "npm") {
-      const npmVersion = options.npmVersion ?? "11.0.0";
-      const majorVersion = npmVersion.split(".")[0];
-      engines.npm = `>=${majorVersion}.0.0`;
-      packageJson.packageManager = `npm@${npmVersion}`;
+    if (packageManager.version != null) {
+      const majorVersion = packageManager.version.split(".")[0];
+      engines[packageManager.name] = `>=${majorVersion}.0.0`;
+      packageJson.packageManager = formatPackageManager(packageManager);
     }
-    if (options.nodeVersion) {
-      const majorVersion = options.nodeVersion.split(".")[0];
-      engines.node = `>=${majorVersion}.0.0`;
+    if (engine.version != null) {
+      const majorVersion = engine.version.split(".")[0];
+      engines[engine.name] = `>=${majorVersion}.0.0`;
     }
     if (Object.keys(engines).length > 0) {
       packageJson.engines = engines;
@@ -752,6 +1268,22 @@ function generateTestFiles(params) {
   return files;
 }
 
+const COMMON_GITIGNORE_LINES = [
+  "node_modules",
+  "dist",
+  "*.tsbuildinfo",
+  ".env",
+  ".env.*",
+  "!.env.example"
+];
+function generateGitignore(variant) {
+  const lines = variant === "workspace-root" ? [...COMMON_GITIGNORE_LINES, ".DS_Store"] : COMMON_GITIGNORE_LINES;
+  return {
+    type: "text",
+    content: lines.join("\n")
+  };
+}
+
 function generateVscodeFiles$1(params) {
   const { codeSnippets, vscodeSettings } = params;
   const files = {};
@@ -774,7 +1306,7 @@ function generateVscodeFiles$1(params) {
     );
     files[".vscode/settings.json"] = {
       type: "text",
-      content: JSON.stringify(sortedSettings, null, "	")
+      content: JSON.stringify(sortedSettings, null, 2)
     };
   }
   return files;
@@ -1227,25 +1759,31 @@ function generateMonorepo(params) {
     linter,
     formatter,
     packageManager,
-    pnpmVersion,
     pnpmManageVersions,
-    nodeVersion,
+    engine,
+    versions = {},
     aiPlatforms
   } = params;
   const files = {};
-  const isPnpm = packageManager === "pnpm";
+  const isPnpm = packageManager.name === "pnpm";
   const devDependencies = {};
+  if (engine?.name === "node" && engine.version) {
+    const majorVersion = engine.version.split(".")[0];
+    devDependencies["@types/node"] = `^${majorVersion}.0.0`;
+  } else {
+    devDependencies["@types/node"] = "^22.0.0";
+  }
   if (linter === "oxlint") {
-    devDependencies["oxlint"] = "^1.36.0";
+    assignResolvedPackageVersion(devDependencies, versions, "oxlint");
   } else if (linter === "eslint") {
-    devDependencies["eslint"] = "^9.17.0";
+    assignResolvedPackageVersion(devDependencies, versions, "eslint");
   } else if (linter === "biome") {
-    devDependencies["@biomejs/biome"] = "^1.9.4";
+    assignResolvedPackageVersion(devDependencies, versions, "@biomejs/biome");
   }
   if (formatter === "oxfmt") {
-    devDependencies["oxfmt"] = "^0.21.0";
+    assignResolvedPackageVersion(devDependencies, versions, "oxfmt");
   } else if (formatter === "prettier") {
-    devDependencies["prettier"] = "^3.4.2";
+    assignResolvedPackageVersion(devDependencies, versions, "prettier");
   }
   const rootPackageJson = {
     name: "root",
@@ -1262,14 +1800,14 @@ function generateMonorepo(params) {
     devDependencies
   };
   const engines = {};
-  if (isPnpm && pnpmVersion) {
-    const majorVersion = pnpmVersion.split(".")[0];
+  if (isPnpm && packageManager.version) {
+    const majorVersion = packageManager.version.split(".")[0];
     engines.pnpm = `>=${majorVersion}.0.0`;
-    rootPackageJson.packageManager = `pnpm@${pnpmVersion}`;
+    rootPackageJson.packageManager = formatPackageManager(packageManager);
   }
-  if (nodeVersion) {
-    const majorVersion = nodeVersion.split(".")[0];
-    engines.node = `>=${majorVersion}.0.0`;
+  if (engine?.version) {
+    const majorVersion = engine.version.split(".")[0];
+    engines[engine.name] = `>=${majorVersion}.0.0`;
   }
   if (Object.keys(engines).length > 0) {
     rootPackageJson.engines = engines;
@@ -1283,13 +1821,7 @@ function generateMonorepo(params) {
     if (pnpmManageVersions) {
       workspaceLines.push("manage-package-manager-versions: true", "");
     }
-    workspaceLines.push(
-      "packages:",
-      '  - ".config/*"',
-      '  - "apps/*"',
-      '  - "packages/*"',
-      ""
-    );
+    workspaceLines.push("packages:", '  - ".config/*"', '  - "apps/*"', '  - "packages/*"', "");
     workspaceLines.push("onlyBuiltDependencies:", "  - esbuild");
     files["pnpm-workspace.yaml"] = {
       type: "text",
@@ -1334,8 +1866,9 @@ export default [...base];
 `
     };
   } else if (linter === "biome") {
+    const biomeVersion = getResolvedPackageVersion(versions, "@biomejs/biome");
     const biomeConfig = {
-      $schema: "https://biomejs.dev/schemas/1.9.4/schema.json",
+      $schema: `https://biomejs.dev/schemas/${biomeVersion}/schema.json`,
       vcs: {
         enabled: true,
         clientKind: "git",
@@ -1361,10 +1894,7 @@ export default [...base];
   } else if (formatter === "prettier") {
     generatePrettierConfigPackage(files);
   }
-  files[".gitignore"] = {
-    type: "text",
-    content: ["node_modules", "dist", "*.tsbuildinfo", ".DS_Store"].join("\n")
-  };
+  files[".gitignore"] = generateGitignore("workspace-root");
   files[".gitattributes"] = {
     type: "text",
     content: `* text=auto eol=lf
@@ -1387,12 +1917,12 @@ This monorepo workspace was generated with create-krispya.
 
 ## Development Commands
 
-- \`${packageManager} install\` to install all dependencies
-- \`${packageManager} run dev\` to run all applications in development mode
-- \`${packageManager} run build\` to build all packages and applications
-- \`${packageManager} run test\` to run tests across the workspace
-- \`${packageManager} run lint\` to lint all code
-- \`${packageManager} run format\` to format all code
+- \`${packageManager.name} install\` to install all dependencies
+- \`${packageManager.name} run dev\` to run all applications in development mode
+- \`${packageManager.name} run build\` to build all packages and applications
+- \`${packageManager.name} run test\` to run tests across the workspace
+- \`${packageManager.name} run lint\` to lint all code
+- \`${packageManager.name} run format\` to format all code
 
 ## Adding Packages
 
@@ -1402,7 +1932,7 @@ To add a new package to this workspace, run create-krispya from this directory a
   if (aiPlatforms && aiPlatforms.length > 0) {
     generateAiFiles(files, {
       name,
-      packageManager,
+      packageManager: packageManager.name,
       linter,
       formatter,
       isMonorepo: true,
@@ -1454,10 +1984,17 @@ function generateVscodeFiles(files, linter, formatter) {
     type: "text",
     content: JSON.stringify({ recommendations }, null, 2)
   };
-  files[".vscode/settings.json"] = {
-    type: "text",
-    content: JSON.stringify(settings, null, "	")
-  };
+  const codeSnippets = {};
+  if (recommendations.length > 0) {
+    codeSnippets["vscode-extension-suggestion"] = recommendations;
+  }
+  Object.assign(
+    files,
+    generateVscodeFiles$1({
+      codeSnippets,
+      vscodeSettings: settings
+    })
+  );
 }
 
 const monorepo = {
@@ -1478,8 +2015,8 @@ function generateBiome(generator, options) {
   if (options == null || !options.linter && !options.formatter) {
     return;
   }
-  const version = generator.versions.biome ?? "2.0.0";
-  generator.addDevDependency("@biomejs/biome", `^${version}`);
+  const version = generator.getVersion("@biomejs/biome");
+  generator.addDevDependency("@biomejs/biome");
   const { rules } = defaultLinterConfig;
   const biomeConfig = {
     $schema: `https://biomejs.dev/schemas/${version}/schema.json`
@@ -1535,10 +2072,7 @@ function generateBiome(generator, options) {
       generator.addScript("lint", "biome lint --config-path .config .");
     }
     if (options.formatter) {
-      generator.addScript(
-        "format",
-        "biome format --config-path .config --write ."
-      );
+      generator.addScript("format", "biome format --config-path .config --write .");
     }
     generator.addVscodeSetting("biome.linter.configPath", ".config/biome.json");
   } else {
@@ -1558,9 +2092,7 @@ function generateBiome(generator, options) {
   if (options.formatter) roles.push("formatter");
   generator.inject(
     "readme-tools",
-    `[Biome](https://biomejs.dev/) - Fast ${roles.join(
-      " and "
-    )} for JavaScript and TypeScript`
+    `[Biome](https://biomejs.dev/) - Fast ${roles.join(" and ")} for JavaScript and TypeScript`
   );
   generator.inject("vscode-extension-suggestion", "biomejs.biome");
   generator.addVscodeSetting("biome.enabled", true);
@@ -1573,7 +2105,7 @@ function generateDrei(generator, options) {
   if (options == null) {
     return;
   }
-  generator.addDependency("@react-three/drei", "^10.0.0");
+  generator.addDependency("@react-three/drei");
   generator.inject("import", `import { Environment } from "@react-three/drei"`);
   generator.inject("scene", '<Environment background preset="city" />');
   generator.inject(
@@ -1582,19 +2114,11 @@ function generateDrei(generator, options) {
   );
 }
 
-function getLanguageFromTemplate(template) {
-  return template.endsWith("-js") ? "javascript" : "typescript";
-}
-function getBaseTemplate(template) {
-  return template.replace("-js", "");
-}
-
 function toEslintLevel(level) {
   return level;
 }
 function generateEslint(generator, options) {
-  const version = generator.versions.eslint ?? "9.17.0";
-  generator.addDevDependency("eslint", `^${version}`);
+  generator.addDevDependency("eslint");
   const template = generator.options.template ?? "vanilla";
   const baseTemplate = getBaseTemplate(template);
   const isTypescript = getLanguageFromTemplate(template) === "typescript";
@@ -1603,12 +2127,12 @@ function generateEslint(generator, options) {
   const imports = ['import js from "@eslint/js"'];
   const configs = ["js.configs.recommended"];
   if (isTypescript) {
-    generator.addDevDependency("typescript-eslint", "^8.18.0");
+    generator.addDevDependency("typescript-eslint");
     imports.push('import tseslint from "typescript-eslint"');
     configs.push("...tseslint.configs.recommended");
   }
   if (isReact) {
-    generator.addDevDependency("eslint-plugin-react-hooks", "^5.1.0");
+    generator.addDevDependency("eslint-plugin-react-hooks");
     imports.push('import reactHooks from "eslint-plugin-react-hooks"');
   }
   const ignoresArray = JSON.stringify(defaultLinterConfig.ignorePatterns);
@@ -1710,7 +2234,7 @@ export function Box(props: ThreeElements['mesh']) {
 }
 
 function generateGithubPages(generator, options) {
-  if (options === false || (generator.options.packageManager ?? "npm") != "npm") {
+  if (options === false || getPackageManagerName(generator.options.packageManager) !== "npm") {
     return;
   }
   generator.addFile(".github/workflows/gh-pages.yml", {
@@ -1774,7 +2298,7 @@ function generateHandle(generator, options) {
   if (options == null) {
     return;
   }
-  generator.addDependency("@react-three/handle", "^6.6.16");
+  generator.addDependency("@react-three/handle");
   generator.inject(
     "readme-libraries",
     `[@react-three/handle](https://pmndrs.github.io/xr/docs/handles/introduction) - interactive controls and handles for your 3D objects`
@@ -1785,7 +2309,7 @@ function generateKoota(generator, options) {
   if (options == null) {
     return;
   }
-  generator.addDependency("koota", "^0.4.0");
+  generator.addDependency("koota");
   generator.inject(
     "readme-libraries",
     `[koota](https://github.com/pmndrs/koota) - ECS-based state management library optimized for real-time apps, games, and XR experiences`
@@ -1796,7 +2320,7 @@ function generateLeva(generator, options) {
   if (options == null) {
     return;
   }
-  generator.addDependency("leva", "^0.10.0");
+  generator.addDependency("leva");
   generator.inject(
     "readme-libraries",
     `[leva](https://github.com/pmndrs/leva) - HTML GUI panel for React with lightweight, beautiful and extensible controls`
@@ -1814,7 +2338,7 @@ function generateOffscreen(generator, options) {
     );
     return;
   }
-  generator.addDependency("@react-three/offscreen", "^0.0.8");
+  generator.addDependency("@react-three/offscreen");
   generator.inject(
     "readme-libraries",
     `[@react-three/offscreen](https://github.com/pmndrs/offscreen) - Offload your scene to a worker thread for better performance`
@@ -1824,13 +2348,12 @@ function generateOffscreen(generator, options) {
 function generateOxfmt(generator, options) {
   const isMonorepo = generator.options.workspaceRoot != null;
   if (isMonorepo) {
-    generator.addDevDependency("@config/oxfmt", "workspace:*");
+    generator.addDevDependency("@config/oxfmt", { version: "workspace:*" });
     const configPath = "node_modules/@config/oxfmt/base.json";
     generator.addScript("format", `oxfmt -c ${configPath} --write .`);
     generator.addVscodeSetting("oxc.fmt.configPath", configPath);
   } else {
-    const version = generator.versions.oxfmt ?? "0.1.0";
-    generator.addDevDependency("oxfmt", `^${version}`);
+    generator.addDevDependency("oxfmt");
     const isStealth = generator.isStealthConfig();
     if (isStealth) {
       generator.addFile(".config/oxfmt.json", {
@@ -1876,13 +2399,12 @@ function generateOxlint(generator, options) {
   const isReact = baseTemplate === "react" || baseTemplate === "r3f";
   const isMonorepo = generator.options.workspaceRoot != null;
   if (isMonorepo) {
-    generator.addDevDependency("@config/oxlint", "workspace:*");
+    generator.addDevDependency("@config/oxlint", { version: "workspace:*" });
     const configPath = isReact ? "node_modules/@config/oxlint/react.json" : "node_modules/@config/oxlint/base.json";
     generator.addScript("lint", `oxlint -c ${configPath}`);
     generator.addVscodeSetting("oxc.configPath", configPath);
   } else {
-    const version = generator.versions.oxlint ?? "0.16.0";
-    generator.addDevDependency("oxlint", `^${version}`);
+    generator.addDevDependency("oxlint");
     const isStealth = generator.isStealthConfig();
     const { rules } = defaultLinterConfig;
     const plugins = ["unicorn", "typescript", "oxc"];
@@ -1943,7 +2465,7 @@ function generatePostprocessing(generator, options) {
     );
     return;
   }
-  generator.addDependency("@react-three/postprocessing", "^3.0.4");
+  generator.addDependency("@react-three/postprocessing");
   generator.inject(
     "readme-libraries",
     `[@react-three/postprocessing](https://react-postprocessing.docs.pmnd.rs/) - Post-processing effects for @react-three/fiber`
@@ -1951,18 +2473,14 @@ function generatePostprocessing(generator, options) {
 }
 
 function generatePrettier(generator, options) {
-  const version = generator.versions.prettier ?? "3.4.2";
-  generator.addDevDependency("prettier", `^${version}`);
+  generator.addDevDependency("prettier");
   const isStealth = generator.isStealthConfig();
   if (isStealth) {
     generator.addFile(".config/prettier.json", {
       type: "text",
       content: JSON.stringify(defaultPrettierConfig, null, 2)
     });
-    generator.addScript(
-      "format",
-      "prettier --config .config/prettier.json --write ."
-    );
+    generator.addScript("format", "prettier --config .config/prettier.json --write .");
     generator.addVscodeSetting("prettier.configPath", ".config/prettier.json");
   } else {
     generator.addFile(".prettierrc", {
@@ -1971,22 +2489,16 @@ function generatePrettier(generator, options) {
     });
     generator.addScript("format", "prettier --write .");
   }
-  generator.inject(
-    "readme-tools",
-    "[Prettier](https://prettier.io/) - Opinionated code formatter"
-  );
+  generator.inject("readme-tools", "[Prettier](https://prettier.io/) - Opinionated code formatter");
   generator.inject("vscode-extension-suggestion", "esbenp.prettier-vscode");
-  generator.addVscodeSetting(
-    "editor.defaultFormatter",
-    "esbenp.prettier-vscode"
-  );
+  generator.addVscodeSetting("editor.defaultFormatter", "esbenp.prettier-vscode");
 }
 
 function generateRapier(generator, options) {
   if (options == null) {
     return;
   }
-  generator.addDependency("@react-three/rapier", "^2.1.0");
+  generator.addDependency("@react-three/rapier");
   generator.inject(
     "readme-libraries",
     `[@react-three/rapier](https://github.com/pmndrs/react-three-rapier) - Physics based on Rapier for your @react-three/fiber scene`
@@ -2085,8 +2597,12 @@ function generateProvidersModule(generator) {
     const wrappedComponents = resolvedProviders.filter(
       (provider) => provider.type === "wrapped-jsx"
     );
-    const inlineComponents = resolvedProviders.filter((provider) => provider.type === "inline-jsx");
-    const layoutEffects = resolvedProviders.filter((provider) => provider.type === "layout-effect");
+    const inlineComponents = resolvedProviders.filter(
+      (provider) => provider.type === "inline-jsx"
+    );
+    const layoutEffects = resolvedProviders.filter(
+      (provider) => provider.type === "layout-effect"
+    );
     const declaredProps = providerProps.map((prop) => `${prop.declaredPropName} = ${prop.declaredPropDefaultValue}`).join(", ");
     const declaredTypes = providerProps.map((prop) => `${prop.declaredPropName}?: ${prop.declaredPropType}`).join("; ");
     const reactImports = ["type ReactNode"];
@@ -2161,7 +2677,7 @@ function generateTriplex(generator, options) {
 }
 
 function generateTsdown(generator) {
-  generator.addDevDependency("tsdown", "^0.12.0");
+  generator.addDevDependency("tsdown");
   const template = generator.options.template ?? "vanilla";
   const baseTemplate = getBaseTemplate(template);
   const language = getLanguageFromTemplate(template);
@@ -2197,7 +2713,7 @@ function generateUikit(generator, options) {
   if (options == null) {
     return;
   }
-  generator.addDependency("@react-three/uikit", "^0.8.15");
+  generator.addDependency("@react-three/uikit");
   generator.inject(
     "readme-libraries",
     `[@react-three/uikit](https://pmndrs.github.io/uikit/docs/) - UI primitives for React Three Fiber`
@@ -2205,7 +2721,7 @@ function generateUikit(generator, options) {
 }
 
 function generateUnbuild(generator) {
-  generator.addDevDependency("unbuild", "^3.5.0");
+  generator.addDevDependency("unbuild");
   const template = generator.options.template ?? "vanilla";
   const baseTemplate = getBaseTemplate(template);
   const language = getLanguageFromTemplate(template);
@@ -2250,15 +2766,14 @@ function generateUnbuild(generator) {
 }
 
 function generateVitest(generator) {
-  const version = generator.versions.vitest ?? "4.0.0";
-  generator.addDevDependency("vitest", `^${version}`);
+  generator.addDevDependency("vitest");
   const template = generator.options.template ?? "vanilla";
   const baseTemplate = getBaseTemplate(template);
   const isReact = baseTemplate === "react" || baseTemplate === "r3f";
   if (isReact) {
-    generator.addDevDependency("@testing-library/react", "^16.2.0");
-    generator.addDevDependency("@testing-library/dom", "^10.4.0");
-    generator.addDevDependency("jsdom", "^26.0.0");
+    generator.addDevDependency("@testing-library/react");
+    generator.addDevDependency("@testing-library/dom");
+    generator.addDevDependency("jsdom");
   }
   if (isReact) {
     generator.configureVite({ test: { environment: "jsdom" } });
@@ -2271,7 +2786,7 @@ function generateVitest(generator) {
 }
 
 function generateViverse(generator, options) {
-  if (options == null || (generator.options.packageManager ?? "npm") != "npm") {
+  if (options == null || getPackageManagerName(generator.options.packageManager) !== "npm") {
     return;
   }
   generator.addFile(".github/workflows/viverse.yml", {
@@ -2329,7 +2844,7 @@ jobs:
 
 `
   });
-  generator.addDependency("@viverse/cli", "^0.9.5-beta.8");
+  generator.addDependency("@viverse/cli");
   generator.inject(
     "readme-start",
     `A GitHub CI/CD workflow for publishing to Viverse is configured.
@@ -2356,8 +2871,8 @@ function generateXr(generator, options) {
   if (options === true) {
     options = {};
   }
-  generator.addDependency("@react-three/xr", "^6.6.16");
-  generator.addDependency("@vitejs/plugin-basic-ssl", "^2.0.0");
+  generator.addDependency("@react-three/xr");
+  generator.addDependency("@vitejs/plugin-basic-ssl");
   generator.inject("import", "import { XR, createXRStore } from '@react-three/xr'");
   generator.inject(
     `global-start`,
@@ -2414,7 +2929,7 @@ function generateZustand(generator, options) {
   if (options == null) {
     return;
   }
-  generator.addDependency("zustand", "^5.0.3");
+  generator.addDependency("zustand");
   generator.inject(
     "readme-libraries",
     `[zustand](https://zustand.docs.pmnd.rs/) - small, fast and scalable state-management solution`
@@ -2452,255 +2967,6 @@ function merge(target, modification) {
   return modification;
 }
 
-async function getLatestNpmVersion(packageName, fallback) {
-  try {
-    const response = await fetch(
-      `https://registry.npmjs.org/${packageName}/latest`
-    );
-    const data = await response.json();
-    return data.version;
-  } catch {
-    return fallback;
-  }
-}
-async function getLatestPnpmVersion() {
-  return getLatestNpmVersion("pnpm", "10.11.0");
-}
-async function getLatestYarnVersion() {
-  return getLatestNpmVersion("yarn", "4.6.0");
-}
-async function getLatestNpmCliVersion() {
-  return getLatestNpmVersion("npm", "11.0.0");
-}
-async function getLatestNodeVersion() {
-  try {
-    const response = await fetch("https://nodejs.org/dist/index.json");
-    const data = await response.json();
-    const ltsVersion = data.find((v) => v.lts);
-    if (ltsVersion) {
-      return ltsVersion.version.replace(/^v/, "");
-    }
-    return "22.0.0";
-  } catch {
-    return "22.0.0";
-  }
-}
-function validateNameSegment(segment, label) {
-  if (!segment.length) {
-    return `${label} is required`;
-  }
-  if (!/^[a-z0-9-]+$/.test(segment)) {
-    return `${label} must be lowercase and contain only letters, numbers, and hyphens`;
-  }
-  if (segment.startsWith("-") || segment.endsWith("-")) {
-    return `${label} cannot start or end with a hyphen`;
-  }
-  if (segment.includes("--")) {
-    return `${label} cannot contain consecutive hyphens`;
-  }
-  return void 0;
-}
-function validatePackageName(name) {
-  if (!name.length) {
-    return "Package name is required";
-  }
-  if (name.includes("..") || name.includes("\\")) {
-    return "Package name cannot contain path traversal sequences";
-  }
-  if (name.startsWith("@")) {
-    const slashIndex = name.indexOf("/");
-    if (slashIndex === -1) {
-      return "Scoped package name must include a package name after the scope (e.g., @scope/name)";
-    }
-    if (name.indexOf("/", slashIndex + 1) !== -1) {
-      return "Package name can only have one slash for scoped packages";
-    }
-    const scope = name.slice(1, slashIndex);
-    const packageName = name.slice(slashIndex + 1);
-    const scopeError = validateNameSegment(scope, "Scope");
-    if (scopeError) return scopeError;
-    const nameError = validateNameSegment(packageName, "Package name");
-    if (nameError) return nameError;
-    return void 0;
-  }
-  if (name.includes("/")) {
-    return "Unscoped package name cannot contain slashes. Use @scope/name format for scoped packages";
-  }
-  return validateNameSegment(name, "Package name");
-}
-function parseWorkspaceYamlContent(content) {
-  const directories = [];
-  let inPackagesSection = false;
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed === "packages:") {
-      inPackagesSection = true;
-      continue;
-    }
-    if (inPackagesSection && trimmed && !line.startsWith(" ") && !line.startsWith("	") && !trimmed.startsWith("-")) {
-      break;
-    }
-    if (inPackagesSection && trimmed.startsWith("-")) {
-      const entry = trimmed.slice(1).trim().replace(/^["']|["']$/g, "").replace(/^\.\//, "").replace(/\/\*.*$/, "");
-      if (entry && !entry.startsWith(".")) {
-        directories.push(entry);
-      }
-    }
-  }
-  return directories;
-}
-async function pathExists(path) {
-  try {
-    await promises.access(path, fs.constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function detectLinterFromScript(script) {
-  if (!script) return void 0;
-  if (script.includes("oxlint")) return "oxlint";
-  if (script.includes("eslint")) return "eslint";
-  if (script.includes("biome check") || script.includes("biome lint")) return "biome";
-  return void 0;
-}
-function detectFormatterFromScript(script) {
-  if (!script) return void 0;
-  if (script.includes("prettier")) return "prettier";
-  if (script.includes("oxfmt")) return "oxfmt";
-  if (script.includes("biome format")) return "biome";
-  return void 0;
-}
-async function detectLinterFromConfig(root) {
-  if (await pathExists(path.join(root, ".config/oxlint"))) return "oxlint";
-  if (await pathExists(path.join(root, ".config/eslint"))) return "eslint";
-  if (await pathExists(path.join(root, "biome.json"))) {
-    try {
-      const content = await promises.readFile(path.join(root, "biome.json"), "utf-8");
-      const config = JSON.parse(content);
-      if (config.linter?.enabled !== false) return "biome";
-    } catch {
-      return "biome";
-    }
-  }
-  return void 0;
-}
-async function detectFormatterFromConfig(root) {
-  if (await pathExists(path.join(root, ".config/prettier"))) return "prettier";
-  if (await pathExists(path.join(root, ".config/oxfmt"))) return "oxfmt";
-  if (await pathExists(path.join(root, "biome.json"))) {
-    try {
-      const content = await promises.readFile(path.join(root, "biome.json"), "utf-8");
-      const config = JSON.parse(content);
-      if (config.formatter?.enabled !== false) return "biome";
-    } catch {
-      return "biome";
-    }
-  }
-  return void 0;
-}
-function detectLinterFromDeps(devDeps) {
-  if (!devDeps) return void 0;
-  if (devDeps["@biomejs/biome"]) return "biome";
-  if (devDeps.eslint) return "eslint";
-  if (devDeps.oxlint) return "oxlint";
-  return void 0;
-}
-function detectFormatterFromDeps(devDeps) {
-  if (!devDeps) return void 0;
-  if (devDeps["@biomejs/biome"]) return "biome";
-  if (devDeps.prettier) return "prettier";
-  if (devDeps.oxfmt) return "oxfmt";
-  return void 0;
-}
-async function detectTooling(root) {
-  try {
-    const pkgPath = path.join(root, "package.json");
-    const content = await promises.readFile(pkgPath, "utf-8");
-    const pkg = JSON.parse(content);
-    const linter = detectLinterFromScript(pkg.scripts?.lint) ?? await detectLinterFromConfig(root) ?? detectLinterFromDeps(pkg.devDependencies);
-    const formatter = detectFormatterFromScript(pkg.scripts?.format) ?? await detectFormatterFromConfig(root) ?? detectFormatterFromDeps(pkg.devDependencies);
-    return { linter, formatter };
-  } catch {
-    return { linter: void 0, formatter: void 0 };
-  }
-}
-function generateRandomName() {
-  const adjectives = [
-    "red",
-    "blue",
-    "green",
-    "yellow",
-    "purple",
-    "orange",
-    "pink",
-    "black",
-    "white",
-    "tiny",
-    "big",
-    "small",
-    "large",
-    "huge",
-    "giant",
-    "mini",
-    "mega",
-    "super",
-    "happy",
-    "sad",
-    "angry",
-    "calm",
-    "quiet",
-    "loud",
-    "silent",
-    "noisy",
-    "shiny",
-    "dull",
-    "bright",
-    "dark",
-    "fuzzy",
-    "smooth",
-    "rough",
-    "soft"
-  ];
-  const nouns = [
-    "apple",
-    "banana",
-    "cherry",
-    "date",
-    "elderberry",
-    "fig",
-    "grape",
-    "honeydew",
-    "cat",
-    "dog",
-    "elephant",
-    "fox",
-    "giraffe",
-    "horse",
-    "iguana",
-    "jaguar",
-    "mountain",
-    "river",
-    "ocean",
-    "desert",
-    "forest",
-    "jungle",
-    "meadow",
-    "valley",
-    "star",
-    "moon",
-    "sun",
-    "planet",
-    "comet",
-    "asteroid",
-    "galaxy",
-    "universe"
-  ];
-  const randomAdjective = adjectives[Math.floor(Math.random() * adjectives.length)];
-  const randomNoun = nouns[Math.floor(Math.random() * nouns.length)];
-  return `${randomAdjective}-${randomNoun}`;
-}
-
 function generate(options) {
   const clonedOptions = structuredClone(options);
   const template = clonedOptions.template ?? "vanilla";
@@ -2722,16 +2988,16 @@ function generate(options) {
   const devDependencies = {};
   const peerDependencies = {};
   if (!isLibrary) {
-    devDependencies.vite = versions.vite ? `^${versions.vite}` : "^6.3.4";
+    assignResolvedPackageVersion(devDependencies, versions, "vite");
   }
   if (isReact || isR3f) {
     if (isLibrary) {
       peerDependencies["react"] = "^18.0.0 || ^19.0.0";
       peerDependencies["react-dom"] = "^18.0.0 || ^19.0.0";
     } else {
-      dependencies["react"] = "^19.0.0";
-      dependencies["react-dom"] = "^19.0.0";
-      devDependencies["@vitejs/plugin-react"] = "^4.4.1";
+      assignResolvedPackageVersion(dependencies, versions, "react");
+      assignResolvedPackageVersion(dependencies, versions, "react-dom");
+      assignResolvedPackageVersion(devDependencies, versions, "@vitejs/plugin-react");
     }
   }
   if (isR3f) {
@@ -2739,15 +3005,17 @@ function generate(options) {
       peerDependencies["three"] = ">=0.150.0";
       peerDependencies["@react-three/fiber"] = "^8.0.0 || ^9.0.0";
     } else {
-      dependencies["three"] = "~0.175.0";
-      dependencies["@react-three/fiber"] = "^9.0.0";
+      assignResolvedPackageVersion(dependencies, versions, "three", "~");
+      assignResolvedPackageVersion(dependencies, versions, "@react-three/fiber");
     }
   }
   if (language === "typescript") {
     const tsResult = generateTypescriptConfig({
       baseTemplate,
       useConfigPackage: clonedOptions.workspaceRoot != null,
-      configStrategy: clonedOptions.configStrategy
+      configStrategy: clonedOptions.configStrategy,
+      engine: clonedOptions.engine,
+      versions
     });
     Object.assign(files, tsResult.files);
     Object.assign(devDependencies, tsResult.devDependencies);
@@ -2759,9 +3027,7 @@ function generate(options) {
     build: "vite build"
   };
   if (!isLibrary && (isReact || isR3f)) {
-    codeSnippets["vite-config-import"] = [
-      "import react from '@vitejs/plugin-react'"
-    ];
+    codeSnippets["vite-config-import"] = ["import react from '@vitejs/plugin-react'"];
   }
   if (!isLibrary && isR3f) {
     codeSnippets["import"] = [`import { Canvas } from "@react-three/fiber"`];
@@ -2781,16 +3047,29 @@ function generate(options) {
   const generator = {
     options: clonedOptions,
     versions,
+    getVersion(name2) {
+      return getResolvedPackageVersion(versions, name2);
+    },
     isStealthConfig() {
       return (clonedOptions.configStrategy ?? "stealth") === "stealth";
     },
-    addDependency(name2, semver) {
-      dependencies[name2];
-      dependencies[name2] = semver;
+    addDependency(name2, options2) {
+      if (dependencies[name2] != null) {
+        return;
+      }
+      dependencies[name2] = resolveDependencySemver(name2, versions, options2);
+    },
+    addDevDependency(name2, options2) {
+      if (devDependencies[name2] != null) {
+        return;
+      }
+      devDependencies[name2] = resolveDependencySemver(name2, versions, options2);
     },
-    addDevDependency(name2, semver) {
-      devDependencies[name2];
-      devDependencies[name2] = semver;
+    addPeerDependency(name2, semver) {
+      if (peerDependencies[name2] != null) {
+        return;
+      }
+      peerDependencies[name2] = semver;
     },
     addFile(path, content) {
       files[path] = content;
@@ -2839,11 +3118,8 @@ function generate(options) {
     } else if (libraryBundler === "tsdown") {
       generateTsdown(generator);
     }
-    const packageManager2 = clonedOptions.packageManager ?? "pnpm";
-    generator.addScript(
-      "release",
-      `${packageManager2} run build && ${packageManager2} publish`
-    );
+    const packageManager2 = getPackageManagerName(clonedOptions.packageManager);
+    generator.addScript("release", `${packageManager2} run build && ${packageManager2} publish`);
   }
   const testing = clonedOptions.testing ?? (isLibrary ? "vitest" : "none");
   if (testing === "vitest") {
@@ -2882,7 +3158,7 @@ function generate(options) {
   if (!isLibrary) {
     files["vite.config.ts"] = generateViteConfig({ viteConfig, codeSnippets });
   }
-  const packageManager = options.packageManager ?? "pnpm";
+  const packageManager = getPackageManagerName(options.packageManager);
   files["README.md"] = generateReadme({
     name,
     baseTemplate,
@@ -2930,16 +3206,13 @@ function generate(options) {
     Object.assign(files, generateVscodeFiles$1({ codeSnippets, vscodeSettings }));
   }
   if (!isMonorepoPackage) {
-    files[".gitignore"] = {
-      type: "text",
-      content: ["node_modules", "dist", "*.tsbuildinfo"].join("\n")
-    };
+    files[".gitignore"] = generateGitignore("standalone");
     files[".gitattributes"] = { type: "text", content: GitAttributes };
   }
   if (!isMonorepoPackage && clonedOptions.aiPlatforms?.length) {
     generateAiFiles(files, {
       name,
-      packageManager: clonedOptions.packageManager ?? "pnpm",
+      packageManager: getPackageManagerName(clonedOptions.packageManager),
       linter: clonedOptions.linter ?? "oxlint",
       formatter: clonedOptions.formatter ?? "prettier",
       isMonorepo: false,
@@ -2949,14 +3222,22 @@ function generate(options) {
   }
   return files;
 }
+function resolveDependencySemver(name, versions, options = {}) {
+  if (options.version != null) {
+    return options.version;
+  }
+  return formatResolvedPackageVersion(versions, name, options.prefix);
+}
 
 exports.AI_PLATFORM_HINTS = AI_PLATFORM_HINTS;
 exports.AI_PLATFORM_LABELS = AI_PLATFORM_LABELS;
 exports.ALL_AI_PLATFORMS = ALL_AI_PLATFORMS;
 exports.detectTooling = detectTooling;
+exports.formatResolvedPackageVersion = formatResolvedPackageVersion;
 exports.generate = generate;
 exports.generateAiFiles = generateAiFiles;
 exports.generateEslintConfigPackage = generateEslintConfigPackage;
+exports.generateGitignore = generateGitignore;
 exports.generateMonorepo = generateMonorepo;
 exports.generateOxfmtConfigPackage = generateOxfmtConfigPackage;
 exports.generateOxlintConfigPackage = generateOxlintConfigPackage;
@@ -2965,12 +3246,21 @@ exports.generateRandomName = generateRandomName;
 exports.generateTypescriptConfigPackage = generateTypescriptConfigPackage;
 exports.generateVscodeFiles = generateVscodeFiles;
 exports.getBaseTemplate = getBaseTemplate;
+exports.getEngineName = getEngineName;
 exports.getLanguageFromTemplate = getLanguageFromTemplate;
 exports.getLatestNodeVersion = getLatestNodeVersion;
 exports.getLatestNpmCliVersion = getLatestNpmCliVersion;
 exports.getLatestNpmVersion = getLatestNpmVersion;
 exports.getLatestPnpmVersion = getLatestPnpmVersion;
 exports.getLatestYarnVersion = getLatestYarnVersion;
+exports.getPackageManagerName = getPackageManagerName;
+exports.getResolvedPackageVersion = getResolvedPackageVersion;
 exports.monorepo = monorepo;
+exports.parseEngine = parseEngine;
+exports.parsePackageManager = parsePackageManager;
 exports.parseWorkspaceYamlContent = parseWorkspaceYamlContent;
+exports.resolveEngine = resolveEngine;
+exports.resolveMonorepoRootPackageVersions = resolveMonorepoRootPackageVersions;
+exports.resolvePackageManager = resolvePackageManager;
+exports.resolveProjectPackageVersions = resolveProjectPackageVersions;
 exports.validatePackageName = validatePackageName;