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

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',
   });
 
@@ -178,6 +211,22 @@ function detectPackageManager(explicitPm) {
   return 'npm';
 }
 
+function resolveCliPackageManager(projectRoot, explicitPm) {
+  if (explicitPm) {
+    return explicitPm;
+  }
+
+  const cliConfig = resolveRsxCliConfig(projectRoot);
+  if (
+    typeof cliConfig.packageManager === 'string' &&
+    ['pnpm', 'npm', 'yarn', 'bun'].includes(cliConfig.packageManager)
+  ) {
+    return cliConfig.packageManager;
+  }
+
+  return detectPackageManager(undefined);
+}
+
 function applyTagToPackages(packages, tag) {
   return packages.map((pkg) => {
     const lastAt = pkg.lastIndexOf('@');
@@ -191,11 +240,68 @@ 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 resolveConfiguredInstallTag(projectRoot, flags) {
+  const explicitTag = resolveInstallTag(flags);
+  if (explicitTag) {
+    return explicitTag;
+  }
+
+  const cliConfig = resolveRsxCliConfig(projectRoot);
+  if (
+    typeof cliConfig.installTag === 'string' &&
+    ['latest', 'next'].includes(cliConfig.installTag)
+  ) {
+    return cliConfig.installTag;
+  }
+
+  return undefined;
+}
+
+function resolveCliVerifyFlag(projectRoot, flags, sectionName) {
+  if (flags.verify !== undefined) {
+    return parseBooleanFlag(flags.verify, false);
+  }
+
+  const cliConfig = resolveRsxCliConfig(projectRoot);
+  const sectionConfig = cliConfig[sectionName];
+  if (
+    typeof sectionConfig === 'object' &&
+    sectionConfig &&
+    typeof sectionConfig.verify === 'boolean'
+  ) {
+    return sectionConfig.verify;
+  }
+
+  return false;
 }
 
 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 +326,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 +418,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) {
@@ -343,6 +535,13 @@ function findRepoRoot(startDir) {
 function runDoctor() {
   const nodeMajor = Number.parseInt(process.versions.node.split('.')[0], 10);
   const hasCode = hasCommand('code');
+  const availablePackageManagers = ['pnpm', 'npm', 'yarn', 'bun'].filter((pm) =>
+    hasCommand(pm),
+  );
+  const packageRoot = findNearestPackageRoot(process.cwd());
+  const duplicateRsxPackages = packageRoot
+    ? findDuplicateRsxPackages(packageRoot)
+    : [];
   const checks = [
     {
       name: 'Node.js >= 20',
@@ -356,12 +555,25 @@ function runDoctor() {
     },
     {
       name: 'Package manager (pnpm/npm/yarn/bun)',
-      ok:
-        hasCommand('pnpm') ||
-        hasCommand('npm') ||
-        hasCommand('yarn') ||
-        hasCommand('bun'),
-      details: 'required for compiler package installation',
+      ok: availablePackageManagers.length > 0,
+      details:
+        availablePackageManagers.length > 0
+          ? `available: ${availablePackageManagers.join(', ')}`
+          : 'required for compiler package installation',
+    },
+    {
+      name: 'Duplicate @rs-x package versions',
+      ok: duplicateRsxPackages.length === 0,
+      details: packageRoot
+        ? duplicateRsxPackages.length === 0
+          ? `not detected in ${path.relative(process.cwd(), packageRoot) || '.'}`
+          : duplicateRsxPackages
+              .map(
+                ({ name, versions }) =>
+                  `${name} (${Array.from(versions).join(', ')})`,
+              )
+              .join('; ')
+        : 'no package.json found in current directory tree',
     },
   ];
 
@@ -369,6 +581,149 @@ function runDoctor() {
     const tag = check.ok ? '[OK]' : '[WARN]';
     console.log(`${tag} ${check.name} - ${check.details}`);
   }
+
+  const failingChecks = checks.filter((check) => !check.ok);
+  if (failingChecks.length > 0) {
+    console.log('');
+    console.log('Suggested next steps:');
+    for (const check of failingChecks) {
+      if (check.name === 'Node.js >= 20') {
+        console.log(
+          '  - Install Node.js 20 or newer before running `rsx setup` or `rsx project`.',
+        );
+      } else if (check.name === 'VS Code CLI (code)') {
+        console.log(
+          '  - Install the VS Code shell command or use `rsx install vscode --force` later.',
+        );
+      } else if (check.name === 'Package manager (pnpm/npm/yarn/bun)') {
+        console.log(
+          '  - Install npm, pnpm, yarn, or bun so the CLI can add RS-X packages.',
+        );
+      } else if (check.name === 'Duplicate @rs-x package versions') {
+        console.log(
+          '  - Reinstall dependencies so all `@rs-x/*` packages resolve to a single version, then rerun `rsx doctor`.',
+        );
+        console.log(
+          '  - If you are linking local packages, remove nested `node_modules` inside linked RS-X packages.',
+        );
+      }
+    }
+    return;
+  }
+
+  console.log('');
+  console.log('Suggested next steps:');
+  console.log(
+    '  - Run `rsx project <framework>` to scaffold a starter, or `rsx setup` inside an existing app.',
+  );
+  console.log('  - Use `rsx add` to create your first expression file.');
+}
+
+function findNearestPackageRoot(startDirectory) {
+  let currentDirectory = path.resolve(startDirectory);
+  while (true) {
+    if (fs.existsSync(path.join(currentDirectory, 'package.json'))) {
+      return currentDirectory;
+    }
+    const parentDirectory = path.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return null;
+    }
+    currentDirectory = parentDirectory;
+  }
+}
+
+function readRsxPackageVersionsFromNodeModules(
+  nodeModulesDirectory,
+  versionsByPackage,
+) {
+  const scopeDirectory = path.join(nodeModulesDirectory, '@rs-x');
+  if (!fs.existsSync(scopeDirectory)) {
+    return [];
+  }
+
+  const packageDirectories = fs
+    .readdirSync(scopeDirectory, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(scopeDirectory, entry.name));
+
+  for (const packageDirectory of packageDirectories) {
+    const packageJsonPath = path.join(packageDirectory, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      continue;
+    }
+
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const packageName = packageJson.name;
+      const packageVersion = packageJson.version;
+      if (
+        typeof packageName === 'string' &&
+        typeof packageVersion === 'string'
+      ) {
+        if (!versionsByPackage.has(packageName)) {
+          versionsByPackage.set(packageName, new Set());
+        }
+        versionsByPackage.get(packageName).add(packageVersion);
+      }
+    } catch {
+      // Ignore malformed package.json files during doctor output.
+    }
+  }
+
+  return packageDirectories;
+}
+
+function collectNestedRsxPackageVersions(
+  packageDirectory,
+  versionsByPackage,
+  depth,
+) {
+  if (depth <= 0) {
+    return;
+  }
+
+  const nestedNodeModulesDirectory = path.join(
+    packageDirectory,
+    'node_modules',
+  );
+  if (!fs.existsSync(nestedNodeModulesDirectory)) {
+    return;
+  }
+
+  const nestedPackageDirectories = readRsxPackageVersionsFromNodeModules(
+    nestedNodeModulesDirectory,
+    versionsByPackage,
+  );
+
+  for (const nestedPackageDirectory of nestedPackageDirectories) {
+    collectNestedRsxPackageVersions(
+      nestedPackageDirectory,
+      versionsByPackage,
+      depth - 1,
+    );
+  }
+}
+
+function findDuplicateRsxPackages(projectRoot) {
+  const rootNodeModulesDirectory = path.join(projectRoot, 'node_modules');
+  if (!fs.existsSync(rootNodeModulesDirectory)) {
+    return [];
+  }
+
+  const versionsByPackage = new Map();
+  const rootPackageDirectories = readRsxPackageVersionsFromNodeModules(
+    rootNodeModulesDirectory,
+    versionsByPackage,
+  );
+
+  for (const packageDirectory of rootPackageDirectories) {
+    collectNestedRsxPackageVersions(packageDirectory, versionsByPackage, 3);
+  }
+
+  return Array.from(versionsByPackage.entries())
+    .filter(([, versions]) => versions.size > 1)
+    .map(([name, versions]) => ({ name, versions }));
 }
 
 function isValidTsIdentifier(input) {
@@ -446,104 +801,540 @@ function stripTsLikeExtension(fileName) {
   return fileName.replace(/\.[cm]?[jt]sx?$/u, '');
 }
 
-function createModelTemplate() {
+function inferModelKeysFromExpression(expressionSource) {
+  const matches = expressionSource.matchAll(
+    /(?<![\w$.])([A-Za-z_$][A-Za-z0-9_$]*)(?![\w$])/gu,
+  );
+  const identifiers = [];
+  const ignoredIdentifiers = new Set([
+    'undefined',
+    'null',
+    'true',
+    'false',
+    'Math',
+    'Date',
+    'Number',
+    'String',
+    'Boolean',
+    'Array',
+    'Object',
+    'JSON',
+    'console',
+  ]);
+
+  for (const match of matches) {
+    const identifier = match[1];
+    if (
+      TS_RESERVED_WORDS.has(identifier) ||
+      ignoredIdentifiers.has(identifier)
+    ) {
+      continue;
+    }
+    if (!identifiers.includes(identifier)) {
+      identifiers.push(identifier);
+    }
+  }
+
+  return identifiers;
+}
+
+function createModelTemplate(expressionSource) {
+  const modelKeys = inferModelKeysFromExpression(expressionSource);
+  const modelBody =
+    modelKeys.length > 0
+      ? modelKeys.map((key) => `  ${key}: 1,`).join('\n')
+      : '  a: 1,';
+
   return `export const model = {
-  a: 1,
+${modelBody}
 };
 `;
 }
 
+function createInlineExpressionTemplate(expressionName, expressionSource) {
+  return `import { rsx } from '@rs-x/expression-parser';
+
+${createModelTemplate(expressionSource).trim()}
+
+export const ${expressionName} = rsx(${JSON.stringify(expressionSource)})(model);
+`;
+}
+
+function createInlineExpressionAppendTemplate(
+  expressionName,
+  expressionSource,
+  fileContent,
+) {
+  const hasRsxImport = fileContent.includes("from '@rs-x/expression-parser'");
+  const hasModelExport = /\bexport\s+const\s+model\s*=/u.test(fileContent);
+  const sections = [];
+
+  if (!hasRsxImport) {
+    sections.push("import { rsx } from '@rs-x/expression-parser';");
+  }
+
+  if (!hasModelExport) {
+    sections.push(createModelTemplate(expressionSource).trim());
+  }
+
+  sections.push(
+    `export const ${expressionName} = rsx(${JSON.stringify(expressionSource)})(model);`,
+  );
+  return `\n${sections.join('\n\n')}\n`;
+}
+
 function createExpressionTemplate(
   expressionName,
+  expressionSource,
   modelImportPath,
   modelExportName,
 ) {
   return `import { rsx } from '@rs-x/expression-parser';
 import { ${modelExportName} } from '${modelImportPath}';
 
-export const ${expressionName} = rsx('a')(${modelExportName});
+export const ${expressionName} = rsx(${JSON.stringify(expressionSource)})(${modelExportName});
 `;
 }
 
-async function askForIdentifierWithDefault(rl, prompt, defaultValue) {
-  while (true) {
-    const answer = (await rl.question(prompt)).trim();
-    if (!answer) {
-      return defaultValue;
+function findExpressionFiles(searchRoot) {
+  const results = [];
+  const expressionPattern =
+    /\b(?:export\s+)?const\s+[A-Za-z_$][\w$]*\s*=\s*rsx\(/u;
+
+  function visit(currentPath) {
+    if (!fs.existsSync(currentPath)) {
+      return;
     }
 
-    if (isValidTsIdentifier(answer)) {
-      return answer;
+    const stat = fs.statSync(currentPath);
+    if (stat.isDirectory()) {
+      const baseName = path.basename(currentPath);
+      if (
+        baseName === 'node_modules' ||
+        baseName === 'dist' ||
+        baseName === 'build' ||
+        baseName === '.git' ||
+        baseName === '.next' ||
+        baseName === 'coverage' ||
+        baseName === '.tests' ||
+        baseName === 'tmp'
+      ) {
+        return;
+      }
+
+      for (const entry of fs.readdirSync(currentPath)) {
+        visit(path.join(currentPath, entry));
+      }
+      return;
     }
 
-    logWarn(`"${answer}" is not a valid TypeScript identifier.`);
+    if (!/\.[cm]?[jt]sx?$/u.test(currentPath)) {
+      return;
+    }
+
+    const content = fs.readFileSync(currentPath, 'utf8');
+    if (
+      content.includes("from '@rs-x/expression-parser'") &&
+      expressionPattern.test(content)
+    ) {
+      results.push(currentPath);
+    }
   }
+
+  visit(searchRoot);
+  return results.sort((left, right) => left.localeCompare(right));
 }
 
-async function runAdd() {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
+function resolveRsxCliAddConfig(projectRoot) {
+  const cliConfig = resolveRsxCliConfig(projectRoot);
+  const addConfig = cliConfig.add ?? {};
+  const defaultSearchRoots = ['src', 'app', 'expressions'];
+  const configuredSearchRoots = Array.isArray(addConfig.searchRoots)
+    ? addConfig.searchRoots.filter(
+        (value) => typeof value === 'string' && value.trim() !== '',
+      )
+    : defaultSearchRoots;
+  const defaultDirectory =
+    typeof addConfig.defaultDirectory === 'string' &&
+    addConfig.defaultDirectory.trim() !== ''
+      ? addConfig.defaultDirectory.trim()
+      : 'src/expressions';
+
+  return {
+    defaultDirectory,
+    searchRoots: configuredSearchRoots,
+  };
+}
+
+function filterPreferredExpressionFiles(candidates, projectRoot, addConfig) {
+  const preferredRootPrefixes = addConfig.searchRoots
+    .map((rootPath) =>
+      path.isAbsolute(rootPath) ? rootPath : path.join(projectRoot, rootPath),
+    )
+    .map((value) => `${value.replace(/\\/gu, '/')}/`);
+
+  const preferredCandidates = candidates.filter((candidate) => {
+    const normalizedCandidate = candidate.replace(/\\/gu, '/');
+    return preferredRootPrefixes.some((prefix) =>
+      normalizedCandidate.startsWith(prefix),
+    );
   });
 
-  try {
-    const expressionName = await askUntilValidIdentifier(rl);
+  return preferredCandidates.length > 0 ? preferredCandidates : candidates;
+}
 
-    const kebabAnswer = await rl.question('Use kebab-case file name? [Y/n]: ');
-    const useKebabCase = normalizeYesNo(kebabAnswer, true);
+function rankExpressionFiles(candidates, resolvedDirectory, projectRoot) {
+  const sourceRootPatterns = ['/src/', '/app/', '/expressions/'];
 
-    const directoryInput = await askUntilNonEmpty(
-      rl,
-      'Directory path (relative or absolute): ',
-    );
-    const resolvedDirectory = path.isAbsolute(directoryInput)
-      ? directoryInput
-      : path.resolve(process.cwd(), directoryInput);
+  function score(filePath) {
+    const normalized = filePath.replace(/\\/gu, '/');
+    let value = 0;
 
-    const baseFileName = useKebabCase
-      ? toKebabCase(expressionName)
-      : expressionName;
-    const expressionFileName = ensureTsExtension(baseFileName);
-    const expressionFileBase = stripTsLikeExtension(expressionFileName);
-    const modelFileName = `${expressionFileBase}.model.ts`;
-    const expressionPath = path.join(resolvedDirectory, expressionFileName);
-    const modelPath = path.join(resolvedDirectory, modelFileName);
-    const useExistingModelAnswer = await rl.question(
-      'Use existing model file? [y/N]: ',
-    );
-    const useExistingModel = normalizeYesNo(useExistingModelAnswer, false);
+    if (normalized.startsWith(resolvedDirectory.replace(/\\/gu, '/'))) {
+      value += 1000;
+    }
 
-    if (
-      fs.existsSync(expressionPath) ||
-      (!useExistingModel && fs.existsSync(modelPath))
-    ) {
-      const overwriteAnswer = await rl.question(
-        `One or more target files already exist. Overwrite? [y/N]: `,
-      );
-      const shouldOverwrite = normalizeYesNo(overwriteAnswer, false);
-      if (!shouldOverwrite) {
-        logInfo('Cancelled. Existing file was not modified.');
-        return;
-      }
+    if (sourceRootPatterns.some((pattern) => normalized.includes(pattern))) {
+      value += 100;
     }
 
-    fs.mkdirSync(resolvedDirectory, { recursive: true });
-    let modelImportPath = `./${expressionFileBase}.model`;
-    let modelExportName = 'model';
+    const relativeSegments = path
+      .relative(projectRoot, filePath)
+      .replace(/\\/gu, '/')
+      .split('/').length;
+    value -= relativeSegments;
+    return value;
+  }
 
-    if (useExistingModel) {
-      const existingModelPathInput = await askUntilNonEmpty(
-        rl,
-        'Existing model file path (relative to output dir or absolute): ',
-      );
-      const resolvedExistingModelPath = path.isAbsolute(existingModelPathInput)
-        ? existingModelPathInput
-        : path.resolve(resolvedDirectory, existingModelPathInput);
+  return [...candidates].sort((left, right) => {
+    const scoreDifference = score(right) - score(left);
+    if (scoreDifference !== 0) {
+      return scoreDifference;
+    }
+    return left.localeCompare(right);
+  });
+}
 
-      if (!fs.existsSync(resolvedExistingModelPath)) {
-        logError(`Model file not found: ${resolvedExistingModelPath}`);
-        return;
-      }
+async function askForExistingExpressionFile(rl, resolvedDirectory) {
+  const projectRoot = process.cwd();
+  const addConfig = resolveRsxCliAddConfig(projectRoot);
+  const directoryCandidates = filterPreferredExpressionFiles(
+    findExpressionFiles(resolvedDirectory),
+    projectRoot,
+    addConfig,
+  );
+  const fallbackCandidates =
+    directoryCandidates.length > 0
+      ? []
+      : rankExpressionFiles(
+          filterPreferredExpressionFiles(
+            findExpressionFiles(projectRoot),
+            projectRoot,
+            addConfig,
+          ),
+          resolvedDirectory,
+          projectRoot,
+        );
+  const candidates =
+    directoryCandidates.length > 0 ? directoryCandidates : fallbackCandidates;
+
+  if (candidates.length > 0) {
+    console.log(
+      directoryCandidates.length > 0
+        ? 'Existing expression files in the selected directory:'
+        : 'Existing expression files in the current project:',
+    );
+    candidates.forEach((candidate, index) => {
+      console.log(
+        `  ${index + 1}. ${path.relative(process.cwd(), candidate).replace(/\\/gu, '/')}`,
+      );
+    });
+    console.log('  0. Enter a custom path');
+  }
+
+  while (true) {
+    const answer = (
+      await rl.question(
+        candidates.length > 0
+          ? 'Choose a file number or enter a file path: '
+          : 'Existing file path (relative to output dir or absolute): ',
+      )
+    ).trim();
+
+    if (!answer && candidates.length > 0) {
+      logWarn('Please choose a file or enter a path.');
+      continue;
+    }
+
+    if (candidates.length > 0 && /^\d+$/u.test(answer)) {
+      const selectedIndex = Number.parseInt(answer, 10);
+      if (selectedIndex === 0) {
+        const customPath = await askUntilNonEmpty(
+          rl,
+          'Existing file path (relative to output dir or absolute): ',
+        );
+        const resolvedPath = path.isAbsolute(customPath)
+          ? customPath
+          : path.resolve(resolvedDirectory, customPath);
+
+        if (!fs.existsSync(resolvedPath)) {
+          logWarn(`File not found: ${resolvedPath}`);
+          continue;
+        }
+
+        return resolvedPath;
+      }
+
+      if (selectedIndex >= 1 && selectedIndex <= candidates.length) {
+        return candidates[selectedIndex - 1];
+      }
+
+      logWarn(`"${answer}" is not a valid file number.`);
+      continue;
+    }
+
+    const resolvedPath = path.isAbsolute(answer)
+      ? answer
+      : path.resolve(resolvedDirectory, answer);
+
+    if (!fs.existsSync(resolvedPath)) {
+      logWarn(`File not found: ${resolvedPath}`);
+      continue;
+    }
+
+    return resolvedPath;
+  }
+}
+
+async function askForIdentifierWithDefault(rl, prompt, defaultValue) {
+  while (true) {
+    const answer = (await rl.question(prompt)).trim();
+    if (!answer) {
+      return defaultValue;
+    }
+
+    if (isValidTsIdentifier(answer)) {
+      return answer;
+    }
+
+    logWarn(`"${answer}" is not a valid TypeScript identifier.`);
+  }
+}
+
+async function askForExpressionSource(rl) {
+  while (true) {
+    const answer = (
+      await rl.question("Initial expression string ['a']: ")
+    ).trim();
+
+    if (!answer) {
+      return 'a';
+    }
+
+    return answer;
+  }
+}
+
+async function askForDirectoryPath(rl, defaultDirectory) {
+  while (true) {
+    const prompt = defaultDirectory
+      ? `Directory path (relative or absolute) [${defaultDirectory}]: `
+      : 'Directory path (relative or absolute): ';
+    const answer = (await rl.question(prompt)).trim();
+
+    if (answer) {
+      return answer;
+    }
+
+    if (defaultDirectory) {
+      return defaultDirectory;
+    }
+
+    logWarn('Please enter a directory path.');
+  }
+}
+
+async function askForAddMode(rl) {
+  console.log('Choose add mode:');
+  console.log(
+    '  1. Create new expression file (model in same file) [Recommended]',
+  );
+  console.log('  2. Create new expression file with separate model');
+  console.log('  3. Update an existing expression file');
+
+  while (true) {
+    const answer = (await rl.question('Add mode [1]: ')).trim();
+
+    if (!answer || answer === '1') {
+      return 'create-inline';
+    }
+    if (answer === '2') {
+      return 'create-separate';
+    }
+    if (answer === '3') {
+      return 'update-existing';
+    }
+
+    logWarn(`"${answer}" is not a valid add mode. Use 1, 2, or 3.`);
+  }
+}
+
+async function runAdd() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const projectRoot = process.cwd();
+    const addConfig = resolveRsxCliAddConfig(projectRoot);
+    const expressionName = await askUntilValidIdentifier(rl);
+    const expressionSource = await askForExpressionSource(rl);
+
+    const kebabAnswer = await rl.question('Use kebab-case file name? [Y/n]: ');
+    const useKebabCase = normalizeYesNo(kebabAnswer, true);
+
+    const directoryInput = await askForDirectoryPath(
+      rl,
+      addConfig.defaultDirectory,
+    );
+    const resolvedDirectory = path.isAbsolute(directoryInput)
+      ? directoryInput
+      : path.resolve(projectRoot, directoryInput);
+
+    const baseFileName = useKebabCase
+      ? toKebabCase(expressionName)
+      : expressionName;
+    const expressionFileName = ensureTsExtension(baseFileName);
+    const expressionFileBase = stripTsLikeExtension(expressionFileName);
+    const modelFileName = `${expressionFileBase}.model.ts`;
+    const expressionPath = path.join(resolvedDirectory, expressionFileName);
+    const modelPath = path.join(resolvedDirectory, modelFileName);
+    const addMode = await askForAddMode(rl);
+    const updateExistingFile = addMode === 'update-existing';
+    const keepModelInSameFile =
+      addMode === 'create-inline'
+        ? true
+        : addMode === 'create-separate'
+          ? false
+          : normalizeYesNo(
+              await rl.question('Keep model in the same file? [Y/n]: '),
+              true,
+            );
+
+    if (updateExistingFile) {
+      const resolvedExistingFilePath = await askForExistingExpressionFile(
+        rl,
+        resolvedDirectory,
+      );
+      const existingFileContent = fs.readFileSync(
+        resolvedExistingFilePath,
+        'utf8',
+      );
+      let appendContent;
+
+      if (keepModelInSameFile) {
+        appendContent = createInlineExpressionAppendTemplate(
+          expressionName,
+          expressionSource,
+          existingFileContent,
+        );
+      } else {
+        const useExistingModelAnswer = await rl.question(
+          'Use existing model file? [y/N]: ',
+        );
+        const useExistingModel = normalizeYesNo(useExistingModelAnswer, false);
+        let modelImportPath = './model';
+        let modelExportName = 'model';
+
+        if (useExistingModel) {
+          const existingModelPathInput = await askUntilNonEmpty(
+            rl,
+            'Existing model file path (relative to output dir or absolute): ',
+          );
+          const resolvedExistingModelPath = path.isAbsolute(
+            existingModelPathInput,
+          )
+            ? existingModelPathInput
+            : path.resolve(resolvedDirectory, existingModelPathInput);
+
+          if (!fs.existsSync(resolvedExistingModelPath)) {
+            logError(`Model file not found: ${resolvedExistingModelPath}`);
+            return;
+          }
+
+          modelImportPath = toModuleImportPath(
+            resolvedExistingFilePath,
+            resolvedExistingModelPath,
+          );
+          modelExportName = await askForIdentifierWithDefault(
+            rl,
+            'Model export name [model]: ',
+            'model',
+          );
+        }
+
+        appendContent = `\n${createExpressionTemplate(
+          expressionName,
+          expressionSource,
+          modelImportPath,
+          modelExportName,
+        )}`;
+      }
+
+      fs.appendFileSync(resolvedExistingFilePath, appendContent, 'utf8');
+      logOk(`Updated ${resolvedExistingFilePath}`);
+      return;
+    }
+
+    const useExistingModel = !keepModelInSameFile
+      ? normalizeYesNo(
+          await rl.question('Use existing model file? [y/N]: '),
+          false,
+        )
+      : false;
+
+    if (
+      fs.existsSync(expressionPath) ||
+      (!keepModelInSameFile && !useExistingModel && fs.existsSync(modelPath))
+    ) {
+      const overwriteAnswer = await rl.question(
+        `One or more target files already exist. Overwrite? [y/N]: `,
+      );
+      const shouldOverwrite = normalizeYesNo(overwriteAnswer, false);
+      if (!shouldOverwrite) {
+        logInfo('Cancelled. Existing file was not modified.');
+        return;
+      }
+    }
+
+    fs.mkdirSync(resolvedDirectory, { recursive: true });
+    let modelImportPath = `./${expressionFileBase}.model`;
+    let modelExportName = 'model';
+
+    if (keepModelInSameFile) {
+      fs.writeFileSync(
+        expressionPath,
+        createInlineExpressionTemplate(expressionName, expressionSource),
+        'utf8',
+      );
+      logOk(`Created ${expressionPath}`);
+      return;
+    }
+
+    if (useExistingModel) {
+      const existingModelPathInput = await askUntilNonEmpty(
+        rl,
+        'Existing model file path (relative to output dir or absolute): ',
+      );
+      const resolvedExistingModelPath = path.isAbsolute(existingModelPathInput)
+        ? existingModelPathInput
+        : path.resolve(resolvedDirectory, existingModelPathInput);
+
+      if (!fs.existsSync(resolvedExistingModelPath)) {
+        logError(`Model file not found: ${resolvedExistingModelPath}`);
+        return;
+      }
 
       modelImportPath = toModuleImportPath(
         expressionPath,
@@ -555,7 +1346,11 @@ async function runAdd() {
         'model',
       );
     } else {
-      fs.writeFileSync(modelPath, createModelTemplate(), 'utf8');
+      fs.writeFileSync(
+        modelPath,
+        createModelTemplate(expressionSource),
+        'utf8',
+      );
       logOk(`Created ${modelPath}`);
     }
 
@@ -563,6 +1358,7 @@ async function runAdd() {
       expressionPath,
       createExpressionTemplate(
         expressionName,
+        expressionSource,
         modelImportPath,
         modelExportName,
       ),
@@ -585,87 +1381,301 @@ function writeFileWithDryRun(filePath, content, dryRun) {
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
-function toFileDependencySpec(fromDir, targetPath) {
-  const relative = path.relative(fromDir, targetPath).replace(/\\/gu, '/');
-  const normalized = relative.startsWith('.') ? relative : `./${relative}`;
-  return `file:${normalized}`;
-}
-
-function findLatestTarball(packageDir, packageSlug) {
-  if (!fs.existsSync(packageDir)) {
-    return null;
-  }
+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;
+    }
 
-  const candidates = [];
-  const stack = [packageDir];
+    if (inBlockComment) {
+      if (current === '*' && next === '/') {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
 
-  while (stack.length > 0) {
-    const currentDir = stack.pop();
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(fullPath);
+    if (inString) {
+      result += current;
+      if (current === '\\') {
+        index += 1;
+        if (index < content.length) {
+          result += content[index];
+        }
         continue;
       }
-
-      if (
-        entry.isFile() &&
-        entry.name.startsWith(`${packageSlug}-`) &&
-        entry.name.endsWith('.tgz')
-      ) {
-        candidates.push(fullPath);
+      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;
   }
 
-  candidates.sort();
-  if (candidates.length === 0) {
-    return null;
+  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;
   }
 
-  return candidates[candidates.length - 1];
+  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 resolveProjectRsxSpecs(
-  projectRoot,
-  workspaceRoot,
-  tarballsDir,
-  options = {},
-) {
-  const includeAngularPackage = Boolean(options.includeAngularPackage);
-  const versionSpec = options.tag ? options.tag : RSX_PACKAGE_VERSION;
-  const defaults = {
-    '@rs-x/core': versionSpec,
-    '@rs-x/state-manager': versionSpec,
-    '@rs-x/expression-parser': versionSpec,
-    '@rs-x/compiler': versionSpec,
-    '@rs-x/typescript-plugin': versionSpec,
-    ...(includeAngularPackage ? { '@rs-x/angular': versionSpec } : {}),
-    '@rs-x/cli': null,
-  };
+function removeFileOrDirectoryWithDryRun(targetPath, dryRun) {
+  if (!fs.existsSync(targetPath)) {
+    return;
+  }
 
-  const tarballSlugs = {
-    '@rs-x/core': 'rs-x-core',
-    '@rs-x/state-manager': 'rs-x-state-manager',
-    '@rs-x/expression-parser': 'rs-x-expression-parser',
-    '@rs-x/compiler': 'rs-x-compiler',
-    '@rs-x/typescript-plugin': 'rs-x-typescript-plugin',
-    ...(includeAngularPackage ? { '@rs-x/angular': 'rs-x-angular' } : {}),
-    '@rs-x/cli': 'rs-x-cli',
-  };
+  if (dryRun) {
+    logInfo(`[dry-run] remove ${targetPath}`);
+    return;
+  }
 
-  if (tarballsDir) {
-    const specs = { ...defaults };
-    const packageDirBySlug = {
-      'rs-x-core': path.join(tarballsDir, 'rs-x-core'),
-      'rs-x-state-manager': path.join(tarballsDir, 'rs-x-state-manager'),
-      'rs-x-expression-parser': path.join(
-        tarballsDir,
-        'rs-x-expression-parser',
-      ),
-      'rs-x-compiler': path.join(tarballsDir, 'rs-x-compiler'),
-      'rs-x-typescript-plugin': path.join(
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+function resolveProjectTsConfig(projectRoot) {
+  const appTsConfigPath = path.join(projectRoot, 'tsconfig.app.json');
+  if (fs.existsSync(appTsConfigPath)) {
+    return appTsConfigPath;
+  }
+
+  return path.join(projectRoot, 'tsconfig.json');
+}
+
+function resolveAngularProjectTsConfig(projectRoot) {
+  return resolveProjectTsConfig(projectRoot);
+}
+
+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}`;
+  return `file:${normalized}`;
+}
+
+function findLatestTarball(packageDir, packageSlug) {
+  if (!fs.existsSync(packageDir)) {
+    return null;
+  }
+
+  const candidates = [];
+  const stack = [packageDir];
+
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+
+      if (
+        entry.isFile() &&
+        entry.name.startsWith(`${packageSlug}-`) &&
+        entry.name.endsWith('.tgz')
+      ) {
+        candidates.push(fullPath);
+      }
+    }
+  }
+
+  candidates.sort();
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  return candidates[candidates.length - 1];
+}
+
+function resolveProjectRsxSpecs(
+  projectRoot,
+  workspaceRoot,
+  tarballsDir,
+  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,
+    '@rs-x/state-manager': versionSpec,
+    '@rs-x/expression-parser': versionSpec,
+    '@rs-x/compiler': versionSpec,
+    '@rs-x/typescript-plugin': versionSpec,
+    ...(includeAngularPackage ? { '@rs-x/angular': versionSpec } : {}),
+    ...(includeReactPackage ? { '@rs-x/react': versionSpec } : {}),
+    ...(includeVuePackage ? { '@rs-x/vue': versionSpec } : {}),
+    '@rs-x/cli': versionSpec,
+  };
+
+  const tarballSlugs = {
+    '@rs-x/core': 'rs-x-core',
+    '@rs-x/state-manager': 'rs-x-state-manager',
+    '@rs-x/expression-parser': 'rs-x-expression-parser',
+    '@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',
+  };
+
+  if (tarballsDir) {
+    const specs = { ...defaults };
+    const packageDirBySlug = {
+      'rs-x-core': path.join(tarballsDir, 'rs-x-core'),
+      'rs-x-state-manager': path.join(tarballsDir, 'rs-x-state-manager'),
+      'rs-x-expression-parser': path.join(
+        tarballsDir,
+        'rs-x-expression-parser',
+      ),
+      'rs-x-compiler': path.join(tarballsDir, 'rs-x-compiler'),
+      'rs-x-typescript-plugin': path.join(
         tarballsDir,
         'rs-x-typescript-plugin',
       ),
@@ -674,6 +1684,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 +1731,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 +1808,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(
@@ -945,8 +1992,9 @@ function applyVueRsxTemplate(projectRoot, dryRun) {
 async function runProject(flags) {
   const dryRun = Boolean(flags['dry-run']);
   const skipInstall = Boolean(flags['skip-install']);
-  const pm = detectPackageManager(flags.pm);
-  const tag = resolveInstallTag(flags);
+  const invocationRoot = process.cwd();
+  const pm = resolveCliPackageManager(invocationRoot, flags.pm);
+  const tag = resolveConfiguredInstallTag(invocationRoot, flags);
   let projectName = typeof flags.name === 'string' ? flags.name.trim() : '';
 
   if (!projectName) {
@@ -961,7 +2009,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'])
@@ -1051,135 +2099,676 @@ export const sampleExpression = rsx('a + b')(model);
     `import { sampleExpression } from './expressions/sample.expression';
 import { initRsx } from './rsx-bootstrap';
 
-async function main(): Promise<void> {
-  await initRsx();
-  console.log('RS-X sample expression initialized:', Boolean(sampleExpression));
-}
+async function main(): Promise<void> {
+  await initRsx();
+  console.log('RS-X sample expression initialized:', Boolean(sampleExpression));
+}
+
+void main();
+`,
+    dryRun,
+  );
+
+  if (!skipInstall) {
+    const installArgsByPm = {
+      pnpm: ['install'],
+      npm: ['install'],
+      yarn: ['install'],
+      bun: ['install'],
+    };
+    const installArgs = installArgsByPm[pm];
+    if (!installArgs) {
+      logError(`Unsupported package manager: ${pm}`);
+      process.exit(1);
+    }
+
+    logInfo(`Installing dependencies with ${pm}...`);
+    run(pm, installArgs, { dryRun, cwd: projectRoot });
+    logOk('Dependencies installed.');
+  } else {
+    logInfo('Skipping dependency install (--skip-install).');
+  }
+
+  logOk(`Created RS-X project: ${projectRoot}`);
+  logInfo('Next steps:');
+  console.log(`  cd ${projectName}`);
+  if (skipInstall) {
+    console.log('  npm install');
+  }
+  console.log('  npm run build');
+  console.log('  npm run start');
+}
+
+async function resolveProjectName(nameFromFlags, fallbackName) {
+  const fromFlags =
+    typeof nameFromFlags === 'string' ? nameFromFlags.trim() : '';
+  if (fromFlags.length > 0) {
+    return fromFlags;
+  }
+
+  const fromFallback =
+    typeof fallbackName === 'string' ? fallbackName.trim() : '';
+  if (fromFallback.length > 0) {
+    return fromFallback;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    return await askUntilNonEmpty(rl, 'Project name: ');
+  } finally {
+    rl.close();
+  }
+}
+
+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 = [
+      '-y',
+      '@angular/cli@latest',
+      'new',
+      projectName,
+      '--directory',
+      scaffoldProjectArg,
+      '--defaults',
+      '--standalone',
+      '--routing',
+      '--style',
+      'css',
+      '--skip-git',
+    ];
+    if (skipInstall) {
+      args.push('--skip-install');
+    }
+    run('npx', args, { dryRun, cwd: scaffoldCwd, env: scaffoldEnv });
+    return;
+  }
+
+  if (template === 'react') {
+    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',
+        scaffoldProjectArg,
+        '--no-interactive',
+        '--template',
+        'vue-ts',
+      ],
+      {
+        dryRun,
+        cwd: scaffoldCwd,
+        env: scaffoldEnv,
+      },
+    );
+    return;
+  }
+
+  if (template === 'nextjs') {
+    const packageManagerFlagByPm = {
+      npm: '--use-npm',
+      pnpm: '--use-pnpm',
+      yarn: '--use-yarn',
+      bun: '--use-bun',
+    };
+    const args = [
+      'create-next-app@latest',
+      scaffoldProjectArg,
+      '--yes',
+      '--ts',
+      '--app',
+      '--eslint',
+      '--import-alias',
+      '@/*',
+      packageManagerFlagByPm[pm] ?? '--use-npm',
+    ];
+    if (skipInstall) {
+      args.push('--skip-install');
+    }
+    run('npx', args, { dryRun, cwd: scaffoldCwd, env: scaffoldEnv });
+    return;
+  }
+
+  logError(`Unknown project template: ${template}`);
+  process.exit(1);
+}
+
+function applyAngularDemoStarter(projectRoot, projectName, pm, flags) {
+  const dryRun = Boolean(flags['dry-run']);
+  ensureRsxConfigFile(projectRoot, 'angular', dryRun);
+  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,
+    );
+  }
+
+  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 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);
+  }
+
+  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.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] patch ${packageJsonPath}`);
+  } else {
+    fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}\n`,
+      'utf8',
+    );
+  }
+
+  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']);
+  ensureRsxConfigFile(projectRoot, 'react', dryRun);
+  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.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']);
+  ensureRsxConfigFile(projectRoot, 'vuejs', dryRun);
+  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,
+    );
+  }
 
-void main();
-`,
-    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);
+  }
 
-  if (!skipInstall) {
-    const installArgsByPm = {
-      pnpm: ['install'],
-      npm: ['install'],
-      yarn: ['install'],
-      bun: ['install'],
-    };
-    const installArgs = installArgsByPm[pm];
-    if (!installArgs) {
-      logError(`Unsupported package manager: ${pm}`);
-      process.exit(1);
+  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');
     }
-
-    logInfo(`Installing dependencies with ${pm}...`);
-    run(pm, installArgs, { dryRun, cwd: projectRoot });
-    logOk('Dependencies installed.');
-  } else {
-    logInfo('Skipping dependency install (--skip-install).');
   }
 
-  logOk(`Created RS-X project: ${projectRoot}`);
-  logInfo('Next steps:');
-  console.log(`  cd ${projectName}`);
-  if (skipInstall) {
-    console.log('  npm install');
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    logError(`package.json not found in generated Vue app: ${packageJsonPath}`);
+    process.exit(1);
   }
-  console.log('  npm run build');
-  console.log('  npm run start');
-}
 
-async function resolveProjectName(nameFromFlags, fallbackName) {
-  const fromFlags =
-    typeof nameFromFlags === 'string' ? nameFromFlags.trim() : '';
-  if (fromFlags.length > 0) {
-    return fromFlags;
+  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.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 fromFallback =
-    typeof fallbackName === 'string' ? fallbackName.trim() : '';
-  if (fromFallback.length > 0) {
-    return fromFallback;
+  const tsConfigAppPath = path.join(projectRoot, 'tsconfig.app.json');
+  if (fs.existsSync(tsConfigAppPath)) {
+    upsertTypescriptPluginInTsConfig(tsConfigAppPath, dryRun);
+    ensureTsConfigIncludePattern(tsConfigAppPath, 'src/**/*.d.ts', dryRun);
   }
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  try {
-    return await askUntilNonEmpty(rl, 'Project name: ');
-  } finally {
-    rl.close();
+  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 scaffoldProjectTemplate(template, projectName, pm, flags) {
+function applyNextDemoStarter(projectRoot, projectName, pm, flags) {
   const dryRun = Boolean(flags['dry-run']);
-  const skipInstall = Boolean(flags['skip-install']);
+  ensureRsxConfigFile(projectRoot, 'nextjs', dryRun);
+  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 },
+  );
 
-  if (template === 'angular') {
-    const args = [
-      '-y',
-      '@angular/cli@latest',
-      'new',
-      projectName,
-      '--defaults',
-      '--standalone',
-      '--routing',
-      '--style',
-      'css',
-      '--skip-git',
-    ];
-    if (skipInstall) {
-      args.push('--skip-install');
+  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');
     }
-    run('npx', args, { dryRun });
-    return;
   }
 
-  if (template === 'react') {
-    run('npx', ['create-vite@latest', projectName, '--template', 'react-ts'], {
-      dryRun,
-    });
-    return;
+  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);
   }
 
-  if (template === 'vuejs') {
-    run('npx', ['create-vite@latest', projectName, '--template', 'vue-ts'], {
-      dryRun,
-    });
-    return;
+  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.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',
+    );
   }
 
-  if (template === 'nextjs') {
-    const packageManagerFlagByPm = {
-      npm: '--use-npm',
-      pnpm: '--use-pnpm',
-      yarn: '--use-yarn',
-      bun: '--use-bun',
-    };
-    const args = [
-      'create-next-app@latest',
-      projectName,
-      '--yes',
-      '--ts',
-      '--app',
-      '--eslint',
-      '--import-alias',
-      '@/*',
-      packageManagerFlagByPm[pm] ?? '--use-npm',
-    ];
-    if (skipInstall) {
-      args.push('--skip-install');
-    }
-    run('npx', args, { dryRun });
-    return;
+  const tsConfigPath = path.join(projectRoot, 'tsconfig.json');
+  if (fs.existsSync(tsConfigPath)) {
+    upsertTypescriptPluginInTsConfig(tsConfigPath, dryRun);
   }
 
-  logError(`Unknown project template: ${template}`);
-  process.exit(1);
+  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) {
@@ -1196,15 +2785,22 @@ async function runProjectWithTemplate(template, flags) {
     return;
   }
 
-  const pm = detectPackageManager(flags.pm);
+  const invocationRoot = process.cwd();
+  const pm = resolveCliPackageManager(invocationRoot, flags.pm);
   const projectName = await resolveProjectName(flags.name, flags._nameHint);
-  const projectRoot = path.resolve(process.cwd(), projectName);
+  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, pm, flags);
+  scaffoldProjectTemplate(
+    normalizedTemplate,
+    projectName,
+    projectRoot,
+    pm,
+    flags,
+  );
   const dryRun = Boolean(flags['dry-run']);
   if (dryRun) {
     logInfo(`[dry-run] setup RS-X in ${projectRoot}`);
@@ -1213,40 +2809,221 @@ async function runProjectWithTemplate(template, flags) {
 
   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);
+    }
+  });
+
+  verifyGeneratedProject(projectRoot, normalizedTemplate);
+  if (resolveCliVerifyFlag(invocationRoot, flags, 'project')) {
+    logInfo('Re-running starter verification (--verify)...');
+    verifyGeneratedProject(projectRoot, normalizedTemplate);
+  }
+
+  logOk(`Created RS-X ${normalizedTemplate} project: ${projectRoot}`);
+  logInfo('Next steps:');
+  console.log(`  cd ${projectName}`);
+  if (Boolean(flags['skip-install'])) {
+    console.log(`  ${pm} install`);
+  }
+  if (normalizedTemplate === 'angular') {
+    console.log(`  ${pm} run start`);
+  } else {
+    console.log(`  ${pm} run dev`);
+  }
+}
+
+function verifyGeneratedProject(projectRoot, template) {
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    logError(`Generated project is missing package.json: ${packageJsonPath}`);
+    process.exit(1);
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const scripts = packageJson.scripts ?? {};
+  const dependencies = {
+    ...(packageJson.dependencies ?? {}),
+    ...(packageJson.devDependencies ?? {}),
+  };
+
+  const expectationsByTemplate = {
+    angular: {
+      scripts: ['build:rsx', 'start'],
+      dependencies: [
+        '@rs-x/angular',
+        '@rs-x/compiler',
+        '@rs-x/typescript-plugin',
+      ],
+      files: [
+        'src/main.ts',
+        'src/app/app.component.ts',
+        'src/app/virtual-table/virtual-table.component.ts',
+      ],
+    },
+    react: {
+      scripts: ['build:rsx', 'dev', 'build'],
+      dependencies: [
+        '@rs-x/react',
+        '@rs-x/compiler',
+        '@rs-x/typescript-plugin',
+      ],
+      files: [
+        'src/main.tsx',
+        'src/rsx-bootstrap.ts',
+        'src/app/app.tsx',
+        'src/app/virtual-table/virtual-table-shell.tsx',
+      ],
+    },
+    vuejs: {
+      scripts: ['build:rsx', 'dev', 'build'],
+      dependencies: ['@rs-x/vue', '@rs-x/compiler', '@rs-x/typescript-plugin'],
+      files: [
+        'src/main.ts',
+        'src/App.vue',
+        'src/lib/rsx-bootstrap.ts',
+        'src/components/VirtualTableShell.vue',
+      ],
+    },
+    nextjs: {
+      scripts: ['build:rsx', 'dev', 'build'],
+      dependencies: [
+        '@rs-x/react',
+        '@rs-x/compiler',
+        '@rs-x/typescript-plugin',
+      ],
+      files: [
+        'app/layout.tsx',
+        'app/page.tsx',
+        'components/demo-app.tsx',
+        'lib/rsx-bootstrap.ts',
+      ],
+    },
+  };
+
+  const expected = expectationsByTemplate[template];
+  if (!expected) {
+    return;
+  }
+
+  for (const scriptName of expected.scripts) {
+    if (
+      typeof scripts[scriptName] !== 'string' ||
+      scripts[scriptName].trim() === ''
+    ) {
+      logError(
+        `Generated ${template} project is missing script "${scriptName}" in package.json.`,
+      );
+      process.exit(1);
+    }
+  }
+
+  for (const dependencyName of expected.dependencies) {
+    if (typeof dependencies[dependencyName] !== 'string') {
+      logError(
+        `Generated ${template} project is missing dependency "${dependencyName}" in package.json.`,
+      );
+      process.exit(1);
+    }
+  }
+
+  for (const relativeFilePath of expected.files) {
+    const absoluteFilePath = path.join(projectRoot, relativeFilePath);
+    if (!fs.existsSync(absoluteFilePath)) {
+      logError(
+        `Generated ${template} project is missing expected file: ${absoluteFilePath}`,
+      );
+      process.exit(1);
+    }
+  }
+
+  const rsxConfigPath = path.join(projectRoot, 'rsx.config.json');
+  if (!fs.existsSync(rsxConfigPath)) {
+    logError(
+      `Generated ${template} project is missing expected file: ${rsxConfigPath}`,
+    );
+    process.exit(1);
+  }
+
+  logOk(`Verified generated ${template} project structure.`);
+}
+
+function verifySetupOutput(projectRoot, template) {
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    logError(`Project is missing package.json: ${packageJsonPath}`);
+    process.exit(1);
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const scripts = packageJson.scripts ?? {};
+
+  const setupExpectations = {
+    react: {
+      scripts: ['build:rsx', 'typecheck:rsx', 'dev', 'build'],
+      files: ['vite.config.ts', 'src/rsx-bootstrap.ts'],
+    },
+    vuejs: {
+      scripts: ['build:rsx', 'typecheck:rsx', 'dev', 'build'],
+      files: ['vite.config.ts', 'src/rsx-bootstrap.ts'],
+    },
+    next: {
+      scripts: ['build:rsx', 'typecheck:rsx', 'dev', 'build'],
+      files: [
+        'next.config.js',
+        'rsx-webpack-loader.cjs',
+        'app/rsx-bootstrap.ts',
+      ],
+    },
+    angular: {
+      scripts: ['build:rsx', 'typecheck:rsx', 'prebuild', 'start'],
+      files: ['src/main.ts', 'angular.json'],
+    },
+  };
+
+  const expected = setupExpectations[template];
+  if (!expected) {
+    return;
+  }
+
+  for (const scriptName of expected.scripts) {
+    if (
+      typeof scripts[scriptName] !== 'string' ||
+      scripts[scriptName].trim() === ''
+    ) {
+      logError(
+        `Setup output is missing script "${scriptName}" in package.json.`,
+      );
+      process.exit(1);
     }
-  });
+  }
 
-  logOk(`Created RS-X ${normalizedTemplate} project: ${projectRoot}`);
-  logInfo('Next steps:');
-  console.log(`  cd ${projectName}`);
-  if (Boolean(flags['skip-install'])) {
-    console.log(`  ${pm} install`);
+  for (const relativeFilePath of expected.files) {
+    const absoluteFilePath = path.join(projectRoot, relativeFilePath);
+    if (!fs.existsSync(absoluteFilePath)) {
+      logError(`Setup output is missing expected file: ${absoluteFilePath}`);
+      process.exit(1);
+    }
   }
-  if (normalizedTemplate === 'angular') {
-    console.log(`  ${pm} run start`);
-  } else {
-    console.log(`  ${pm} run dev`);
+
+  const rsxConfigPath = path.join(projectRoot, 'rsx.config.json');
+  if (!fs.existsSync(rsxConfigPath)) {
+    logError(`Setup output is missing expected file: ${rsxConfigPath}`);
+    process.exit(1);
   }
+
+  logOk(`Verified ${template} setup output.`);
 }
 
 function detectProjectContext(projectRoot) {
@@ -1507,12 +3284,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(() => {
@@ -1726,15 +3503,14 @@ function patchEntryFileForRsx(entryFile, bootstrapFile, context, dryRun) {
 
 function runInit(flags) {
   const dryRun = Boolean(flags['dry-run']);
-  const skipVscode = Boolean(flags['skip-vscode']);
   const skipInstall = Boolean(flags['skip-install']);
-  const pm = detectPackageManager(flags.pm);
-  const tag = resolveInstallTag(flags);
   const projectRoot = process.cwd();
+  const pm = resolveCliPackageManager(projectRoot, flags.pm);
+  const tag = resolveConfiguredInstallTag(projectRoot, flags);
 
   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,13 +3564,179 @@ function runInit(flags) {
     }
   }
 
-  if (!skipVscode) {
-    installVsCodeExtension(flags);
-  }
+  ensureRsxConfigFile(projectRoot, effectiveContext, dryRun);
 
   logOk('RS-X init completed.');
 }
 
+function ensureAngularProvidersInEntry(entryFile, dryRun) {
+  if (!fs.existsSync(entryFile)) {
+    return false;
+  }
+
+  const original = fs.readFileSync(entryFile, 'utf8');
+
+  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 bootstrapCallMatch = original.match(
+    /bootstrapApplication\(\s*([A-Za-z_$][\w$]*)\s*(?:,\s*([A-Za-z_$][\w$]*|\{[\s\S]*?\}))?\s*\)/mu,
+  );
+  const componentIdentifier = bootstrapCallMatch?.[1] ?? null;
+  const configArgument = bootstrapCallMatch?.[2] ?? null;
+  const configImportIdentifier =
+    configArgument && /^[A-Za-z_$][\w$]*$/u.test(configArgument)
+      ? configArgument
+      : original.includes('appConfig')
+        ? 'appConfig'
+        : null;
+
+  const staticImportPattern = new RegExp(
+    String.raw`^\s*import\s+\{\s*([^}]*)\b${componentIdentifier ?? ''}\b([^}]*)\}\s+from\s+['"]([^'"]+)['"];\s*$`,
+    'mu',
+  );
+  const componentImportMatch = componentIdentifier
+    ? original.match(staticImportPattern)
+    : null;
+  const dynamicComponentImportMatch = componentIdentifier
+    ? original.match(
+        new RegExp(
+          String.raw`const\s+\{\s*${componentIdentifier}\s*\}\s*=\s*await\s+import\('([^']+)'\);`,
+          'mu',
+        ),
+      )
+    : null;
+  const componentImportPath =
+    componentImportMatch?.[3] ?? dynamicComponentImportMatch?.[1] ?? null;
+
+  const configImportMatch = configImportIdentifier
+    ? original.match(
+        new RegExp(
+          String.raw`^\s*import\s+\{\s*([^}]*)\b${configImportIdentifier}\b([^}]*)\}\s+from\s+['"]([^'"]+)['"];\s*$`,
+          'mu',
+        ),
+      )
+    : null;
+  const configImportPath = configImportMatch?.[3] ?? null;
+
+  const canPreloadBeforeComponentImport =
+    componentIdentifier !== null && componentImportPath !== null;
+
+  if (canPreloadBeforeComponentImport) {
+    const importLines = original
+      .split('\n')
+      .filter((line) => /^\s*import\s+/u.test(line))
+      .filter((line) => !line.match(staticImportPattern))
+      .filter((line) =>
+        configImportMatch
+          ? !line.match(
+              new RegExp(
+                String.raw`^\s*import\s+\{\s*([^}]*)\b${configImportIdentifier}\b([^}]*)\}\s+from\s+['"][^'"]+['"];\s*$`,
+                'u',
+              ),
+            )
+          : true,
+      )
+      .filter(
+        (line) =>
+          !line.includes("import { providexRsx } from '@rs-x/angular';"),
+      )
+      .filter(
+        (line) =>
+          !line.includes("import { InjectionContainer } from '@rs-x/core';"),
+      )
+      .filter(
+        (line) =>
+          !line.includes(
+            "import { RsXExpressionParserModule } from '@rs-x/expression-parser';",
+          ),
+      );
+
+    const bootstrapConfigExpression =
+      configImportPath && configImportIdentifier
+        ? `const [{ ${configImportIdentifier} }, { ${componentIdentifier} }] = await Promise.all([\n    import('${configImportPath}'),\n    import('${componentImportPath}'),\n  ]);\n\n  await bootstrapApplication(${componentIdentifier}, {\n    ...${configImportIdentifier},\n    providers: [...(${configImportIdentifier}.providers ?? []), ...providexRsx()],\n  });`
+        : `const { ${componentIdentifier} } = await import('${componentImportPath}');\n\n  await bootstrapApplication(${componentIdentifier}, {\n    providers: [...providexRsx()],\n  });`;
+
+    const rewritten = `${importLines.join('\n')}
+import { providexRsx } from '@rs-x/angular';
+import { InjectionContainer } from '@rs-x/core';
+import { RsXExpressionParserModule } from '@rs-x/expression-parser';
+
+const bootstrap = async (): Promise<void> => {
+  await InjectionContainer.load(RsXExpressionParserModule);
+  ${bootstrapConfigExpression}
+};
+
+void bootstrap().catch((error) => {
+  console.error(error);
+});
+`;
+
+    if (dryRun) {
+      logInfo(`[dry-run] patch ${entryFile} (providexRsx + preload)`);
+      return true;
+    }
+
+    fs.writeFileSync(entryFile, rewritten, 'utf8');
+    logOk(`Patched ${entryFile} to preload RS-X and include providexRsx.`);
+    return true;
+  }
+
+  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(
   projectRoot,
   scriptName,
@@ -1906,109 +3848,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 +3857,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,96 +3979,15 @@ ${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);
-  const tag = resolveInstallTag(flags);
   const projectRoot = process.cwd();
+  const pm = resolveCliPackageManager(projectRoot, flags.pm);
+  const tag = resolveConfiguredInstallTag(projectRoot, flags);
+  const reactTsConfigPath = resolveProjectTsConfig(projectRoot);
+  const reactTsConfigRelative = path
+    .relative(projectRoot, reactTsConfigPath)
+    .replace(/\\/gu, '/');
   const packageJsonPath = path.join(projectRoot, 'package.json');
   if (!fs.existsSync(packageJsonPath)) {
     logError(`package.json not found in ${projectRoot}`);
@@ -2266,124 +4010,318 @@ 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).');
   }
+  ensureRsxConfigFile(projectRoot, 'react', dryRun);
+  upsertScriptInPackageJson(
+    projectRoot,
+    'build:rsx',
+    `rsx build --project ${reactTsConfigRelative} --no-emit --prod`,
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'typecheck:rsx',
+    `rsx typecheck --project ${reactTsConfigRelative}`,
+    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);
+  if (resolveCliVerifyFlag(projectRoot, flags, 'setup')) {
+    verifySetupOutput(projectRoot, 'react');
   }
   logOk('RS-X React setup completed.');
 }
 
 function runSetupNext(flags) {
   const dryRun = Boolean(flags['dry-run']);
-  const pm = detectPackageManager(flags.pm);
-  const tag = resolveInstallTag(flags);
+  const projectRoot = process.cwd();
+  const pm = resolveCliPackageManager(projectRoot, flags.pm);
+  const tag = resolveConfiguredInstallTag(projectRoot, flags);
+  const nextTsConfigPath = resolveProjectTsConfig(projectRoot);
+  const nextTsConfigRelative = path
+    .relative(projectRoot, nextTsConfigPath)
+    .replace(/\\/gu, '/');
   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);
+  ensureRsxConfigFile(projectRoot, 'next', dryRun);
+  upsertScriptInPackageJson(
+    projectRoot,
+    'build:rsx',
+    `rsx build --project ${nextTsConfigRelative} --no-emit --prod`,
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'typecheck:rsx',
+    `rsx typecheck --project ${nextTsConfigRelative}`,
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'dev',
+    'npm run build:rsx && next dev',
+    dryRun,
+  );
+  upsertScriptInPackageJson(
+    projectRoot,
+    'build',
+    'npm run build:rsx && next build',
+    dryRun,
+  );
+  wireRsxNextWebpack(projectRoot, dryRun);
+  if (resolveCliVerifyFlag(projectRoot, flags, 'setup')) {
+    verifySetupOutput(projectRoot, 'next');
   }
   logOk('RS-X Next.js setup completed.');
 }
 
 function runSetupVue(flags) {
   const dryRun = Boolean(flags['dry-run']);
-  const pm = detectPackageManager(flags.pm);
-  const tag = resolveInstallTag(flags);
+  const projectRoot = process.cwd();
+  const pm = resolveCliPackageManager(projectRoot, flags.pm);
+  const tag = resolveConfiguredInstallTag(projectRoot, flags);
   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);
+  ensureRsxConfigFile(projectRoot, 'vuejs', dryRun);
+  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);
+  if (resolveCliVerifyFlag(projectRoot, flags, 'setup')) {
+    verifySetupOutput(projectRoot, 'vuejs');
   }
   logOk('RS-X Vue setup completed.');
 }
 
 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 pm = resolveCliPackageManager(projectRoot, flags.pm);
+  const tag = resolveConfiguredInstallTag(projectRoot, flags);
+  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);
+  ensureRsxConfigFile(projectRoot, 'angular', 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,
+  });
+
+  if (resolveCliVerifyFlag(projectRoot, flags, 'setup')) {
+    verifySetupOutput(projectRoot, 'angular');
   }
+
   logOk('RS-X Angular setup completed.');
 }
 
 function runSetupAuto(flags) {
   const projectRoot = process.cwd();
   const context = detectProjectContext(projectRoot);
-  const tag = resolveInstallTag(flags);
+  const tag = resolveConfiguredInstallTag(projectRoot, flags);
 
   if (context === 'react') {
     logInfo('Auto-detected framework: react');
@@ -2410,10 +4348,21 @@ 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);
+  const pm = resolveCliPackageManager(projectRoot, flags.pm);
+  installRuntimePackages(
+    pm,
+    Boolean(flags['dry-run']),
+    tag,
+    projectRoot,
+    flags,
+  );
+  installCompilerPackages(
+    pm,
+    Boolean(flags['dry-run']),
+    tag,
+    projectRoot,
+    flags,
+  );
 }
 
 function resolveProjectModule(projectRoot, moduleName) {
@@ -2430,8 +4379,13 @@ function runBuild(flags) {
   const dryRun = Boolean(flags['dry-run']);
   const noEmit = Boolean(flags['no-emit']);
   const prodMode = parseBooleanFlag(flags.prod, false);
+  const invocationConfig = resolveRsxBuildConfig(invocationRoot);
   const projectArg =
-    typeof flags.project === 'string' ? flags.project : 'tsconfig.json';
+    typeof flags.project === 'string'
+      ? flags.project
+      : typeof invocationConfig.tsconfig === 'string'
+        ? invocationConfig.tsconfig
+        : 'tsconfig.json';
   const configPath = path.resolve(invocationRoot, projectArg);
   const projectRoot = path.dirname(configPath);
   const context = detectProjectContext(projectRoot);
@@ -2530,7 +4484,9 @@ function runBuild(flags) {
   const outDirOverride =
     typeof flags['out-dir'] === 'string'
       ? path.resolve(projectRoot, flags['out-dir'])
-      : null;
+      : typeof rsxBuildConfig.outDir === 'string'
+        ? path.resolve(projectRoot, rsxBuildConfig.outDir)
+        : null;
   const outDir =
     outDirOverride ??
     parsedConfig.options.outDir ??
@@ -2978,9 +4934,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) =>
@@ -3047,20 +5008,286 @@ function ensureAngularPolyfillsContainsFile({
   logOk(`Updated angular.json to inject RS-X AOT runtime registration.`);
 }
 
-function resolveRsxBuildConfig(projectRoot) {
-  const packageJsonPath = path.join(projectRoot, 'package.json');
-  if (!fs.existsSync(packageJsonPath)) {
-    return {};
+function readJsonFileIfPresent(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
   }
 
   try {
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    const rsxConfig = packageJson.rsx ?? {};
-    const buildConfig = rsxConfig.build ?? {};
-    return typeof buildConfig === 'object' && buildConfig ? buildConfig : {};
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
   } catch {
-    return {};
+    return null;
+  }
+}
+
+function validateRsxConfigShape(config, filePath) {
+  if (typeof config !== 'object' || !config || Array.isArray(config)) {
+    logError(
+      `Invalid RS-X config in ${filePath}: expected a JSON object at the top level.`,
+    );
+    process.exit(1);
+  }
+
+  const build = config.build;
+  if (build !== undefined) {
+    if (typeof build !== 'object' || !build || Array.isArray(build)) {
+      logError(
+        `Invalid RS-X config in ${filePath}: "build" must be an object.`,
+      );
+      process.exit(1);
+    }
+
+    const stringKeys = ['preparseFile', 'compiledFile', 'registrationFile'];
+    const extraStringKeys = ['tsconfig', 'outDir'];
+    for (const key of extraStringKeys) {
+      if (build[key] !== undefined && typeof build[key] !== 'string') {
+        logError(
+          `Invalid RS-X config in ${filePath}: "build.${key}" must be a string.`,
+        );
+        process.exit(1);
+      }
+    }
+    for (const key of stringKeys) {
+      if (build[key] !== undefined && typeof build[key] !== 'string') {
+        logError(
+          `Invalid RS-X config in ${filePath}: "build.${key}" must be a string.`,
+        );
+        process.exit(1);
+      }
+    }
+
+    const booleanKeys = ['preparse', 'compiled', 'compiledResolvedEvaluator'];
+    for (const key of booleanKeys) {
+      if (build[key] !== undefined && typeof build[key] !== 'boolean') {
+        logError(
+          `Invalid RS-X config in ${filePath}: "build.${key}" must be a boolean.`,
+        );
+        process.exit(1);
+      }
+    }
+  }
+
+  const cli = config.cli;
+  if (cli !== undefined) {
+    if (typeof cli !== 'object' || !cli || Array.isArray(cli)) {
+      logError(`Invalid RS-X config in ${filePath}: "cli" must be an object.`);
+      process.exit(1);
+    }
+
+    const cliStringKeys = ['packageManager', 'installTag'];
+    for (const key of cliStringKeys) {
+      if (cli[key] !== undefined && typeof cli[key] !== 'string') {
+        logError(
+          `Invalid RS-X config in ${filePath}: "cli.${key}" must be a string.`,
+        );
+        process.exit(1);
+      }
+    }
+
+    if (
+      cli.packageManager !== undefined &&
+      !['pnpm', 'npm', 'yarn', 'bun'].includes(cli.packageManager)
+    ) {
+      logError(
+        `Invalid RS-X config in ${filePath}: "cli.packageManager" must be one of pnpm, npm, yarn, or bun.`,
+      );
+      process.exit(1);
+    }
+
+    if (
+      cli.installTag !== undefined &&
+      !['latest', 'next'].includes(cli.installTag)
+    ) {
+      logError(
+        `Invalid RS-X config in ${filePath}: "cli.installTag" must be "latest" or "next".`,
+      );
+      process.exit(1);
+    }
+
+    const cliBooleanSections = ['setup', 'project'];
+    for (const key of cliBooleanSections) {
+      if (cli[key] !== undefined) {
+        if (
+          typeof cli[key] !== 'object' ||
+          !cli[key] ||
+          Array.isArray(cli[key])
+        ) {
+          logError(
+            `Invalid RS-X config in ${filePath}: "cli.${key}" must be an object.`,
+          );
+          process.exit(1);
+        }
+        if (
+          cli[key].verify !== undefined &&
+          typeof cli[key].verify !== 'boolean'
+        ) {
+          logError(
+            `Invalid RS-X config in ${filePath}: "cli.${key}.verify" must be a boolean.`,
+          );
+          process.exit(1);
+        }
+      }
+    }
+
+    const add = cli.add;
+    if (add !== undefined) {
+      if (typeof add !== 'object' || !add || Array.isArray(add)) {
+        logError(
+          `Invalid RS-X config in ${filePath}: "cli.add" must be an object.`,
+        );
+        process.exit(1);
+      }
+
+      if (
+        add.defaultDirectory !== undefined &&
+        typeof add.defaultDirectory !== 'string'
+      ) {
+        logError(
+          `Invalid RS-X config in ${filePath}: "cli.add.defaultDirectory" must be a string.`,
+        );
+        process.exit(1);
+      }
+
+      if (add.searchRoots !== undefined) {
+        if (
+          !Array.isArray(add.searchRoots) ||
+          add.searchRoots.some((entry) => typeof entry !== 'string')
+        ) {
+          logError(
+            `Invalid RS-X config in ${filePath}: "cli.add.searchRoots" must be an array of strings.`,
+          );
+          process.exit(1);
+        }
+      }
+    }
+  }
+}
+
+function mergeRsxConfig(baseConfig, overrideConfig) {
+  const base = typeof baseConfig === 'object' && baseConfig ? baseConfig : {};
+  const override =
+    typeof overrideConfig === 'object' && overrideConfig ? overrideConfig : {};
+
+  return {
+    ...base,
+    ...override,
+    build: {
+      ...(typeof base.build === 'object' && base.build ? base.build : {}),
+      ...(typeof override.build === 'object' && override.build
+        ? override.build
+        : {}),
+    },
+    cli: {
+      ...(typeof base.cli === 'object' && base.cli ? base.cli : {}),
+      ...(typeof override.cli === 'object' && override.cli ? override.cli : {}),
+      add: {
+        ...(typeof base.cli?.add === 'object' && base.cli?.add
+          ? base.cli.add
+          : {}),
+        ...(typeof override.cli?.add === 'object' && override.cli?.add
+          ? override.cli.add
+          : {}),
+      },
+    },
+  };
+}
+
+function resolveRsxProjectConfig(projectRoot) {
+  const fileConfigPath = path.join(projectRoot, 'rsx.config.json');
+  const fileRsxConfig = readJsonFileIfPresent(fileConfigPath) ?? {};
+  validateRsxConfigShape(fileRsxConfig, fileConfigPath);
+  return mergeRsxConfig({}, fileRsxConfig);
+}
+
+function defaultCliAddConfigForTemplate(template) {
+  if (template === 'next' || template === 'nextjs') {
+    return {
+      defaultDirectory: 'app/expressions',
+      searchRoots: ['app', 'src', 'expressions'],
+    };
+  }
+
+  return {
+    defaultDirectory: 'src/expressions',
+    searchRoots: ['src', 'app', 'expressions'],
+  };
+}
+
+function defaultCliConfigForTemplate(template) {
+  return {
+    packageManager: 'npm',
+    installTag: 'next',
+    setup: {
+      verify: false,
+    },
+    project: {
+      verify: false,
+    },
+    add: defaultCliAddConfigForTemplate(template),
+  };
+}
+
+function defaultRsxBuildConfigForTemplate(template) {
+  if (template === 'next' || template === 'nextjs') {
+    return {
+      preparse: true,
+      preparseFile: 'app/rsx-generated/rsx-aot-preparsed.generated.ts',
+      compiled: true,
+      compiledFile: 'app/rsx-generated/rsx-aot-compiled.generated.ts',
+      registrationFile: 'app/rsx-generated/rsx-aot-registration.generated.ts',
+      compiledResolvedEvaluator: false,
+    };
+  }
+
+  return {
+    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,
+  };
+}
+
+function ensureRsxConfigFile(projectRoot, template, dryRun) {
+  const configPath = path.join(projectRoot, 'rsx.config.json');
+  const defaultConfig = {
+    build: defaultRsxBuildConfigForTemplate(template),
+    cli: defaultCliConfigForTemplate(template),
+  };
+
+  const existingConfig = readJsonFileIfPresent(configPath);
+  const nextConfig = mergeRsxConfig(defaultConfig, existingConfig ?? {});
+
+  if (
+    existingConfig &&
+    JSON.stringify(existingConfig) === JSON.stringify(nextConfig)
+  ) {
+    return false;
+  }
+
+  if (dryRun) {
+    logInfo(`[dry-run] ${existingConfig ? 'patch' : 'create'} ${configPath}`);
+    return true;
   }
+
+  fs.writeFileSync(
+    configPath,
+    `${JSON.stringify(nextConfig, null, 2)}\n`,
+    'utf8',
+  );
+  logOk(`${existingConfig ? 'Patched' : 'Created'} ${configPath}`);
+  return true;
+}
+
+function resolveRsxBuildConfig(projectRoot) {
+  const buildConfig = resolveRsxProjectConfig(projectRoot).build ?? {};
+  return typeof buildConfig === 'object' && buildConfig ? buildConfig : {};
+}
+
+function resolveRsxCliConfig(projectRoot) {
+  const cliConfig = resolveRsxProjectConfig(projectRoot).cli ?? {};
+  return typeof cliConfig === 'object' && cliConfig ? cliConfig : {};
 }
 
 function parseBooleanFlag(value, defaultValue) {
@@ -3121,7 +5348,7 @@ function printGeneralHelp() {
   console.log(
     '  typecheck               Type-check project + RS-X semantic checks',
   );
-  console.log('  version | -v            Print CLI version');
+  console.log('  version | v | -v        Print CLI version');
   console.log('');
   console.log('Help Aliases:');
   console.log('  rsx -h');
@@ -3155,14 +5382,28 @@ function printAddHelp() {
   console.log(
     '  - Prompts for expression export name (must be valid TS identifier)',
   );
+  console.log("  - Prompts for the initial expression string (default: 'a')");
+  console.log(
+    '  - Seeds the generated model with top-level identifiers found in that expression when possible',
+  );
   console.log(
     '  - Prompts whether file name should be kebab-case (default: yes)',
   );
   console.log('  - Prompts for output directory (relative or absolute)');
-  console.log('  - Prompts whether to reuse an existing model file');
-  console.log('  - Creates <name>.ts and optionally creates <name>.model.ts');
   console.log(
-    '  - Expression file imports selected model and exports rsx expression',
+    '  - Prompts for add mode: new one-file, new separate-model, or update existing',
+  );
+  console.log(
+    '  - Defaults to keeping the model in the same file as the expression',
+  );
+  console.log(
+    '  - If you choose an existing file, shows a list of files that already contain RS-X expressions',
+  );
+  console.log(
+    '  - Can still create or reuse a separate model file when you opt out of same-file mode',
+  );
+  console.log(
+    '  - Respects rsx.config.json (`cli.add`) for add defaults and file discovery',
   );
 }
 
@@ -3201,7 +5442,7 @@ function printInstallHelp(target) {
 function printSetupHelp() {
   console.log('Usage:');
   console.log(
-    '  rsx setup [--pm <pnpm|npm|yarn|bun>] [--next] [--force] [--local] [--dry-run]',
+    '  rsx setup [--pm <pnpm|npm|yarn|bun>] [--next] [--verify] [--force] [--local] [--dry-run]',
   );
   console.log('');
   console.log('What it does:');
@@ -3210,12 +5451,17 @@ function printSetupHelp() {
   );
   console.log('  - Installs runtime packages');
   console.log('  - Installs compiler tooling packages');
-  console.log('  - Installs VS Code extension');
+  console.log('  - Writes rsx.build config plus build/typecheck scripts');
+  console.log('  - Creates rsx.config.json with CLI defaults you can override');
   console.log('  - Applies framework-specific transform/build integration');
+  console.log('  - Does not install the VS Code extension automatically');
   console.log('');
   console.log('Options:');
   console.log('  --pm        Explicit package manager');
   console.log('  --next      Install prerelease versions (dist-tag next)');
+  console.log(
+    '  --verify    Validate the resulting setup output before returning',
+  );
   console.log('  --force     Reinstall extension if already installed');
   console.log('  --local     Build/install local VSIX from repo workspace');
   console.log('  --dry-run   Print commands without executing them');
@@ -3234,14 +5480,17 @@ function printInitHelp() {
   console.log(
     '  - Detects project context and wires RS-X bootstrap in entry file',
   );
-  console.log('  - Installs VS Code extension (unless --skip-vscode)');
+  console.log('  - Creates rsx.config.json with CLI defaults you can override');
+  console.log('  - Does not install the VS Code extension automatically');
   console.log('');
   console.log('Options:');
   console.log('  --pm            Explicit package manager');
   console.log('  --entry         Explicit application entry file');
   console.log('  --next          Install prerelease versions (dist-tag next)');
   console.log('  --skip-install  Skip npm/pnpm/yarn/bun package installation');
-  console.log('  --skip-vscode   Skip VS Code extension installation');
+  console.log(
+    '  --skip-vscode   Accepted for compatibility; VS Code is not auto-installed',
+  );
   console.log('  --force         Reinstall extension if already installed');
   console.log('  --local         Build/install local VSIX from repo workspace');
   console.log('  --dry-run       Print commands without executing them');
@@ -3250,21 +5499,30 @@ function printInitHelp() {
 function printProjectHelp() {
   console.log('Usage:');
   console.log(
-    '  rsx project [angular|vuejs|react|nextjs|nodejs] [--name <project-name>] [--pm <pnpm|npm|yarn|bun>] [--next] [--template <angular|vuejs|react|nextjs|nodejs>] [--tarballs-dir <path>] [--skip-install] [--skip-vscode] [--dry-run]',
+    '  rsx project [angular|vuejs|react|nextjs|nodejs] [--name <project-name>] [--pm <pnpm|npm|yarn|bun>] [--next] [--template <angular|vuejs|react|nextjs|nodejs>] [--tarballs-dir <path>] [--skip-install] [--skip-vscode] [--verify] [--dry-run]',
   );
   console.log('');
   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(
+    '  - Creates rsx.config.json with starter CLI defaults you can override',
+  );
   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)');
+  console.log('  - Verifies the generated starter before reporting success');
   console.log('');
   console.log('Options:');
   console.log('  --name          Project folder/package name');
@@ -3278,7 +5536,12 @@ function printProjectHelp() {
   );
   console.log('                  (or set RSX_TARBALLS_DIR env var)');
   console.log('  --skip-install  Skip dependency installation');
-  console.log('  --skip-vscode   Skip VS Code extension installation');
+  console.log(
+    '  --skip-vscode   Accepted for compatibility; VS Code is not auto-installed',
+  );
+  console.log(
+    '  --verify       Re-run starter structure checks explicitly after generation',
+  );
   console.log('  --dry-run       Print actions without writing files');
 }
 
@@ -3338,6 +5601,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 +5613,7 @@ function isHelpToken(value) {
 
 function isVersionToken(value) {
   return (
+    value === 'v' ||
     value === '-v' ||
     value === '--version' ||
     value === '-version' ||
@@ -3409,6 +5674,7 @@ function printHelpFor(command, target) {
   }
 
   if (
+    command === 'v' ||
     command === 'version' ||
     command === '-v' ||
     command === '--version' ||
@@ -3493,9 +5759,16 @@ function main() {
   }
 
   if (command === 'install' && target === 'compiler') {
-    const pm = detectPackageManager(flags.pm);
-    const tag = resolveInstallTag(flags);
-    installCompilerPackages(pm, Boolean(flags['dry-run']), tag);
+    const projectRoot = process.cwd();
+    const pm = resolveCliPackageManager(projectRoot, flags.pm);
+    const tag = resolveConfiguredInstallTag(projectRoot, flags);
+    installCompilerPackages(
+      pm,
+      Boolean(flags['dry-run']),
+      tag,
+      projectRoot,
+      flags,
+    );
     return;
   }