@shriyanss/js-recon 1.4.1-alpha.4 → 1.4.1-alpha.6

package/build/refactor/index.js

@@ -13,15 +13,19 @@ import path from "path";
 import { execSync } from "child_process";
 import prettier from "prettier";
 // Next.js
-import refactorNext from "./next/index.js";
+import refactorNext, { refactorNextWebpack } from "./next/index.js";
 // React
 import refactorReact from "./react/index.js";
 // React (Vite)
 import refactorVite from "./react-vite/index.js";
+// Vue
+import refactorVueWebpack from "./vue/index.js";
+import { refactorVueVite } from "./vue/vite.js";
 // Remote HuggingFace client + cache
-import { TECH_TO_BRANCH, getHfRawUrl, fetchCollisionsJson, listCollisionsFiles, validateRemoteBranch, getSampleSize, getTechnology, } from "./remote/hf-client.js";
-import { loadRefactorConfig, validateRefactorConfig } from "./remote/config.js";
+import { TECH_TO_BRANCH, getHfRawUrl, fetchCollisionsJson, listCollisionsFiles, validateRemoteBranch, validateRemotePath, getSampleSize, getTechnology, } from "./remote/hf-client.js";
+import { loadRefactorConfig, validateRefactorConfig, purgeDynamicVersionDetectionScatConfig, saveDynamicVersionDetectionScatConfig, } from "./remote/config.js";
 import { loadListCache, saveListCache, shouldRefreshListCache, loadCachedSignature, saveSignatureToCache, isSignatureCacheFresh, validateCaches, } from "./remote/cache.js";
