@js-recon/js-recon 1.3.2 → 1.4.1-alpha.10

package/build/refactor/index.js

@@ -9,15 +9,612 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import chalk from "chalk";
 import fs from "fs";
+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, listCollisionsFileHashes, 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`.
+ * Returns null if the assets directory cannot be determined or does not exist.
+ */
+function findAssetsDir(chunks, mappedJsonPath) {
+    var _a;
+    for (const chunk of Object.values(chunks)) {
+        const firstLine = ((_a = chunk.code) !== null && _a !== void 0 ? _a : "").split("\n")[0];
+        const urlMatch = firstLine.match(/\/\/ File Source: (https?:\/\/[^\s]+)/);
+        if (!urlMatch)
+            continue;
+        try {
+            const url = new URL(urlMatch[1]);
+            const port = url.port;
+            const hostname = url.hostname + (port ? `_${port}` : "");
+            const assetsDir = path.join(path.dirname(path.resolve(mappedJsonPath)), "output", hostname, "assets");
+            if (fs.existsSync(assetsDir))
+                return assetsDir;
+        }
+        catch (_b) {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Returns paths to .js files in `assetsDir` that are NOT covered by any chunk in `chunks`.
+ * Chunks cover a file when `path.basename(chunk.file)` matches the assets filename.
+ */
+function findVendorChunkFiles(chunks, assetsDir) {
+    const coveredFiles = new Set();
+    for (const chunk of Object.values(chunks)) {
+        if (chunk.file)
+            coveredFiles.add(path.basename(chunk.file));
+    }
+    return fs
+        .readdirSync(assetsDir)
+        .filter((f) => f.endsWith(".js") && !coveredFiles.has(f))
+        .map((f) => path.join(assetsDir, f));
+}
+// Maps a refactor tech to the scat-combo directory name in a baseline tree.
+// The directory name is the scat categories joined by "-" in the order they appear in
+// ALL_SCAT_CATEGORIES (matching the naming convention used by jsr-cs-mast-s-gen/experiment/csmast.mjs).
+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.
+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.
+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));
+};
+// Resolves `--collisions <path>` to a library signature set. Accepts:
+//   - a file path → reads directly (max-count signatures)
+//   - a standard directory → tries known candidate paths in order:
+//       <dir>/baselines/<tech>/<scat>/collisions.json
+//       <dir>/<tech>/<scat>/collisions.json
+//       <dir>/<scat>/collisions.json
+//       <dir>/collisions.json
+//   - a per-feature results directory → detects <dir>/<feature>/<scat>/collisions.json
+//       and intersects max-count signatures across all feature subdirs (reads only
+//       the relevant scat files, not the full dataset tree)
+const buildLibSigs = (input, tech, scatOverride) => {
+    if (!fs.existsSync(input))
+        return null;
+    const stat = fs.statSync(input);
+    const scat = scatOverride ? scatToDir(scatOverride) : BASELINE_SCAT_DIR[tech];
+    // Case 1: direct file path
+    if (stat.isFile()) {
+        return { sigs: loadCollisionsFile(input), desc: input };
+    }
+    // Case 2: standard directory candidates (existing layout)
+    const candidates = [
+        scat ? path.join(input, "baselines", tech, scat, "collisions.json") : null,
+        scat ? path.join(input, tech, scat, "collisions.json") : null,
+        scat ? path.join(input, scat, "collisions.json") : null,
+        path.join(input, "collisions.json"),
+    ].filter(Boolean);
+    for (const c of candidates) {
+        if (fs.existsSync(c) && fs.statSync(c).isFile()) {
+            return { sigs: loadCollisionsFile(c), desc: c };
+        }
+    }
+    // Case 3: per-feature results directory — <dir>/<feature>/<scat>/collisions.json
+    // Only the scat-relevant files are read (one per feature subdir), so memory usage
+    // stays low even when the full dataset tree is hundreds of gigabytes.
+    if (scat) {
+        const featureFiles = [];
+        for (const entry of fs.readdirSync(input, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const p = path.join(input, entry.name, scat, "collisions.json");
+            if (fs.existsSync(p))
+                featureFiles.push(p);
+        }
+        if (featureFiles.length > 0) {
+            // Intersect max-count signatures across all feature subdirs.
+            // A signature present in every feature's max-count set must come from
+            // code shared by all apps — i.e. library code.
+            let intersection = null;
+            for (const p of featureFiles) {
+                const sigs = loadCollisionsFile(p);
+                if (intersection === null) {
+                    intersection = sigs;
+                }
+                else {
+                    for (const sig of intersection) {
+                        if (!sigs.has(sig))
+                            intersection.delete(sig);
+                    }
+                }
+            }
+            if (intersection && intersection.size > 0) {
+                return {
+                    sigs: intersection,
+                    desc: `${input} (intersection of ${featureFiles.length} feature dirs)`,
+                };
+            }
+        }
+    }
+    return null;
+};
+// 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, _d, _e;
+    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];
+    if (!scatDir)
+        return null;
+    // Load and validate config.
+    const config = loadRefactorConfig();
+    const configWarnings = validateRefactorConfig(config);
+    for (const w of configWarnings) {
+        console.log(chalk.yellow(`[!] Refactor config warning: ${w}`));
+    }
+    // Validate cache files.
+    const cacheWarnings = validateCaches();
+    for (const w of cacheWarnings) {
+        console.log(chalk.yellow(`[!] Cache validation warning: ${w} (will refresh)`));
+    }
+    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);
+        }
+    }
+    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 (_f) {
+            // Custom path may not have sample_size; quality filter will be skipped (sampleSize=0)
+        }
+    }
+    else {
+        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();
+    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 = (_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 = (_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) {
+        console.log(chalk.yellow(`[!] No remote collisions files found for scat "${scatDir}" in branch "${branch}"`));
+        return null;
+    }
+    console.log(chalk.cyan(`[i] Loading ${matchingPaths.length} remote signature files (quality threshold: ${opts.signatureQuality}%)...`));
+    // Content-based cache validation: fetch the upstream tree's per-file hashes once per
+    // branch so each cache entry below can be checked against current dataset content
+    // instead of trusting its local age alone. Skipped entirely under --skip-cache-checks.
+    // A failure here (e.g. HF rate-limiting under concurrent load) must never abort the
+    // whole refactor run — fall back to an empty map, which degrades each cache-freshness
+    // check below to the pre-existing age-based TTL.
+    let remoteHashes = new Map();
+    if (!opts.skipCacheChecks) {
+        try {
+            remoteHashes = yield listCollisionsFileHashes(branch, scatDir);
+        }
+        catch (e) {
+            console.log(chalk.yellow(`[!] Could not fetch upstream content hashes for cache validation (${e.message}) — falling back to age-based cache checks.`));
+        }
+    }
+    let intersection = null;
+    let loadedCount = 0;
+    for (const relPath of matchingPaths) {
+        let records = null;
+        const remoteHash = (_d = remoteHashes.get(relPath)) !== null && _d !== void 0 ? _d : null;
+        // Check local signature cache first.
+        if (isSignatureCacheFresh(branch, relPath, opts.skipCacheChecks, remoteHash)) {
+            records = loadCachedSignature(branch, relPath);
+        }
+        if (records === null) {
+            // Fetch from remote.
+            const url = getHfRawUrl(branch, relPath);
+            records = yield fetchCollisionsJson(url);
+            if (records === null) {
+                // 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 = (_e = listCache === null || listCache === void 0 ? void 0 : listCache.branches) !== null && _e !== void 0 ? _e : {};
+                    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, remoteHash);
+        }
+        // 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) {
+            intersection = sigSet;
+        }
+        else {
+            for (const sig of intersection) {
+                if (!sigSet.has(sig))
+                    intersection.delete(sig);
+            }
+        }
+        loadedCount++;
+    }
+    if (!intersection || intersection.size === 0) {
+        console.log(chalk.red(`[!] Remote signatures loaded but intersection is empty — library stripping will find nothing to skip ` +
+            `(quality threshold may be too high, or every dataset entry fetched 0 records). ` +
+            `If this is unexpected, purge ~/.js-recon/refactor/{signature_cache,cs-mast-s-list-cache.json} and retry.`));
+        return null;
+    }
+    console.log(chalk.cyan(`[i] Loaded ${intersection.size} library signatures from remote (${loadedCount} files, bucket prefix: ${branch})`));
+    return { sigs: intersection, desc: `remote:${branch} (${loadedCount} files, quality>=${opts.signatureQuality}%)` };
+});
 const availableTechs = {
-    next: "Next.js",
-    react: "React",
+    "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,
+ * webpack.config.js, index.html), then runs `npm install` + `npm run build`
+ * as a build check.  Uses babel-loader so JSX in .js files is handled without
+ * renaming.
+ *
+ * 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, detectedVersion) {
+    var _a;
+    if (writtenFiles.length === 0)
+        return;
+    // Find the entry file: the module that calls createRoot().
+    const entryFile = (_a = writtenFiles.find((f) => {
+        try {
+            return fs.readFileSync(f, "utf8").includes("createRoot(");
+        }
+        catch (_a) {
+            return false;
+        }
+    })) !== 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,
+        devDependencies: {
+            "@babel/core": "^7.25.0",
+            "@babel/preset-env": "^7.25.0",
+            "@babel/preset-react": "^7.25.0",
+            "babel-loader": "^9.2.1",
+            "html-webpack-plugin": "^5.6.0",
+            webpack: "^5.95.0",
+            "webpack-cli": "^5.1.4",
+        },
+    };
+    fs.writeFileSync(path.join(outputDir, "package.json"), JSON.stringify(pkg, null, 2));
+    // webpack.config.js — babel-loader with preset-react handles JSX in .js files
+    const webpackConfig = `const path = require('path');
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+module.exports = {
+  mode: 'production',
+  entry: '${entryRelative}',
+  output: { path: path.resolve(__dirname, 'dist'), filename: 'bundle.js', clean: true },
+  module: {
+    rules: [{
+      test: /\\.jsx?$/,
+      exclude: /node_modules/,
+      use: {
+        loader: 'babel-loader',
+        options: {
+          presets: [
+            ['@babel/preset-env', { targets: 'defaults' }],
+            ['@babel/preset-react', { runtime: 'automatic' }],
+          ],
+        },
+      },
+    }],
+  },
+  resolve: { extensions: ['.js', '.jsx'] },
+  plugins: [new HtmlWebpackPlugin({ template: './index.html' })],
+};
+`;
+    fs.writeFileSync(path.join(outputDir, "webpack.config.js"), webpackConfig);
+    // index.html — HtmlWebpackPlugin injects the bundle script automatically
+    const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head><meta charset="UTF-8" /><title>Refactored App</title></head>
+  <body><div id="root"></div></body>
+</html>
+`;
+    fs.writeFileSync(path.join(outputDir, "index.html"), indexHtml);
+    console.log(chalk.cyan("[i] Installing dependencies..."));
+    try {
+        execSync("npm install", { cwd: outputDir, stdio: "inherit" });
+    }
+    catch (_b) {
+        console.log(chalk.red("[!] npm install failed — skipping build check"));
+        return;
+    }
+    console.log(chalk.cyan("[i] Running build check..."));
+    try {
+        execSync("npm run build", { cwd: outputDir, stdio: "inherit" });
+        console.log(chalk.green("[✓] Build check passed"));
+    }
+    catch (_c) {
+        console.log(chalk.red("[!] Build check failed — review output above"));
+    }
+}
+/**
+ * Scaffolds a minimal Vite project in `outputDir` and runs `npm install` + `npm run build`
+ * as a build check. Uses @vitejs/plugin-react so JSX in .js files is handled.
+ *
+ * The entry file is the first written file that contains `createRoot(`.
+ */
+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 = uniqueFiles.map((f) => {
+        if (!f.endsWith(".js"))
+            return f;
+        const jsxPath = f.replace(/\.js$/, ".jsx");
+        fs.renameSync(f, jsxPath);
+        return jsxPath;
+    });
+    // After renaming to .jsx, update relative dynamic imports inside each file:
+    // import('./Foo.js') → import('./Foo.jsx') — only for same-dir relative imports.
+    const outputFileBasenames = new Set(jsxFiles.map((f) => path.basename(f)));
+    for (const f of jsxFiles) {
+        let content = fs.readFileSync(f, "utf8");
+        // Replace ./Foo.js with ./Foo.jsx only when Foo.jsx exists as an output file.
+        content = content.replace(/(import\([`'"])(\.\/[^`'"]+?)\.js([`'"]\))/g, (_match, open, stem, close) => {
+            const candidate = path.basename(stem) + ".jsx";
+            return outputFileBasenames.has(candidate) ? `${open}${stem}.jsx${close}` : _match;
+        });
+        fs.writeFileSync(f, content);
+    }
+    const entryFile = (_a = jsxFiles.find((f) => {
+        try {
+            return fs.readFileSync(f, "utf8").includes("createRoot(");
+        }
+        catch (_a) {
+            return false;
+        }
+    })) !== 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,
+        devDependencies: {
+            "@vitejs/plugin-react": "^4.3.1",
+            vite: "^5.4.0",
+        },
+    };
+    fs.writeFileSync(path.join(outputDir, "package.json"), JSON.stringify(pkg, null, 2));
+    const viteConfig = `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+export default defineConfig({
+  plugins: [react()],
+  build: { rollupOptions: { input: '${entryRelative}' } },
+});
+`;
+    fs.writeFileSync(path.join(outputDir, "vite.config.js"), viteConfig);
+    const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head><meta charset="UTF-8" /><title>Refactored App</title></head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="${entryRelative}"></script>
+  </body>
+</html>
+`;
+    fs.writeFileSync(path.join(outputDir, "index.html"), indexHtml);
+    console.log(chalk.cyan("[i] Installing dependencies..."));
+    try {
+        execSync("npm install", { cwd: outputDir, stdio: "inherit" });
+    }
+    catch (_b) {
+        console.log(chalk.red("[!] npm install failed — skipping build check"));
+        return;
+    }
+    console.log(chalk.cyan("[i] Running Vite build check..."));
+    try {
+        execSync("npm run build", { cwd: outputDir, stdio: "inherit" });
+        console.log(chalk.green("[✓] Vite build check passed"));
+    }
+    catch (_c) {
+        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.
  *
@@ -31,20 +628,21 @@ const availableTechs = {
  * @param list - Whether to list available technologies instead of running refactoring
  * @returns Promise that resolves when refactoring is complete
  */
-const refactor = (mappedJson, outputDir, tech, list) => __awaiter(void 0, void 0, void 0, function* () {
+const refactor = (mappedJson, outputDir, tech, list, collisionsFile, remoteOpts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     console.log(chalk.cyan("[i] Loading refactor module..."));
-    // check if the file exists
-    if (!fs.existsSync(mappedJson)) {
-        console.error(chalk.red("[!] Mapped JSON file does not exist"));
-        process.exit(7);
-    }
     if (list) {
         console.log(chalk.cyan("[i] Listing available technologies"));
-        for (const tech of Object.keys(availableTechs)) {
-            console.log(chalk.green(`- ${tech}: ${availableTechs[tech]}`));
+        for (const key of Object.keys(availableTechs)) {
+            console.log(chalk.green(`- ${key}: ${availableTechs[key]}`));
         }
         return;
     }
+    // check if the file exists
+    if (!fs.existsSync(mappedJson)) {
+        console.error(chalk.red("[!] Mapped JSON file does not exist"));
+        process.exit(7);
+    }
     // verify if the tech provided is valid
     if (!Object.keys(availableTechs).includes(tech)) {
         console.error(chalk.red("[!] Invalid technology provided"));
@@ -60,24 +658,372 @@ const refactor = (mappedJson, outputDir, tech, list) => __awaiter(void 0, void 0
     }
     // read the mapped JSON file
     const chunks = JSON.parse(fs.readFileSync(mappedJson, "utf8"));
+    // Load CS-MAST cross-app baseline signatures.
+    // Priority: --collisions (local path) > remote HF (default) > none.
+    let libSigs;
+    let libStrippingSkipped = null;
+    if (collisionsFile) {
+        // Explicit local path — use existing resolver unchanged.
+        const result = buildLibSigs(collisionsFile, tech, remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.scat);
+        if (!result) {
+            console.log(chalk.red(`[!] Could not resolve library signatures from: ${collisionsFile}`));
+            const scat = BASELINE_SCAT_DIR[tech];
+            if (scat) {
+                console.log(chalk.red(`    accepted layouts:\n` +
+                    `      <file>                                           (direct collisions.json)\n` +
+                    `      <dir>/baselines/${tech}/${scat}/collisions.json\n` +
+                    `      <dir>/${tech}/${scat}/collisions.json\n` +
+                    `      <dir>/${scat}/collisions.json\n` +
+                    `      <dir>/collisions.json\n` +
+                    `      <dir>/<feature>/${scat}/collisions.json          (per-feature results dir)`));
+            }
+            process.exit(10);
+        }
+        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.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) {
+            libSigs = result.sigs;
+        }
+        else {
+            console.log(chalk.yellow(`[~] Remote signatures unavailable — proceeding without library stripping`));
+            const branch = (_e = (_d = opts.remoteCollisions) !== null && _d !== void 0 ? _d : TECH_TO_BRANCH[tech]) !== null && _e !== void 0 ? _e : "unknown";
+            const scatDir = opts.scat ? scatToDir(opts.scat) : ((_f = BASELINE_SCAT_DIR[tech]) !== null && _f !== void 0 ? _f : "unknown");
+            libStrippingSkipped = { tech, scat: scatDir, branch };
+        }
+    }
     // iterate through the chunks
-    for (const [key, value] of Object.entries(chunks)) {
-        let code;
-        if (tech === "next") {
-            code = yield refactorNext(value);
-        }
-        else if (tech === "react") {
-            code = yield refactorReact(value);
-        }
-        // prettify the code before writing
-        code = yield prettier.format(code, {
-            parser: "babel",
-            singleQuote: true,
-            trailingComma: "none",
+    if (tech === "next-turbopack") {
+        for (const [, value] of Object.entries(chunks)) {
+            const moduleFiles = yield refactorNext(value);
+            for (const [moduleId, rawCode] of Object.entries(moduleFiles)) {
+                const formatted = yield prettier.format(rawCode, {
+                    parser: "babel",
+                    singleQuote: true,
+                    trailingComma: "none",
+                });
+                // 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 (_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 === "react-webpack") {
+        // Sort chunks so the main bundle (contains library module definitions) is processed
+        // first.  Its libModuleMap is then available when processing lazy chunks that import
+        // those same library module IDs (e.g. 540=React, 848=jsx-runtime, 671=react-router-dom).
+        const sortedEntries = Object.entries(chunks).sort(([a], [b]) => {
+            const aIsLazy = /^\d+_/.test(a);
+            const bIsLazy = /^\d+_/.test(b);
+            if (!aIsLazy && bIsLazy)
+                return -1; // main bundle first
+            if (aIsLazy && !bIsLazy)
+                return 1;
+            return 0;
         });
-        // write the code to a file
-        fs.writeFileSync(`${outputDir}/${key}.js`, code);
-        console.log(chalk.green(`[i] Chunk ${key} written to ${outputDir}/${key}.js`));
+        // Accumulated library module map — grows as main bundles are processed.
+        // Passed to each subsequent chunk so lazy chunks can rewrite library imports.
+        const accLibModuleMap = new Map();
+        // Pre-scan vendor chunks from the assets directory that are not in mapped.json.
+        // These files (e.g. vendor-router.*.js, vendor-react-dom.*.js) contain library
+        // modules whose export maps must be classified before processing application chunks.
+        const assetsDir = findAssetsDir(chunks, mappedJson);
+        if (assetsDir) {
+            const vendorFiles = findVendorChunkFiles(chunks, assetsDir);
+            for (const vendorFile of vendorFiles) {
+                console.log(chalk.cyan(`[i] Pre-scanning vendor chunk: ${path.basename(vendorFile)}`));
+                const vendorCode = fs.readFileSync(vendorFile, "utf8");
+                const vendorChunk = {
+                    id: path.basename(vendorFile, ".js"),
+                    description: "",
+                    loadedOn: [],
+                    containsFetch: false,
+                    isAxiosLibrary: false,
+                    exports: [],
+                    callStack: [],
+                    code: vendorCode,
+                    imports: [],
+                    file: vendorFile,
+                };
+                const vendorResult = yield refactorReact(vendorChunk, undefined, undefined, true);
+                for (const [id, info] of vendorResult.libModuleMap) {
+                    accLibModuleMap.set(id, info);
+                    console.log(chalk.gray(`  [-] Vendor module ${id} → ${info.type} (${info.exportMap.size} exports)`));
+                }
+            }
+        }
+        if (remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.scat) {
+            console.log(chalk.cyan(`[i] Using custom scat config: ${remoteOpts.scat.join(",")}`));
+        }
+        const writtenFiles = [];
+        for (const [, value] of sortedEntries) {
+            const result = yield refactorReact(value, libSigs, accLibModuleMap, false, remoteOpts === null || remoteOpts === void 0 ? void 0 : remoteOpts.scat);
+            // Merge this chunk's library classifications into the accumulator.
+            for (const [id, info] of result.libModuleMap) {
+                accLibModuleMap.set(id, info);
+            }
+            for (const [moduleId, rawCode] of Object.entries(result.files)) {
+                const formatted = yield prettier.format(rawCode, {
+                    parser: "babel",
+                    singleQuote: true,
+                    trailingComma: "none",
+                });
+                // Skip writing empty files (e.g. index.js after webpack runtime stripping).
+                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);
+                writtenFiles.push(filePath);
+                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 (_k) {
+                            // 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, detectedVersion);
+    }
+    else if (tech === "react-vite") {
+        // 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 ? ((_g = chunkInfo.file) !== null && _g !== void 0 ? _g : 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(combined, {
+                    parser: "babel",
+                    singleQuote: true,
+                    trailingComma: "none",
+                });
+            }
+            catch (_l) {
+                formatted = combined;
+            }
+            if (formatted.trim().length === 0) {
+                console.log(chalk.gray(`[~] Chunk ${keys.join("+")} is empty after refactoring — skipping`));
+                continue;
+            }
+            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 (_m) {
+                    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 ? ((_h = chunkInfo.file) !== null && _h !== void 0 ? _h : 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 (_o) {
+                formatted = rawCode;
+            }
+            if (formatted.trim().length === 0) {
+                console.log(chalk.gray(`[~] Chunk ${chunkKey} is empty after refactoring — skipping`));
+                continue;
+            }
+            fs.writeFileSync(filePath, formatted);
+            console.log(chalk.green(`[✓] Chunk ${chunkKey} written to ${filePath}`));
+        }
+    }
+    if (libStrippingSkipped) {
+        const { tech: skippedTech, scat, branch } = libStrippingSkipped;
+        console.log(chalk.yellow.bold("=".repeat(60)));
+        console.log(chalk.yellow.bold("[!] LIBRARY STRIPPING WAS SKIPPED FOR THIS RUN"));
+        console.log(chalk.yellow(`    tech: ${skippedTech}  scat: ${scat}  branch: ${branch}`));
+        console.log(chalk.yellow("    No remote collisions data available — output includes library code."));
+        console.log(chalk.yellow.bold("=".repeat(60)));
     }
     console.log(chalk.green("[✓] Refactoring complete."));
 });