@rs-x/cli 2.0.0-next.2 → 2.0.0-next.20

package/bin/rsx.cjs

@@ -5,8 +5,40 @@ const path = require('node:path');
 const readline = require('node:readline/promises');
 const { spawnSync } = require('node:child_process');
 
-const CLI_VERSION = '0.2.0';
+const CLI_VERSION = (() => {
+  try {
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.version ?? '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+})();
 const VS_CODE_EXTENSION_ID = 'rs-x.rs-x-vscode-extension';
+const ANGULAR_DEMO_TEMPLATE_DIR = path.join(
+  __dirname,
+  '..',
+  'templates',
+  'angular-demo',
+);
+const REACT_DEMO_TEMPLATE_DIR = path.join(
+  __dirname,
+  '..',
+  'templates',
+  'react-demo',
+);
+const VUE_DEMO_TEMPLATE_DIR = path.join(
+  __dirname,
+  '..',
+  'templates',
+  'vue-demo',
+);
+const NEXT_DEMO_TEMPLATE_DIR = path.join(
+  __dirname,
+  '..',
+  'templates',
+  'next-demo',
+);
 const RUNTIME_PACKAGES = [
   '@rs-x/core',
   '@rs-x/state-manager',
@@ -119,7 +151,7 @@ function parseArgs(argv) {
 }
 
 function run(command, args, options = {}) {
-  const { dryRun, cwd = process.cwd() } = options;
+  const { dryRun, cwd = process.cwd(), env } = options;
   const printable = [command, ...args].join(' ');
 
   if (dryRun) {
@@ -129,6 +161,7 @@ function run(command, args, options = {}) {
 
   const result = spawnSync(command, args, {
     cwd,
+    env: env ? { ...process.env, ...env } : process.env,
     stdio: 'inherit',
   });
 
@@ -191,11 +224,33 @@ function applyTagToPackages(packages, tag) {
 }
 
 function resolveInstallTag(flags) {
-  return parseBooleanFlag(flags.next, false) ? 'next' : undefined;
+  if (parseBooleanFlag(flags.next, false)) {
+    return 'next';
+  }
+
+  if (CLI_VERSION.includes('-')) {
+    return 'next';
+  }
+
+  const checkoutRoot = findRepoRoot(__dirname);
+  if (!checkoutRoot) {
+    return undefined;
+  }
+
+  const branchResult = spawnSync('git', ['branch', '--show-current'], {
+    cwd: checkoutRoot,
+    encoding: 'utf8',
+  });
+  const branch = branchResult.status === 0 ? branchResult.stdout.trim() : '';
+  if (branch && branch !== 'main') {
+    return 'next';
+  }
+
+  return undefined;
 }
 
 function installPackages(pm, packages, options = {}) {
-  const { dev = false, dryRun = false, label = 'packages', tag } = options;
+  const { dev = false, dryRun = false, label = 'packages', tag, cwd } = options;
   const resolvedPackages = tag ? applyTagToPackages(packages, tag) : packages;
   const argsByPm = {
     pnpm: dev
@@ -220,24 +275,74 @@ function installPackages(pm, packages, options = {}) {
 
   const tagInfo = tag ? ` (tag: ${tag})` : '';
   logInfo(`Installing ${label} with ${pm}${tagInfo}...`);
-  run(pm, installArgs, { dryRun });
+  run(pm, installArgs, { dryRun, cwd });
   logOk(`Installed ${label}.`);
 }
 
-function installRuntimePackages(pm, dryRun, tag) {
-  installPackages(pm, RUNTIME_PACKAGES, {
+function resolveLocalRsxSpecs(projectRoot, flags, options = {}) {
+  const tarballsDir =
+    typeof flags?.['tarballs-dir'] === 'string'
+      ? path.resolve(projectRoot, flags['tarballs-dir'])
+      : typeof process.env.RSX_TARBALLS_DIR === 'string' &&
+          process.env.RSX_TARBALLS_DIR.trim().length > 0
+        ? path.resolve(projectRoot, process.env.RSX_TARBALLS_DIR)
+        : null;
+  const workspaceRoot = findRepoRoot(projectRoot);
+  return resolveProjectRsxSpecs(
+    projectRoot,
+    workspaceRoot,
+    tarballsDir,
+    options,
+  );
+}
+
+function installResolvedPackages(pm, packageNames, options = {}) {
+  const {
+    dryRun = false,
+    label = 'packages',
+    tag,
+    cwd,
+    specs,
+    dev = false,
+  } = options;
+  const resolvedPackages = packageNames.map((packageName) => {
+    const spec = specs?.[packageName];
+    return spec ? `${packageName}@${spec}` : packageName;
+  });
+
+  installPackages(pm, resolvedPackages, {
+    dev,
+    dryRun,
+    label,
+    tag: specs ? undefined : tag,
+    cwd,
+  });
+}
+
+function installRuntimePackages(pm, dryRun, tag, projectRoot, flags) {
+  const specs = resolveLocalRsxSpecs(projectRoot ?? process.cwd(), flags, {
+    tag,
+  });
+  installResolvedPackages(pm, RUNTIME_PACKAGES, {
     dev: false,
     dryRun,
     tag,
+    specs,
+    cwd: projectRoot,
     label: 'runtime RS-X packages',
   });
 }
 
-function installCompilerPackages(pm, dryRun, tag) {
-  installPackages(pm, COMPILER_PACKAGES, {
+function installCompilerPackages(pm, dryRun, tag, projectRoot, flags) {
+  const specs = resolveLocalRsxSpecs(projectRoot ?? process.cwd(), flags, {
+    tag,
+  });
+  installResolvedPackages(pm, COMPILER_PACKAGES, {
     dev: true,
     dryRun,
     tag,
+    specs,
+    cwd: projectRoot,
     label: 'compiler tooling',
   });
 }
@@ -262,14 +367,50 @@ function installVsCodeExtension(flags) {
     return;
   }
 
-  const args = ['--install-extension', VS_CODE_EXTENSION_ID];
+  installBundledVsix(dryRun, force);
+}
+
+function resolveBundledVsix() {
+  const packageRoot = path.resolve(__dirname, '..');
+  const candidates = fs
+    .readdirSync(packageRoot)
+    .filter((name) => /^rs-x-vscode-extension-.*\.vsix$/u.test(name))
+    .map((name) => path.join(packageRoot, name));
+
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  const latest = candidates
+    .map((fullPath) => ({
+      fullPath,
+      mtimeMs: fs.statSync(fullPath).mtimeMs,
+    }))
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)[0];
+
+  return latest?.fullPath ?? null;
+}
+
+function installBundledVsix(dryRun, force) {
+  const bundledVsix = resolveBundledVsix();
+  if (!bundledVsix) {
+    logWarn(
+      'No bundled VSIX found in @rs-x/cli. Skipping VS Code extension install.',
+    );
+    logInfo(
+      'If you are developing in the rs-x repo, use `rsx install vscode --local` instead.',
+    );
+    return;
+  }
+
+  const args = ['--install-extension', bundledVsix];
   if (force) {
     args.push('--force');
   }
 
-  logInfo(`Installing ${VS_CODE_EXTENSION_ID} from VS Code marketplace...`);
+  logInfo(`Installing bundled VSIX from ${bundledVsix}...`);
   run('code', args, { dryRun });
-  logOk('VS Code extension installed.');
+  logOk('VS Code extension installed from bundled VSIX.');
 }
 
 function installLocalVsix(dryRun, force) {
@@ -585,6 +726,210 @@ function writeFileWithDryRun(filePath, content, dryRun) {
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
+function stripJsonComments(content) {
+  let result = '';
+  let inString = false;
+  let stringDelimiter = '"';
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = 0; index < content.length; index += 1) {
+    const current = content[index];
+    const next = content[index + 1];
+
+    if (inLineComment) {
+      if (current === '\n') {
+        inLineComment = false;
+        result += current;
+      }
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (current === '*' && next === '/') {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (inString) {
+      result += current;
+      if (current === '\\') {
+        index += 1;
+        if (index < content.length) {
+          result += content[index];
+        }
+        continue;
+      }
+      if (current === stringDelimiter) {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (current === '"' || current === "'") {
+      inString = true;
+      stringDelimiter = current;
+      result += current;
+      continue;
+    }
+
+    if (current === '/' && next === '/') {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+
+    if (current === '/' && next === '*') {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+
+    result += current;
+  }
+
+  return result;
+}
+
+function parseJsonc(content) {
+  return JSON.parse(stripJsonComments(content.replace(/^\uFEFF/u, '')));
+}
+
+function copyPathWithDryRun(sourcePath, targetPath, dryRun) {
+  if (dryRun) {
+    logInfo(`[dry-run] copy ${sourcePath} -> ${targetPath}`);
+    return;
+  }
+
+  const stat = fs.statSync(sourcePath);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(targetPath, { recursive: true });
+    for (const entry of fs.readdirSync(sourcePath, { withFileTypes: true })) {
+      copyPathWithDryRun(
+        path.join(sourcePath, entry.name),
+        path.join(targetPath, entry.name),
+        false,
+      );
+    }
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function removeFileOrDirectoryWithDryRun(targetPath, dryRun) {
+  if (!fs.existsSync(targetPath)) {
+    return;
+  }
+
+  if (dryRun) {
+    logInfo(`[dry-run] remove ${targetPath}`);
+    return;
+  }
+
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function resolveAngularProjectTsConfig(projectRoot) {
+  const appTsConfigPath = path.join(projectRoot, 'tsconfig.app.json');
+  if (fs.existsSync(appTsConfigPath)) {
+    return appTsConfigPath;
+  }
+
+  return path.join(projectRoot, 'tsconfig.json');
+}
+
+function upsertTypescriptPluginInTsConfig(configPath, dryRun) {
+  if (!fs.existsSync(configPath)) {
+    logWarn(`TypeScript config not found: ${configPath}`);
+    return;
+  }
+
+  const tsConfig = parseJsonc(fs.readFileSync(configPath, 'utf8'));
+  const compilerOptions = tsConfig.compilerOptions ?? {};
+  const plugins = Array.isArray(compilerOptions.plugins)
+    ? compilerOptions.plugins
+    : [];
+
+  if (
+    !plugins.some(
+      (plugin) =>
+        plugin &&
+        typeof plugin === 'object' &&
+        plugin.name === '@rs-x/typescript-plugin',
+    )
+  ) {
+    plugins.push({ name: '@rs-x/typescript-plugin' });
+  }
+
+  compilerOptions.plugins = plugins;
+  tsConfig.compilerOptions = compilerOptions;
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${configPath}`);
+    return;
+  }
+
+  fs.writeFileSync(
+    configPath,
+    `${JSON.stringify(tsConfig, null, 2)}\n`,
+    'utf8',
+  );
+}
+
+function ensureTsConfigIncludePattern(configPath, pattern, dryRun) {
+  if (!fs.existsSync(configPath)) {
+    return;
+  }
+
+  const tsConfig = parseJsonc(fs.readFileSync(configPath, 'utf8'));
+  const include = Array.isArray(tsConfig.include) ? tsConfig.include : [];
+  if (!include.includes(pattern)) {
+    include.push(pattern);
+  }
+  tsConfig.include = include;
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${configPath}`);
+    return;
+  }
+
+  fs.writeFileSync(
+    configPath,
+    `${JSON.stringify(tsConfig, null, 2)}\n`,
+    'utf8',
+  );
+}
+
+function ensureVueEnvTypes(projectRoot, dryRun) {
+  const envTypesPath = path.join(projectRoot, 'src', 'vite-env.d.ts');
+  const envTypesSource = `/// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue';
+
+  const component: DefineComponent<{}, {}, any>;
+  export default component;
+}
+`;
+
+  if (fs.existsSync(envTypesPath)) {
+    return;
+  }
+
+  if (dryRun) {
+    logInfo(`[dry-run] create ${envTypesPath}`);
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(envTypesPath), { recursive: true });
+  fs.writeFileSync(envTypesPath, envTypesSource, 'utf8');
+  logOk(`Created ${envTypesPath}`);
+}
+
 function toFileDependencySpec(fromDir, targetPath) {
   const relative = path.relative(fromDir, targetPath).replace(/\\/gu, '/');
   const normalized = relative.startsWith('.') ? relative : `./${relative}`;
@@ -634,6 +979,8 @@ function resolveProjectRsxSpecs(
   options = {},
 ) {
   const includeAngularPackage = Boolean(options.includeAngularPackage);
+  const includeReactPackage = Boolean(options.includeReactPackage);
+  const includeVuePackage = Boolean(options.includeVuePackage);
   const versionSpec = options.tag ? options.tag : RSX_PACKAGE_VERSION;
   const defaults = {
     '@rs-x/core': versionSpec,
@@ -642,7 +989,9 @@ function resolveProjectRsxSpecs(
     '@rs-x/compiler': versionSpec,
     '@rs-x/typescript-plugin': versionSpec,
     ...(includeAngularPackage ? { '@rs-x/angular': versionSpec } : {}),
-    '@rs-x/cli': null,
+    ...(includeReactPackage ? { '@rs-x/react': versionSpec } : {}),
+    ...(includeVuePackage ? { '@rs-x/vue': versionSpec } : {}),
+    '@rs-x/cli': versionSpec,
   };
 
   const tarballSlugs = {
@@ -652,6 +1001,8 @@ function resolveProjectRsxSpecs(
     '@rs-x/compiler': 'rs-x-compiler',
     '@rs-x/typescript-plugin': 'rs-x-typescript-plugin',
     ...(includeAngularPackage ? { '@rs-x/angular': 'rs-x-angular' } : {}),
+    ...(includeReactPackage ? { '@rs-x/react': 'rs-x-react' } : {}),
+    ...(includeVuePackage ? { '@rs-x/vue': 'rs-x-vue' } : {}),
     '@rs-x/cli': 'rs-x-cli',
   };
 
@@ -674,6 +1025,16 @@ function resolveProjectRsxSpecs(
             'rs-x-angular': path.join(tarballsDir, 'rs-x-angular'),
           }
         : {}),
+      ...(includeReactPackage
+        ? {
+            'rs-x-react': path.join(tarballsDir, 'rs-x-react'),
+          }
+        : {}),
+      ...(includeVuePackage
+        ? {
+            'rs-x-vue': path.join(tarballsDir, 'rs-x-vue'),
+          }
+        : {}),
       'rs-x-cli': path.join(tarballsDir, 'rs-x-cli'),
     };
 
@@ -711,10 +1072,21 @@ function resolveProjectRsxSpecs(
     ),
     ...(includeAngularPackage
       ? {
-          '@rs-x/angular': path.join(
-            workspaceRoot,
-            'rs-x-angular/projects/rsx',
-          ),
+          '@rs-x/angular': fs.existsSync(
+            path.join(workspaceRoot, 'rs-x-angular/dist/rsx'),
+          )
+            ? path.join(workspaceRoot, 'rs-x-angular/dist/rsx')
+            : path.join(workspaceRoot, 'rs-x-angular/projects/rsx'),
+        }
+      : {}),
+    ...(includeReactPackage
+      ? {
+          '@rs-x/react': path.join(workspaceRoot, 'rs-x-react'),
+        }
+      : {}),
+    ...(includeVuePackage
+      ? {
+          '@rs-x/vue': path.join(workspaceRoot, 'rs-x-vue'),
         }
       : {}),
     '@rs-x/cli': path.join(workspaceRoot, 'rs-x-cli'),
@@ -777,6 +1149,22 @@ function createProjectPackageJson(projectName, rsxSpecs) {
   );
 }
 
+function resolveProjectRoot(projectName, flags) {
+  const parentDir =
+    typeof flags?.['project-parent-dir'] === 'string'
+      ? flags['project-parent-dir']
+      : typeof process.env.RSX_PROJECT_PARENT_DIR === 'string' &&
+          process.env.RSX_PROJECT_PARENT_DIR.trim().length > 0
+        ? process.env.RSX_PROJECT_PARENT_DIR
+        : null;
+
+  if (parentDir) {
+    return path.resolve(parentDir, projectName);
+  }
+
+  return path.resolve(process.cwd(), projectName);
+}
+
 function createProjectTsConfig() {
   return (
     JSON.stringify(
@@ -961,7 +1349,7 @@ async function runProject(flags) {
     }
   }
 
-  const projectRoot = path.resolve(process.cwd(), projectName);
+  const projectRoot = resolveProjectRoot(projectName, flags);
   const tarballsDir =
     typeof flags['tarballs-dir'] === 'string'
       ? path.resolve(process.cwd(), flags['tarballs-dir'])
@@ -1115,9 +1503,24 @@ async function resolveProjectName(nameFromFlags, fallbackName) {
   }
 }
 
-function scaffoldProjectTemplate(template, projectName, pm, flags) {
+function scaffoldProjectTemplate(
+  template,
+  projectName,
+  projectRoot,
+  pm,
+  flags,
+) {
   const dryRun = Boolean(flags['dry-run']);
   const skipInstall = Boolean(flags['skip-install']);
+  const scaffoldCwd = path.dirname(projectRoot);
+  const scaffoldProjectArg = `./${projectName}`;
+  const scaffoldEnv = {
+    INIT_CWD: scaffoldCwd,
+    npm_config_local_prefix: scaffoldCwd,
+    npm_prefix: scaffoldCwd,
+    PWD: scaffoldCwd,
+    CI: 'true',
+  };
 
   if (template === 'angular') {
     const args = [
@@ -1125,6 +1528,8 @@ function scaffoldProjectTemplate(template, projectName, pm, flags) {
       '@angular/cli@latest',
       'new',
       projectName,
+      '--directory',
+      scaffoldProjectArg,
       '--defaults',
       '--standalone',
       '--routing',
@@ -1135,21 +1540,45 @@ function scaffoldProjectTemplate(template, projectName, pm, flags) {
     if (skipInstall) {
       args.push('--skip-install');
     }
-    run('npx', args, { dryRun });
+    run('npx', args, { dryRun, cwd: scaffoldCwd, env: scaffoldEnv });
     return;
   }
 
   if (template === 'react') {
-    run('npx', ['create-vite@latest', projectName, '--template', 'react-ts'], {
-      dryRun,
-    });
+    run(
+      'npx',
+      [
+        'create-vite@latest',
+        scaffoldProjectArg,
+        '--no-interactive',
+        '--template',
+        'react-ts',
+      ],
+      {
+        dryRun,
+        cwd: scaffoldCwd,
+        env: scaffoldEnv,
+      },
+    );
     return;
   }
 
   if (template === 'vuejs') {
-    run('npx', ['create-vite@latest', projectName, '--template', 'vue-ts'], {
-      dryRun,
-    });
+    run(
+      'npx',
+      [
+        'create-vite@latest',
+        scaffoldProjectArg,
+        '--no-interactive',
+        '--template',
+        'vue-ts',
+      ],
+      {
+        dryRun,
+        cwd: scaffoldCwd,
+        env: scaffoldEnv,
+      },
+    );
     return;
   }
 
@@ -1162,7 +1591,7 @@ function scaffoldProjectTemplate(template, projectName, pm, flags) {
     };
     const args = [
       'create-next-app@latest',
-      projectName,
+      scaffoldProjectArg,
       '--yes',
       '--ts',
       '--app',
@@ -1174,7 +1603,7 @@ function scaffoldProjectTemplate(template, projectName, pm, flags) {
     if (skipInstall) {
       args.push('--skip-install');
     }
-    run('npx', args, { dryRun });
+    run('npx', args, { dryRun, cwd: scaffoldCwd, env: scaffoldEnv });
     return;
   }
 
@@ -1182,57 +1611,589 @@ function scaffoldProjectTemplate(template, projectName, pm, flags) {
   process.exit(1);
 }
 
-async function runProjectWithTemplate(template, flags) {
-  const normalizedTemplate = normalizeProjectTemplate(template);
-  if (!normalizedTemplate) {
-    logError(
-      `Unsupported template '${template}'. Choose one of: ${PROJECT_TEMPLATES.join(', ')}`,
+function applyAngularDemoStarter(projectRoot, projectName, pm, flags) {
+  const dryRun = Boolean(flags['dry-run']);
+  const tag = resolveInstallTag(flags);
+  const tarballsDir =
+    typeof flags['tarballs-dir'] === 'string'
+      ? path.resolve(process.cwd(), flags['tarballs-dir'])
+      : typeof process.env.RSX_TARBALLS_DIR === 'string' &&
+          process.env.RSX_TARBALLS_DIR.trim().length > 0
+        ? path.resolve(process.cwd(), process.env.RSX_TARBALLS_DIR)
+        : null;
+  const workspaceRoot = findRepoRoot(projectRoot);
+  const rsxSpecs = resolveProjectRsxSpecs(
+    projectRoot,
+    workspaceRoot,
+    tarballsDir,
+    { tag, includeAngularPackage: true },
+  );
+
+  const templateFiles = ['README.md', 'src'];
+  for (const entry of templateFiles) {
+    copyPathWithDryRun(
+      path.join(ANGULAR_DEMO_TEMPLATE_DIR, entry),
+      path.join(projectRoot, entry),
+      dryRun,
     );
-    process.exit(1);
   }
 
-  if (normalizedTemplate === 'nodejs') {
-    await runProject(flags);
-    return;
+  const staleAngularFiles = [
+    path.join(projectRoot, 'src/app/app.ts'),
+    path.join(projectRoot, 'src/app/app.spec.ts'),
+    path.join(projectRoot, 'src/app/app.html'),
+    path.join(projectRoot, 'src/app/app.css'),
+    path.join(projectRoot, 'src/app/app.routes.ts'),
+    path.join(projectRoot, 'src/app/app.config.ts'),
+  ];
+  for (const stalePath of staleAngularFiles) {
+    removeFileOrDirectoryWithDryRun(stalePath, dryRun);
   }
 
-  const pm = detectPackageManager(flags.pm);
-  const projectName = await resolveProjectName(flags.name, flags._nameHint);
-  const projectRoot = path.resolve(process.cwd(), projectName);
-  if (fs.existsSync(projectRoot) && fs.readdirSync(projectRoot).length > 0) {
-    logError(`Target directory is not empty: ${projectRoot}`);
+  const readmePath = path.join(projectRoot, 'README.md');
+  if (fs.existsSync(readmePath)) {
+    const readmeSource = fs.readFileSync(readmePath, 'utf8');
+    const nextReadme = readmeSource.replace(
+      /^#\s+rsx-angular-example/mu,
+      `# ${projectName}`,
+    );
+    if (dryRun) {
+      logInfo(`[dry-run] patch ${readmePath}`);
+    } else {
+      fs.writeFileSync(readmePath, nextReadme, 'utf8');
+    }
+  }
+
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    logError(
+      `package.json not found in generated Angular app: ${packageJsonPath}`,
+    );
     process.exit(1);
   }
 
-  scaffoldProjectTemplate(normalizedTemplate, projectName, pm, flags);
-  const dryRun = Boolean(flags['dry-run']);
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const angularTsConfigPath = resolveAngularProjectTsConfig(projectRoot);
+  const angularTsConfigRelative = path
+    .relative(projectRoot, angularTsConfigPath)
+    .replace(/\\/gu, '/');
+  packageJson.name = projectName;
+  packageJson.private = true;
+  packageJson.version = '0.1.0';
+  packageJson.scripts = {
+    'build:rsx': `rsx build --project ${angularTsConfigRelative} --no-emit --prod`,
+    'typecheck:rsx': `rsx typecheck --project ${angularTsConfigRelative}`,
+    prebuild: 'npm run build:rsx',
+    start: 'npm run build:rsx && ng serve',
+    build: 'ng build',
+  };
+  packageJson.rsx = {
+    build: {
+      preparse: true,
+      preparseFile: 'src/rsx-generated/rsx-aot-preparsed.generated.ts',
+      compiled: true,
+      compiledFile: 'src/rsx-generated/rsx-aot-compiled.generated.ts',
+      registrationFile: 'src/rsx-generated/rsx-aot-registration.generated.ts',
+      compiledResolvedEvaluator: false,
+    },
+  };
+  packageJson.dependencies = {
+    ...(packageJson.dependencies ?? {}),
+    '@rs-x/angular': rsxSpecs['@rs-x/angular'],
+    '@rs-x/core': rsxSpecs['@rs-x/core'],
+    '@rs-x/state-manager': rsxSpecs['@rs-x/state-manager'],
+    '@rs-x/expression-parser': rsxSpecs['@rs-x/expression-parser'],
+  };
+  packageJson.devDependencies = {
+    ...(packageJson.devDependencies ?? {}),
+    '@rs-x/cli': rsxSpecs['@rs-x/cli'],
+    '@rs-x/compiler': rsxSpecs['@rs-x/compiler'],
+    '@rs-x/typescript-plugin': rsxSpecs['@rs-x/typescript-plugin'],
+  };
+
   if (dryRun) {
-    logInfo(`[dry-run] setup RS-X in ${projectRoot}`);
-    return;
+    logInfo(`[dry-run] patch ${packageJsonPath}`);
+  } else {
+    fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}\n`,
+      'utf8',
+    );
   }
 
-  withWorkingDirectory(projectRoot, () => {
+  const angularJsonPath = path.join(projectRoot, 'angular.json');
+  if (!fs.existsSync(angularJsonPath)) {
+    logError(
+      `angular.json not found in generated Angular app: ${angularJsonPath}`,
+    );
+    process.exit(1);
+  }
+
+  const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf8'));
+  const projects = angularJson.projects ?? {};
+  const [angularProjectName] = Object.keys(projects);
+  if (!angularProjectName) {
+    logError('Generated angular.json does not define any projects.');
+    process.exit(1);
+  }
+
+  const angularProject = projects[angularProjectName];
+  const architect = angularProject.architect ?? angularProject.targets;
+  const build = architect?.build;
+  if (!build) {
+    logError('Generated Angular project is missing a build target.');
+    process.exit(1);
+  }
+
+  const buildOptions = build.options ?? {};
+  const styles = Array.isArray(buildOptions.styles) ? buildOptions.styles : [];
+  if (!styles.includes('src/styles.css')) {
+    styles.push('src/styles.css');
+  }
+  buildOptions.styles = styles;
+  buildOptions.preserveSymlinks = true;
+
+  const registrationFile =
+    'src/rsx-generated/rsx-aot-registration.generated.ts';
+  let polyfills = buildOptions.polyfills;
+  if (typeof polyfills === 'string') {
+    polyfills = [polyfills];
+  } else if (!Array.isArray(polyfills)) {
+    polyfills = [];
+  }
+  if (!polyfills.includes(registrationFile)) {
+    polyfills.push(registrationFile);
+  }
+  buildOptions.polyfills = polyfills;
+  build.options = buildOptions;
+
+  if (build.configurations?.production?.budgets) {
+    delete build.configurations.production.budgets;
+  }
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${angularJsonPath}`);
+  } else {
+    fs.writeFileSync(
+      angularJsonPath,
+      `${JSON.stringify(angularJson, null, 2)}\n`,
+      'utf8',
+    );
+  }
+
+  if (!Boolean(flags['skip-install'])) {
+    logInfo(`Refreshing ${pm} dependencies for the RS-X Angular starter...`);
+    run(pm, ['install'], { dryRun });
+    logOk('Angular starter dependencies are up to date.');
+  }
+}
+
+function applyReactDemoStarter(projectRoot, projectName, pm, flags) {
+  const dryRun = Boolean(flags['dry-run']);
+  const tag = resolveInstallTag(flags);
+  const tarballsDir =
+    typeof flags['tarballs-dir'] === 'string'
+      ? path.resolve(process.cwd(), flags['tarballs-dir'])
+      : typeof process.env.RSX_TARBALLS_DIR === 'string' &&
+          process.env.RSX_TARBALLS_DIR.trim().length > 0
+        ? path.resolve(process.cwd(), process.env.RSX_TARBALLS_DIR)
+        : null;
+  const workspaceRoot = findRepoRoot(projectRoot);
+  const rsxSpecs = resolveProjectRsxSpecs(
+    projectRoot,
+    workspaceRoot,
+    tarballsDir,
+    { tag, includeReactPackage: true },
+  );
+
+  const templateFiles = [
+    'README.md',
+    'index.html',
+    'src',
+    'tsconfig.json',
+    'vite.config.ts',
+  ];
+  for (const entry of templateFiles) {
+    copyPathWithDryRun(
+      path.join(REACT_DEMO_TEMPLATE_DIR, entry),
+      path.join(projectRoot, entry),
+      dryRun,
+    );
+  }
+
+  const staleReactFiles = [
+    path.join(projectRoot, 'src/App.tsx'),
+    path.join(projectRoot, 'src/App.css'),
+    path.join(projectRoot, 'src/index.css'),
+    path.join(projectRoot, 'src/vite-env.d.ts'),
+    path.join(projectRoot, 'src/assets'),
+    path.join(projectRoot, 'public'),
+    path.join(projectRoot, 'eslint.config.js'),
+    path.join(projectRoot, 'eslint.config.ts'),
+    path.join(projectRoot, 'tsconfig.app.json'),
+    path.join(projectRoot, 'tsconfig.node.json'),
+  ];
+  for (const stalePath of staleReactFiles) {
+    removeFileOrDirectoryWithDryRun(stalePath, dryRun);
+  }
+
+  const readmePath = path.join(projectRoot, 'README.md');
+  if (fs.existsSync(readmePath)) {
+    const readmeSource = fs.readFileSync(readmePath, 'utf8');
+    const nextReadme = readmeSource.replace(
+      /^#\s+rsx-react-example/mu,
+      `# ${projectName}`,
+    );
+    if (dryRun) {
+      logInfo(`[dry-run] patch ${readmePath}`);
+    } else {
+      fs.writeFileSync(readmePath, nextReadme, 'utf8');
+    }
+  }
+
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    logError(
+      `package.json not found in generated React app: ${packageJsonPath}`,
+    );
+    process.exit(1);
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  packageJson.name = projectName;
+  packageJson.private = true;
+  packageJson.version = '0.1.0';
+  packageJson.type = 'module';
+  packageJson.scripts = {
+    'build:rsx': 'rsx build --project tsconfig.json --no-emit --prod',
+    dev: 'npm run build:rsx && vite',
+    build: 'npm run build:rsx && vite build',
+    preview: 'vite preview',
+  };
+  packageJson.rsx = {
+    build: {
+      preparse: true,
+      preparseFile: 'src/rsx-generated/rsx-aot-preparsed.generated.ts',
+      compiled: true,
+      compiledFile: 'src/rsx-generated/rsx-aot-compiled.generated.ts',
+      compiledResolvedEvaluator: false,
+    },
+  };
+  packageJson.dependencies = {
+    react: packageJson.dependencies?.react ?? '^19.2.4',
+    'react-dom': packageJson.dependencies?.['react-dom'] ?? '^19.2.4',
+    '@rs-x/core': rsxSpecs['@rs-x/core'],
+    '@rs-x/state-manager': rsxSpecs['@rs-x/state-manager'],
+    '@rs-x/expression-parser': rsxSpecs['@rs-x/expression-parser'],
+    '@rs-x/react': rsxSpecs['@rs-x/react'],
+  };
+  packageJson.devDependencies = {
+    typescript: packageJson.devDependencies?.typescript ?? '^5.9.3',
+    vite: packageJson.devDependencies?.vite ?? '^7.3.1',
+    '@vitejs/plugin-react':
+      packageJson.devDependencies?.['@vitejs/plugin-react'] ?? '^5.1.4',
+    '@types/react': packageJson.devDependencies?.['@types/react'] ?? '^19.2.2',
+    '@types/react-dom':
+      packageJson.devDependencies?.['@types/react-dom'] ?? '^19.2.2',
+    '@rs-x/cli': rsxSpecs['@rs-x/cli'],
+    '@rs-x/compiler': rsxSpecs['@rs-x/compiler'],
+    '@rs-x/typescript-plugin': rsxSpecs['@rs-x/typescript-plugin'],
+  };
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${packageJsonPath}`);
+  } else {
+    fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}\n`,
+      'utf8',
+    );
+  }
+
+  const tsConfigPath = path.join(projectRoot, 'tsconfig.json');
+  if (fs.existsSync(tsConfigPath)) {
+    upsertTypescriptPluginInTsConfig(tsConfigPath, dryRun);
+  }
+
+  if (!Boolean(flags['skip-install'])) {
+    logInfo(`Refreshing ${pm} dependencies for the RS-X React starter...`);
+    run(pm, ['install'], { dryRun });
+    logOk('React starter dependencies are up to date.');
+  }
+}
+
+function applyVueDemoStarter(projectRoot, projectName, pm, flags) {
+  const dryRun = Boolean(flags['dry-run']);
+  const tag = resolveInstallTag(flags);
+  const tarballsDir =
+    typeof flags['tarballs-dir'] === 'string'
+      ? path.resolve(process.cwd(), flags['tarballs-dir'])
+      : typeof process.env.RSX_TARBALLS_DIR === 'string' &&
+          process.env.RSX_TARBALLS_DIR.trim().length > 0
+        ? path.resolve(process.cwd(), process.env.RSX_TARBALLS_DIR)
+        : null;
+  const workspaceRoot = findRepoRoot(projectRoot);
+  const rsxSpecs = resolveProjectRsxSpecs(
+    projectRoot,
+    workspaceRoot,
+    tarballsDir,
+    { tag, includeVuePackage: true },
+  );
+
+  const templateFiles = ['README.md', 'src'];
+  for (const entry of templateFiles) {
+    copyPathWithDryRun(
+      path.join(VUE_DEMO_TEMPLATE_DIR, entry),
+      path.join(projectRoot, entry),
+      dryRun,
+    );
+  }
+
+  const staleVueFiles = [
+    path.join(projectRoot, 'public'),
+    path.join(projectRoot, 'src/components/HelloWorld.vue'),
+    path.join(projectRoot, 'src/assets'),
+  ];
+  for (const stalePath of staleVueFiles) {
+    removeFileOrDirectoryWithDryRun(stalePath, dryRun);
+  }
+
+  const readmePath = path.join(projectRoot, 'README.md');
+  if (fs.existsSync(readmePath)) {
+    const readmeSource = fs.readFileSync(readmePath, 'utf8');
+    const nextReadme = readmeSource.replace(
+      /^#\s+rsx-vue-example/mu,
+      `# ${projectName}`,
+    );
+    if (dryRun) {
+      logInfo(`[dry-run] patch ${readmePath}`);
+    } else {
+      fs.writeFileSync(readmePath, nextReadme, 'utf8');
+    }
+  }
+
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    logError(`package.json not found in generated Vue app: ${packageJsonPath}`);
+    process.exit(1);
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  packageJson.name = projectName;
+  packageJson.private = true;
+  packageJson.version = '0.1.0';
+  packageJson.type = 'module';
+  packageJson.scripts = {
+    'build:rsx': 'rsx build --project tsconfig.app.json --no-emit --prod',
+    'typecheck:rsx': 'rsx typecheck --project tsconfig.app.json',
+    dev: 'npm run build:rsx && vite',
+    build: 'npm run build:rsx && vue-tsc -b && vite build',
+    preview: 'vite preview',
+  };
+  packageJson.rsx = {
+    build: {
+      preparse: true,
+      preparseFile: 'src/rsx-generated/rsx-aot-preparsed.generated.ts',
+      compiled: true,
+      compiledFile: 'src/rsx-generated/rsx-aot-compiled.generated.ts',
+      compiledResolvedEvaluator: false,
+    },
+  };
+  packageJson.dependencies = {
+    vue: packageJson.dependencies?.vue ?? '^3.5.30',
+    '@rs-x/core': rsxSpecs['@rs-x/core'],
+    '@rs-x/state-manager': rsxSpecs['@rs-x/state-manager'],
+    '@rs-x/expression-parser': rsxSpecs['@rs-x/expression-parser'],
+    '@rs-x/vue': rsxSpecs['@rs-x/vue'],
+  };
+  packageJson.devDependencies = {
+    ...(packageJson.devDependencies ?? {}),
+    '@rs-x/cli': rsxSpecs['@rs-x/cli'],
+    '@rs-x/compiler': rsxSpecs['@rs-x/compiler'],
+    '@rs-x/typescript-plugin': rsxSpecs['@rs-x/typescript-plugin'],
+  };
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${packageJsonPath}`);
+  } else {
+    fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}\n`,
+      'utf8',
+    );
+  }
+
+  const tsConfigAppPath = path.join(projectRoot, 'tsconfig.app.json');
+  if (fs.existsSync(tsConfigAppPath)) {
+    upsertTypescriptPluginInTsConfig(tsConfigAppPath, dryRun);
+    ensureTsConfigIncludePattern(tsConfigAppPath, 'src/**/*.d.ts', dryRun);
+  }
+
+  if (!Boolean(flags['skip-install'])) {
+    logInfo(`Refreshing ${pm} dependencies for the RS-X Vue starter...`);
+    run(pm, ['install'], { dryRun });
+    logOk('Vue starter dependencies are up to date.');
+  }
+}
+
+function applyNextDemoStarter(projectRoot, projectName, pm, flags) {
+  const dryRun = Boolean(flags['dry-run']);
+  const tag = resolveInstallTag(flags);
+  const tarballsDir =
+    typeof flags['tarballs-dir'] === 'string'
+      ? path.resolve(process.cwd(), flags['tarballs-dir'])
+      : typeof process.env.RSX_TARBALLS_DIR === 'string' &&
+          process.env.RSX_TARBALLS_DIR.trim().length > 0
+        ? path.resolve(process.cwd(), process.env.RSX_TARBALLS_DIR)
+        : null;
+  const workspaceRoot = findRepoRoot(projectRoot);
+  const rsxSpecs = resolveProjectRsxSpecs(
+    projectRoot,
+    workspaceRoot,
+    tarballsDir,
+    { tag, includeReactPackage: true },
+  );
+
+  const templateFiles = ['README.md', 'app', 'components', 'hooks', 'lib'];
+  for (const entry of templateFiles) {
+    copyPathWithDryRun(
+      path.join(NEXT_DEMO_TEMPLATE_DIR, entry),
+      path.join(projectRoot, entry),
+      dryRun,
+    );
+  }
+
+  const readmePath = path.join(projectRoot, 'README.md');
+  if (fs.existsSync(readmePath)) {
+    const readmeSource = fs.readFileSync(readmePath, 'utf8');
+    const nextReadme = readmeSource.replace(
+      /^#\s+rsx-next-example/mu,
+      `# ${projectName}`,
+    );
+    if (dryRun) {
+      logInfo(`[dry-run] patch ${readmePath}`);
+    } else {
+      fs.writeFileSync(readmePath, nextReadme, 'utf8');
+    }
+  }
+
+  const publicDir = path.join(projectRoot, 'public');
+  removeFileOrDirectoryWithDryRun(publicDir, dryRun);
+
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    logError(
+      `package.json not found in generated Next.js app: ${packageJsonPath}`,
+    );
+    process.exit(1);
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  packageJson.name = projectName;
+  packageJson.private = true;
+  packageJson.version = '0.1.0';
+  packageJson.scripts = {
+    ...packageJson.scripts,
+    'build:rsx': 'rsx build --project tsconfig.json --no-emit --prod',
+    dev: 'npm run build:rsx && next dev',
+    build: 'npm run build:rsx && next build',
+    start: 'next start',
+  };
+  packageJson.rsx = {
+    build: {
+      preparse: true,
+      preparseFile: 'app/rsx-generated/rsx-aot-preparsed.generated.ts',
+      compiled: true,
+      compiledFile: 'app/rsx-generated/rsx-aot-compiled.generated.ts',
+      compiledResolvedEvaluator: false,
+    },
+  };
+  packageJson.dependencies = {
+    ...(packageJson.dependencies ?? {}),
+    '@rs-x/core': rsxSpecs['@rs-x/core'],
+    '@rs-x/state-manager': rsxSpecs['@rs-x/state-manager'],
+    '@rs-x/expression-parser': rsxSpecs['@rs-x/expression-parser'],
+    '@rs-x/react': rsxSpecs['@rs-x/react'],
+  };
+  packageJson.devDependencies = {
+    ...(packageJson.devDependencies ?? {}),
+    '@rs-x/cli': rsxSpecs['@rs-x/cli'],
+    '@rs-x/compiler': rsxSpecs['@rs-x/compiler'],
+    '@rs-x/typescript-plugin': rsxSpecs['@rs-x/typescript-plugin'],
+  };
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${packageJsonPath}`);
+  } else {
+    fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}\n`,
+      'utf8',
+    );
+  }
+
+  const tsConfigPath = path.join(projectRoot, 'tsconfig.json');
+  if (fs.existsSync(tsConfigPath)) {
+    upsertTypescriptPluginInTsConfig(tsConfigPath, dryRun);
+  }
+
+  if (!Boolean(flags['skip-install'])) {
+    logInfo(`Refreshing ${pm} dependencies for the RS-X Next.js starter...`);
+    run(pm, ['install'], { dryRun });
+    logOk('Next.js starter dependencies are up to date.');
+  }
+}
+
+async function runProjectWithTemplate(template, flags) {
+  const normalizedTemplate = normalizeProjectTemplate(template);
+  if (!normalizedTemplate) {
+    logError(
+      `Unsupported template '${template}'. Choose one of: ${PROJECT_TEMPLATES.join(', ')}`,
+    );
+    process.exit(1);
+  }
+
+  if (normalizedTemplate === 'nodejs') {
+    await runProject(flags);
+    return;
+  }
+
+  const pm = detectPackageManager(flags.pm);
+  const projectName = await resolveProjectName(flags.name, flags._nameHint);
+  const projectRoot = resolveProjectRoot(projectName, flags);
+  if (fs.existsSync(projectRoot) && fs.readdirSync(projectRoot).length > 0) {
+    logError(`Target directory is not empty: ${projectRoot}`);
+    process.exit(1);
+  }
+
+  scaffoldProjectTemplate(
+    normalizedTemplate,
+    projectName,
+    projectRoot,
+    pm,
+    flags,
+  );
+  const dryRun = Boolean(flags['dry-run']);
+  if (dryRun) {
+    logInfo(`[dry-run] setup RS-X in ${projectRoot}`);
+    return;
+  }
+
+  withWorkingDirectory(projectRoot, () => {
     if (normalizedTemplate === 'angular') {
-      runSetupAngular(flags);
+      applyAngularDemoStarter(projectRoot, projectName, pm, flags);
       return;
     }
     if (normalizedTemplate === 'react') {
-      runSetupReact({
-        ...flags,
-        entry: flags.entry ?? 'src/main.tsx',
-      });
+      applyReactDemoStarter(projectRoot, projectName, pm, flags);
       return;
     }
     if (normalizedTemplate === 'nextjs') {
-      runSetupNext(flags);
+      applyNextDemoStarter(projectRoot, projectName, pm, flags);
       return;
     }
     if (normalizedTemplate === 'vuejs') {
-      runSetupVue({
-        ...flags,
-        entry: flags.entry ?? 'src/main.ts',
-      });
-      applyVueRsxTemplate(projectRoot, dryRun);
+      applyVueDemoStarter(projectRoot, projectName, pm, flags);
     }
   });
 
@@ -1507,12 +2468,12 @@ function ensureNextGateFile(gateFile, bootstrapFile, dryRun) {
   const content = useTypeScript
     ? `'use client';
 
-import { type ReactNode, useEffect, useState } from 'react';
+import { type ReactElement, type ReactNode, useEffect, useState } from 'react';
 
 import { initRsx } from '${importPath}';
 
 // Generated by rsx init
-export function RsxBootstrapGate(props: { children: ReactNode }): JSX.Element | null {
+export function RsxBootstrapGate(props: { children: ReactNode }): ReactElement | null {
   const [ready, setReady] = useState(false);
 
   useEffect(() => {
@@ -1733,8 +2694,8 @@ function runInit(flags) {
   const projectRoot = process.cwd();
 
   if (!skipInstall) {
-    installRuntimePackages(pm, dryRun, tag);
-    installCompilerPackages(pm, dryRun, tag);
+    installRuntimePackages(pm, dryRun, tag, projectRoot, flags);
+    installCompilerPackages(pm, dryRun, tag, projectRoot, flags);
   } else {
     logInfo('Skipping package installation (--skip-install).');
   }
@@ -1788,11 +2749,117 @@ function runInit(flags) {
     }
   }
 
-  if (!skipVscode) {
-    installVsCodeExtension(flags);
+  logOk('RS-X init completed.');
+}
+
+function upsertRsxBuildConfigInPackageJson(projectRoot, dryRun) {
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
   }
 
-  logOk('RS-X init completed.');
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const currentRsx = packageJson.rsx ?? {};
+  const currentBuild = currentRsx.build ?? {};
+  const nextBuild = {
+    preparse: true,
+    preparseFile: 'src/rsx-generated/rsx-aot-preparsed.generated.ts',
+    compiled: true,
+    compiledFile: 'src/rsx-generated/rsx-aot-compiled.generated.ts',
+    registrationFile: 'src/rsx-generated/rsx-aot-registration.generated.ts',
+    compiledResolvedEvaluator: false,
+    ...currentBuild,
+  };
+
+  const nextPackageJson = {
+    ...packageJson,
+    rsx: {
+      ...currentRsx,
+      build: nextBuild,
+    },
+  };
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${packageJsonPath} (rsx.build)`);
+    return true;
+  }
+
+  fs.writeFileSync(
+    packageJsonPath,
+    `${JSON.stringify(nextPackageJson, null, 2)}\n`,
+    'utf8',
+  );
+  logOk(`Patched ${packageJsonPath} (rsx.build)`);
+  return true;
+}
+
+function ensureAngularProvidersInEntry(entryFile, dryRun) {
+  if (!fs.existsSync(entryFile)) {
+    return false;
+  }
+
+  const original = fs.readFileSync(entryFile, 'utf8');
+  if (original.includes('providexRsx')) {
+    logInfo(`Angular entry already includes providexRsx: ${entryFile}`);
+    return true;
+  }
+
+  if (!original.includes('bootstrapApplication(')) {
+    logWarn(
+      `Could not automatically patch Angular providers in ${entryFile}. Expected bootstrapApplication(...).`,
+    );
+    logInfo(
+      "Manual setup: import { providexRsx } from '@rs-x/angular' and add providers: [...providexRsx()] to bootstrapApplication(...).",
+    );
+    return false;
+  }
+
+  const sourceWithImport = injectImport(
+    original,
+    "import { providexRsx } from '@rs-x/angular';",
+  );
+
+  let updated = sourceWithImport;
+  if (/bootstrapApplication\([\s\S]*?,\s*appConfig\s*\)/mu.test(updated)) {
+    updated = updated.replace(
+      /bootstrapApplication\(([\s\S]*?),\s*appConfig\s*\)/mu,
+      'bootstrapApplication($1, {\n  ...appConfig,\n  providers: [...(appConfig.providers ?? []), ...providexRsx()],\n})',
+    );
+  } else if (
+    /bootstrapApplication\([\s\S]*?,\s*\{[\s\S]*?providers\s*:/mu.test(updated)
+  ) {
+    updated = updated.replace(
+      /providers\s*:\s*\[/mu,
+      'providers: [...providexRsx(), ',
+    );
+  } else if (/bootstrapApplication\([\s\S]*?,\s*\{/mu.test(updated)) {
+    updated = updated.replace(
+      /bootstrapApplication\(([\s\S]*?),\s*\{/mu,
+      'bootstrapApplication($1, {\n  providers: [...providexRsx()],',
+    );
+  } else {
+    updated = updated.replace(
+      /bootstrapApplication\(([\s\S]*?)\)\s*(?:\.catch\([\s\S]*?\))?\s*;/mu,
+      'bootstrapApplication($1, {\n  providers: [...providexRsx()],\n}).catch((error) => {\n  console.error(error);\n});',
+    );
+  }
+
+  if (updated === sourceWithImport) {
+    logWarn(`Could not automatically inject providexRsx into ${entryFile}.`);
+    logInfo(
+      "Manual setup: import { providexRsx } from '@rs-x/angular' and add providers: [...providexRsx()] to bootstrapApplication(...).",
+    );
+    return false;
+  }
+
+  if (dryRun) {
+    logInfo(`[dry-run] patch ${entryFile} (providexRsx)`);
+    return true;
+  }
+
+  fs.writeFileSync(entryFile, updated, 'utf8');
+  logOk(`Patched ${entryFile} to include providexRsx.`);
+  return true;
 }
 
 function upsertScriptInPackageJson(
@@ -1906,109 +2973,6 @@ module.exports = function rsxWebpackLoader(source) {
 }
 
 function wireRsxVitePlugin(projectRoot, dryRun) {
-  const pluginFile = path.join(projectRoot, 'rsx-vite-plugin.mjs');
-  const pluginSource = `import path from 'node:path';
-
-import ts from 'typescript';
-
-import { createExpressionCachePreloadTransformer } from '@rs-x/compiler';
-
-function normalizeFileName(fileName) {
-  return path.resolve(fileName).replace(/\\\\/gu, '/');
-}
-
-function buildTransformedSourceMap(tsconfigPath) {
-  const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-  if (configFile.error) {
-    return new Map();
-  }
-
-  const parsed = ts.parseJsonConfigFileContent(
-    configFile.config,
-    ts.sys,
-    path.dirname(tsconfigPath),
-    undefined,
-    tsconfigPath,
-  );
-  if (parsed.errors.length > 0) {
-    return new Map();
-  }
-
-  const program = ts.createProgram({
-    rootNames: parsed.fileNames,
-    options: parsed.options,
-  });
-  const transformer = createExpressionCachePreloadTransformer(program);
-  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-  const transformedByFile = new Map();
-
-  for (const sourceFile of program.getSourceFiles()) {
-    if (sourceFile.isDeclarationFile) {
-      continue;
-    }
-
-    if (sourceFile.fileName.includes('/node_modules/')) {
-      continue;
-    }
-
-    const transformed = ts.transform(sourceFile, [transformer]);
-    const transformedSource = transformed.transformed[0];
-    const transformedText = printer.printFile(transformedSource);
-    transformed.dispose();
-
-    transformedByFile.set(normalizeFileName(sourceFile.fileName), transformedText);
-  }
-
-  return transformedByFile;
-}
-
-export function rsxVitePlugin(tsconfigPath = 'tsconfig.json') {
-  let transformedByFile = new Map();
-  let resolvedTsConfigPath = '';
-
-  const refresh = () => {
-    transformedByFile = buildTransformedSourceMap(resolvedTsConfigPath);
-  };
-
-  return {
-    name: 'rsx-vite-transform',
-    enforce: 'pre',
-    configResolved(config) {
-      resolvedTsConfigPath = normalizeFileName(path.resolve(config.root, tsconfigPath));
-      refresh();
-    },
-    buildStart() {
-      if (!resolvedTsConfigPath) {
-        resolvedTsConfigPath = normalizeFileName(path.resolve(process.cwd(), tsconfigPath));
-      }
-      refresh();
-    },
-    handleHotUpdate() {
-      refresh();
-    },
-    transform(_code, id) {
-      const normalizedId = normalizeFileName(id.split('?')[0]);
-      const transformed = transformedByFile.get(normalizedId);
-      if (!transformed) {
-        return null;
-      }
-
-      return {
-        code: transformed,
-        map: null,
-      };
-    },
-  };
-}
-`;
-
-  if (dryRun) {
-    logInfo(`[dry-run] create ${pluginFile}`);
-  } else {
-    fs.writeFileSync(pluginFile, pluginSource, 'utf8');
-    logOk(`Created ${pluginFile}`);
-  }
-
   const viteConfigCandidates = [
     'vite.config.ts',
     'vite.config.mts',
@@ -2018,61 +2982,47 @@ export function rsxVitePlugin(tsconfigPath = 'tsconfig.json') {
   const viteConfigPath = viteConfigCandidates.find((candidate) =>
     fs.existsSync(candidate),
   );
+  const stalePluginFiles = [
+    path.join(projectRoot, 'rsx-vite-plugin.ts'),
+    path.join(projectRoot, 'rsx-vite-plugin.mjs'),
+    path.join(projectRoot, 'rsx-vite-plugin.d.ts'),
+  ];
+
   if (!viteConfigPath) {
-    logWarn(
-      'No vite.config.[ts|mts|js|mjs] found. RS-X Vite plugin file was created, but config patch was skipped.',
-    );
-    logInfo(
-      "Add it manually: import { rsxVitePlugin } from './rsx-vite-plugin.mjs' and include rsxVitePlugin() in plugins.",
-    );
+    for (const staleFile of stalePluginFiles) {
+      removeFileOrDirectoryWithDryRun(staleFile, dryRun);
+    }
     return;
   }
 
   const original = fs.readFileSync(viteConfigPath, 'utf8');
-  if (original.includes('rsxVitePlugin(')) {
-    logInfo(`Vite config already includes RS-X plugin: ${viteConfigPath}`);
-    return;
-  }
-
-  let updated = original;
-  const importStatement =
-    "import { rsxVitePlugin } from './rsx-vite-plugin.mjs';";
-  if (!updated.includes(importStatement)) {
-    const lines = updated.split('\n');
-    let insertAt = 0;
-    while (
-      insertAt < lines.length &&
-      lines[insertAt].trim().startsWith('import ')
-    ) {
-      insertAt += 1;
+  const updated = original
+    .replace(
+      /import\s+\{\s*rsxVitePlugin\s*\}\s+from\s+['"]\.\/rsx-vite-plugin(?:\.mjs)?['"];\n?/gu,
+      '',
+    )
+    .replace(/rsxVitePlugin\(\)\s*,\s*/gu, '')
+    .replace(/,\s*rsxVitePlugin\(\)/gu, '')
+    .replace(/\[\s*rsxVitePlugin\(\)\s*\]/gu, '[]');
+
+  if (updated !== original) {
+    if (dryRun) {
+      logInfo(
+        `[dry-run] patch ${viteConfigPath} (remove legacy RS-X Vite plugin)`,
+      );
+    } else {
+      fs.writeFileSync(viteConfigPath, updated, 'utf8');
+      logOk(`Patched ${viteConfigPath} (removed legacy RS-X Vite plugin).`);
     }
-    lines.splice(insertAt, 0, importStatement);
-    updated = lines.join('\n');
-  }
-
-  if (/plugins\s*:\s*\[/u.test(updated)) {
-    updated = updated.replace(
-      /plugins\s*:\s*\[/u,
-      'plugins: [rsxVitePlugin(), ',
-    );
-  } else if (/defineConfig\s*\(\s*\{/u.test(updated)) {
-    updated = updated.replace(
-      /defineConfig\s*\(\s*\{/u,
-      'defineConfig({\n  plugins: [rsxVitePlugin()],',
-    );
   } else {
-    logWarn(`Could not patch Vite config automatically: ${viteConfigPath}`);
-    logInfo('Add `rsxVitePlugin()` to your Vite plugins manually.');
-    return;
+    logInfo(
+      `Vite config already uses the default plugin list: ${viteConfigPath}`,
+    );
   }
 
-  if (dryRun) {
-    logInfo(`[dry-run] patch ${viteConfigPath}`);
-    return;
+  for (const staleFile of stalePluginFiles) {
+    removeFileOrDirectoryWithDryRun(staleFile, dryRun);
   }
-
-  fs.writeFileSync(viteConfigPath, updated, 'utf8');
-  logOk(`Patched ${viteConfigPath} with RS-X Vite plugin.`);
 }
 
 function wireRsxNextWebpack(projectRoot, dryRun) {
@@ -2154,91 +3104,6 @@ ${patchBlock}
   logOk(`Patched ${nextConfigJs} with RS-X webpack loader.`);
 }
 
-function wireRsxAngularWebpack(projectRoot, dryRun) {
-  const angularJsonPath = path.join(projectRoot, 'angular.json');
-  if (!fs.existsSync(angularJsonPath)) {
-    logWarn('angular.json not found. Skipping Angular build integration.');
-    return;
-  }
-
-  createRsxWebpackLoaderFile(projectRoot, dryRun);
-
-  const webpackConfigPath = path.join(projectRoot, 'rsx-angular-webpack.cjs');
-  const webpackConfigSource = `const path = require('node:path');
-
-module.exports = {
-  module: {
-    rules: [
-      {
-        test: /\\.[jt]sx?$/u,
-        exclude: /node_modules/u,
-        use: [
-          {
-            loader: path.resolve(__dirname, './rsx-webpack-loader.cjs'),
-          },
-        ],
-      },
-    ],
-  },
-};
-`;
-
-  if (dryRun) {
-    logInfo(`[dry-run] create ${webpackConfigPath}`);
-  } else {
-    fs.writeFileSync(webpackConfigPath, webpackConfigSource, 'utf8');
-    logOk(`Created ${webpackConfigPath}`);
-  }
-
-  const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf8'));
-  const projects = angularJson.projects ?? {};
-  const projectNames = Object.keys(projects);
-  if (projectNames.length === 0) {
-    logWarn('No Angular projects found in angular.json.');
-    return;
-  }
-
-  const patchPath = 'rsx-angular-webpack.cjs';
-  for (const projectName of projectNames) {
-    const project = projects[projectName];
-    const architect = project.architect ?? project.targets;
-    if (!architect?.build) {
-      continue;
-    }
-
-    const build = architect.build;
-    if (build.builder !== '@angular-builders/custom-webpack:browser') {
-      build.builder = '@angular-builders/custom-webpack:browser';
-    }
-    build.options = build.options ?? {};
-    build.options.customWebpackConfig = build.options.customWebpackConfig ?? {};
-    build.options.customWebpackConfig.path = patchPath;
-
-    if (architect.serve) {
-      const serve = architect.serve;
-      if (serve.builder !== '@angular-builders/custom-webpack:dev-server') {
-        serve.builder = '@angular-builders/custom-webpack:dev-server';
-      }
-      serve.options = serve.options ?? {};
-      serve.options.buildTarget =
-        serve.options.buildTarget ?? `${projectName}:build`;
-      serve.options.browserTarget =
-        serve.options.browserTarget ?? `${projectName}:build`;
-    }
-  }
-
-  if (dryRun) {
-    logInfo(`[dry-run] patch ${angularJsonPath}`);
-  } else {
-    fs.writeFileSync(
-      angularJsonPath,
-      `${JSON.stringify(angularJson, null, 2)}\n`,
-      'utf8',
-    );
-    logOk(`Patched ${angularJsonPath} for RS-X Angular webpack integration.`);
-  }
-}
-
 function runSetupReact(flags) {
   const dryRun = Boolean(flags['dry-run']);
   const pm = detectPackageManager(flags.pm);
@@ -2266,19 +3131,48 @@ function runSetupReact(flags) {
     'skip-vscode': true,
   });
   if (!Boolean(flags['skip-install'])) {
-    installPackages(pm, ['@rs-x/react'], {
+    const specs = resolveLocalRsxSpecs(projectRoot, flags, {
+      tag,
+      includeReactPackage: true,
+    });
+    installResolvedPackages(pm, ['@rs-x/react'], {
       dev: false,
       dryRun,
       tag,
+      specs,
+      cwd: projectRoot,
       label: 'RS-X React bindings',
     });
+    installResolvedPackages(pm, ['@rs-x/cli'], {
+      dev: true,
+      dryRun,
+      tag,
+      specs,
+      cwd: projectRoot,
+      label: 'RS-X CLI',
+    });
   } else {
     logInfo('Skipping RS-X React bindings install (--skip-install).');
   }
+  upsertScriptInPackageJson(
+    projectRoot,
+    'build:rsx',
+    'rsx build --project tsconfig.json --no-emit --prod',
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'dev',
+    'npm run build:rsx && vite',
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'build',
+    'npm run build:rsx && vite build',
+    dryRun,
+  );
   wireRsxVitePlugin(projectRoot, dryRun);
-  if (!Boolean(flags['skip-vscode'])) {
-    installVsCodeExtension(flags);
-  }
   logOk('RS-X React setup completed.');
 }
 
@@ -2286,24 +3180,28 @@ function runSetupNext(flags) {
   const dryRun = Boolean(flags['dry-run']);
   const pm = detectPackageManager(flags.pm);
   const tag = resolveInstallTag(flags);
+  const projectRoot = process.cwd();
   runInit({
     ...flags,
     'skip-vscode': true,
   });
   if (!Boolean(flags['skip-install'])) {
-    installPackages(pm, ['@rs-x/react'], {
+    const specs = resolveLocalRsxSpecs(projectRoot, flags, {
+      tag,
+      includeReactPackage: true,
+    });
+    installResolvedPackages(pm, ['@rs-x/react'], {
       dev: false,
       dryRun,
       tag,
+      specs,
+      cwd: projectRoot,
       label: 'RS-X React bindings',
     });
   } else {
     logInfo('Skipping RS-X React bindings install (--skip-install).');
   }
-  wireRsxNextWebpack(process.cwd(), dryRun);
-  if (!Boolean(flags['skip-vscode'])) {
-    installVsCodeExtension(flags);
-  }
+  wireRsxNextWebpack(projectRoot, dryRun);
   logOk('RS-X Next.js setup completed.');
 }
 
@@ -2311,24 +3209,64 @@ function runSetupVue(flags) {
   const dryRun = Boolean(flags['dry-run']);
   const pm = detectPackageManager(flags.pm);
   const tag = resolveInstallTag(flags);
+  const projectRoot = process.cwd();
   runInit({
     ...flags,
     'skip-vscode': true,
   });
   if (!Boolean(flags['skip-install'])) {
-    installPackages(pm, ['@rs-x/vue'], {
+    const specs = resolveLocalRsxSpecs(projectRoot, flags, {
+      tag,
+      includeVuePackage: true,
+    });
+    installResolvedPackages(pm, ['@rs-x/vue'], {
       dev: false,
       dryRun,
       tag,
+      specs,
+      cwd: projectRoot,
       label: 'RS-X Vue bindings',
     });
+    installResolvedPackages(pm, ['@rs-x/cli'], {
+      dev: true,
+      dryRun,
+      tag,
+      specs,
+      cwd: projectRoot,
+      label: 'RS-X CLI',
+    });
   } else {
     logInfo('Skipping RS-X Vue bindings install (--skip-install).');
   }
-  wireRsxVitePlugin(process.cwd(), dryRun);
-  if (!Boolean(flags['skip-vscode'])) {
-    installVsCodeExtension(flags);
-  }
+  upsertScriptInPackageJson(
+    projectRoot,
+    'build:rsx',
+    'rsx build --project tsconfig.app.json --no-emit --prod',
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'typecheck:rsx',
+    'rsx typecheck --project tsconfig.app.json',
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'dev',
+    'npm run build:rsx && vite',
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'build',
+    'npm run build:rsx && vue-tsc -b && vite build',
+    dryRun,
+  );
+  const vueTsConfigPath = path.join(projectRoot, 'tsconfig.app.json');
+  upsertTypescriptPluginInTsConfig(vueTsConfigPath, dryRun);
+  ensureTsConfigIncludePattern(vueTsConfigPath, 'src/**/*.d.ts', dryRun);
+  ensureVueEnvTypes(projectRoot, dryRun);
+  wireRsxVitePlugin(projectRoot, dryRun);
   logOk('RS-X Vue setup completed.');
 }
 
@@ -2336,47 +3274,118 @@ function runSetupAngular(flags) {
   const dryRun = Boolean(flags['dry-run']);
   const pm = detectPackageManager(flags.pm);
   const tag = resolveInstallTag(flags);
-
-  runInit({
-    ...flags,
-    'skip-vscode': true,
-  });
+  const projectRoot = process.cwd();
+  const angularTsConfigPath = resolveAngularProjectTsConfig(projectRoot);
+  const angularTsConfigRelative = path
+    .relative(projectRoot, angularTsConfigPath)
+    .replace(/\\/gu, '/');
 
   if (!Boolean(flags['skip-install'])) {
-    installPackages(pm, ['@rs-x/angular'], {
+    installRuntimePackages(pm, dryRun, tag, projectRoot, flags);
+    installCompilerPackages(pm, dryRun, tag, projectRoot, flags);
+    const specs = resolveLocalRsxSpecs(projectRoot, flags, {
+      tag,
+      includeAngularPackage: true,
+    });
+    installResolvedPackages(pm, ['@rs-x/angular'], {
       dev: false,
       dryRun,
       tag,
+      specs,
+      cwd: projectRoot,
       label: 'RS-X Angular bindings',
     });
-    installPackages(pm, ['@angular-builders/custom-webpack'], {
+    installResolvedPackages(pm, ['@rs-x/cli'], {
       dev: true,
       dryRun,
-      label: 'Angular custom webpack builder',
+      tag,
+      specs,
+      cwd: projectRoot,
+      label: 'RS-X CLI',
     });
   } else {
+    logInfo('Skipping package installation (--skip-install).');
+  }
+
+  const entryFile = resolveEntryFile(projectRoot, 'angular', flags.entry);
+  if (entryFile) {
+    logInfo(`Using Angular entry file: ${entryFile}`);
+    ensureAngularProvidersInEntry(entryFile, dryRun);
+  } else {
+    logWarn('Could not detect an Angular entry file automatically.');
     logInfo(
-      'Skipping Angular custom webpack builder install (--skip-install).',
+      'Manual setup: add providexRsx() to bootstrapApplication(...) in your main entry file.',
     );
   }
 
-  wireRsxAngularWebpack(process.cwd(), dryRun);
+  upsertRsxBuildConfigInPackageJson(projectRoot, dryRun);
+
   upsertScriptInPackageJson(
-    process.cwd(),
+    projectRoot,
     'build:rsx',
-    'rsx build --project tsconfig.json',
+    `rsx build --project ${angularTsConfigRelative} --no-emit --prod`,
     dryRun,
   );
   upsertScriptInPackageJson(
-    process.cwd(),
+    projectRoot,
     'typecheck:rsx',
-    'rsx typecheck --project tsconfig.json',
+    `rsx typecheck --project ${angularTsConfigRelative}`,
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'prebuild',
+    'npm run build:rsx',
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'start',
+    'npm run build:rsx && ng serve',
     dryRun,
   );
 
-  if (!Boolean(flags['skip-vscode'])) {
-    installVsCodeExtension(flags);
+  const rsxRegistrationFile = path.join(
+    projectRoot,
+    'src/rsx-generated/rsx-aot-registration.generated.ts',
+  );
+  const angularJsonPath = path.join(projectRoot, 'angular.json');
+  if (fs.existsSync(angularJsonPath)) {
+    const angularJson = JSON.parse(fs.readFileSync(angularJsonPath, 'utf8'));
+    const projects = angularJson.projects ?? {};
+    for (const projectConfig of Object.values(projects)) {
+      const buildOptions = projectConfig?.architect?.build?.options;
+      if (buildOptions && typeof buildOptions === 'object') {
+        buildOptions.preserveSymlinks = true;
+      }
+      if (
+        projectConfig?.architect?.build?.configurations?.production?.budgets
+      ) {
+        delete projectConfig.architect.build.configurations.production.budgets;
+      }
+    }
+    if (dryRun) {
+      logInfo(
+        `[dry-run] patch ${angularJsonPath} (preserveSymlinks, production budgets)`,
+      );
+    } else {
+      fs.writeFileSync(
+        angularJsonPath,
+        `${JSON.stringify(angularJson, null, 2)}\n`,
+        'utf8',
+      );
+      logOk(
+        `Patched ${angularJsonPath} (preserveSymlinks, production budgets).`,
+      );
+    }
   }
+  ensureAngularPolyfillsContainsFile({
+    projectRoot,
+    configPath: angularTsConfigPath,
+    filePath: rsxRegistrationFile,
+    dryRun,
+  });
+
   logOk('RS-X Angular setup completed.');
 }
 
@@ -2411,9 +3420,20 @@ function runSetupAuto(flags) {
 
   logInfo('No framework-specific setup detected; running generic setup.');
   const pm = detectPackageManager(flags.pm);
-  installRuntimePackages(pm, Boolean(flags['dry-run']), tag);
-  installCompilerPackages(pm, Boolean(flags['dry-run']), tag);
-  installVsCodeExtension(flags);
+  installRuntimePackages(
+    pm,
+    Boolean(flags['dry-run']),
+    tag,
+    projectRoot,
+    flags,
+  );
+  installCompilerPackages(
+    pm,
+    Boolean(flags['dry-run']),
+    tag,
+    projectRoot,
+    flags,
+  );
 }
 
 function resolveProjectModule(projectRoot, moduleName) {
@@ -2978,9 +3998,14 @@ function ensureAngularPolyfillsContainsFile({
   });
 
   const selectedEntries = targetEntries.length > 0 ? targetEntries : entries;
-  const polyfillsPath = path
+  const polyfillsRelativePath = path
     .relative(projectRoot, filePath)
     .replace(/\\/g, '/');
+  const polyfillsPath =
+    polyfillsRelativePath.startsWith('./') ||
+    polyfillsRelativePath.startsWith('../')
+      ? polyfillsRelativePath
+      : `./${polyfillsRelativePath}`;
 
   let changed = false;
   const isRsxAotRegistrationEntry = (entry) =>
@@ -3256,12 +4281,17 @@ function printProjectHelp() {
   console.log('What it does:');
   console.log('  - Creates a new project folder');
   console.log('  - Supports templates: angular, vuejs, react, nextjs, nodejs');
+  console.log(
+    '  - Angular generates the RS-X virtual-table demo starter on top of the latest Angular scaffold',
+  );
   console.log('  - Scaffolds framework app and wires RS-X bootstrap/setup');
   console.log('  - Writes package.json with RS-X dependencies');
   console.log(
     '  - Adds tsconfig + TypeScript plugin config for editor support',
   );
-  console.log('  - For Angular template: also installs @rs-x/angular');
+  console.log(
+    '  - For Angular template: uses the latest Angular CLI scaffold, then applies the RS-X demo starter',
+  );
   console.log('  - For React/Next templates: also installs @rs-x/react');
   console.log('  - For Vue template: also installs @rs-x/vue');
   console.log('  - Installs dependencies (unless --skip-install)');
@@ -3338,6 +4368,7 @@ function printTypecheckHelp() {
 function printVersionHelp() {
   console.log('Usage:');
   console.log('  rsx version');
+  console.log('  rsx v');
   console.log('  rsx -v');
   console.log('  rsx -version');
   console.log('  rsx --version');
@@ -3349,6 +4380,7 @@ function isHelpToken(value) {
 
 function isVersionToken(value) {
   return (
+    value === 'v' ||
     value === '-v' ||
     value === '--version' ||
     value === '-version' ||
@@ -3409,6 +4441,7 @@ function printHelpFor(command, target) {
   }
 
   if (
+    command === 'v' ||
     command === 'version' ||
     command === '-v' ||
     command === '--version' ||
@@ -3495,7 +4528,13 @@ function main() {
   if (command === 'install' && target === 'compiler') {
     const pm = detectPackageManager(flags.pm);
     const tag = resolveInstallTag(flags);
-    installCompilerPackages(pm, Boolean(flags['dry-run']), tag);
+    installCompilerPackages(
+      pm,
+      Boolean(flags['dry-run']),
+      tag,
+      process.cwd(),
+      flags,
+    );
     return;
   }