+import { detectReactVersion, VERSION_TECH_TO_BUNDLER, listAvailableVersions, selectDynamicScatConfigs, validateStaticScatConfig, } from "./remote/version-detect.js";
 /**
  * Derives the assets directory from the URL embedded in any chunk's code comment.
  * Chunks have a header like `// File Source: http://localhost:3001/assets/foo.js`.
@@ -69,17 +73,18 @@ function findVendorChunkFiles(chunks, assetsDir) {
 const BASELINE_SCAT_DIR = {
     "react-webpack": "lit-decl-loop-cond",
     "react-vite": "lit-decl-loop-cond",
+    "next-webpack": "lit-decl-loop-cond",
 };
 // Canonical ordering of scat categories (matches ALL_SCAT_CATEGORIES in csmast.mjs).
 // Used when converting a user-supplied --scat list to a bucket directory name.
 const ALL_SCAT_CATEGORIES = ["lit", "id", "op", "decl", "loop", "cond", "name", "val", "op_name"];
 // Converts a scat list to the bucket directory name, preserving canonical category order.
-const scatToDir = (scat) => {
+export const scatToDir = (scat) => {
     const scatSet = new Set(scat);
     return ALL_SCAT_CATEGORIES.filter((c) => scatSet.has(c)).join("-") || scat.join("-");
 };
 // Parses a collisions.json file and returns signatures whose count equals the maximum.
-const loadCollisionsFile = (filePath) => {
+export const loadCollisionsFile = (filePath) => {
     const records = JSON.parse(fs.readFileSync(filePath, "utf8"));
     const maxCount = records.reduce((m, r) => (r.count > m ? r.count : m), 0);
     return new Set(records.filter((r) => r.count >= maxCount).map((r) => r.signature));
@@ -156,9 +161,12 @@ const buildLibSigs = (input, tech, scatOverride) => {
 };
 // Loads library signatures from the remote HuggingFace dataset.
 // Returns null if the branch is not configured for `tech` or if validation fails.
+// When opts.remoteCollisions is provided it is used directly as the bucket path,
+// bypassing the TECH_TO_BRANCH lookup and metadata-file validation.
+// Exits with code 25 if opts.remoteCollisions is set but the path does not exist.
 const loadRemoteLibSigs = (tech, opts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
-    const branch = TECH_TO_BRANCH[tech];
+    var _a, _b, _c, _d;
+    const branch = (_a = opts.remoteCollisions) !== null && _a !== void 0 ? _a : TECH_TO_BRANCH[tech];
     if (!branch)
         return null;
     const scatDir = opts.scat ? scatToDir(opts.scat) : BASELINE_SCAT_DIR[tech];
@@ -175,33 +183,60 @@ const loadRemoteLibSigs = (tech, opts) => __awaiter(void 0, void 0, void 0, func
     for (const w of cacheWarnings) {
         console.log(chalk.yellow(`[!] Cache validation warning: ${w} (will refresh)`));
     }
-    // Validate remote bucket prefix has required metadata files.
-    console.log(chalk.cyan(`[i] Validating remote bucket prefix "${branch}"...`));
-    const branchOk = yield validateRemoteBranch(branch);
-    if (!branchOk) {
-        console.log(chalk.red(`[!] Remote bucket prefix "${branch}" is missing required metadata (sample_size / technology). Skipping remote signatures.`));
-        return null;
+    if (opts.remoteCollisions) {
+        // User-supplied path: validate it exists in the HF bucket.
+        console.log(chalk.cyan(`[i] Validating remote dataset path "${branch}"...`));
+        const pathExists = yield validateRemotePath(branch);
+        if (!pathExists) {
+            console.error(chalk.red(`[!] Remote dataset path "${branch}" not found in the shriyanss/cs-mast-s-dataset bucket.`));
+            process.exit(25);
+        }
     }
-    // Verify the bucket prefix technology matches.
-    const remoteTech = yield getTechnology(branch);
-    if (remoteTech !== tech) {
-        console.log(chalk.red(`[!] Remote bucket prefix "${branch}" is for technology "${remoteTech}", not "${tech}". Skipping remote signatures.`));
-        return null;
+    else {
+        // Auto-detected branch: validate metadata files exist.
+        console.log(chalk.cyan(`[i] Validating remote bucket prefix "${branch}"...`));
+        const branchOk = yield validateRemoteBranch(branch);
+        if (!branchOk) {
+            console.log(chalk.red(`[!] Remote bucket prefix "${branch}" is missing required metadata (sample_size / technology). Skipping remote signatures.`));
+            return null;
+        }
+        // Verify the bucket prefix technology matches.
+        const remoteTech = yield getTechnology(branch);
+        if (remoteTech !== tech) {
+            console.log(chalk.red(`[!] Remote bucket prefix "${branch}" is for technology "${remoteTech}", not "${tech}". Skipping remote signatures.`));
+            return null;
+        }
+    }
+    // Try to load the sample size for quality filtering.
+    // Custom paths may not have a sample_size file; fall back to 0 (skip quality filter).
+    let sampleSize = 0;
+    if (opts.remoteCollisions) {
+        try {
+            sampleSize = yield getSampleSize(branch);
+        }
+        catch (_e) {
+            // Custom path may not have sample_size; quality filter will be skipped (sampleSize=0)
+        }
+    }
+    else {
+        sampleSize = yield getSampleSize(branch);
     }
-    const sampleSize = yield getSampleSize(branch);
     // Build / refresh file list cache.
+    // Also refresh if the specific branch is not yet in the cache (e.g. first run
+    // with a new --remote-collisions path, or a new tech added after initial cache).
     let listCache = cacheWarnings.length > 0 ? null : loadListCache();
-    if (shouldRefreshListCache(listCache, opts)) {
+    const branchMissingFromCache = !(listCache === null || listCache === void 0 ? void 0 : listCache.branches[branch]);
+    if (shouldRefreshListCache(listCache, opts) || branchMissingFromCache) {
         console.log(chalk.cyan(`[i] Refreshing remote file list cache for bucket prefix "${branch}"...`));
         const paths = yield listCollisionsFiles(branch, scatDir);
         const now = Date.now();
-        const branches = (_a = listCache === null || listCache === void 0 ? void 0 : listCache.branches) !== null && _a !== void 0 ? _a : {};
+        const branches = (_b = listCache === null || listCache === void 0 ? void 0 : listCache.branches) !== null && _b !== void 0 ? _b : {};
         branches[branch] = paths;
         listCache = { generatedAt: now, branches };
         saveListCache(listCache);
         console.log(chalk.cyan(`[i] File list cache updated: ${paths.length} files found`));
     }
-    const filePaths = (_b = listCache === null || listCache === void 0 ? void 0 : listCache.branches[branch]) !== null && _b !== void 0 ? _b : [];
+    const filePaths = (_c = listCache === null || listCache === void 0 ? void 0 : listCache.branches[branch]) !== null && _c !== void 0 ? _c : [];
     // Filter to only paths that match <something>/<scatDir>/collisions.json
     const matchingPaths = filePaths.filter((p) => p.endsWith(`/${scatDir}/collisions.json`));
     if (matchingPaths.length === 0) {
@@ -222,21 +257,34 @@ const loadRemoteLibSigs = (tech, opts) => __awaiter(void 0, void 0, void 0, func
             const url = getHfRawUrl(branch, relPath);
             records = yield fetchCollisionsJson(url);
             if (records === null) {
-                // 404 or error — invalidate list cache unless skip-cache-checks.
-                if (!opts.skipCacheChecks) {
+                // 404 or network error.
+                // For user-specified --remote-collisions paths the list is stable;
+                // just skip this file and continue without poisoning the list cache.
+                // For auto-detected branches, invalidate the list cache so a stale
+                // entry (e.g. a deleted file) is not tried again on the next run.
+                if (!opts.remoteCollisions && !opts.skipCacheChecks) {
                     console.log(chalk.yellow(`[!] Could not fetch ${relPath} (404 or error) — refreshing list cache`));
                     const freshPaths = yield listCollisionsFiles(branch, scatDir);
-                    const updatedBranches = (_c = listCache === null || listCache === void 0 ? void 0 : listCache.branches) !== null && _c !== void 0 ? _c : {};
+                    const updatedBranches = (_d = listCache === null || listCache === void 0 ? void 0 : listCache.branches) !== null && _d !== void 0 ? _d : {};
                     updatedBranches[branch] = freshPaths;
                     saveListCache({ generatedAt: Date.now(), branches: updatedBranches });
                     listCache = { generatedAt: Date.now(), branches: updatedBranches };
                 }
+                else {
+                    console.log(chalk.yellow(`[!] Could not fetch ${relPath} — skipping`));
+                }
                 continue;
             }
             saveSignatureToCache(branch, relPath, records, config.maxCacheSizeMb);
         }
-        // Apply signature quality filter: (count / sampleSize) * 100 >= threshold
-        const filtered = records.filter((r) => sampleSize > 0 && (r.count / sampleSize) * 100 >= opts.signatureQuality);
+        // Apply signature quality filter: (count / sampleSize) * 100 >= threshold.
+        // When sampleSize is 0 (no sample_size file on the remote path), skip quality
+        // filtering and include all records.
+        const filtered = sampleSize === 0 ? records : records.filter((r) => (r.count / sampleSize) * 100 >= opts.signatureQuality);
+        // Skip feature dirs with no records — they indicate missing/empty dataset
+        // entries and would collapse the intersection to zero if included.
+        if (filtered.length === 0)
+            continue;
         // Intersect with previous sets.
         const sigSet = new Set(filtered.map((r) => r.signature));
         if (intersection === null) {
@@ -258,9 +306,12 @@ const loadRemoteLibSigs = (tech, opts) => __awaiter(void 0, void 0, void 0, func
     return { sigs: intersection, desc: `remote:${branch} (${loadedCount} files, quality>=${opts.signatureQuality}%)` };
 });
 const availableTechs = {
-    next: "Next.js",
+    "next-turbopack": "Next.js (Turbopack)",
+    "next-webpack": "Next.js (webpack)",
     "react-webpack": "React (webpack)",
     "react-vite": "React (Vite)",
+    "vue-webpack": "Vue.js (webpack)",
+    "vue-vite": "Vue.js (Vite)",
 };
 /**
  * Scaffolds a minimal webpack project in `outputDir` (package.json,
@@ -271,7 +322,7 @@ const availableTechs = {
  * The entry file is the first written file that contains `createRoot(` — i.e.
  * the app entry point.  If no such file is found, the first written file is used.
  */
