@schemyx/mcp 0.1.0 → 0.1.1

package/dist/codebase-scanner/extractors.js

@@ -0,0 +1,2600 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImports = extractImports;
+exports.extractExports = extractExports;
+exports.extractSymbols = extractSymbols;
+exports.extractFunctions = extractFunctions;
+exports.extractClasses = extractClasses;
+exports.extractTypes = extractTypes;
+exports.extractConstants = extractConstants;
+exports.extractComponents = extractComponents;
+exports.extractComponentProps = extractComponentProps;
+exports.extractHooks = extractHooks;
+exports.extractJsxElements = extractJsxElements;
+exports.extractRoutes = extractRoutes;
+exports.extractApiHandlers = extractApiHandlers;
+exports.extractDecoratedClasses = extractDecoratedClasses;
+exports.extractControllers = extractControllers;
+exports.extractServices = extractServices;
+exports.extractModules = extractModules;
+exports.extractNamedClasses = extractNamedClasses;
+exports.extractPrismaModels = extractPrismaModels;
+exports.extractSqlModels = extractSqlModels;
+exports.extractOrmModels = extractOrmModels;
+exports.extractModelFields = extractModelFields;
+exports.extractCssVariables = extractCssVariables;
+exports.extractCssVariableValues = extractCssVariableValues;
+exports.extractCssRules = extractCssRules;
+exports.extractCssClasses = extractCssClasses;
+exports.extractCssIds = extractCssIds;
+exports.extractCssVariableReferences = extractCssVariableReferences;
+exports.extractClassReferences = extractClassReferences;
+exports.extractClassExpressions = extractClassExpressions;
+exports.extractComponentStyleDefinitions = extractComponentStyleDefinitions;
+exports.extractThemeTokens = extractThemeTokens;
+exports.extractInlineStyles = extractInlineStyles;
+exports.nearestCssSelector = nearestCssSelector;
+exports.parseCssDeclarations = parseCssDeclarations;
+exports.parseJsStyleObject = parseJsStyleObject;
+exports.readTagBefore = readTagBefore;
+exports.readBalancedCall = readBalancedCall;
+exports.readBalancedBlock = readBalancedBlock;
+exports.readBalancedRange = readBalancedRange;
+exports.skipQuoted = skipQuoted;
+exports.isInsideQuotedString = isInsideQuotedString;
+exports.extractClassListsFromStrings = extractClassListsFromStrings;
+exports.analyzeClassSource = analyzeClassSource;
+exports.toClassSourceAnalysis = toClassSourceAnalysis;
+exports.isConditionalClassLiteral = isConditionalClassLiteral;
+exports.readStringLiteralRanges = readStringLiteralRanges;
+exports.directClassCandidate = directClassCandidate;
+exports.readStringLiterals = readStringLiterals;
+exports.looksLikeClassList = looksLikeClassList;
+exports.isLikelyStyleClass = isLikelyStyleClass;
+exports.firstStringLiteral = firstStringLiteral;
+exports.extractNamedObjectBlock = extractNamedObjectBlock;
+exports.parseVariantGroups = parseVariantGroups;
+exports.parseStringValueMap = parseStringValueMap;
+exports.parseClassValueMap = parseClassValueMap;
+exports.parseTopLevelObjectEntries = parseTopLevelObjectEntries;
+exports.stripOuterBraces = stripOuterBraces;
+exports.skipSeparators = skipSeparators;
+exports.skipWhitespace = skipWhitespace;
+exports.readObjectKey = readObjectKey;
+exports.readObjectValueEnd = readObjectValueEnd;
+exports.splitTopLevel = splitTopLevel;
+exports.cleanupBareValue = cleanupBareValue;
+exports.classifyThemeToken = classifyThemeToken;
+exports.flattenJsonTokens = flattenJsonTokens;
+exports.readOpeningTags = readOpeningTags;
+exports.annotateOpeningTags = annotateOpeningTags;
+exports.findClosingTagEnd = findClosingTagEnd;
+exports.isVoidHtmlElement = isVoidHtmlElement;
+exports.extractElementLabel = extractElementLabel;
+exports.readClassSource = readClassSource;
+exports.readUiProps = readUiProps;
+exports.readVariantProps = readVariantProps;
+exports.readAttrSource = readAttrSource;
+exports.readAttrValueSource = readAttrValueSource;
+exports.cleanupAttrValue = cleanupAttrValue;
+exports.hasBooleanAttr = hasBooleanAttr;
+exports.groupTailwindClasses = groupTailwindClasses;
+exports.addClassGroup = addClassGroup;
+exports.mergeClassGroups = mergeClassGroups;
+exports.mergeVariantProps = mergeVariantProps;
+exports.isCompositionElement = isCompositionElement;
+exports.filterClasses = filterClasses;
+exports.isResponsiveClass = isResponsiveClass;
+exports.isSpacingClass = isSpacingClass;
+exports.isSurfaceClass = isSurfaceClass;
+exports.isDecorativeAccentClass = isDecorativeAccentClass;
+exports.isTypographyClass = isTypographyClass;
+exports.groupClassExpressionsByTarget = groupClassExpressionsByTarget;
+exports.buildComponentSlots = buildComponentSlots;
+exports.createUiCompositionGuidance = createUiCompositionGuidance;
+exports.createUiPatternGuidance = createUiPatternGuidance;
+exports.extractTailwindUtilities = extractTailwindUtilities;
+exports.extractPackageDependencies = extractPackageDependencies;
+exports.extractUiElements = extractUiElements;
+exports.summarizeDirectUiChildren = summarizeDirectUiChildren;
+exports.deriveLayoutRole = deriveLayoutRole;
+exports.isStateClass = isStateClass;
+exports.extractApiCalls = extractApiCalls;
+exports.extractEnvVars = extractEnvVars;
+exports.extractTestNames = extractTestNames;
+exports.extractDocsHeadings = extractDocsHeadings;
+exports.extractConfigKeys = extractConfigKeys;
+exports.extractTemplateIncludes = extractTemplateIncludes;
+exports.extractAuthHints = extractAuthHints;
+exports.extractMiddleware = extractMiddleware;
+exports.extractJobs = extractJobs;
+exports.extractEvents = extractEvents;
+exports.detectKind = detectKind;
+exports.detectLayer = detectLayer;
+exports.detectLanguage = detectLanguage;
+exports.summarizeFile = summarizeFile;
+exports.isNextPageFile = isNextPageFile;
+exports.isNextLayoutFile = isNextLayoutFile;
+exports.isNextRouteFile = isNextRouteFile;
+exports.isPagesRouterPageFile = isPagesRouterPageFile;
+exports.isSvelteKitPageFile = isSvelteKitPageFile;
+exports.isAstroPageFile = isAstroPageFile;
+exports.isNuxtPageFile = isNuxtPageFile;
+exports.isRawPageFile = isRawPageFile;
+exports.toNextRoutePath = toNextRoutePath;
+exports.toPagesRoutePath = toPagesRoutePath;
+exports.toSvelteKitRoutePath = toSvelteKitRoutePath;
+exports.toAstroRoutePath = toAstroRoutePath;
+exports.toNuxtRoutePath = toNuxtRoutePath;
+exports.toRawPageRoutePath = toRawPageRoutePath;
+exports.extractFrameworkRoutePaths = extractFrameworkRoutePaths;
+exports.normalizeRoutePath = normalizeRoutePath;
+exports.shouldIgnoreDirectory = shouldIgnoreDirectory;
+exports.isExcluded = isExcluded;
+exports.shouldIgnoreNonCanonicalPath = shouldIgnoreNonCanonicalPath;
+exports.isScannableFile = isScannableFile;
+exports.shouldIgnoreFileName = shouldIgnoreFileName;
+exports.isUiFile = isUiFile;
+exports.isTemplateFile = isTemplateFile;
+exports.isTestFile = isTestFile;
+exports.isConfigFile = isConfigFile;
+exports.routeExtractorForFile = routeExtractorForFile;
+exports.routeConfidenceForFile = routeConfidenceForFile;
+exports.apiExtractorForFile = apiExtractorForFile;
+exports.controllerExtractorForFile = controllerExtractorForFile;
+exports.serviceExtractorForFile = serviceExtractorForFile;
+exports.moduleExtractorForFile = moduleExtractorForFile;
+exports.modelExtractorForFile = modelExtractorForFile;
+exports.styleExtractorForFile = styleExtractorForFile;
+exports.styleConfidenceForFile = styleConfidenceForFile;
+exports.entryMatchesConcept = entryMatchesConcept;
+exports.splitClassList = splitClassList;
+exports.classifyUiElement = classifyUiElement;
+exports.stripTags = stripTags;
+const path = require("node:path");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+function extractImports(content) {
+    const imports = new Set();
+    const importPattern = /import(?:\s+type)?[\s\S]*?\sfrom\s+['"]([^'"]+)['"]/g;
+    const sideEffectPattern = /import\s+['"]([^'"]+)['"]/g;
+    const requirePattern = /require\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const cssImportPattern = /@import\s+(?:url\()?['"]?([^'");]+)['"]?\)?/g;
+    const phpIncludePattern = /\b(?:require|require_once|include|include_once)\s*(?:\(?\s*)['"]([^'"]+)['"]/g;
+    const phpUsePattern = /^\s*use\s+([A-Za-z_\\][A-Za-z0-9_\\]*)\s*;/gm;
+    const pythonImportPattern = /^\s*(?:from\s+([A-Za-z_][\w.]*)(?:\s+import\s+[\w*,\s]+)|import\s+([A-Za-z_][\w.]*))/gm;
+    const rubyRequirePattern = /\brequire(?:_relative)?\s+['"]([^'"]+)['"]/g;
+    const javaLikeImportPattern = /^\s*import\s+(?:static\s+)?([A-Za-z_][\w.*]*);/gm;
+    const goImportPattern = /^\s*import\s+(?:\(\s*([\s\S]*?)\s*\)|"([^"]+)")/gm;
+    for (const pattern of [
+        importPattern,
+        sideEffectPattern,
+        requirePattern,
+        cssImportPattern,
+        phpIncludePattern,
+        phpUsePattern,
+        pythonImportPattern,
+        rubyRequirePattern,
+        javaLikeImportPattern,
+        goImportPattern,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            if (pattern === goImportPattern && match[1]) {
+                for (const importMatch of match[1].matchAll(/"([^"]+)"/g)) {
+                    imports.add(importMatch[1]);
+                }
+                continue;
+            }
+            imports.add(match[1] || match[2]);
+        }
+    }
+    return Array.from(imports).filter(Boolean).sort();
+}
+function extractExports(content) {
+    const exports = new Set();
+    const patterns = [
+        /export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g,
+        /export\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g,
+        /export\s+class\s+([A-Za-z_$][\w$]*)/g,
+        /export\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)?/g,
+        /module\.exports\s*=\s*([A-Za-z_$][\w$]*)/g,
+        /exports\.([A-Za-z_$][\w$]*)\s*=/g,
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            exports.add(match[1] || 'default');
+        }
+    }
+    return Array.from(exports).sort();
+}
+function extractSymbols(content, relPath) {
+    return (0, utils_1.unique)([
+        ...extractExports(content),
+        ...extractFunctions(content, relPath),
+        ...extractClasses(content, relPath),
+        ...extractTypes(content, relPath),
+        ...extractConstants(content, relPath),
+    ]).sort();
+}
+function extractFunctions(content, relPath) {
+    const names = new Set();
+    const language = detectLanguage(relPath);
+    const patterns = [
+        /(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/g,
+        /(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(?[^=]*?\)?\s*=>/g,
+        /function\s+([A-Za-z_][\w]*)\s*\(/g,
+        /def\s+([A-Za-z_][\w]*)\s*\(/g,
+        /func\s+(?:\([^)]+\)\s*)?([A-Za-z_][\w]*)\s*\(/g,
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            names.add(match[1]);
+        }
+    }
+    if (language === 'rb') {
+        for (const match of content.matchAll(/^\s*def\s+([A-Za-z_][\w!?=]*)/gm)) {
+            names.add(match[1]);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractClasses(content, relPath) {
+    const names = new Set();
+    for (const pattern of [
+        /(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/g,
+        /(?:class|interface|enum)\s+([A-Z][A-Za-z0-9_]*)/g,
+        /class\s+([A-Za-z_][\w]*)\s*(?:\(|:|<|{|extends)?/g,
+        /module\s+([A-Z][A-Za-z0-9_:]*)/g,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            names.add(match[1]);
+        }
+    }
+    if (/\.(java|kt|kts|cs)$/.test(relPath)) {
+        for (const match of content.matchAll(/\b(?:class|interface|record|enum|object)\s+([A-Z][A-Za-z0-9_]*)/g)) {
+            names.add(match[1]);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractTypes(content, relPath) {
+    const names = new Set();
+    for (const pattern of [
+        /(?:export\s+)?(?:type|interface|enum)\s+([A-Za-z_$][\w$]*)/g,
+        /type\s+([A-Za-z_][\w]*)\s+(?:struct|interface)/g,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            names.add(match[1]);
+        }
+    }
+    if (/\.graphql$/.test(relPath)) {
+        for (const match of content.matchAll(/\b(?:type|interface|enum|input)\s+([A-Za-z_][\w]*)/g)) {
+            names.add(match[1]);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractConstants(content, relPath) {
+    const names = new Set();
+    for (const pattern of [
+        /(?:export\s+)?(?:const|let|var)\s+([A-Z][A-Z0-9_]*)\b/g,
+        /^\s*([A-Z][A-Z0-9_]+)\s*=/gm,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            names.add(match[1]);
+        }
+    }
+    if (/\.(go|rs)$/.test(relPath)) {
+        for (const match of content.matchAll(/\bconst\s+([A-Za-z_][\w]*)/g)) {
+            names.add(match[1]);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractComponents(content, filePath, relPath) {
+    const names = new Set();
+    const extension = path.extname(filePath);
+    if (!isUiFile(relPath)) {
+        return [];
+    }
+    for (const exported of extractExports(content)) {
+        if ((0, utils_1.isPascalCase)(exported)) {
+            names.add(exported);
+        }
+    }
+    for (const pattern of [
+        /function\s+([A-Z][A-Za-z0-9_]*)\s*\(/g,
+        /const\s+([A-Z][A-Za-z0-9_]*)\s*=\s*(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/g,
+        /name\s*:\s*['"]([A-Z][A-Za-z0-9_]*)['"]/g,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            names.add(match[1]);
+        }
+    }
+    if (['.vue', '.svelte', '.astro'].includes(extension) || isTemplateFile(relPath)) {
+        const fileStem = (0, utils_1.toPascalCase)(path.basename(relPath).replace(/\.[^.]+(?:\.[^.]+)?$/, ''));
+        if (fileStem && !['Index', 'Page', 'Layout'].includes(fileStem)) {
+            names.add(fileStem);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractComponentProps(content, components) {
+    const propsByComponent = {};
+    for (const component of components) {
+        const props = new Set();
+        const paramPattern = new RegExp(`(?:function\\s+${(0, utils_1.escapeRegExp)(component)}|const\\s+${(0, utils_1.escapeRegExp)(component)}\\s*=)\\s*\\(?\\s*\\{([^}]+)\\}`);
+        const paramMatch = content.match(paramPattern);
+        if (paramMatch) {
+            for (const prop of paramMatch[1]
+                .split(',')
+                .map((item) => item.trim().replace(/[:=].*$/, ''))) {
+                if (/^[A-Za-z_$][\w$]*$/.test(prop)) {
+                    props.add(prop);
+                }
+            }
+        }
+        const typePattern = new RegExp(`(?:type|interface)\\s+${(0, utils_1.escapeRegExp)(component)}Props\\b[\\s\\S]*?[{=]([\\s\\S]*?)[};]`, 'm');
+        const typeMatch = content.match(typePattern);
+        if (typeMatch) {
+            for (const propMatch of typeMatch[1].matchAll(/([A-Za-z_$][\w$]*)\??\s*:/g)) {
+                props.add(propMatch[1]);
+            }
+        }
+        propsByComponent[component] = Array.from(props).sort();
+    }
+    return propsByComponent;
+}
+function extractHooks(content) {
+    const hooks = new Set();
+    for (const pattern of [
+        /export\s+function\s+(use[A-Z][A-Za-z0-9_]*)\s*\(/g,
+        /export\s+const\s+(use[A-Z][A-Za-z0-9_]*)\s*=/g,
+        /function\s+(use[A-Z][A-Za-z0-9_]*)\s*\(/g,
+        /const\s+(use[A-Z][A-Za-z0-9_]*)\s*=/g,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            hooks.add(match[1]);
+        }
+    }
+    return Array.from(hooks).sort();
+}
+function extractJsxElements(content) {
+    const elements = new Set();
+    for (const match of content.matchAll(/<([A-Z][A-Za-z0-9_.]*)\b/g)) {
+        elements.add(match[1].split('.')[0]);
+    }
+    return Array.from(elements).sort();
+}
+function extractRoutes(relPath, content) {
+    const routes = new Set();
+    if (isNextPageFile(relPath) || isNextLayoutFile(relPath)) {
+        routes.add(toNextRoutePath(relPath));
+    }
+    if (isPagesRouterPageFile(relPath)) {
+        routes.add(toPagesRoutePath(relPath));
+    }
+    if (isSvelteKitPageFile(relPath)) {
+        routes.add(toSvelteKitRoutePath(relPath));
+    }
+    if (isAstroPageFile(relPath)) {
+        routes.add(toAstroRoutePath(relPath));
+    }
+    if (isNuxtPageFile(relPath)) {
+        routes.add(toNuxtRoutePath(relPath));
+    }
+    if (isRawPageFile(relPath)) {
+        routes.add(toRawPageRoutePath(relPath));
+    }
+    for (const route of extractFrameworkRoutePaths(relPath, content)) {
+        routes.add(route);
+    }
+    return Array.from(routes).sort();
+}
+function extractApiHandlers(relPath, content) {
+    const handlers = new Set();
+    const routePath = isNextRouteFile(relPath) ? toNextRoutePath(relPath) : null;
+    if (routePath) {
+        for (const method of ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD']) {
+            if (new RegExp(`export\\s+(?:async\\s+)?(?:function\\s+${method}|const\\s+${method})\\b`).test(content)) {
+                handlers.add(`${method} ${routePath}`);
+            }
+        }
+    }
+    for (const match of content.matchAll(/\b(?:router|app|server|route)\.(get|post|put|patch|delete|options|head)\(\s*['"`]([^'"`]+)/g)) {
+        handlers.add(`${match[1].toUpperCase()} ${match[2]}`);
+    }
+    for (const match of content.matchAll(/\b(?:fastify|hono|fiber|mux)\.(get|post|put|patch|delete|options|head)\(\s*['"`]([^'"`]+)/gi)) {
+        handlers.add(`${match[1].toUpperCase()} ${match[2]}`);
+    }
+    for (const match of content.matchAll(/@(Get|Post|Put|Patch|Delete)\(\s*['"`]?([^'"`)]*)/g)) {
+        handlers.add(`${match[1].toUpperCase()} /${match[2]}`.replace(/\/+$/, '/'));
+    }
+    for (const match of content.matchAll(/Route::(get|post|put|patch|delete|options|any)\(\s*['"`]([^'"`]+)/gi)) {
+        handlers.add(`${match[1].toUpperCase()} ${normalizeRoutePath(match[2])}`);
+    }
+    for (const match of content.matchAll(/^\s*(get|post|put|patch|delete|resources?)\s+['"]([^'"]+)/gim)) {
+        const method = match[1].toLowerCase() === 'resources' ? 'RESOURCE' : match[1].toUpperCase();
+        handlers.add(`${method} ${normalizeRoutePath(match[2])}`);
+    }
+    for (const match of content.matchAll(/@(app|router|api)\.(get|post|put|patch|delete|route)\(\s*['"]([^'"]+)/gi)) {
+        const method = match[2].toLowerCase() === 'route' ? 'ANY' : match[2].toUpperCase();
+        handlers.add(`${method} ${normalizeRoutePath(match[3])}`);
+    }
+    for (const match of content.matchAll(/\bpath\(\s*['"]([^'"]+)['"]/g)) {
+        handlers.add(`ANY ${normalizeRoutePath(match[1])}`);
+    }
+    for (const match of content.matchAll(/\burl\(r?['"]\^?([^'"]+)['"]/g)) {
+        handlers.add(`ANY ${normalizeRoutePath(match[1].replace(/\$$/, ''))}`);
+    }
+    return Array.from(handlers).sort();
+}
+function extractDecoratedClasses(content, decoratorName) {
+    const names = new Set();
+    const pattern = new RegExp(`@${decoratorName}\\([^)]*\\)\\s*(?:export\\s+)?class\\s+([A-Za-z_$][\\w$]*)`, 'g');
+    for (const match of content.matchAll(pattern)) {
+        names.add(match[1]);
+    }
+    return Array.from(names).sort();
+}
+function extractControllers(content, relPath) {
+    const names = new Set();
+    for (const className of extractClasses(content, relPath)) {
+        if (/Controller$/.test(className) || /controllers?\//i.test(relPath)) {
+            names.add(className);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractServices(content, relPath) {
+    return (0, utils_1.unique)([
+        ...extractNamedClasses(content, /Service$/),
+        ...extractClasses(content, relPath).filter((name) => /(Service|Repository|Client|Gateway|Provider|Manager)$/.test(name)),
+    ]).sort();
+}
+function extractModules(content, relPath) {
+    return (0, utils_1.unique)([
+        ...extractNamedClasses(content, /Module$/),
+        ...extractClasses(content, relPath).filter((name) => /(Module|Package|Bundle)$/.test(name)),
+    ]).sort();
+}
+function extractNamedClasses(content, suffix) {
+    const names = new Set();
+    for (const match of content.matchAll(/(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/g)) {
+        if (suffix.test(match[1])) {
+            names.add(match[1]);
+        }
+    }
+    return Array.from(names).sort();
+}
+function extractPrismaModels(content) {
+    const models = new Set();
+    for (const match of content.matchAll(/^model\s+([A-Za-z_$][\w$]*)/gm)) {
+        models.add(match[1]);
+    }
+    return Array.from(models).sort();
+}
+function extractSqlModels(content) {
+    const models = new Set();
+    for (const match of content.matchAll(/\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?/gi)) {
+        models.add(match[1].split('.').pop() ?? match[1]);
+    }
+    return Array.from(models).sort();
+}
+function extractOrmModels(content, relPath) {
+    const models = new Set();
+    for (const match of content.matchAll(/@Entity\([^)]*\)\s*(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/g)) {
+        models.add(match[1]);
+    }
+    for (const match of content.matchAll(/mongoose\.model\(\s*['"]([^'"]+)['"]/g)) {
+        models.add(match[1]);
+    }
+    for (const match of content.matchAll(/\b(?:sequelize|db)\.define\(\s*['"]([^'"]+)['"]/g)) {
+        models.add((0, utils_1.toPascalCase)(match[1]));
+    }
+    for (const match of content.matchAll(/class\s+([A-Z][A-Za-z0-9_]*)\s*<\s*(?:ApplicationRecord|ActiveRecord::Base|Model)\b/g)) {
+        models.add(match[1]);
+    }
+    for (const match of content.matchAll(/class\s+([A-Z][A-Za-z0-9_]*)\s*\([^)]*models\.Model[^)]*\)/g)) {
+        models.add(match[1]);
+    }
+    for (const match of content.matchAll(/class\s+([A-Z][A-Za-z0-9_]*)\s+extends\s+Model\b/g)) {
+        models.add(match[1]);
+    }
+    if (/models?\//.test(relPath) || /\/models?\./.test(relPath)) {
+        for (const className of extractClasses(content, relPath)) {
+            if ((0, utils_1.isPascalCase)(className)) {
+                models.add(className);
+            }
+        }
+    }
+    return Array.from(models).sort();
+}
+function extractModelFields(content, relPath) {
+    const fieldsByModel = {};
+    for (const match of content.matchAll(/^model\s+([A-Za-z_$][\w$]*)\s*\{([\s\S]*?)^}/gm)) {
+        fieldsByModel[match[1]] = match[2]
+            .split('\n')
+            .map((line) => line.trim().match(/^([A-Za-z_$][\w$]*)\s+/)?.[1])
+            .filter((field) => Boolean(field))
+            .slice(0, 80);
+    }
+    for (const match of content.matchAll(/\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"[]?([A-Za-z_][\w.]*)[`"\]]?\s*\(([\s\S]*?)\);/gi)) {
+        const modelName = match[1].split('.').pop() ?? match[1];
+        fieldsByModel[modelName] = match[2]
+            .split(',')
+            .map((line) => line.trim().match(/^[`"[]?([A-Za-z_][\w]*)[`"\]]?\s+/)?.[1] ?? '')
+            .filter((field) => Boolean(field) && !/^(PRIMARY|FOREIGN|UNIQUE|KEY|CONSTRAINT)$/i.test(field))
+            .slice(0, 80);
+    }
+    for (const model of extractOrmModels(content, relPath)) {
+        const fields = new Set();
+        for (const match of content.matchAll(/(?:this\.|self\.|attr_accessor\s+:|property\s+:|field\s+:)([A-Za-z_][\w]*)/g)) {
+            fields.add(match[1]);
+        }
+        for (const match of content.matchAll(/([A-Za-z_][\w]*)\s*=\s*(?:models\.|Column\(|db\.Column|fields\.)/g)) {
+            fields.add(match[1]);
+        }
+        if (fields.size) {
+            fieldsByModel[model] = Array.from(fields).sort().slice(0, 80);
+        }
+    }
+    return fieldsByModel;
+}
+function extractCssVariables(content) {
+    return (0, utils_1.unique)(Array.from(content.matchAll(/--[a-zA-Z0-9-_]+/g)).map((match) => match[0])).slice(0, 80);
+}
+function extractCssVariableValues(content) {
+    const values = [];
+    for (const match of content.matchAll(/(--[a-zA-Z0-9-_]+)\s*:\s*([^;{}]+);/g)) {
+        const selector = nearestCssSelector(content, match.index ?? 0);
+        values.push({
+            name: match[1],
+            value: match[2].trim(),
+            ...(selector ? { selector } : {}),
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+        });
+    }
+    return (0, utils_1.uniqueBy)(values, (value) => `${value.name}:${value.value}:${value.selector ?? ''}`).slice(0, 240);
+}
+function extractCssRules(content, relPath) {
+    if (!/\.(css|scss|vue|svelte|astro|html|htm|php|phtml|twig|erb)$/.test(relPath)) {
+        return [];
+    }
+    const rules = [];
+    for (const match of content.matchAll(/([^{}@][^{}]{0,240})\{([^{}]{1,2400})\}/g)) {
+        const selector = match[1].trim().replace(/\s+/g, ' ');
+        if (!selector || selector.includes(';') || selector.startsWith('import')) {
+            continue;
+        }
+        const declarations = parseCssDeclarations(match[2]).slice(0, 40);
+        if (!declarations.length) {
+            continue;
+        }
+        rules.push({
+            selector,
+            declarations,
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+        });
+    }
+    return (0, utils_1.uniqueBy)(rules, (rule) => `${rule.selector}:${rule.line}`).slice(0, 200);
+}
+function extractCssClasses(content) {
+    return (0, utils_1.unique)(Array.from(content.matchAll(/\.([a-zA-Z][a-zA-Z0-9_-]+)\b/g)).map((match) => match[1])).slice(0, 80);
+}
+function extractCssIds(content) {
+    return (0, utils_1.unique)(Array.from(content.matchAll(/#([a-zA-Z][a-zA-Z0-9_-]+)\b/g)).map((match) => match[1])).slice(0, 80);
+}
+function extractCssVariableReferences(content) {
+    return (0, utils_1.unique)(Array.from(content.matchAll(/var\(\s*(--[a-zA-Z0-9-_]+)/g)).map((match) => match[1])).slice(0, 80);
+}
+function extractClassReferences(content, classExpressions = extractClassExpressions(content)) {
+    const classes = new Set(classExpressions.flatMap((expression) => expression.classes));
+    const patterns = [
+        /\bclass(?:Name)?\s*=\s*["'`]([^"'`]+)["'`]/g,
+        /\bclass(?:Name)?\s*=\s*\{\s*["'`]([^"'`]+)["'`]\s*\}/g,
+        /\bclass:\s*["'`]([^"'`]+)["'`]/g,
+        /\bclassList\.(?:add|remove|toggle)\(([^)]*)\)/g,
+    ];
+    for (const pattern of patterns) {
+        for (const match of content.matchAll(pattern)) {
+            for (const className of splitClassList(match[1])) {
+                classes.add(className);
+            }
+        }
+    }
+    return Array.from(classes).sort().slice(0, 500);
+}
+function extractClassExpressions(content) {
+    const expressions = [];
+    for (const pattern of [
+        /\bclass(?:Name)?\s*=\s*(["'`])([\s\S]*?)\1/g,
+        /\bclass(?:Name)?\s*=\s*\{\s*(["'`])([\s\S]*?)\1\s*\}/g,
+        /\bclass:\s*(["'`])([\s\S]*?)\1/g,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            const raw = match[0];
+            const classValue = match[2] ?? match[1] ?? '';
+            const classes = splitClassList(classValue);
+            if (classes.length) {
+                const analysis = analyzeClassSource(classValue);
+                expressions.push({
+                    kind: 'attribute',
+                    raw: (0, utils_1.truncate)(raw, 500),
+                    classes,
+                    defaultClasses: analysis.defaultClasses,
+                    conditionalClasses: analysis.conditionalClasses,
+                    line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+                    target: readTagBefore(content, match.index ?? 0),
+                });
+            }
+        }
+    }
+    for (const helperName of ['cn', 'clsx', 'classNames', 'twMerge', 'cva']) {
+        const helperPattern = new RegExp(`\\b${helperName}\\s*\\(`, 'g');
+        for (const match of content.matchAll(helperPattern)) {
+            if (isInsideQuotedString(content, match.index ?? 0)) {
+                continue;
+            }
+            const call = readBalancedCall(content, match.index ?? 0);
+            if (!call) {
+                continue;
+            }
+            const analysis = analyzeClassSource(call);
+            const classes = analysis.classes;
+            if (classes.length) {
+                expressions.push({
+                    kind: helperName === 'cva' ? 'variant-definition' : 'helper',
+                    raw: (0, utils_1.truncate)(call, 900),
+                    classes,
+                    defaultClasses: analysis.defaultClasses,
+                    conditionalClasses: analysis.conditionalClasses,
+                    line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+                    target: helperName,
+                });
+            }
+        }
+    }
+    for (const match of content.matchAll(/(["'`])([^"'`]{5,900})\1/g)) {
+        const classes = splitClassList(match[2]);
+        if (classes.length >= 2 && looksLikeClassList(classes)) {
+            expressions.push({
+                kind: 'string-literal',
+                raw: (0, utils_1.truncate)(match[0], 500),
+                classes,
+                defaultClasses: classes,
+                conditionalClasses: [],
+                line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+            });
+        }
+    }
+    return (0, utils_1.uniqueBy)(expressions, (expression) => `${expression.kind}:${expression.line}:${expression.raw}`).slice(0, 240);
+}
+function extractComponentStyleDefinitions(content) {
+    const definitions = [];
+    const cvaPattern = /(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*cva\s*\(/g;
+    for (const match of content.matchAll(cvaPattern)) {
+        if (isInsideQuotedString(content, match.index ?? 0)) {
+            continue;
+        }
+        const call = readBalancedCall(content, (match.index ?? 0) + match[0].lastIndexOf('cva'));
+        if (!call) {
+            continue;
+        }
+        const baseClasses = splitClassList(firstStringLiteral(call) ?? '');
+        const variantsBlock = extractNamedObjectBlock(call, 'variants');
+        const defaultVariantsBlock = extractNamedObjectBlock(call, 'defaultVariants');
+        const variants = variantsBlock ? parseVariantGroups(variantsBlock) : {};
+        const defaultVariants = defaultVariantsBlock ? parseStringValueMap(defaultVariantsBlock) : {};
+        const classes = (0, utils_1.unique)([
+            ...baseClasses,
+            ...Object.values(variants).flatMap((variant) => Object.values(variant).flat()),
+        ]);
+        definitions.push({
+            name: match[1],
+            kind: 'cva',
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+            baseClasses,
+            variants,
+            defaultVariants,
+            classes,
+            source: (0, utils_1.truncate)(call, 2200),
+        });
+    }
+    for (const match of content.matchAll(/(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*(?:Classes|ClassNames|Styles|Variants|Config|Map))\s*=\s*\{/g)) {
+        if (isInsideQuotedString(content, match.index ?? 0)) {
+            continue;
+        }
+        const block = readBalancedBlock(content, (match.index ?? 0) + match[0].lastIndexOf('{'));
+        if (!block) {
+            continue;
+        }
+        const variants = { values: parseClassValueMap(block) };
+        const classes = (0, utils_1.unique)(Object.values(variants.values).flat());
+        if (!classes.length) {
+            continue;
+        }
+        definitions.push({
+            name: match[1],
+            kind: /variant/i.test(match[1]) ? 'variant-object' : 'class-map',
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+            baseClasses: [],
+            variants,
+            defaultVariants: {},
+            classes,
+            source: (0, utils_1.truncate)(block, 2200),
+        });
+    }
+    return (0, utils_1.uniqueBy)(definitions, (definition) => `${definition.name}:${definition.line}`).slice(0, 80);
+}
+function extractThemeTokens(relPath, content) {
+    const shouldExtract = /(?:theme|token|tailwind|config|globals|styles?|css|scss)/i.test(relPath) ||
+        /--[a-zA-Z0-9-_]+\s*:/.test(content);
+    if (!shouldExtract) {
+        return [];
+    }
+    const tokens = [];
+    for (const variable of extractCssVariableValues(content)) {
+        tokens.push({
+            path: variable.name,
+            value: variable.value,
+            type: classifyThemeToken(variable.name, variable.value),
+            line: variable.line,
+        });
+    }
+    if (/\.json$/.test(relPath)) {
+        try {
+            flattenJsonTokens(JSON.parse(content), [], tokens);
+        }
+        catch {
+        }
+    }
+    for (const match of content.matchAll(/["']?([A-Za-z_$][\w$-]*(?:Color|Radius|Spacing|Shadow|Font|Size|Height|Width|Padding|Gap|Background|Foreground|Border|Ring|Surface|Text)?|--[a-zA-Z0-9-_]+)["']?\s*:\s*(["'`])([^"'`]{1,220})\2/g)) {
+        tokens.push({
+            path: match[1],
+            value: match[3],
+            type: classifyThemeToken(match[1], match[3]),
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+        });
+    }
+    return (0, utils_1.uniqueBy)(tokens, (token) => `${token.path}:${token.value}`).slice(0, 300);
+}
+function extractInlineStyles(content) {
+    const styles = [];
+    for (const match of content.matchAll(/\bstyle\s*=\s*(["'])([^"']+)\1/g)) {
+        styles.push({
+            tag: readTagBefore(content, match.index ?? 0),
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+            raw: (0, utils_1.truncate)(match[0], 500),
+            properties: parseCssDeclarations(match[2]),
+        });
+    }
+    for (const match of content.matchAll(/\bstyle\s*=\s*\{\{([\s\S]{1,1200}?)\}\}/g)) {
+        styles.push({
+            tag: readTagBefore(content, match.index ?? 0),
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+            raw: (0, utils_1.truncate)(match[0], 700),
+            properties: parseJsStyleObject(match[1]),
+        });
+    }
+    return styles.slice(0, 120);
+}
+function nearestCssSelector(content, index) {
+    const openIndex = content.lastIndexOf('{', index);
+    if (openIndex < 0) {
+        return undefined;
+    }
+    const previousClose = content.lastIndexOf('}', openIndex);
+    const selector = content
+        .slice(previousClose + 1, openIndex)
+        .replace(/\/\*[\s\S]*?\*\//g, ' ')
+        .trim()
+        .replace(/\s+/g, ' ');
+    return selector ? (0, utils_1.truncate)(selector, 240) : undefined;
+}
+function parseCssDeclarations(block) {
+    return splitTopLevel(block, ';')
+        .map((declaration) => {
+        const separatorIndex = declaration.indexOf(':');
+        if (separatorIndex <= 0) {
+            return null;
+        }
+        const property = declaration.slice(0, separatorIndex).trim();
+        const value = declaration.slice(separatorIndex + 1).trim();
+        if (!property || !value || property.startsWith('@')) {
+            return null;
+        }
+        return { property, value };
+    })
+        .filter((item) => Boolean(item));
+}
+function parseJsStyleObject(block) {
+    return parseTopLevelObjectEntries(`{${block}}`)
+        .map((entry) => {
+        const value = firstStringLiteral(entry.rawValue) ?? cleanupBareValue(entry.rawValue);
+        if (!value) {
+            return null;
+        }
+        return {
+            property: (0, utils_1.toKebabCase)(entry.key),
+            value,
+        };
+    })
+        .filter((item) => Boolean(item));
+}
+function readTagBefore(content, index) {
+    const start = content.lastIndexOf('<', index);
+    if (start < 0 || ['/', '!', '?'].includes(content[start + 1] ?? '')) {
+        return undefined;
+    }
+    const match = content.slice(start + 1, index).match(/^([A-Za-z][A-Za-z0-9:._-]*)/);
+    return match?.[1];
+}
+function readBalancedCall(content, startIndex) {
+    const openIndex = content.indexOf('(', startIndex);
+    if (openIndex < 0) {
+        return undefined;
+    }
+    const args = readBalancedRange(content, openIndex, '(', ')');
+    return args ? content.slice(startIndex, openIndex) + args : undefined;
+}
+function readBalancedBlock(content, openIndex) {
+    return readBalancedRange(content, openIndex, '{', '}');
+}
+function readBalancedRange(content, openIndex, openChar, closeChar) {
+    if (content[openIndex] !== openChar) {
+        return undefined;
+    }
+    let depth = 0;
+    for (let index = openIndex; index < content.length; index += 1) {
+        const char = content[index];
+        if (char === '"' || char === "'" || char === '`') {
+            index = skipQuoted(content, index, char);
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '/') {
+            const lineEnd = content.indexOf('\n', index + 2);
+            index = lineEnd >= 0 ? lineEnd : content.length;
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            const commentEnd = content.indexOf('*/', index + 2);
+            index = commentEnd >= 0 ? commentEnd + 1 : content.length;
+            continue;
+        }
+        if (char === openChar) {
+            depth += 1;
+            continue;
+        }
+        if (char === closeChar) {
+            depth -= 1;
+            if (depth === 0) {
+                return content.slice(openIndex, index + 1);
+            }
+        }
+    }
+    return undefined;
+}
+function skipQuoted(content, quoteIndex, quote) {
+    for (let index = quoteIndex + 1; index < content.length; index += 1) {
+        if (content[index] === '\\') {
+            index += 1;
+            continue;
+        }
+        if (content[index] === quote) {
+            return index;
+        }
+    }
+    return content.length - 1;
+}
+function isInsideQuotedString(content, targetIndex) {
+    let quote = null;
+    for (let index = 0; index < targetIndex; index += 1) {
+        const char = content[index];
+        if (quote) {
+            if (char === '\\') {
+                index += 1;
+                continue;
+            }
+            if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '/') {
+            const lineEnd = content.indexOf('\n', index + 2);
+            index = lineEnd >= 0 ? lineEnd : targetIndex;
+            continue;
+        }
+        if (char === '/' && content[index + 1] === '*') {
+            const commentEnd = content.indexOf('*/', index + 2);
+            index = commentEnd >= 0 ? commentEnd + 1 : targetIndex;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+        }
+    }
+    return Boolean(quote);
+}
+function extractClassListsFromStrings(source) {
+    return analyzeClassSource(source).classes;
+}
+function analyzeClassSource(source) {
+    const classes = new Set();
+    const defaultClasses = new Set();
+    const conditionalClasses = new Set();
+    const directCandidate = directClassCandidate(source);
+    const directClasses = directCandidate ? splitClassList(directCandidate) : [];
+    if (directCandidate && looksLikeClassList(directClasses)) {
+        for (const className of directClasses) {
+            classes.add(className);
+            defaultClasses.add(className);
+        }
+        return toClassSourceAnalysis(classes, defaultClasses, conditionalClasses);
+    }
+    for (const literal of readStringLiteralRanges(source)) {
+        const literalClasses = splitClassList(literal.value);
+        if (!looksLikeClassList(literalClasses)) {
+            continue;
+        }
+        const targetSet = isConditionalClassLiteral(source, literal.start)
+            ? conditionalClasses
+            : defaultClasses;
+        for (const className of literalClasses) {
+            classes.add(className);
+            targetSet.add(className);
+        }
+    }
+    return toClassSourceAnalysis(classes, defaultClasses, conditionalClasses);
+}
+function toClassSourceAnalysis(classes, defaultClasses, conditionalClasses) {
+    const allClasses = Array.from(classes).sort();
+    const defaultClassList = Array.from(defaultClasses).sort();
+    const conditionalClassList = Array.from(conditionalClasses).sort();
+    return {
+        classes: allClasses,
+        defaultClasses: defaultClassList,
+        conditionalClasses: conditionalClassList,
+        decorativeAccentClasses: allClasses.filter(isDecorativeAccentClass).sort(),
+    };
+}
+function isConditionalClassLiteral(source, literalStart) {
+    const openIndex = source.indexOf('(');
+    const before = source.slice(Math.max(openIndex + 1, literalStart - 140), literalStart);
+    const sanitizedBefore = before.replace(/(["'`])(?:\\.|(?!\1)[\s\S])*\1/g, ' ');
+    const segmentStart = Math.max(sanitizedBefore.lastIndexOf(','), sanitizedBefore.lastIndexOf('('), sanitizedBefore.lastIndexOf('{'), sanitizedBefore.lastIndexOf('['));
+    const segment = sanitizedBefore.slice(segmentStart + 1);
+    return /(?:&&|\?|:)\s*[^"'`]*$/.test(segment);
+}
+function readStringLiteralRanges(source) {
+    const literals = [];
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        if (char !== '"' && char !== "'" && char !== '`') {
+            continue;
+        }
+        const end = skipQuoted(source, index, char);
+        literals.push({
+            value: source.slice(index + 1, end),
+            start: index,
+            end,
+        });
+        index = end;
+    }
+    return literals;
+}
+function directClassCandidate(source) {
+    const trimmed = source.trim();
+    if (!trimmed ||
+        trimmed.startsWith('{') ||
+        /\b(?:cn|clsx|classNames|twMerge|cva|buttonVariants)\s*\(/.test(trimmed)) {
+        return undefined;
+    }
+    const withoutTemplateExpressions = trimmed.replace(/\$\{[\s\S]*?\}/g, ' ');
+    if (/[{}"'`,;]/.test(withoutTemplateExpressions)) {
+        return undefined;
+    }
+    return withoutTemplateExpressions;
+}
+function readStringLiterals(source) {
+    return readStringLiteralRanges(source).map((literal) => literal.value);
+}
+function looksLikeClassList(classes) {
+    if (!classes.length) {
+        return false;
+    }
+    const likelyCount = classes.filter(isLikelyStyleClass).length;
+    return likelyCount >= Math.min(2, classes.length) || likelyCount / classes.length >= 0.5;
+}
+function isLikelyStyleClass(className) {
+    const base = className.split(':').pop() ?? className;
+    return (/^(?:-?m[trblxy]?|-?p[trblxy]?|flex|grid|block|inline|hidden|items-|justify-|content-|self-|gap-|space-|w-|h-|min-|max-|size-|rounded|border|bg-|from-|via-|to-|text-|font-|leading-|tracking-|shadow|ring|outline|opacity|transition|duration|ease|animate-|hover|focus|active|disabled|dark|sm|md|lg|xl|2xl|container|sr-only|absolute|relative|fixed|sticky|inset-|top-|right-|bottom-|left-|z-|overflow-|object-|aspect-|backdrop-|blur|scale-|translate-|rotate-)/.test(className) ||
+        /^(?:button|btn|card|panel|surface|badge|pill|chip|nav|field|input|dialog|modal|drawer|sheet|container|wrapper|section|hero|header|footer|sidebar|menu)$/.test(base) ||
+        className.includes('[') ||
+        className.includes(']'));
+}
+function firstStringLiteral(source) {
+    return readStringLiterals(source)[0];
+}
+function extractNamedObjectBlock(source, name) {
+    const pattern = new RegExp(`\\b${(0, utils_1.escapeRegExp)(name)}\\s*:`, 'g');
+    for (const match of source.matchAll(pattern)) {
+        const openIndex = source.indexOf('{', (match.index ?? 0) + match[0].length);
+        if (openIndex < 0) {
+            continue;
+        }
+        return readBalancedBlock(source, openIndex);
+    }
+    return undefined;
+}
+function parseVariantGroups(block) {
+    const variants = {};
+    for (const entry of parseTopLevelObjectEntries(block)) {
+        if (!entry.rawValue.trim().startsWith('{')) {
+            continue;
+        }
+        const values = parseClassValueMap(entry.rawValue);
+        if (Object.keys(values).length) {
+            variants[entry.key] = values;
+        }
+    }
+    return variants;
+}
+function parseStringValueMap(block) {
+    const values = {};
+    for (const entry of parseTopLevelObjectEntries(block)) {
+        const value = firstStringLiteral(entry.rawValue) ?? cleanupBareValue(entry.rawValue);
+        if (value) {
+            values[entry.key] = value;
+        }
+    }
+    return values;
+}
+function parseClassValueMap(block) {
+    const values = {};
+    for (const entry of parseTopLevelObjectEntries(block)) {
+        const classes = extractClassListsFromStrings(entry.rawValue);
+        if (classes.length) {
+            values[entry.key] = classes;
+        }
+    }
+    return values;
+}
+function parseTopLevelObjectEntries(block) {
+    const source = stripOuterBraces(block);
+    const entries = [];
+    let index = 0;
+    while (index < source.length) {
+        index = skipSeparators(source, index);
+        if (index >= source.length) {
+            break;
+        }
+        const keyResult = readObjectKey(source, index);
+        if (!keyResult) {
+            index += 1;
+            continue;
+        }
+        index = skipWhitespace(source, keyResult.nextIndex);
+        if (source[index] !== ':') {
+            index += 1;
+            continue;
+        }
+        index = skipWhitespace(source, index + 1);
+        const valueEnd = readObjectValueEnd(source, index);
+        const rawValue = source.slice(index, valueEnd).trim();
+        if (rawValue) {
+            entries.push({ key: keyResult.key, rawValue });
+        }
+        index = valueEnd + 1;
+    }
+    return entries;
+}
+function stripOuterBraces(block) {
+    const trimmed = block.trim();
+    return trimmed.startsWith('{') && trimmed.endsWith('}') ? trimmed.slice(1, -1) : trimmed;
+}
+function skipSeparators(source, index) {
+    let cursor = index;
+    while (cursor < source.length && /[\s,]/.test(source[cursor])) {
+        cursor += 1;
+    }
+    return cursor;
+}
+function skipWhitespace(source, index) {
+    let cursor = index;
+    while (cursor < source.length && /\s/.test(source[cursor])) {
+        cursor += 1;
+    }
+    return cursor;
+}
+function readObjectKey(source, index) {
+    const char = source[index];
+    if (char === '"' || char === "'" || char === '`') {
+        const end = skipQuoted(source, index, char);
+        return { key: source.slice(index + 1, end), nextIndex: end + 1 };
+    }
+    const match = source.slice(index).match(/^([A-Za-z_$][\w$-]*|true|false|\d+)/);
+    return match ? { key: match[1], nextIndex: index + match[0].length } : undefined;
+}
+function readObjectValueEnd(source, index) {
+    let cursor = index;
+    let parenDepth = 0;
+    let blockDepth = 0;
+    let arrayDepth = 0;
+    while (cursor < source.length) {
+        const char = source[cursor];
+        if (char === '"' || char === "'" || char === '`') {
+            cursor = skipQuoted(source, cursor, char) + 1;
+            continue;
+        }
+        if (char === '(') {
+            parenDepth += 1;
+        }
+        else if (char === ')') {
+            parenDepth = Math.max(0, parenDepth - 1);
+        }
+        else if (char === '{') {
+            blockDepth += 1;
+        }
+        else if (char === '}') {
+            if (blockDepth === 0) {
+                break;
+            }
+            blockDepth -= 1;
+        }
+        else if (char === '[') {
+            arrayDepth += 1;
+        }
+        else if (char === ']') {
+            arrayDepth = Math.max(0, arrayDepth - 1);
+        }
+        else if (char === ',' && parenDepth === 0 && blockDepth === 0 && arrayDepth === 0) {
+            break;
+        }
+        cursor += 1;
+    }
+    return cursor;
+}
+function splitTopLevel(source, delimiter) {
+    const parts = [];
+    let start = 0;
+    let parenDepth = 0;
+    let blockDepth = 0;
+    let arrayDepth = 0;
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === '"' || char === "'" || char === '`') {
+            index = skipQuoted(source, index, char);
+            continue;
+        }
+        if (char === '(') {
+            parenDepth += 1;
+        }
+        else if (char === ')') {
+            parenDepth = Math.max(0, parenDepth - 1);
+        }
+        else if (char === '{') {
+            blockDepth += 1;
+        }
+        else if (char === '}') {
+            blockDepth = Math.max(0, blockDepth - 1);
+        }
+        else if (char === '[') {
+            arrayDepth += 1;
+        }
+        else if (char === ']') {
+            arrayDepth = Math.max(0, arrayDepth - 1);
+        }
+        else if (char === delimiter && parenDepth === 0 && blockDepth === 0 && arrayDepth === 0) {
+            parts.push(source.slice(start, index));
+            start = index + 1;
+        }
+    }
+    parts.push(source.slice(start));
+    return parts;
+}
+function cleanupBareValue(value) {
+    const cleaned = value
+        .trim()
+        .replace(/,$/, '')
+        .replace(/^['"`]|['"`]$/g, '');
+    return cleaned && cleaned.length < 220 ? cleaned : undefined;
+}
+function classifyThemeToken(key, value) {
+    const haystack = `${key} ${value}`.toLowerCase();
+    if (/(#[0-9a-f]{3,8}\b|rgb\(|rgba\(|hsl\(|hsla\(|oklch\(|color|foreground|background|surface|border|ring|accent|primary|secondary|muted|destructive)/.test(haystack)) {
+        return 'color';
+    }
+    if (/(radius|rounded|border-radius)/.test(haystack)) {
+        return 'radius';
+    }
+    if (/(spacing|space|gap|padding|margin|inset)/.test(haystack)) {
+        return 'spacing';
+    }
+    if (/(font|family|weight|leading|tracking|letter|line-height)/.test(haystack)) {
+        return 'font';
+    }
+    if (/(shadow|elevation|drop-shadow)/.test(haystack)) {
+        return 'shadow';
+    }
+    if (/(size|width|height|text-|rem|px|vh|vw|%)/.test(haystack)) {
+        return 'size';
+    }
+    return 'unknown';
+}
+function flattenJsonTokens(value, pathParts, tokens) {
+    if (value === null || value === undefined) {
+        return;
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        const pathValue = pathParts.join('.');
+        const stringValue = String(value);
+        if (pathValue) {
+            tokens.push({
+                path: pathValue,
+                value: stringValue,
+                type: classifyThemeToken(pathValue, stringValue),
+            });
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value
+            .slice(0, 80)
+            .forEach((item, index) => flattenJsonTokens(item, [...pathParts, String(index)], tokens));
+        return;
+    }
+    if (typeof value === 'object') {
+        for (const [key, childValue] of Object.entries(value).slice(0, 200)) {
+            flattenJsonTokens(childValue, [...pathParts, key], tokens);
+        }
+    }
+}
+function readOpeningTags(content) {
+    const tags = [];
+    for (let index = 0; index < content.length; index += 1) {
+        if (content[index] !== '<' || !/[A-Za-z]/.test(content[index + 1] ?? '')) {
+            continue;
+        }
+        const start = index;
+        let cursor = index + 1;
+        while (cursor < content.length && /[A-Za-z0-9:._-]/.test(content[cursor])) {
+            cursor += 1;
+        }
+        const originalTag = content.slice(index + 1, cursor);
+        if (!originalTag) {
+            continue;
+        }
+        let braceDepth = 0;
+        let end = -1;
+        for (; cursor < content.length; cursor += 1) {
+            const char = content[cursor];
+            if (char === '"' || char === "'" || char === '`') {
+                cursor = skipQuoted(content, cursor, char);
+                continue;
+            }
+            if (char === '{') {
+                braceDepth += 1;
+                continue;
+            }
+            if (char === '}') {
+                braceDepth = Math.max(0, braceDepth - 1);
+                continue;
+            }
+            if (char === '>' && braceDepth === 0) {
+                end = cursor;
+                break;
+            }
+        }
+        if (end < 0) {
+            continue;
+        }
+        const attrs = content.slice(start + originalTag.length + 1, end);
+        tags.push({
+            originalTag,
+            attrs,
+            start,
+            end,
+            selfClosing: /\/\s*$/.test(attrs),
+        });
+        index = end;
+    }
+    annotateOpeningTags(content, tags);
+    return tags;
+}
+function annotateOpeningTags(content, tags) {
+    for (const tag of tags) {
+        tag.closeEnd = findClosingTagEnd(content, tag);
+    }
+    for (const [index, tag] of tags.entries()) {
+        let parentIndex;
+        let parentStart = -1;
+        for (let candidateIndex = 0; candidateIndex < index; candidateIndex += 1) {
+            const candidate = tags[candidateIndex];
+            const candidateCloseEnd = candidate.closeEnd ?? candidate.end;
+            if (candidate.start < tag.start &&
+                candidateCloseEnd > tag.end &&
+                candidate.start > parentStart) {
+                parentIndex = candidateIndex;
+                parentStart = candidate.start;
+            }
+        }
+        tag.parentIndex = parentIndex;
+        tag.depth = parentIndex === undefined ? 0 : Math.min(24, (tags[parentIndex].depth ?? 0) + 1);
+    }
+}
+function findClosingTagEnd(content, tagInfo) {
+    if (tagInfo.selfClosing || isVoidHtmlElement(tagInfo.originalTag)) {
+        return tagInfo.end;
+    }
+    const tagPattern = new RegExp(`<\\/?${(0, utils_1.escapeRegExp)(tagInfo.originalTag)}(?=\\s|>|\\/)[\\s\\S]*?>`, 'g');
+    tagPattern.lastIndex = tagInfo.end + 1;
+    let depth = 1;
+    for (const match of content.matchAll(tagPattern)) {
+        const raw = match[0];
+        if (raw.startsWith('</')) {
+            depth -= 1;
+            if (depth === 0) {
+                return (match.index ?? 0) + raw.length;
+            }
+            continue;
+        }
+        if (!/\/\s*>$/.test(raw)) {
+            depth += 1;
+        }
+    }
+    return undefined;
+}
+function isVoidHtmlElement(tag) {
+    return /^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/i.test(tag);
+}
+function extractElementLabel(content, tagInfo) {
+    if (tagInfo.selfClosing || tagInfo.originalTag.includes('.')) {
+        return undefined;
+    }
+    const closeTag = `</${tagInfo.originalTag}>`;
+    const closeIndex = content.indexOf(closeTag, tagInfo.end + 1);
+    if (closeIndex < 0 || closeIndex - tagInfo.end > 1800) {
+        return undefined;
+    }
+    const label = stripTags(content.slice(tagInfo.end + 1, closeIndex))
+        .replace(/\{[\s\S]*?\}/g, ' ')
+        .trim()
+        .replace(/\s+/g, ' ');
+    return label ? (0, utils_1.truncate)(label, 120) : undefined;
+}
+function readClassSource(attrs) {
+    const classNames = ['className', 'class', 'class:list', 'classList', ':class', 'ngClass'];
+    const sources = [];
+    for (const className of classNames) {
+        const source = readAttrSource(attrs, className);
+        if (source) {
+            sources.push(source);
+        }
+    }
+    return sources.length ? sources.join(' ') : undefined;
+}
+function readUiProps(attrs) {
+    const props = {};
+    const names = [
+        'variant',
+        'size',
+        'intent',
+        'tone',
+        'color',
+        'appearance',
+        'type',
+        'role',
+        'href',
+        'disabled',
+        'checked',
+        'aria-label',
+        'data-slot',
+        'asChild',
+    ];
+    for (const name of names) {
+        const value = (0, utils_1.readAttr)(attrs, name) ?? readAttrSource(attrs, name);
+        if (value) {
+            props[name] = (0, utils_1.truncate)(cleanupAttrValue(value), 160);
+            continue;
+        }
+        if (hasBooleanAttr(attrs, name)) {
+            props[name] = 'true';
+        }
+    }
+    return props;
+}
+function readVariantProps(props) {
+    const variantProps = {};
+    for (const name of ['variant', 'size', 'intent', 'tone', 'color', 'appearance', 'type']) {
+        const value = props[name];
+        if (value) {
+            variantProps[name] = value;
+        }
+    }
+    return variantProps;
+}
+function readAttrSource(attrs, name) {
+    const pattern = new RegExp(`(?:^|\\s)${(0, utils_1.escapeRegExp)(name)}\\s*=`, 'g');
+    const match = pattern.exec(attrs);
+    if (!match) {
+        return undefined;
+    }
+    return readAttrValueSource(attrs, match.index + match[0].length);
+}
+function readAttrValueSource(attrs, index) {
+    const cursor = skipWhitespace(attrs, index);
+    const char = attrs[cursor];
+    if (!char) {
+        return undefined;
+    }
+    if (char === '"' || char === "'" || char === '`') {
+        const end = skipQuoted(attrs, cursor, char);
+        return attrs.slice(cursor + 1, end);
+    }
+    if (char === '{') {
+        return readBalancedBlock(attrs, cursor);
+    }
+    const match = attrs.slice(cursor).match(/^[^\s>]+/);
+    return match?.[0];
+}
+function cleanupAttrValue(value) {
+    let cleaned = value.trim();
+    if (cleaned.startsWith('{') && cleaned.endsWith('}')) {
+        cleaned = cleaned.slice(1, -1).trim();
+    }
+    const first = cleaned[0];
+    const last = cleaned[cleaned.length - 1];
+    if ((first === '"' || first === "'" || first === '`') && first === last) {
+        cleaned = cleaned.slice(1, -1).trim();
+    }
+    return cleaned;
+}
+function hasBooleanAttr(attrs, name) {
+    return new RegExp(`(?:^|\\s)${(0, utils_1.escapeRegExp)(name)}(?:\\s|$|>)`).test(attrs);
+}
+function groupTailwindClasses(classes) {
+    const groups = {};
+    for (const className of classes) {
+        const variants = className.split(':');
+        const base = variants[variants.length - 1];
+        if (variants.length > 1) {
+            const prefixes = variants.slice(0, -1);
+            if (prefixes.some((prefix) => /^(sm|md|lg|xl|2xl|max-|min-)/.test(prefix))) {
+                addClassGroup(groups, 'responsive', className);
+            }
+            if (prefixes.some((prefix) => /^(hover|focus|active|disabled|visited|dark|group|peer|aria|data)/.test(prefix))) {
+                addClassGroup(groups, 'state', className);
+            }
+        }
+        if (/^(flex|grid|block|inline|hidden|items-|justify-|content-|self-|place-|order-|col-|row-)/.test(base)) {
+            addClassGroup(groups, 'layout', className);
+        }
+        else if (/^(?:-?m[trblxy]?|-?p[trblxy]?|gap-|space-|inset-|top-|right-|bottom-|left-)/.test(base)) {
+            addClassGroup(groups, 'spacing', className);
+        }
+        else if (/^(w-|h-|min-|max-|size-|aspect-|basis-|grow|shrink)/.test(base)) {
+            addClassGroup(groups, 'sizing', className);
+        }
+        else if (/^(bg-|from-|via-|to-|text-|decoration-|accent-|caret-|fill-|stroke-)/.test(base)) {
+            addClassGroup(groups, 'color', className);
+        }
+        else if (/^(rounded|border|divide-|outline|ring)/.test(base)) {
+            addClassGroup(groups, 'border', className);
+        }
+        else if (/^(font-|text-|leading-|tracking-|line-clamp|list-|whitespace-|break-|truncate)/.test(base)) {
+            addClassGroup(groups, 'typography', className);
+        }
+        else if (/^(shadow|opacity|blur|backdrop|mix-|bg-blend|drop-shadow|filter)/.test(base)) {
+            addClassGroup(groups, 'effects', className);
+        }
+        else if (/^(absolute|relative|fixed|sticky|z-|overflow-|object-)/.test(base)) {
+            addClassGroup(groups, 'position', className);
+        }
+        else if (/^(transition|duration|ease|delay|animate-|transform|scale-|rotate-|translate-)/.test(base)) {
+            addClassGroup(groups, 'motion', className);
+        }
+        else {
+            addClassGroup(groups, 'other', className);
+        }
+    }
+    return Object.fromEntries(Object.entries(groups).map(([group, values]) => [group, (0, utils_1.unique)(values).slice(0, 80)]));
+}
+function addClassGroup(groups, group, className) {
+    groups[group] = [...(groups[group] ?? []), className];
+}
+function mergeClassGroups(groups) {
+    const merged = {};
+    for (const group of groups) {
+        for (const [name, values] of Object.entries(group)) {
+            merged[name] = (0, utils_1.unique)([...(merged[name] ?? []), ...values]).slice(0, 120);
+        }
+    }
+    return merged;
+}
+function mergeVariantProps(variants) {
+    const merged = {};
+    for (const variant of variants) {
+        for (const [name, value] of Object.entries(variant)) {
+            merged[name] = (0, utils_1.unique)([...(merged[name] ?? []), value]).slice(0, 40);
+        }
+    }
+    return merged;
+}
+function isCompositionElement(element) {
+    return ([
+        'section',
+        'layout',
+        'card',
+        'form',
+        'nav',
+        'table',
+        'heading',
+        'badge',
+        'button',
+        'input',
+    ].includes(element.kind) ||
+        Boolean(element.layoutRole) ||
+        element.classes.some((className) => /^(?:section-frame|context-surface|brand-spectrum-card|load-in-section|reveal-up)$/.test(className.replace(/^[a-z0-9-]+:/, ''))));
+}
+function filterClasses(classes, predicate) {
+    return (0, utils_1.unique)(classes.filter(predicate));
+}
+function isResponsiveClass(className) {
+    return /^(?:sm|md|lg|xl|2xl|max-|min-):/.test(className);
+}
+function isSpacingClass(className) {
+    const base = (0, utils_1.classBase)(className);
+    return /^(?:-?m[trblxy]?|-?p[trblxy]?|gap-|space-|inset-|top-|right-|bottom-|left-)/.test(base);
+}
+function isSurfaceClass(className) {
+    const base = (0, utils_1.classBase)(className);
+    return (/^(?:bg-|border|rounded|shadow|ring|outline|divide-|opacity|backdrop|blur|drop-shadow)/.test(base) ||
+        ['section-frame', 'context-surface', 'brand-spectrum-card', 'brand-spectrum-line'].includes(base));
+}
+function isDecorativeAccentClass(className) {
+    const base = (0, utils_1.classBase)(className);
+    return (['brand-spectrum-card', 'brand-spectrum-line'].includes(base) ||
+        base === 'bg-[var(--brand-spectrum-gradient)]' ||
+        /^(?:shadow|drop-shadow)-\[.*rgba\(96,48,232/.test(base) ||
+        /^(?:bg|border)-\[rgba\(96,48,232/.test(base));
+}
+function isTypographyClass(className) {
+    const base = (0, utils_1.classBase)(className);
+    return /^(?:text-|font-|leading-|tracking-|line-clamp|whitespace-|break-|truncate|max-w-|text-balance)/.test(base);
+}
+function groupClassExpressionsByTarget(expressions) {
+    const grouped = {};
+    for (const expression of expressions) {
+        const target = expression.target ?? expression.kind;
+        grouped[target] = [
+            ...(grouped[target] ?? []),
+            {
+                kind: expression.kind,
+                line: expression.line,
+                classes: expression.classes,
+                defaultClasses: expression.defaultClasses,
+                conditionalClasses: expression.conditionalClasses,
+                decorativeAccentClasses: expression.classes.filter(isDecorativeAccentClass),
+                classGroups: groupTailwindClasses(expression.classes),
+                raw: (0, utils_1.truncate)(expression.raw, 600),
+            },
+        ].slice(0, 40);
+    }
+    return grouped;
+}
+function buildComponentSlots(elements) {
+    return elements
+        .filter((element) => /^(Card|CardHeader|CardContent|CardFooter|CardTitle|CardDescription|Container|Section)$/i.test(element.originalTag))
+        .slice(0, 80)
+        .map((element) => ({
+        index: element.index,
+        tag: element.originalTag,
+        kind: element.kind,
+        layoutRole: element.layoutRole,
+        line: element.line,
+        classes: element.classes,
+        defaultClasses: element.defaultClasses,
+        conditionalClasses: element.conditionalClasses,
+        decorativeAccentClasses: element.decorativeAccentClasses,
+        classGroups: element.classGroups,
+        parentIndex: element.parentIndex,
+        parentTag: element.parentTag,
+        childSummary: element.childSummary,
+        label: element.label,
+    }));
+}
+function createUiCompositionGuidance(file) {
+    const classes = new Set(file.classReferences);
+    const guidance = [];
+    if (classes.has('sm:section-frame') && classes.has('bg-transparent')) {
+        guidance.push('Preserve mobile-first shell behavior: transparent/unframed on mobile, section-frame at sm and above.');
+    }
+    if (classes.has('p-[var(--panel-padding)]') &&
+        (classes.has('p-3') || classes.has('p-4') || classes.has('sm:p-6') || classes.has('sm:p-8'))) {
+        guidance.push('Do not apply panel padding everywhere; card and section padding is slot-specific and responsive.');
+    }
+    if (classes.has('hidden') &&
+        (classes.has('sm:block') || classes.has('md:block') || classes.has('sm:inline-flex'))) {
+        guidance.push('Preserve responsive visibility rules; some secondary copy, cards, and CTAs are intentionally hidden on small screens.');
+    }
+    if (classes.has('max-w-[11ch]') ||
+        classes.has('leading-[0.98]') ||
+        classes.has('sm:text-balance')) {
+        guidance.push('Hero headline typography is exact: keep narrow mobile measure, tight leading, and desktop balancing classes.');
+    }
+    if (file.imports.some((item) => item.includes('/ui/card'))) {
+        guidance.push('Card is a shell primitive; use CardHeader/CardContent/CardFooter usage classes for padding and hierarchy.');
+    }
+    if (classes.has('section-frame') || classes.has('context-surface')) {
+        guidance.push('Use section-frame/context-surface only for framed technical panels, not every repeated card.');
+    }
+    if (file.classReferences.some(isDecorativeAccentClass)) {
+        guidance.push('Treat brand-spectrum-card and purple glow shadow classes as accent/highlight-only; do not use them for default repeated cards unless the source element is explicitly current, highlighted, or featured.');
+    }
+    return guidance;
+}
+function createUiPatternGuidance(kind, decorativeAccentClasses) {
+    const guidance = [];
+    if (kind === 'card') {
+        guidance.push('Use defaultClasses for ordinary cards; decorativeAccentClasses are opt-in highlight treatments.');
+    }
+    if (decorativeAccentClasses.length) {
+        guidance.push('Do not apply decorativeAccentClasses by default. They are reserved for explicitly featured/current/highlighted states.');
+    }
+    return guidance;
+}
+function extractTailwindUtilities(classReferences) {
+    return classReferences
+        .filter((className) => /^(?:-?m[trblxy]?|-?p[trblxy]?|flex|grid|block|inline|hidden|items-|justify-|gap-|space-|w-|h-|min-|max-|rounded|border|bg-|text-|font-|leading-|tracking-|shadow|ring|opacity|transition|duration|ease|hover:|focus:|active:|disabled:|dark:|sm:|md:|lg:|xl:|2xl:|container|sr-only)/.test(className))
+        .slice(0, 160);
+}
+function extractPackageDependencies(relPath, content) {
+    const baseName = path.basename(relPath);
+    if (baseName === 'package.json' || baseName === 'composer.json') {
+        try {
+            const parsed = JSON.parse(content);
+            return (0, utils_1.unique)([
+                ...Object.keys(parsed.dependencies ?? {}),
+                ...Object.keys(parsed.devDependencies ?? {}),
+                ...Object.keys(parsed.require ?? {}),
+                ...Object.keys(parsed.requireDev ?? {}),
+                ...Object.keys(parsed['require-dev'] ?? {}),
+            ]).sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    if (baseName === 'requirements.txt') {
+        return (0, utils_1.unique)(content
+            .split('\n')
+            .map((line) => line
+            .trim()
+            .replace(/\s*#.*$/, '')
+            .split(/[<>=~!]/)[0])
+            .filter((line) => Boolean(line) && !line.startsWith('-'))).sort();
+    }
+    if (baseName === 'Gemfile') {
+        return (0, utils_1.unique)(Array.from(content.matchAll(/^\s*gem\s+['"]([^'"]+)['"]/gm)).map((match) => match[1])).sort();
+    }
+    if (baseName === 'go.mod') {
+        return (0, utils_1.unique)(Array.from(content.matchAll(/^\s*(?:require\s+)?([a-zA-Z0-9_.\-/]+)\s+v\d/gm)).map((match) => match[1])).sort();
+    }
+    if (baseName === 'Cargo.toml' || baseName === 'pyproject.toml') {
+        return (0, utils_1.unique)(Array.from(content.matchAll(/^\s*([A-Za-z0-9_.-]+)\s*=\s*["{]/gm)).map((match) => match[1])).sort();
+    }
+    return [];
+}
+function extractUiElements(content, relPath) {
+    if (!isUiFile(relPath) &&
+        !isTemplateFile(relPath) &&
+        !/\.(html|htm|php|phtml|erb|twig|blade\.php)$/.test(relPath)) {
+        return [];
+    }
+    const elements = [];
+    const tags = readOpeningTags(content);
+    for (const [index, tagInfo] of tags.entries()) {
+        const tag = tagInfo.originalTag.toLowerCase();
+        const attrs = tagInfo.attrs;
+        const label = extractElementLabel(content, tagInfo);
+        const classSource = readClassSource(attrs);
+        const classAnalysis = classSource ? analyzeClassSource(classSource) : undefined;
+        const classes = classAnalysis?.classes ?? [];
+        const role = (0, utils_1.readAttr)(attrs, 'role');
+        const props = readUiProps(attrs);
+        const variants = readVariantProps(props);
+        const kind = classifyUiElement(tagInfo.originalTag, attrs, classes, role);
+        const parentTagInfo = tagInfo.parentIndex === undefined ? undefined : tags[tagInfo.parentIndex];
+        const parentClassSource = parentTagInfo ? readClassSource(parentTagInfo.attrs) : undefined;
+        const parentClasses = parentClassSource ? analyzeClassSource(parentClassSource).classes : [];
+        const parentRole = parentTagInfo ? (0, utils_1.readAttr)(parentTagInfo.attrs, 'role') : undefined;
+        const parentKind = parentTagInfo
+            ? classifyUiElement(parentTagInfo.originalTag, parentTagInfo.attrs, parentClasses, parentRole)
+            : undefined;
+        const layoutRole = deriveLayoutRole(tagInfo.originalTag, kind, classes, label);
+        const responsiveClasses = classes.filter(isResponsiveClass);
+        const stateClasses = classes.filter(isStateClass);
+        const childSummary = summarizeDirectUiChildren(content, tags, index);
+        if (kind === 'unknown') {
+            continue;
+        }
+        elements.push({
+            index,
+            kind,
+            tag,
+            originalTag: tagInfo.originalTag,
+            line: (0, utils_1.lineNumberAt)(content, tagInfo.start),
+            ...(tagInfo.depth ? { depth: tagInfo.depth } : {}),
+            ...(tagInfo.parentIndex !== undefined ? { parentIndex: tagInfo.parentIndex } : {}),
+            ...(parentKind && parentKind !== 'unknown' ? { parentKind } : {}),
+            ...(parentTagInfo ? { parentTag: parentTagInfo.originalTag } : {}),
+            ...(parentClasses.length ? { parentClasses: parentClasses.slice(0, 40) } : {}),
+            ...(parentClasses.length ? { parentClassGroups: groupTailwindClasses(parentClasses) } : {}),
+            ...(layoutRole ? { layoutRole } : {}),
+            ...(label ? { label } : {}),
+            classes,
+            ...(classAnalysis?.defaultClasses.length
+                ? { defaultClasses: classAnalysis.defaultClasses.slice(0, 80) }
+                : {}),
+            ...(classAnalysis?.conditionalClasses.length
+                ? { conditionalClasses: classAnalysis.conditionalClasses.slice(0, 80) }
+                : {}),
+            ...(classAnalysis?.decorativeAccentClasses.length
+                ? { decorativeAccentClasses: classAnalysis.decorativeAccentClasses.slice(0, 40) }
+                : {}),
+            ...(classSource ? { classSource: (0, utils_1.truncate)(classSource, 700) } : {}),
+            classGroups: groupTailwindClasses(classes),
+            ...(responsiveClasses.length ? { responsiveClasses } : {}),
+            ...(stateClasses.length ? { stateClasses } : {}),
+            ...(childSummary.length ? { childSummary } : {}),
+            ...((0, utils_1.readAttr)(attrs, 'id') ? { id: (0, utils_1.readAttr)(attrs, 'id') } : {}),
+            ...(role ? { role } : {}),
+            ...((0, utils_1.readAttr)(attrs, 'type') ? { type: (0, utils_1.readAttr)(attrs, 'type') } : {}),
+            ...((0, utils_1.readAttr)(attrs, 'href') ? { href: (0, utils_1.readAttr)(attrs, 'href') } : {}),
+            ...((0, utils_1.readAttr)(attrs, 'action') ? { action: (0, utils_1.readAttr)(attrs, 'action') } : {}),
+            ...((0, utils_1.readAttr)(attrs, 'method') ? { method: (0, utils_1.readAttr)(attrs, 'method')?.toUpperCase() } : {}),
+            ...(Object.keys(props).length ? { props } : {}),
+            ...(Object.keys(variants).length ? { variants } : {}),
+            evidence: `<${tagInfo.originalTag}${classes.length ? ` class="${classes.slice(0, 6).join(' ')}"` : ''}>`,
+        });
+    }
+    return elements.slice(0, 240);
+}
+function summarizeDirectUiChildren(content, tags, parentIndex) {
+    return tags
+        .map((tagInfo, index) => ({ tagInfo, index }))
+        .filter(({ tagInfo }) => tagInfo.parentIndex === parentIndex)
+        .map(({ tagInfo, index }) => {
+        const classSource = readClassSource(tagInfo.attrs);
+        const classAnalysis = classSource ? analyzeClassSource(classSource) : undefined;
+        const classes = classAnalysis?.classes ?? [];
+        const role = (0, utils_1.readAttr)(tagInfo.attrs, 'role');
+        const kind = classifyUiElement(tagInfo.originalTag, tagInfo.attrs, classes, role);
+        const label = extractElementLabel(content, tagInfo);
+        const layoutRole = deriveLayoutRole(tagInfo.originalTag, kind, classes, label);
+        return {
+            index,
+            kind,
+            tag: tagInfo.originalTag.toLowerCase(),
+            originalTag: tagInfo.originalTag,
+            ...(layoutRole ? { layoutRole } : {}),
+            classes: classes.slice(0, 32),
+            ...(classAnalysis?.defaultClasses.length
+                ? { defaultClasses: classAnalysis.defaultClasses.slice(0, 32) }
+                : {}),
+            ...(classAnalysis?.conditionalClasses.length
+                ? { conditionalClasses: classAnalysis.conditionalClasses.slice(0, 32) }
+                : {}),
+            ...(label ? { label } : {}),
+        };
+    })
+        .filter((child) => child.kind !== 'unknown' || child.classes.length || child.label)
+        .slice(0, 16);
+}
+function deriveLayoutRole(tag, kind, classes, label) {
+    const tagName = tag.toLowerCase();
+    const tagBase = tag.split('.')[0].split(':').pop() ?? tag;
+    const lowerBase = tagBase.toLowerCase();
+    const classSet = new Set(classes);
+    const classHaystack = classes.join(' ').toLowerCase();
+    const labelHaystack = (label ?? '').toLowerCase();
+    if (lowerBase === 'container') {
+        return 'container';
+    }
+    if (lowerBase === 'cardheader') {
+        return 'card-header-slot';
+    }
+    if (lowerBase === 'cardcontent') {
+        return 'card-content-slot';
+    }
+    if (lowerBase === 'cardfooter') {
+        return 'card-footer-slot';
+    }
+    if (lowerBase === 'cardtitle') {
+        return 'card-title-slot';
+    }
+    if (lowerBase === 'carddescription') {
+        return 'card-description-slot';
+    }
+    if (tagName === 'h1') {
+        return 'page-heading';
+    }
+    if (/^h[2-6]$/.test(tagName)) {
+        return kind === 'heading' && classSet.has('text-xl')
+            ? 'card-or-section-heading'
+            : 'section-heading';
+    }
+    if (kind === 'badge' ||
+        classSet.has('uppercase') ||
+        /\beyebrow\b/.test(classHaystack) ||
+        /\b(product context|platform|workflow|plans|contact|faq|final cta)\b/.test(labelHaystack)) {
+        return 'eyebrow-or-badge';
+    }
+    if (classSet.has('section-frame') || classSet.has('sm:section-frame')) {
+        return 'framed-section-shell';
+    }
+    if (classSet.has('context-surface')) {
+        return 'technical-context-surface';
+    }
+    if (tagName === 'section' || lowerBase === 'section') {
+        return 'page-section';
+    }
+    if (classSet.has('grid') ||
+        classes.some((className) => (0, utils_1.classBase)(className).startsWith('grid-cols-'))) {
+        return 'grid-layout';
+    }
+    if (classSet.has('flex') || classSet.has('inline-flex')) {
+        return 'flex-layout';
+    }
+    if (classes.some((className) => (0, utils_1.classBase)(className).startsWith('space-y-'))) {
+        return 'stack-layout';
+    }
+    if (tagName === 'p' || tagName === 'span' || tagName === 'small' || tagName === 'code') {
+        return 'text-copy';
+    }
+    return undefined;
+}
+function isStateClass(className) {
+    return /^(?:hover|focus|active|disabled|visited|dark|group|peer|aria|data):/.test(className);
+}
+function extractApiCalls(content) {
+    const calls = new Set();
+    for (const pattern of [
+        /\bfetch\(\s*['"`]([^'"`]+)['"`]/g,
+        /\baxios\.(?:get|post|put|patch|delete)\(\s*['"`]([^'"`]+)['"`]/g,
+        /\b(?:get|post|put|patch|delete)Json\(\s*['"`]([^'"`]+)['"`]/g,
+        /\$\.ajax\(\s*\{[\s\S]*?url\s*:\s*['"`]([^'"`]+)['"`]/g,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            const value = match[1].trim();
+            if (value.startsWith('/')) {
+                calls.add((0, utils_1.stripQuery)(value));
+            }
+        }
+    }
+    return Array.from(calls).sort();
+}
+function extractEnvVars(content) {
+    return (0, utils_1.unique)(Array.from(content.matchAll(/(?:process\.env\.|process\.env\[['"]|os\.environ\[['"]|ENV\[['"]|getenv\(['"]|env\(['"]|import\.meta\.env\.)([A-Z][A-Z0-9_]*)/g)).map((match) => match[1])).slice(0, 80);
+}
+function extractTestNames(content, relPath) {
+    if (!isTestFile(relPath)) {
+        return [];
+    }
+    const names = new Set();
+    for (const match of content.matchAll(/\b(?:describe|it|test|specify)\(\s*['"`]([^'"`]+)['"`]/g)) {
+        names.add(match[1].slice(0, 120));
+    }
+    for (const match of content.matchAll(/^\s*def\s+(test_[A-Za-z0-9_]+)/gm)) {
+        names.add(match[1]);
+    }
+    return Array.from(names).sort().slice(0, 80);
+}
+function extractDocsHeadings(content, relPath) {
+    if (!/\.(md|mdx)$/i.test(relPath)) {
+        return [];
+    }
+    return Array.from(content.matchAll(/^#{1,4}\s+(.+)$/gm))
+        .map((match) => match[1].trim())
+        .slice(0, 80);
+}
+function extractConfigKeys(relPath, content) {
+    const baseName = path.basename(relPath);
+    if (!isConfigFile(relPath)) {
+        return [];
+    }
+    if (/\.(json)$/.test(relPath) || baseName === 'composer.json' || baseName === 'package.json') {
+        try {
+            const parsed = JSON.parse(content);
+            return Object.keys(parsed).slice(0, 80);
+        }
+        catch {
+            return [];
+        }
+    }
+    if (/\.(yml|yaml|toml)$/.test(relPath) ||
+        ['Gemfile', 'go.mod', 'requirements.txt'].includes(baseName)) {
+        return (0, utils_1.unique)(content
+            .split('\n')
+            .map((line) => line.trim().match(/^([A-Za-z0-9_.-]+)\s*[:=]/)?.[1])
+            .filter((item) => Boolean(item))).slice(0, 80);
+    }
+    return Array.from(content.matchAll(/\b([A-Za-z_$][\w$]*)\s*[:=]/g))
+        .map((match) => match[1])
+        .slice(0, 80);
+}
+function extractTemplateIncludes(content, relPath) {
+    if (!isTemplateFile(relPath) && !/\.(html|htm|php|phtml)$/.test(relPath)) {
+        return [];
+    }
+    const includes = new Set();
+    for (const pattern of [
+        /@include\(\s*['"]([^'"]+)['"]/g,
+        /\b(?:include|require|include_once|require_once)\s*(?:\(?\s*)['"]([^'"]+)['"]/g,
+        /\{%\s*(?:include|extends|embed)\s+['"]([^'"]+)['"]/g,
+        /<%-?\s*include\(\s*['"]([^'"]+)['"]/g,
+        /{{>\s*([A-Za-z0-9_./-]+)/g,
+    ]) {
+        for (const match of content.matchAll(pattern)) {
+            includes.add(match[1]);
+        }
+    }
+    return Array.from(includes).sort();
+}
+function extractAuthHints(content) {
+    const hints = new Set();
+    for (const hint of [
+        'auth',
+        'authenticated',
+        'authorize',
+        'permission',
+        'role',
+        'guard',
+        'session',
+        'csrf',
+        'jwt',
+        'token',
+    ]) {
+        if (new RegExp(`\\b${hint}\\b`, 'i').test(content)) {
+            hints.add(hint);
+        }
+    }
+    return Array.from(hints).sort();
+}
+function extractMiddleware(content, relPath) {
+    const names = new Set();
+    if (/middleware/i.test(relPath)) {
+        names.add(path.basename(relPath).replace(/\.[^.]+$/, ''));
+    }
+    for (const match of content.matchAll(/\b(?:middleware|use|before_action|before_filter)\(\s*['"]?([A-Za-z_][\w:.-]*)/g)) {
+        names.add(match[1]);
+    }
+    for (const match of content.matchAll(/class\s+([A-Z][A-Za-z0-9_]*Middleware)\b/g)) {
+        names.add(match[1]);
+    }
+    return Array.from(names).sort();
+}
+function extractJobs(content, relPath) {
+    const jobs = new Set();
+    for (const className of extractClasses(content, relPath)) {
+        if (/(Job|Worker|Task|Command|Cron|Queue)$/.test(className)) {
+            jobs.add(className);
+        }
+    }
+    for (const match of content.matchAll(/\b(?:queue|dispatch|enqueue|schedule|cron)\(['"`]?([A-Za-z0-9_.:-]+)?/g)) {
+        if (match[1]) {
+            jobs.add(match[1]);
+        }
+    }
+    return Array.from(jobs).sort();
+}
+function extractEvents(content) {
+    const events = new Set();
+    for (const match of content.matchAll(/\b(?:emit|dispatch|publish|subscribe|on)\(\s*['"`]([^'"`]+)['"`]/g)) {
+        events.add(match[1]);
+    }
+    return Array.from(events).sort().slice(0, 80);
+}
+function detectKind(relPath, content) {
+    const baseName = path.basename(relPath);
+    if (baseName === 'package.json') {
+        return 'package';
+    }
+    if (isConfigFile(relPath)) {
+        return 'config';
+    }
+    if (isTestFile(relPath)) {
+        return 'test';
+    }
+    if (/\.(md|mdx)$/i.test(relPath)) {
+        return 'doc';
+    }
+    if (isNextPageFile(relPath)) {
+        return 'next-page';
+    }
+    if (isNextLayoutFile(relPath)) {
+        return 'next-layout';
+    }
+    if (isNextRouteFile(relPath)) {
+        return 'next-route-handler';
+    }
+    if (isPagesRouterPageFile(relPath)) {
+        return 'pages-route';
+    }
+    if (isRawPageFile(relPath)) {
+        return 'web-page';
+    }
+    if (/\.module\.(css|scss)$/.test(relPath)) {
+        return 'css-module';
+    }
+    if (/\.(css|scss)$/.test(relPath) || /tailwind\.config\./.test(relPath)) {
+        return 'stylesheet';
+    }
+    if (/schema\.prisma$/.test(relPath) || /\.(sql|graphql)$/.test(relPath)) {
+        return 'database-schema';
+    }
+    if (/@Controller\(/.test(content)) {
+        return 'backend-controller';
+    }
+    if (/\bclass\s+\w+Controller\b/.test(content) || /Controller\.php$/.test(relPath)) {
+        return 'backend-controller';
+    }
+    if (/(?:export\s+)?class\s+\w+(Service|Repository|Client|Gateway|Provider|Manager)\b/.test(content)) {
+        return 'backend-service';
+    }
+    if (/(?:export\s+)?class\s+\w+(Module|Package|Bundle)\b/.test(content)) {
+        return 'backend-module';
+    }
+    if (/\b(?:router|app|server|Route::)\.(?:get|post|put|patch|delete)|Route::(?:get|post|put|patch|delete)/i.test(content)) {
+        return 'api-route';
+    }
+    if (/\.(tsx|jsx|vue|svelte|astro)$/.test(relPath)) {
+        return 'ui-component';
+    }
+    if (isTemplateFile(relPath)) {
+        return 'template';
+    }
+    return 'source';
+}
+function detectLayer(relPath, kind) {
+    if (kind === 'doc') {
+        return 'docs';
+    }
+    if (kind === 'test') {
+        return 'tests';
+    }
+    if (kind === 'config') {
+        return 'config';
+    }
+    if (kind.startsWith('backend') ||
+        relPath.startsWith('prisma/') ||
+        relPath.startsWith('database/') ||
+        relPath.startsWith('db/')) {
+        return 'backend';
+    }
+    if (kind.startsWith('next') ||
+        kind.includes('component') ||
+        relPath.includes('/components/') ||
+        relPath.startsWith('components/')) {
+        return 'frontend';
+    }
+    if (kind.includes('page') || kind === 'template' || isTemplateFile(relPath)) {
+        return 'frontend';
+    }
+    if (kind.includes('style') || kind.includes('css')) {
+        return 'style';
+    }
+    if (relPath.includes('/api/') || relPath.startsWith('api/')) {
+        return 'api';
+    }
+    return 'shared';
+}
+function detectLanguage(filePath) {
+    const normalized = (0, utils_1.toPosixPath)(filePath).toLowerCase();
+    if (normalized.endsWith('.blade.php')) {
+        return 'blade.php';
+    }
+    if (normalized.endsWith('.module.scss')) {
+        return 'scss-module';
+    }
+    if (normalized.endsWith('.module.css')) {
+        return 'css-module';
+    }
+    const extension = path.extname(filePath).replace('.', '');
+    return extension || path.basename(filePath);
+}
+function summarizeFile(input) {
+    if (input.routes.length) {
+        return `Frontend route ${input.routes.join(', ')}.`;
+    }
+    if (input.apiHandlers.length) {
+        return `API handlers: ${input.apiHandlers.join(', ')}.`;
+    }
+    if (input.components.length) {
+        return `UI components: ${input.components.join(', ')}.`;
+    }
+    if (input.controllers.length) {
+        return `Backend controllers: ${input.controllers.join(', ')}.`;
+    }
+    if (input.services.length) {
+        return `Backend services: ${input.services.join(', ')}.`;
+    }
+    if (input.modules.length) {
+        return `Backend modules: ${input.modules.join(', ')}.`;
+    }
+    if (input.models.length) {
+        return `Data models: ${input.models.join(', ')}.`;
+    }
+    if (input.hooks.length) {
+        return `Hooks: ${input.hooks.join(', ')}.`;
+    }
+    if (input.dependencies.length) {
+        return `Package manifest with ${input.dependencies.length} dependencies.`;
+    }
+    if (input.uiElements.length) {
+        const kinds = (0, utils_1.unique)(input.uiElements.map((element) => element.kind));
+        return `Template UI surface with ${kinds.join(', ')} elements.`;
+    }
+    if (input.tests.length) {
+        return `Test file with ${input.tests.length} discovered test cases.`;
+    }
+    if (input.docsHeadings.length) {
+        return `Documentation file with headings: ${input.docsHeadings.slice(0, 3).join(', ')}.`;
+    }
+    if (input.configKeys.length) {
+        return `Config file with keys: ${input.configKeys.slice(0, 5).join(', ')}.`;
+    }
+    if (input.symbols.length) {
+        return `Source file with symbols: ${input.symbols.slice(0, 5).join(', ')}.`;
+    }
+    return `${input.kind} file: ${input.relPath}.`;
+}
+function isNextPageFile(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    return parts.includes('app') && /^page\.(tsx|jsx|ts|js)$/.test(parts[parts.length - 1]);
+}
+function isNextLayoutFile(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    return parts.includes('app') && /^layout\.(tsx|jsx|ts|js)$/.test(parts[parts.length - 1]);
+}
+function isNextRouteFile(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    return parts.includes('app') && /^route\.(tsx|jsx|ts|js)$/.test(parts[parts.length - 1]);
+}
+function isPagesRouterPageFile(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    const pagesIndex = parts.lastIndexOf('pages');
+    const fileName = parts[parts.length - 1];
+    return pagesIndex >= 0 && !parts.includes('api') && /\.(tsx|jsx|ts|js|vue)$/.test(fileName);
+}
+function isSvelteKitPageFile(relPath) {
+    return /(?:^|\/)routes\/.*\/\+page\.svelte$/.test((0, utils_1.toPosixPath)(relPath));
+}
+function isAstroPageFile(relPath) {
+    return /(?:^|\/)pages\/.*\.astro$/.test((0, utils_1.toPosixPath)(relPath));
+}
+function isNuxtPageFile(relPath) {
+    return /(?:^|\/)pages\/.*\.(vue|ts|js)$/.test((0, utils_1.toPosixPath)(relPath));
+}
+function isRawPageFile(relPath) {
+    const normalized = (0, utils_1.toPosixPath)(relPath);
+    if (!/\.(html|htm|php|phtml)$/.test(normalized)) {
+        return false;
+    }
+    return !/(?:^|\/)(partials?|includes?|components?|layouts?|templates\/partials)\//.test(normalized);
+}
+function toNextRoutePath(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    const appIndex = parts.lastIndexOf('app');
+    const routeParts = parts
+        .slice(appIndex + 1, -1)
+        .filter((part) => part && !part.startsWith('(') && !part.startsWith('@'))
+        .map((part) => part.startsWith('[') && part.endsWith(']')
+        ? `:${part.slice(1, -1).replace('...', '')}`
+        : part);
+    return `/${routeParts.join('/')}`.replace(/\/+$/, '') || '/';
+}
+function toPagesRoutePath(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    const pagesIndex = parts.lastIndexOf('pages');
+    const routeParts = parts
+        .slice(pagesIndex + 1)
+        .join('/')
+        .replace(/\.(tsx|jsx|ts|js|vue)$/, '')
+        .split('/')
+        .filter((part) => part !== 'index' && !part.startsWith('_'))
+        .map((part) => part.startsWith('[') && part.endsWith(']')
+        ? `:${part.slice(1, -1).replace('...', '')}`
+        : part);
+    return `/${routeParts.join('/')}`.replace(/\/+$/, '') || '/';
+}
+function toSvelteKitRoutePath(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    const routesIndex = parts.lastIndexOf('routes');
+    const routeParts = parts
+        .slice(routesIndex + 1, -1)
+        .filter((part) => part && !part.startsWith('('))
+        .map((part) => (part.startsWith('[') && part.endsWith(']') ? `:${part.slice(1, -1)}` : part));
+    return `/${routeParts.join('/')}`.replace(/\/+$/, '') || '/';
+}
+function toAstroRoutePath(relPath) {
+    const parts = (0, utils_1.toPosixPath)(relPath).split('/');
+    const pagesIndex = parts.lastIndexOf('pages');
+    const routeParts = parts
+        .slice(pagesIndex + 1)
+        .join('/')
+        .replace(/\.astro$/, '')
+        .split('/')
+        .filter((part) => part !== 'index')
+        .map((part) => (part.startsWith('[') && part.endsWith(']') ? `:${part.slice(1, -1)}` : part));
+    return `/${routeParts.join('/')}`.replace(/\/+$/, '') || '/';
+}
+function toNuxtRoutePath(relPath) {
+    return toPagesRoutePath(relPath).replace(/\/_/g, '/:');
+}
+function toRawPageRoutePath(relPath) {
+    const normalized = (0, utils_1.toPosixPath)(relPath);
+    const withoutExtension = normalized.replace(/\.(html|htm|php|phtml)$/, '');
+    const route = withoutExtension
+        .replace(/^(public|static|web|src|app)\//, '')
+        .replace(/^resources\/views\//, '')
+        .replace(/^views\//, '')
+        .replace(/^templates\//, '')
+        .replace(/\/index$/, '')
+        .replace(/^index$/, '');
+    return normalizeRoutePath(route);
+}
+function extractFrameworkRoutePaths(relPath, content) {
+    const routes = new Set();
+    for (const handler of extractApiHandlers(relPath, content)) {
+        routes.add(handler.replace(/^[A-Z]+\s+/, ''));
+    }
+    return Array.from(routes).filter(Boolean);
+}
+function normalizeRoutePath(value) {
+    const route = (0, utils_1.stripQuery)(value)
+        .replace(/^['"`]|['"`]$/g, '')
+        .replace(/^\^/, '')
+        .replace(/\$$/, '')
+        .replace(/\/+$/, '')
+        .replace(/^\s+|\s+$/g, '');
+    return `/${route.replace(/^\/+/, '')}`.replace(/\/+$/, '') || '/';
+}
+function shouldIgnoreDirectory(relPath) {
+    if (relPath === '.') {
+        return false;
+    }
+    return relPath.split('/').some((part) => constants_1.ignoredDirNames.has(part));
+}
+function isExcluded(relPath, excludePaths, explicitIncludePaths = false) {
+    const normalized = relPath === '.' ? relPath : (0, utils_1.stripLeadingDot)((0, utils_1.toPosixPath)(relPath));
+    if (shouldIgnoreFileName(path.basename(normalized))) {
+        return true;
+    }
+    if (!explicitIncludePaths && shouldIgnoreNonCanonicalPath(normalized)) {
+        return true;
+    }
+    return excludePaths.some((excludePath) => {
+        const normalizedExclude = (0, utils_1.stripLeadingDot)((0, utils_1.toPosixPath)(excludePath));
+        return normalized === normalizedExclude || normalized.startsWith(`${normalizedExclude}/`);
+    });
+}
+function shouldIgnoreNonCanonicalPath(relPath) {
+    return (/^(?:src\/)?app\/test(?:\/|$)/i.test(relPath) ||
+        /^(?:src\/)?pages\/test(?:\/|$)/i.test(relPath) ||
+        /^(?:src\/)?app\/(?:playground|playgrounds|demo|demos|example|examples|sandbox)(?:\/|$)/i.test(relPath) ||
+        /(?:^|\/)playwright-mcp\.page[^/]*\.(?:tsx|jsx|ts|js|html|mdx?)$/i.test(relPath));
+}
+function isScannableFile(filePath) {
+    const fileName = path.basename(filePath);
+    const normalized = (0, utils_1.toPosixPath)(filePath).toLowerCase();
+    return (constants_1.scannableFileNames.has(fileName) ||
+        constants_1.scannableExtensions.has(path.extname(filePath)) ||
+        normalized.endsWith('.blade.php'));
+}
+function shouldIgnoreFileName(fileName) {
+    if (constants_1.ignoredFileNames.has(fileName)) {
+        return true;
+    }
+    if (/^\.env(?:\.|$)/.test(fileName)) {
+        return true;
+    }
+    if (/\.(pem|key|crt|p12|pfx|keystore|jks)$/i.test(fileName)) {
+        return true;
+    }
+    return false;
+}
+function isUiFile(relPath) {
+    return /\.(tsx|jsx|vue|svelte|astro)$/.test(relPath) || isTemplateFile(relPath);
+}
+function isTemplateFile(relPath) {
+    return (/\.(html|htm|php|phtml|twig|erb|ejs|hbs|handlebars|liquid|njk|pug)$/.test(relPath) ||
+        relPath.endsWith('.blade.php'));
+}
+function isTestFile(relPath) {
+    return (/(?:^|\/)(?:__tests__|tests?|spec)\//i.test(relPath) ||
+        /\.(test|spec)\.[A-Za-z0-9]+$/.test(relPath));
+}
+function isConfigFile(relPath) {
+    const baseName = path.basename(relPath);
+    return (constants_1.rootConfigFiles.includes(baseName) ||
+        constants_1.scannableFileNames.has(baseName) ||
+        /(?:^|\/)\.github\/workflows\/.*\.ya?ml$/.test(relPath) ||
+        /(?:^|\/)(?:docker-compose|compose)\.ya?ml$/.test(relPath) ||
+        /(?:^|\/)(?:config|configs?)\/.+\.(json|ya?ml|toml|xml)$/.test(relPath) ||
+        /\.(config|conf)\.(js|mjs|ts|json|ya?ml)$/.test(relPath));
+}
+function routeExtractorForFile(file) {
+    if (file.kind.startsWith('next')) {
+        return 'nextjs.app-router';
+    }
+    if (file.kind === 'pages-route') {
+        return 'nextjs.pages-router';
+    }
+    if (file.language === 'svelte') {
+        return 'sveltekit';
+    }
+    if (file.language === 'astro') {
+        return 'astro';
+    }
+    if (file.language === 'vue') {
+        return 'vue-nuxt';
+    }
+    if (file.language === 'php' || file.language === 'blade.php') {
+        return 'php-web';
+    }
+    if (file.language === 'py') {
+        return 'python-web';
+    }
+    if (file.language === 'rb') {
+        return 'ruby-web';
+    }
+    return 'web.routes';
+}
+function routeConfidenceForFile(file) {
+    return file.kind.startsWith('next') || file.kind === 'pages-route' || file.kind === 'web-page'
+        ? 'high'
+        : 'medium';
+}
+function apiExtractorForFile(file) {
+    if (file.kind.includes('next')) {
+        return 'nextjs.route-handler';
+    }
+    if (file.language === 'php' || file.language === 'blade.php') {
+        return 'php.routes';
+    }
+    if (file.language === 'py') {
+        return 'python.routes';
+    }
+    if (file.language === 'rb') {
+        return 'ruby.routes';
+    }
+    if (file.language === 'go') {
+        return 'go.routes';
+    }
+    return 'api.routes';
+}
+function controllerExtractorForFile(file) {
+    if (file.language === 'php') {
+        return 'php-controller';
+    }
+    if (file.language === 'rb') {
+        return 'rails-controller';
+    }
+    if (file.language === 'py') {
+        return 'python-controller';
+    }
+    return 'nestjs';
+}
+function serviceExtractorForFile(file) {
+    if (file.language === 'php') {
+        return 'php-service';
+    }
+    if (file.language === 'rb') {
+        return 'ruby-service';
+    }
+    if (file.language === 'py') {
+        return 'python-service';
+    }
+    if (file.language === 'go') {
+        return 'go-service';
+    }
+    return 'service-convention';
+}
+function moduleExtractorForFile(file) {
+    return file.language === 'ts' ? 'nestjs' : 'module-convention';
+}
+function modelExtractorForFile(file) {
+    if (file.language === 'prisma') {
+        return 'prisma';
+    }
+    if (file.language === 'sql') {
+        return 'sql';
+    }
+    if (file.language === 'rb') {
+        return 'rails-model';
+    }
+    if (file.language === 'py') {
+        return 'django-model';
+    }
+    if (file.language === 'php') {
+        return 'php-model';
+    }
+    return 'orm-model';
+}
+function styleExtractorForFile(file) {
+    if (file.language === 'css' ||
+        file.language === 'scss' ||
+        file.language === 'css-module' ||
+        file.language === 'scss-module') {
+        return 'styles';
+    }
+    if (file.tailwindUtilities.length) {
+        return 'tailwind-classes';
+    }
+    if (isTemplateFile(file.relPath)) {
+        return 'template-styles';
+    }
+    return 'ui-styles';
+}
+function styleConfidenceForFile(file) {
+    return file.cssClasses.length ||
+        file.cssVariables.length ||
+        file.cssVariableValues.length ||
+        file.cssRules.length ||
+        file.componentStyleDefinitions.length ||
+        file.themeTokens.length ||
+        file.inlineStyles.length
+        ? 'high'
+        : file.classReferences.length || file.classExpressions.length || file.uiElements.length
+            ? 'medium'
+            : 'low';
+}
+function entryMatchesConcept(entry, terms) {
+    const uiElements = Array.isArray(entry.value.uiElements) ? entry.value.uiElements : [];
+    const componentStyleDefinitions = Array.isArray(entry.value.componentStyleDefinitions)
+        ? entry.value.componentStyleDefinitions
+        : [];
+    const themeTokens = Array.isArray(entry.value.themeTokens) ? entry.value.themeTokens : [];
+    const haystack = [
+        entry.key,
+        entry.summary,
+        ...entry.tags,
+        String(entry.path ?? ''),
+        String(entry.value.name ?? ''),
+        String(entry.value.kind ?? ''),
+        String(entry.value.concept ?? ''),
+        Array.isArray(entry.value.classes) ? entry.value.classes.join(' ') : '',
+        Array.isArray(entry.value.classReferences) ? entry.value.classReferences.join(' ') : '',
+        Array.isArray(entry.value.cssClasses) ? entry.value.cssClasses.join(' ') : '',
+        Array.isArray(entry.value.tailwindUtilities) ? entry.value.tailwindUtilities.join(' ') : '',
+        Array.isArray(entry.value.cssVariables) ? entry.value.cssVariables.join(' ') : '',
+        Array.isArray(entry.value.cssVariableReferences)
+            ? entry.value.cssVariableReferences.join(' ')
+            : '',
+        ...componentStyleDefinitions.map((definition) => typeof definition === 'object' && definition !== null && 'name' in definition
+            ? String(definition.name)
+            : ''),
+        ...themeTokens.map((token) => typeof token === 'object' && token !== null && 'path' in token ? String(token.path) : ''),
+        ...uiElements.flatMap((element) => {
+            if (typeof element !== 'object' || element === null) {
+                return [];
+            }
+            const value = element;
+            return [
+                String(value.kind ?? ''),
+                String(value.tag ?? ''),
+                String(value.originalTag ?? ''),
+                Array.isArray(value.classes) ? value.classes.join(' ') : '',
+            ];
+        }),
+    ]
+        .join(' ')
+        .toLowerCase();
+    return terms.some((term) => {
+        const normalized = term.toLowerCase();
+        return (new RegExp(`\\b${(0, utils_1.escapeRegExp)(normalized)}s?\\b`).test(haystack) ||
+            haystack.includes(normalized));
+    });
+}
+function splitClassList(value) {
+    return (0, utils_1.unique)(value
+        .replace(/\{[^}]*\}/g, ' ')
+        .replace(/\$\([^)]*\)/g, ' ')
+        .split(/\s+/)
+        .map((item) => item
+        .trim()
+        .replace(/^['"`]+|['"`]+$/g, '')
+        .replace(/,$/, ''))
+        .filter((item) => Boolean(item) &&
+        item.length <= 180 &&
+        !/[{};'"]/.test(item) &&
+        !item.includes('=') &&
+        !item.endsWith(':') &&
+        !/(?:^|\/)<\/?[A-Za-z]/.test(item) &&
+        (!/[<>]/.test(item) || item.includes('[')) &&
+        (!/[()]/.test(item) || item.includes('[')) &&
+        !/^(?:const|let|var|return|class|className|defaultVariants|variants|variant|size|true|false|null|undefined|map|item|props|children|function)$/.test(item) &&
+        !constants_1.classTokenStopWords.has(item.toLowerCase()) &&
+        !/^[A-Z][a-z]+$/.test(item) &&
+        /[A-Za-z0-9\]]/.test(item)));
+}
+function classifyUiElement(tag, attrs, classes, role) {
+    const originalTag = tag;
+    const tagName = originalTag.toLowerCase();
+    const tagBase = originalTag.split('.')[0].split(':').pop() ?? originalTag;
+    const lowerBase = tagBase.toLowerCase();
+    const classHaystack = [tagName, role ?? '', ...classes].join(' ').toLowerCase();
+    const propHaystack = [
+        tagName,
+        role ?? '',
+        (0, utils_1.readAttr)(attrs, 'variant') ?? '',
+        (0, utils_1.readAttr)(attrs, 'type') ?? '',
+    ]
+        .join(' ')
+        .toLowerCase();
+    if (tagName === 'form' || lowerBase === 'form') {
+        return 'form';
+    }
+    if (/^h[1-6]$/.test(tagName) || /^(heading|title|headline)$/i.test(tagBase)) {
+        return 'heading';
+    }
+    if (['input', 'textarea', 'select', 'option', 'label', 'fieldset'].includes(tagName) ||
+        /^(input|textarea|select|field|fieldlabel|label|checkbox|switch|slider|radio|combobox)$/i.test(tagBase) ||
+        /\b(field|input|textarea|select|checkbox|switch|slider|radio)\b/.test(classHaystack)) {
+        return 'input';
+    }
+    if (tagName === 'button' ||
+        role === 'button' ||
+        /^(button|iconbutton|submitbutton|cta)$/i.test(tagBase) ||
+        /\b(btn|button|cta|submit)\b/.test(classHaystack) ||
+        /\bsubmit\b/.test(propHaystack)) {
+        return 'button';
+    }
+    if (tagName === 'a' ||
+        role === 'link' ||
+        /^(link|navlink|menulink)$/i.test(tagBase) ||
+        /\blink\b/.test(classHaystack)) {
+        return 'link';
+    }
+    if (tagName === 'nav' ||
+        role === 'navigation' ||
+        /^(nav|navbar|navigation|menu|menubar|breadcrumb|sidebar)$/i.test(tagBase) ||
+        /\b(nav|navbar|navigation|menu|sidebar|breadcrumb)\b/.test(classHaystack)) {
+        return 'nav';
+    }
+    if (tagName === 'table' || ['thead', 'tbody', 'tfoot', 'tr', 'td', 'th'].includes(tagName)) {
+        return 'table';
+    }
+    if (tagName === 'dialog' ||
+        role === 'dialog' ||
+        /^(dialog|modal|popover|drawer|sheet|alertdialog)$/i.test(tagBase) ||
+        /\b(dialog|modal|popover|drawer|sheet)\b/.test(classHaystack)) {
+        return 'dialog';
+    }
+    if (/^(badge|chip|pill|tag|status|eyebrow)$/i.test(tagBase) ||
+        /\b(badge|chip|pill|tag|status|eyebrow)\b/.test(classHaystack)) {
+        return 'badge';
+    }
+    if (/^(card|panel|tile|surface|sectionframe|frame|callout)$/i.test(tagBase) ||
+        /\b(card|panel|tile|surface|section-frame|frame|callout)\b/.test(classHaystack)) {
+        return 'card';
+    }
+    if (tagName === 'section' || lowerBase === 'section') {
+        return 'section';
+    }
+    if (['p', 'span', 'small', 'strong', 'em', 'code', 'pre', 'li'].includes(tagName) &&
+        classes.some((className) => isTypographyClass(className) || isSpacingClass(className))) {
+        return 'text';
+    }
+    if (classes.some((className) => /^(?:grid|flex|inline-flex|block|hidden|relative|absolute|mx-auto|max-w-|min-w-|w-full|gap-|space-y-|items-|justify-)/.test((0, utils_1.classBase)(className)))) {
+        return 'layout';
+    }
+    return 'unknown';
+}
+function stripTags(value) {
+    return value.replace(/<[^>]+>/g, ' ').replace(/\{[{%][\s\S]*?[}%]\}/g, ' ');
+}
+//# sourceMappingURL=extractors.js.map