prodex 1.3.0 → 1.4.1

package/dist/debug.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+(async () => {
+    const mockArgs = ["node", "prodex", "C:\\Users\\USER\\Herd\\fireshot", "-f", "**/(dashboard|accounts).tsx", "-cd"];
+    process.argv = mockArgs;
+    console.log("🧩 Debug runner starting...");
+    await (0, index_1.default)();
+    console.log("🧩 Debug runner done.");
+})();

package/dist/index.js

@@ -1,26 +1,55 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = startProdex;
-const combine_1 = require("./core/combine");
 const init_1 = require("./cli/init");
 const cli_input_1 = require("./cli/cli-input");
-const config_loader_1 = require("./constants/config-loader");
-require("./lib/polyfills");
-const summary_1 = require("./cli/summary");
-async function startProdex() {
-    const args = process.argv;
-    // Handle init mode
-    if (args.includes("init")) {
+const config_1 = require("./core/managers/config");
+const store_1 = require("./store");
+const combine_1 = require("./core/combine");
+async function startProdex(args = process.argv) {
+    if (args.includes("init"))
         return (0, init_1.initProdex)();
-    }
-    // Parse CLI input
     const { root, flags } = (0, cli_input_1.parseCliInput)(args);
-    // Load and merge configuration (with flag overrides)
-    const config = await (0, config_loader_1.loadProdexConfig)(flags, root);
-    (0, summary_1.introSummary)({ flags, config });
+    const userConfig = config_1.ConfigManager.load(root);
+    const config = config_1.ConfigManager.merge(userConfig, flags, root);
+    (0, store_1.setGlobals)(config, flags);
     const opts = {
         showUi: !flags.ci && !flags?.files?.length && !config?.entry?.ui?.enablePicker,
         cliName: config.name,
     };
+    await Promise.resolve().then(() => __importStar(require("./lib/polyfills")));
     await (0, combine_1.runCombine)({ cfg: config, opts });
 }

package/dist/lib/logger.js

@@ -1,14 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = void 0;
-const env = () => {
-    const obj = { debug: process.env.PRODEX_DEBUG === "1", silent: process.env.PRODEX_SILENT === "1" };
-    return obj;
-};
+const store_1 = require("../store");
+let FLAGS = null;
+let DEBUG = false;
+let SILENT = false;
+function ensureFlags() {
+    if (FLAGS)
+        return;
+    FLAGS = (0, store_1.getFlags)() || {};
+    DEBUG = !!FLAGS.debug;
+    SILENT = !!FLAGS.silent;
+}
 exports.logger = {
-    debug: (...args) => !env().silent && env().debug && console.log("\n🪶 [debug]", ...args),
-    info: (...args) => !env().silent && console.log("\n📌 [info]", ...args),
-    warn: (...args) => !env().silent && console.warn("\n⚠️  [warn]", ...args),
-    error: (...args) => !env().silent && console.error("\n💥 [error]", ...args),
-    log: (...args) => !env().silent && console.log("\n", ...args),
+    debug: (...a) => {
+        ensureFlags();
+        if (DEBUG && !SILENT)
+            console.log("\n🪶 [debug]", ...a);
+    },
+    info: (...a) => {
+        ensureFlags();
+        if (!SILENT)
+            console.log("\n📌 [info]", ...a);
+    },
+    warn: (...a) => {
+        ensureFlags();
+        if (!SILENT)
+            console.warn("\n⚠️  [warn]", ...a);
+    },
+    error: (...a) => {
+        ensureFlags();
+        if (!SILENT)
+            console.error("\n💥 [error]", ...a);
+    },
+    log: (...a) => {
+        ensureFlags();
+        if (!SILENT)
+            console.log("\n", ...a);
+    },
+    clear: () => console.clear(),
 };

package/dist/lib/polyfills.js

@@ -15,13 +15,3 @@ if (!String.prototype.clean) {
     };
 }
 globalThis._2j = (obj) => util_1.default.inspect(obj, { colors: true, depth: null, breakLength: 150, compact: 3 });