-function runBuildCheck(outputDir, writtenFiles) {
+function runBuildCheck(outputDir, writtenFiles, detectedVersion) {
     var _a;
     if (writtenFiles.length === 0)
         return;
@@ -286,16 +337,23 @@ function runBuildCheck(outputDir, writtenFiles) {
     })) !== null && _a !== void 0 ? _a : writtenFiles[0];
     const entryRelative = `./${path.basename(entryFile)}`;
     console.log(chalk.cyan(`[i] Setting up webpack build check in ${outputDir}/ (entry: ${entryRelative})`));
+    // Use detected React version when available, fall back to React 18.
+    const reactVersion = detectedVersion ? `^${detectedVersion.reactNpm}` : "^18.3.1";
+    const reactDomVersion = (detectedVersion === null || detectedVersion === void 0 ? void 0 : detectedVersion.reactDomNpm)
+        ? `^${detectedVersion.reactDomNpm}`
+        : detectedVersion
+            ? undefined // pre-0.14: no react-dom
+            : "^18.3.1";
+    if (detectedVersion) {
+        console.log(chalk.cyan(`[i] Using detected React version ${detectedVersion.versionKey} in package.json (react@${reactVersion})`));
+    }
+    const dependencies = Object.assign(Object.assign({ react: reactVersion }, (reactDomVersion ? { "react-dom": reactDomVersion } : {})), { "react-router-dom": "^6.27.0" });
     // package.json — no "type": "module" so webpack.config.js can use CommonJS require
     const pkg = {
         name: "refactored-app",
         version: "1.0.0",
         scripts: { build: "webpack" },
-        dependencies: {
-            react: "^18.3.1",
-            "react-dom": "^18.3.1",
-            "react-router-dom": "^6.27.0",
-        },
+        dependencies,
         devDependencies: {
             "@babel/core": "^7.25.0",
             "@babel/preset-env": "^7.25.0",
@@ -365,13 +423,17 @@ module.exports = {
  *
  * The entry file is the first written file that contains `createRoot(`.
  */
-function runViteBuildCheck(outputDir, writtenFiles) {
+function runViteBuildCheck(outputDir, writtenFiles, detectedVersion) {
     var _a;
     if (writtenFiles.length === 0)
         return;
+    // Deduplicate — callers should not pass duplicates, but guard here too so a
+    // duplicate does not cause the renameSync below to throw ENOENT on the
+    // second occurrence of the same path.
+    const uniqueFiles = [...new Set(writtenFiles)];
     // Rename .js files to .jsx — Vite's import analysis can't parse JSX in .js files,
     // and refactored Vite chunks always contain JSX. The original source files were .jsx.
-    const jsxFiles = writtenFiles.map((f) => {
+    const jsxFiles = uniqueFiles.map((f) => {
         if (!f.endsWith(".js"))
             return f;
         const jsxPath = f.replace(/\.js$/, ".jsx");
@@ -400,16 +462,23 @@ function runViteBuildCheck(outputDir, writtenFiles) {
     })) !== null && _a !== void 0 ? _a : jsxFiles[0];
     const entryRelative = `./${path.basename(entryFile)}`;
     console.log(chalk.cyan(`[i] Setting up Vite build check in ${outputDir}/ (entry: ${entryRelative})`));
+    // Use detected React version when available, fall back to React 18.
+    const reactVersion = detectedVersion ? `^${detectedVersion.reactNpm}` : "^18.3.1";
+    const reactDomVersion = (detectedVersion === null || detectedVersion === void 0 ? void 0 : detectedVersion.reactDomNpm)
+        ? `^${detectedVersion.reactDomNpm}`
+        : detectedVersion
+            ? undefined
+            : "^18.3.1";
+    if (detectedVersion) {
+        console.log(chalk.cyan(`[i] Using detected React version ${detectedVersion.versionKey} in package.json (react@${reactVersion})`));
+    }
+    const dependencies = Object.assign(Object.assign({ react: reactVersion }, (reactDomVersion ? { "react-dom": reactDomVersion } : {})), { "react-router-dom": "^6.27.0" });
     const pkg = {
         name: "refactored-app",
         version: "1.0.0",
         type: "module",
         scripts: { build: "vite build" },
-        dependencies: {
-            react: "^18.3.1",
-            "react-dom": "^18.3.1",
-            "react-router-dom": "^6.27.0",
-        },
+        dependencies,
         devDependencies: {
             "@vitejs/plugin-react": "^4.3.1",
             vite: "^5.4.0",
@@ -451,6 +520,83 @@ export default defineConfig({
         console.log(chalk.red("[!] Vite build check failed — review output above"));
     }
 }
+/**
+ * Resolves the scat dir list to use for version detection based on the user's options.
+ * Returns an empty array when version detection should be skipped (e.g., invalid static config).
+ *
+ * Dynamic mode (default):
+ *   - Reads cached dynamic scat configs from ~/.js-recon/refactor/config.json.
+ *   - If --detect-version-dynamic-conf-purge is set, clears the cache first.
+ *   - If no cached configs exist, runs selectDynamicScatConfigs() and saves the result.
+ *
+ * Static mode (user passes comma-separated categories):
+ *   - Validates that reliable_signatures.json is non-empty for all known versions.
+ *   - Exits with code 26 if the config is invalid or empty for any version.
+ */
+function resolveVersionDetectionScatDirs(bundler, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const detectConfig = (_a = opts.detectVersionConfig) !== null && _a !== void 0 ? _a : "dynamic";
+        if (detectConfig === "dynamic") {
+            if (opts.detectVersionDynamicConfPurge) {
+                console.log(chalk.cyan("[i] Version detection: purging cached dynamic scat config..."));
+                purgeDynamicVersionDetectionScatConfig();
+            }
+            const cfg = loadRefactorConfig();
+            if (cfg.dynamicVersionDetectionScatConfig && cfg.dynamicVersionDetectionScatConfig.length > 0) {
+                console.log(chalk.cyan(`[i] Version detection: using cached dynamic scat config (${cfg.dynamicVersionDetectionScatConfig.join(", ")})`));
+                return cfg.dynamicVersionDetectionScatConfig;
+            }
+            // No cached config — discover versions and run dynamic selection.
+            let versions;
+            try {
+                versions = yield listAvailableVersions(bundler);
+            }
+            catch (e) {
+                console.log(chalk.yellow(`[!] Version detection: could not list versions (${String(e)})`));
+                return [];
+            }
+            if (versions.length === 0) {
+                console.log(chalk.yellow(`[!] Version detection: no version data found for ${bundler}`));
+                return [];
+            }
+            const threshold = Math.max(1, (_b = opts.detectVersionDynamicThreshold) !== null && _b !== void 0 ? _b : 3);
+            const selected = yield selectDynamicScatConfigs(bundler, versions, threshold);
+            if (selected.length > 0) {
+                saveDynamicVersionDetectionScatConfig(selected);
+            }
+            else {
+                console.log(chalk.yellow(`[!] Version detection: dynamic selection found no valid scat configs`));
+            }
+            return selected;
+        }
+        // Static config: parse comma-separated scat categories and convert to bucket dir name.
+        const categories = detectConfig
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        const scatDir = scatToDir(categories);
+        if (!scatDir) {
+            console.log(chalk.red(`[!] --detect-version-config "${detectConfig}" produced an empty scat dir; check category names`));
+            process.exit(26);
+        }
+        // Validate by checking that reliable_signatures.json is non-empty for all versions.
+        let versions;
+        try {
+            versions = yield listAvailableVersions(bundler);
+        }
+        catch (e) {
+            console.log(chalk.yellow(`[!] Version detection: could not list versions to validate static config (${String(e)})`));
+            return [];
+        }
+        const valid = yield validateStaticScatConfig(bundler, versions, scatDir);
+        if (!valid) {
+            console.log(chalk.red(`[!] --detect-version-config "${detectConfig}" (scat dir: "${scatDir}") has empty reliable_signatures.json for one or more versions. Cannot use for version detection.`));
+            process.exit(26);
+        }
+        return [scatDir];
+    });
+}
 /**
  * Refactors JavaScript code chunks based on technology-specific patterns.
  *
@@ -465,7 +611,7 @@ export default defineConfig({
  * @returns Promise that resolves when refactoring is complete
  */
 const refactor = (mappedJson, outputDir, tech, list, collisionsFile, remoteOpts) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     console.log(chalk.cyan("[i] Loading refactor module..."));
     if (list) {
         console.log(chalk.cyan("[i] Listing available technologies"));
@@ -517,12 +663,15 @@ const refactor = (mappedJson, outputDir, tech, list, collisionsFile, remoteOpts)
         libSigs = result.sigs;
         console.log(chalk.cyan(`[i] Loaded ${libSigs.size} library signatures from ${result.desc}`));
     }
-    else if (!(remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.noRemote) && TECH_TO_BRANCH[tech]) {
-        // Default: load from remote HuggingFace dataset.
+    else if ((remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.remoteCollisions) || (!(remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.noRemote) && TECH_TO_BRANCH[tech])) {
+        // Load from remote HuggingFace dataset.
+        // --remote-collisions uses the explicit path; otherwise falls back to TECH_TO_BRANCH.
         const opts = {
             signatureQuality: (_a = remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.signatureQuality) !== null && _a !== void 0 ? _a : 100,
             refreshCache: (_b = remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.refreshCache) !== null && _b !== void 0 ? _b : false,
             skipCacheChecks: (_c = remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.skipCacheChecks) !== null && _c !== void 0 ? _c : false,
+            remoteCollisions: remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.remoteCollisions,
+            scat: remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.scat,
         };
         const result = yield loadRemoteLibSigs(tech, opts);
         if (result) {
@@ -533,7 +682,7 @@ const refactor = (mappedJson, outputDir, tech, list, collisionsFile, remoteOpts)
         }
     }
     // iterate through the chunks
-    if (tech === "next") {
+    if (tech === "next-turbopack") {
         for (const [, value] of Object.entries(chunks)) {
             const moduleFiles = yield refactorNext(value);
             for (const [moduleId, rawCode] of Object.entries(moduleFiles)) {
@@ -542,8 +691,42 @@ const refactor = (mappedJson, outputDir, tech, list, collisionsFile, remoteOpts)
                     singleQuote: true,
                     trailingComma: "none",
                 });
-                fs.writeFileSync(`${outputDir}/${moduleId}.js`, formatted);
-                console.log(chalk.green(`[✓] Module ${moduleId} written to ${outputDir}/${moduleId}.js`));
+                // Skip writing empty files
+                if (formatted.trim().length === 0) {
+                    console.log(chalk.gray(`[~] Module ${moduleId} is empty after stripping — skipping`));
+                    continue;
+                }
+                const filePath = `${outputDir}/${moduleId}.js`;
+                fs.writeFileSync(filePath, formatted);
+                console.log(chalk.green(`[✓] Module ${moduleId} written to ${filePath}`));
+            }
+        }
+    }
+    else if (tech === "next-webpack") {
+        if (remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.scat) {
+            console.log(chalk.cyan(`[i] Using custom scat config: ${remoteOpts.scat.join(",")}`));
+        }
+        for (const [, value] of Object.entries(chunks)) {
+            const moduleFiles = yield refactorNextWebpack(value, libSigs, remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.scat);
+            for (const [moduleId, rawCode] of Object.entries(moduleFiles)) {
+                let formatted;
+                try {
+                    formatted = yield prettier.format(rawCode, {
+                        parser: "babel",
+                        singleQuote: true,
+                        trailingComma: "none",
+                    });
+                }
+                catch (_f) {
+                    formatted = rawCode;
+                }
+                if (formatted.trim().length === 0) {
+                    console.log(chalk.gray(`[~] Module ${moduleId} is empty after stripping — skipping`));
+                    continue;
+                }
+                const filePath = `${outputDir}/${moduleId}.js`;
+                fs.writeFileSync(filePath, formatted);
+                console.log(chalk.green(`[✓] Module ${moduleId} written to ${filePath}`));
             }
         }
     }
@@ -618,43 +801,199 @@ const refactor = (mappedJson, outputDir, tech, list, collisionsFile, remoteOpts)
                 console.log(chalk.green(`[✓] Module ${moduleId} written to ${outputDir}/${moduleId}.js`));
             }
         }
+        // Version detection — run before build check so the detected version can be
+        // written into package.json by runBuildCheck.
+        let detectedVersion;
+        if ((remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.detectVersion) && VERSION_TECH_TO_BUNDLER[tech]) {
+            const bundler = VERSION_TECH_TO_BUNDLER[tech];
+            const vScatDirs = yield resolveVersionDetectionScatDirs(bundler, remoteOpts);
+            if (vScatDirs.length > 0) {
+                // Include vendor chunk file contents (e.g. vendor-react-dom.*.js) that hold
+                // React library code but are not present in mapped.json.  Without these, the
+                // signature set contains only app-level code and misses version-specific React
+                // library signatures.
+                const vendorCodes = [];
+                const vDetectAssetsDir = findAssetsDir(chunks, mappedJson);
+                if (vDetectAssetsDir) {
+                    for (const vendorFile of findVendorChunkFiles(chunks, vDetectAssetsDir)) {
+                        try {
+                            vendorCodes.push(fs.readFileSync(vendorFile, "utf8"));
+                        }
+                        catch (_g) {
+                            // non-fatal
+                        }
+                    }
+                }
+                const vResult = yield detectReactVersion(chunks, tech, vScatDirs, vendorCodes.length > 0 ? vendorCodes : undefined);
+                if (vResult) {
+                    console.log(chalk.green(`[✓] Detected React version: ${vResult.versionKey} (${vResult.matchCount} signature matches)`));
+                    detectedVersion = vResult;
+                }
+                else {
+                    console.log(chalk.yellow(`[!] Version detection: no matching version found`));
+                }
+            }
+        }
         // Build check — scaffold a minimal webpack project and verify the refactored
         // code compiles.
-        runBuildCheck(outputDir, writtenFiles);
+        runBuildCheck(outputDir, writtenFiles, detectedVersion);
     }
     else if (tech === "react-vite") {
-        const viteFiles = yield refactorVite(chunks, libSigs);
-        const writtenFiles = [];
+        // Pre-scan vendor chunks from the assets directory that are not in mapped.json.
+        // Vendor chunks (vendor-react-*.js) are referenced by app chunks but are typically
+        // absent from mapped.json. Without them, vendorExportMaps is empty and vendor
+        // import statements are never rewritten — leaving unresolvable references in output.
+        const vitAssetsDir = findAssetsDir(chunks, mappedJson);
+        if (vitAssetsDir) {
+            const missingFiles = findVendorChunkFiles(chunks, vitAssetsDir);
+            for (const vendorFile of missingFiles) {
+                const basename = path.basename(vendorFile);
+                if (!/vendor[-_]react/i.test(basename) && !/rolldown[-_]runtime/i.test(basename))
+                    continue;
+                console.log(chalk.cyan(`[i] Including missing vendor chunk: ${basename}`));
+                const key = basename.replace(/\.js$/, "");
+                chunks[key] = {
+                    id: basename,
+                    description: "",
+                    loadedOn: [],
+                    containsFetch: false,
+                    isAxiosLibrary: false,
+                    exports: [],
+                    callStack: [],
+                    code: fs.readFileSync(vendorFile, "utf8"),
+                    imports: [],
+                    file: `assets/${basename}`,
+                };
+            }
+        }
+        const viteFiles = yield refactorVite(chunks, libSigs, remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.scat);
+        // Group chunk outputs by their output file path before writing.
+        // Multiple mapped.json sub-chunks can originate from the same Vite source
+        // file (one per top-level function detected by `map`). Writing each
+        // sub-chunk independently would overwrite previous writes so only the last
+        // sub-chunk would survive. Grouping and concatenating avoids the overwrite:
+        // all sub-chunks for the same file are merged into one formatted output.
+        const fileGroups = new Map();
         for (const [chunkKey, rawCode] of Object.entries(viteFiles)) {
+            // Use the original chunk basename so dynamic imports (which reference
+            // the original Vite filenames) resolve correctly in the build check.
+            const chunkInfo = chunks[chunkKey];
+            const originalFile = chunkInfo ? ((_d = chunkInfo.file) !== null && _d !== void 0 ? _d : chunkInfo.id) : null;
+            const outputBasename = originalFile
+                ? path.basename(originalFile)
+                : chunkKey.replace(/[/\\]/g, "_").replace(/\.js$/, "") + ".js";
+            const filePath = `${outputDir}/${outputBasename}`;
+            if (!fileGroups.has(filePath)) {
+                fileGroups.set(filePath, { codes: [], keys: [] });
+            }
+            fileGroups.get(filePath).codes.push(rawCode);
+            fileGroups.get(filePath).keys.push(chunkKey);
+        }
+        const writtenFiles = [];
+        for (const [filePath, { codes, keys }] of fileGroups) {
+            // Put import-bearing code parts first so ESM import statements end up
+            // at the top of the concatenated file. Helper sub-chunks typically have
+            // no imports; the component sub-chunk that has peer imports (e.g.
+            // from ./shared-*.js) must come first or the combined file is invalid.
+            const importBearing = codes.filter((c) => /^import\s/m.test(c));
+            const rest = codes.filter((c) => !/^import\s/m.test(c));
+            const combined = [...importBearing, ...rest].join("\n\n");
             let formatted;
             try {
-                formatted = yield prettier.format(rawCode, {
+                formatted = yield prettier.format(combined, {
                     parser: "babel",
                     singleQuote: true,
                     trailingComma: "none",
                 });
             }
-            catch (_e) {
-                formatted = rawCode;
+            catch (_h) {
+                formatted = combined;
             }
             if (formatted.trim().length === 0) {
-                console.log(chalk.gray(`[~] Chunk ${chunkKey} is empty after refactoring — skipping`));
+                console.log(chalk.gray(`[~] Chunk ${keys.join("+")} is empty after refactoring — skipping`));
                 continue;
             }
-            // Use the original chunk basename so dynamic imports (which reference
-            // the original Vite filenames) resolve correctly in the build check.
+            fs.writeFileSync(filePath, formatted);
+            // Push exactly once per output file — prevents duplicate entries in
+            // writtenFiles that would cause the rename loop in runViteBuildCheck
+            // to attempt renaming the same path twice (ENOENT on the second try).
+            writtenFiles.push(filePath);
+            for (const key of keys) {
+                console.log(chalk.green(`[✓] Chunk ${key} written to ${filePath}`));
+            }
+        }
+        // Version detection — run before build check so the detected version can be
+        // written into package.json by runViteBuildCheck.
+        let viteDetectedVersion;
+        if ((remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.detectVersion) && VERSION_TECH_TO_BUNDLER[tech]) {
+            const bundler = VERSION_TECH_TO_BUNDLER[tech];
+            const vScatDirs = yield resolveVersionDetectionScatDirs(bundler, remoteOpts);
+            if (vScatDirs.length > 0) {
+                const vResult = yield detectReactVersion(chunks, tech, vScatDirs);
+                if (vResult) {
+                    console.log(chalk.green(`[✓] Detected React version: ${vResult.versionKey} (${vResult.matchCount} signature matches)`));
+                    viteDetectedVersion = vResult;
+                }
+                else {
+                    console.log(chalk.yellow(`[!] Version detection: no matching version found`));
+                }
+            }
+        }
+        // Build check with Vite scaffold
+        runViteBuildCheck(outputDir, writtenFiles, viteDetectedVersion);
+    }
+    else if (tech === "vue-webpack") {
+        for (const [, value] of Object.entries(chunks)) {
+            const moduleFiles = yield refactorVueWebpack(value);
+            for (const [moduleId, rawCode] of Object.entries(moduleFiles)) {
+                let formatted;
+                try {
+                    formatted = yield prettier.format(rawCode, {
+                        parser: "babel",
+                        singleQuote: true,
+                        trailingComma: "none",
+                    });
+                }
+                catch (_j) {
+                    formatted = rawCode;
+                }
+                if (formatted.trim().length === 0) {
+                    console.log(chalk.gray(`[~] Module ${moduleId} is empty after stripping — skipping`));
+                    continue;
+                }
+                const filePath = `${outputDir}/${moduleId}.js`;
+                fs.writeFileSync(filePath, formatted);
+                console.log(chalk.green(`[✓] Module ${moduleId} written to ${filePath}`));
+            }
+        }
+    }
+    else if (tech === "vue-vite") {
+        const viteFiles = yield refactorVueVite(chunks);
+        for (const [chunkKey, rawCode] of Object.entries(viteFiles)) {
             const chunkInfo = chunks[chunkKey];
-            const originalFile = chunkInfo ? ((_d = chunkInfo.file) !== null && _d !== void 0 ? _d : chunkInfo.id) : null;
+            const originalFile = chunkInfo ? ((_e = chunkInfo.file) !== null && _e !== void 0 ? _e : chunkInfo.id) : null;
             const outputBasename = originalFile
                 ? path.basename(originalFile)
                 : chunkKey.replace(/[/\\]/g, "_").replace(/\.js$/, "") + ".js";
             const filePath = `${outputDir}/${outputBasename}`;
+            let formatted;
+            try {
+                formatted = yield prettier.format(rawCode, {
+                    parser: "babel",
+                    singleQuote: true,
+                    trailingComma: "none",
+                });
+            }
+            catch (_k) {
+                formatted = rawCode;
+            }
+            if (formatted.trim().length === 0) {
+                console.log(chalk.gray(`[~] Chunk ${chunkKey} is empty after refactoring — skipping`));
+                continue;
+            }
             fs.writeFileSync(filePath, formatted);
-            writtenFiles.push(filePath);
             console.log(chalk.green(`[✓] Chunk ${chunkKey} written to ${filePath}`));
         }
-        // Build check with Vite scaffold
-        runViteBuildCheck(outputDir, writtenFiles);
     }
     console.log(chalk.green("[✓] Refactoring complete."));
 });