-globalThis._bpt = function (param) {
-    if (process.env.PRODEX_DEBUG !== "1")
-        return;
-    console.log("⭕ BREAKPOINT");
-    if (typeof param === "function")
-        param();
-    else
-        console.log(_2j(param));
-    process.exit(1);
-};

package/dist/lib/utils.js

@@ -1,21 +1,8 @@
 "use strict";
-// @ts-nocheck
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unique = unique;
-exports.setDiff = setDiff;
-exports.toArray = toArray;
 exports.shortTimestamp = shortTimestamp;
 exports.normalizePatterns = normalizePatterns;
 const config_1 = require("../constants/config");
-function unique(arr) {
-    return [...new Set(arr)];
-}
-function setDiff(A, B) {
-    return new Set([...A].filter((x) => !B.has(x)));
-}
-function toArray(v) {
-    return Array.isArray(v) ? v : [v];
-}
 /** Compact YYMMDD-HHmm timestamp for versioned filenames. */
 function shortTimestamp() {
     const d = new Date();

package/dist/{core/parsers → resolvers/js}/extract-imports.js

@@ -1,5 +1,4 @@
 "use strict";
-// @ts-nocheck
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -35,12 +34,7 @@ async function extractImports(filePath, code) {
     }
 }
 function fallbackRegex(code) {
-    const patterns = [
-        /import\s+[^'"]*['"]([^'"]+)['"]/g,
-        /import\(\s*['"]([^'"]+)['"]\s*\)/g,
-        /require\(\s*['"]([^'"]+)['"]\s*\)/g,
-        /export\s+\*\s+from\s+['"]([^'"]+)['"]/g,
-    ];
+    const patterns = [/import\s+[^'"]*['"]([^'"]+)['"]/g, /import\(\s*['"]([^'"]+)['"]\s*\)/g, /require\(\s*['"]([^'"]+)['"]\s*\)/g, /export\s+\*\s+from\s+['"]([^'"]+)['"]/g];
     const matches = new Set();
     for (const r of patterns) {
         let m;

package/dist/resolvers/js/js-resolver.js

@@ -1,153 +1,129 @@
 "use strict";
-// @ts-nocheck
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveJsImports = resolveJsImports;
-const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
-const micromatch_1 = __importDefault(require("micromatch"));
-const extract_imports_1 = require("../../core/parsers/extract-imports");
-const alias_loader_1 = require("./alias-loader");
+const extract_imports_1 = require("./extract-imports");
 const config_1 = require("../../constants/config");
-const utils_1 = require("../../lib/utils");
+const collections_1 = require("../../shared/collections");
 const logger_1 = require("../../lib/logger");
-const IMPORTS_CACHE = new Map();
-const STAT_CACHE = new Map();
-async function resolveJsImports(filePath, cfg, visited = new Set(), depth = 0, maxDepth = cfg?.resolve?.depth ?? 8, ctx = {}) {
-    if (depth >= maxDepth)
-        return empty(visited);
-    const ROOT = cfg.root;
-    const resolveCfg = cfg.resolve ?? {};
-    // Single exclude list, applied to RAW SPECIFIERS only.
-    const exclude = resolveCfg.exclude ?? [];
-    const isExcluded = micromatch_1.default.matcher(exclude);
+const store_1 = require("../../store");
+const resolve_alias_1 = require("./resolve-alias"); // alias: config + cache + fast-glob
+const cache_1 = require("../../core/managers/cache");
+const cache_keys_1 = require("../../constants/cache-keys");
+const shared_1 = require("../../shared");
+const shared_2 = require("../../shared");
+const { JS_STATS, JS_IMPORTS } = cache_keys_1.CACHE_KEYS;
+async function resolveJsImports({ filePath, visited = new Set(), depth = 0, maxDepth }) {
+    const limitDepth = maxDepth;
+    if (depth >= limitDepth)
+        return (0, collections_1.emptyResult)(visited);
     if (visited.has(filePath))
-        return empty(visited);
+        return (0, collections_1.emptyResult)(visited);
     visited.add(filePath);
+    const { root: ROOT, resolve: { exclude: excludePatterns }, } = (0, store_1.getConfig)();
     const ext = path_1.default.extname(filePath).toLowerCase();
     const isDts = ext === config_1.DTS_EXT;
     if (!config_1.BASE_EXTS.includes(ext) && !isDts)
-        return empty(visited);
-    let code;
-    try {
-        code = await promises_1.default.readFile(filePath, "utf8");
-    }
-    catch {
-        return empty(visited);
-    }
-    if (!ctx.aliases) {
-        ctx.aliases = { ...(0, alias_loader_1.loadProjectAliases)(ROOT), ...(resolveCfg.aliases || {}) };
-    }
-    const aliases = ctx.aliases;
-    const matches = await getImportsCached(filePath, code);
-    if (!matches.size)
-        return empty(visited);
-    const filesOut = [];
+        return (0, collections_1.emptyResult)(visited);
+    let code = (0, shared_1.readFileSafe)(filePath);
+    if (!code)
+        return (0, collections_1.emptyResult)(visited);
+    // Extract imports ---------------------------------------
+    const imports = await getImportsCached(filePath, code);
+    if (!imports.size)
+        return (0, collections_1.emptyResult)(visited);
+    // Trackers ----------------------------------------------
     const expected = new Set();
-    const resolvedSet = new Set();
-    for (const imp of matches) {
-        // Only consider relative, absolute, or known-alias specifiers
-        if (!imp.startsWith(".") && !imp.startsWith("/") && !startsWithAnyAlias(imp, aliases)) {
+    const resolved = new Set();
+    const files = [];
+    // Main resolution loop ----------------------------------
+    for (const imp of imports) {
+        // skip bare packages (react, lodash, etc.)
+        if (!imp.startsWith(".") && !imp.startsWith("/") && !imp.startsWith("@"))
             continue;
-        }
-        // Apply single exclude matcher to the RAW specifier
-        if (isExcluded(imp))
+        if ((0, shared_1.isExcluded)(imp, excludePatterns))
             continue;
-        // Always count valid, non-excluded specifiers as "expected"
-        expected.add(imp);
-        const basePath = resolveBasePath(filePath, imp, aliases);
-        if (!basePath)
+        let base = null;
+        if (imp.startsWith(".")) {
+            // relative → like original resolver
+            base = path_1.default.resolve(path_1.default.dirname(filePath), imp);
+        }
+        else if (imp.startsWith("/")) {
+            // absolute path import → like original resolver
+            base = path_1.default.resolve(imp);
+        }
+        else {
+            // alias (@...) → unified resolver (config + cache + glob)
+            base = await (0, resolve_alias_1.resolveAliasPath)(imp, ROOT, (0, store_1.getConfig)());
+        }
+        if (!base)
             continue;
-        const resolvedPath = await tryResolveImport(basePath, ROOT);
+        const absBase = path_1.default.resolve(base);
+        expected.add(absBase);
+        const resolvedPath = await tryResolveImport(absBase);
         if (!resolvedPath)
             continue;
-        filesOut.push(resolvedPath);
-        resolvedSet.add(imp);
-        // Never recurse into `.d.ts`
-        if (resolvedPath.toLowerCase().endsWith(config_1.DTS_EXT)) {
-            continue;
-            logger_1.logger.debug("HERE HERE");
-        }
-        const sub = await resolveJsImports(resolvedPath, cfg, visited, depth + 1, maxDepth, ctx);
-        if (sub.files.length)
-            filesOut.push(...sub.files);
-        for (const s of sub.stats.expected)
-            expected.add(s);
+        resolved.add(absBase);
+        files.push(resolvedPath);
+        // Recursive traversal
+        const sub = await resolveJsImports({
+            filePath: resolvedPath,
+            visited,
+            depth: depth + 1,
+            maxDepth: limitDepth,
+        });
+        files.push(...sub.files);
+        for (const e of sub.stats.expected)
+            expected.add(e);
         for (const r of sub.stats.resolved)
-            resolvedSet.add(r);
+            resolved.add(r);
     }
-    const uniqueFiles = [...new Set(filesOut)];
-    //Stat Log
-    const expCount = expected.size;
-    const resCount = resolvedSet.size;
-    const diff = (0, utils_1.setDiff)(expected, resolvedSet);
-    logger_1.logger.debug(`🪶 [js-resolver] ${filePath} → expected: ${expCount}, resolved: ${resCount}`);
-    logger_1.logger.debug([...diff], "🔴THE diff");
-    return { files: uniqueFiles, visited, stats: { expected, resolved: resolvedSet } };
-}
-// ---------- helpers ----------
-function startsWithAnyAlias(imp, aliases) {
-    return Object.keys(aliases).some((a) => imp === a || imp.startsWith(a + "/"));
+    const uniqueFiles = (0, collections_1.unique)(files);
+    const diff = (0, shared_2.setDiff)(expected, resolved);
+    logger_1.logger.debug(`🪶 [js-resolver] ${filePath} → expected: ${expected.size}, resolved: ${resolved.size}`);
+    if (diff.size)
+        logger_1.logger.debug([...diff], "🔴 THE diff");
+    return { files: uniqueFiles, visited, stats: { expected, resolved } };
 }
-function resolveBasePath(fromFile, specifier, aliases) {
-    if (specifier.startsWith("@")) {
-        const key = Object.keys(aliases)
-            .filter((a) => specifier === a || specifier.startsWith(a + "/"))
-            .sort((a, b) => b.length - a.length)[0];
-        if (!key)
-            return null;
-        const relPart = specifier.slice(key.length).replace(/^\/+/, "");
-        return path_1.default.resolve(aliases[key], relPart);
-    }
-    if (specifier.startsWith(".")) {
-        return path_1.default.resolve(path_1.default.dirname(fromFile), specifier);
-    }
-    if (specifier.startsWith("/")) {
-        return path_1.default.resolve(specifier);
-    }
-    return null;
-}
-async function tryResolveImport(basePath, ROOT) {
+// ---------------------------------------------------------
+// tryResolveImport (pure)
+// ---------------------------------------------------------
+async function tryResolveImport(basePath) {
     const candidates = [];
-    if (path_1.default.extname(basePath)) {
+    const ext = path_1.default.extname(basePath).toLowerCase();
+    if (ext && config_1.REAL_EXTS.has(ext)) {
         candidates.push(basePath);
     }
     else {
-        for (const ext of [...config_1.BASE_EXTS, config_1.DTS_EXT]) {
-            candidates.push(basePath + ext);
-            candidates.push(path_1.default.join(basePath, "index" + ext));
+        for (const e of [...config_1.BASE_EXTS, config_1.DTS_EXT]) {
+            candidates.push(basePath + e);
+            candidates.push(path_1.default.join(basePath, "index" + e));
         }
     }
-    for (const c of candidates) {
+    // Run all stat checks in parallel
+    const results = await Promise.allSettled(candidates.map(async (c) => {
         const abs = path_1.default.resolve(c);
-        const st = await safeStat(abs);
-        if (st && st.isFile())
-            return abs;
+        const st = await (0, shared_1.safeStatCached)(JS_STATS, abs);
+        return st && st.isFile() ? abs : null;
+    }));
+    // Find the first fulfilled non-null result
+    for (const r of results) {
+        if (r.status === "fulfilled" && r.value)
+            return r.value;
     }
     return null;
 }
-async function safeStat(p) {
-    if (STAT_CACHE.has(p))
-        return STAT_CACHE.get(p);
-    try {
-        const st = await promises_1.default.stat(p);
-        STAT_CACHE.set(p, st);
-        return st;
-    }
-    catch {
-        STAT_CACHE.set(p, null);
-        return null;
-    }
-}
+// ---------------------------------------------------------
+// Cached stat + import scanners
+// ---------------------------------------------------------
 async function getImportsCached(filePath, code) {
-    if (IMPORTS_CACHE.has(filePath))
-        return IMPORTS_CACHE.get(filePath);
+    const cached = cache_1.CacheManager.get(JS_IMPORTS, filePath);
+    if (cached)
+        return cached;
     const set = await (0, extract_imports_1.extractImports)(filePath, code);
-    IMPORTS_CACHE.set(filePath, set);
+    cache_1.CacheManager.set(JS_IMPORTS, filePath, set);
     return set;
 }
-function empty(visited) {
-    return { files: [], visited, stats: { expected: new Set(), resolved: new Set() } };
-}

package/dist/resolvers/js/resolve-alias.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAliasPath = resolveAliasPath;
+const path_1 = __importDefault(require("path"));
+const cache_1 = require("../../core/managers/cache");
+const constants_1 = require("../../constants");
+const helpers_1 = require("../../core/helpers");
+/**
+ * 🧩 resolveAliasPath()
+ * Unifies alias lookup across config, cache, and fallback discovery.
+ *
+ * - Checks cfg.resolve.aliases first.
+ * - Then cached aliases (from Cache Manager).
+ * - If still unresolved, runs Fast-Glob to discover and cache new alias root.
+ */
+async function resolveAliasPath(specifier, root, cfg) {
+    if (!specifier.includes("/"))
+        return null;
+    const [aliasName, ...rest] = specifier.split("/");
+    const remainder = rest.join("/");
+    const knownAliases = cfg.resolve.aliases || {};
+    const aliasKey = aliasName.startsWith("@") ? aliasName : `@${aliasName}`;
+    // 1️⃣ Check config-defined aliases
+    if (knownAliases[aliasKey]) {
+        const relPart = remainder.replace(/^\/+/, "");
+        return path_1.default.resolve(root, knownAliases[aliasKey], relPart);
+    }
+    // 2️⃣ Check cached aliases
+    const cached = cache_1.CacheManager.get(constants_1.CACHE_KEYS.ALIASES, aliasKey);
+    if (cached) {
+        const relPart = remainder.replace(/^\/+/, "");
+        return path_1.default.resolve(root, cached, relPart);
+    }
+    // 3️⃣ Fallback discovery with Fast-Glob
+    const stripped = remainder; // remove prefix before first '/'
+    const hasExt = /\.[a-z0-9]+$/i.test(stripped);
+    const patterns = hasExt ? [`**/${stripped}`] : [`**/${stripped}.*`, `**/${stripped}/index.*`];
+    const { files: matches } = await (0, helpers_1.globScan)(patterns, { cwd: root });
+    if (matches.length === 1) {
+        return resolveMatches(matches, remainder, aliasKey);
+    }
+    //There are multiple matches, Assuming they match the target approximate folder.
+    if (matches.length > 1) {
+        const resolvedMatch = resolveMatches(matches, remainder, aliasKey);
+        return resolvedMatch.replace(/\.[^/.]+$/, "");
+    }
+    return null;
+}
+function resolveMatches(matches, remainder, aliasKey) {
+    const foundFile = matches[0];
+    const aliasRoot = foundFile.split(remainder)[0].replace(/\\/g, "/");
+    cache_1.CacheManager.set(constants_1.CACHE_KEYS.ALIASES, aliasKey, aliasRoot);
+    return foundFile;
+}

package/dist/resolvers/php/bindings.js

@@ -1,5 +1,4 @@
 "use strict";
-// @ts-nocheck
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,18 +6,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadLaravelBindings = loadLaravelBindings;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const config_1 = require("../../constants/config");
-function loadLaravelBindings() {
-    const providersDir = path_1.default.join(config_1.ROOT, "app", "Providers");
+const cache_1 = require("../../core/managers/cache");
+const cache_keys_1 = require("../../constants/cache-keys");
+/**
+ * Scans app/Providers/*.php for `$this->app->bind()` / `singleton()` calls
+ * and returns a map of Interface::class → Implementation::class (FQCN strings).
+ */
+function loadLaravelBindings(root) {
+    const cached = cache_1.CacheManager.get(cache_keys_1.CACHE_KEYS.PHP_BINDINGS, root);
+    if (cached)
+        return cached;
+    const providersDir = path_1.default.join(root, "app", "Providers");
     const bindings = {};
-    if (!fs_1.default.existsSync(providersDir))
+    if (!fs_1.default.existsSync(providersDir)) {
+        cache_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_BINDINGS, root, bindings);
         return bindings;
+    }
     const files = fs_1.default
         .readdirSync(providersDir)
-        .filter(f => f.endsWith(".php"))
-        .map(f => path_1.default.join(providersDir, f));
-    // Match: $this->app->bind(Interface::class, Implementation::class)
-    const re = /$this->app->(?:bind|singleton)\s*\(\s*([A-Za-z0-9_:\\\\]+)::class\s*,\s*([A-Za-z0-9_:\\\\]+)::class/g;
+        .filter((f) => f.endsWith(".php"))
+        .map((f) => path_1.default.join(providersDir, f));
+    // $this->app->bind(Interface::class, Implementation::class)
+    // $this->app->singleton(Interface::class, Implementation::class)
+    const re = /\$this->app->(?:bind|singleton)\s*\(\s*([A-Za-z0-9_:\\\\]+)::class\s*,\s*([A-Za-z0-9_:\\\\]+)::class/g;
     for (const file of files) {
         const code = fs_1.default.readFileSync(file, "utf8");
         let m;
@@ -28,5 +38,6 @@ function loadLaravelBindings() {
             bindings[iface] = impl;
         }
     }
+    cache_1.CacheManager.set(cache_keys_1.CACHE_KEYS.PHP_BINDINGS, root, bindings);
     return bindings;
 }

package/dist/resolvers/php/extract-imports.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPhpImports = extractPhpImports;
+exports.expandGroupedUses = expandGroupedUses;
+/**
+ * Extracts import-like references from PHP code.
+ * Supports:
+ *  - require/include/require_once/include_once
+ *  - use statements (including grouped imports like `use App\Models\{User, Team};`)
+ */
+function extractPhpImports(code) {
+    const out = new Set();
+    const patterns = [
+        /\b(?:require|include|require_once|include_once)\s*\(?['"]([^'"]+)['"]\)?/g,
+        /\buse\s+([A-Z][\w\\]+(?:\s*{[^}]+})?)/g,
+    ];
+    for (const r of patterns) {
+        let m;
+        while ((m = r.exec(code))) {
+            const val = m[1];
+            if (val)
+                out.add(val);
+        }
+    }
+    return out;
+}
+/**
+ * Expands grouped `use` imports into individual fully qualified names.
+ * Example:
+ *   "App\\Models\\{User, Team}" → ["App\\Models\\User", "App\\Models\\Team"]
+ */
+function expandGroupedUses(raw) {
+    const out = new Set();
+    for (const imp of raw) {
+        const g = imp.match(/^(.+?)\s*{([^}]+)}/);
+        if (g) {
+            const base = g[1].trim().replace(/\\+$/, "");
+            g[2]
+                .split(",")
+                .map((x) => x.trim())
+                .filter(Boolean)
+                .forEach((p) => out.add(`${base}\\${p}`));
+        }
+        else {
+            out.add(imp.trim());
+        }
+    }
+    return out;
+}