@schemyx/mcp 0.1.0 → 0.1.2

package/dist/codebase-scanner/extractors.js

@@ -0,0 +1,3513 @@
+"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.extractCssAtRuleBlocks = extractCssAtRuleBlocks;
+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.readPrimaryClassHelperUsage = readPrimaryClassHelperUsage;
+exports.readClassHelperUsages = readClassHelperUsages;
+exports.parseHelperVariantProps = parseHelperVariantProps;
+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.isLayoutClass = isLayoutClass;
+exports.isSurfaceClass = isSurfaceClass;
+exports.isDecorativeAccentClass = isDecorativeAccentClass;
+exports.isTypographyClass = isTypographyClass;
+exports.isTypographyScaleBase = isTypographyScaleBase;
+exports.isLayoutSafetyBase = isLayoutSafetyBase;
+exports.isSizingClass = isSizingClass;
+exports.isVisibilityClass = isVisibilityClass;
+exports.isLineHeightClass = isLineHeightClass;
+exports.isMaxWidthClass = isMaxWidthClass;
+exports.createUiLayoutSafety = createUiLayoutSafety;
+exports.createUiResponsiveProfile = createUiResponsiveProfile;
+exports.createUiScaleProfile = createUiScaleProfile;
+exports.responsivePrefix = responsivePrefix;
+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.createUiSemanticProfile = createUiSemanticProfile;
+exports.createUiRoleSignature = createUiRoleSignature;
+exports.exactRoleClassFacts = exactRoleClassFacts;
+exports.createRoleScaleKey = createRoleScaleKey;
+exports.createRoleDensityKey = createRoleDensityKey;
+exports.createRoleSurfaceKey = createRoleSurfaceKey;
+exports.createRoleLayoutKey = createRoleLayoutKey;
+exports.isCompactHeroEyebrow = isCompactHeroEyebrow;
+exports.isOverlayPill = isOverlayPill;
+exports.isHeroHeadingScale = isHeroHeadingScale;
+exports.isOversizedHeadingScale = isOversizedHeadingScale;
+exports.isMetricValueScale = isMetricValueScale;
+exports.isCompactStatValue = isCompactStatValue;
+exports.isLargeMetricValue = isLargeMetricValue;
+exports.isCompactStatCard = isCompactStatCard;
+exports.isInteractiveServiceCard = isInteractiveServiceCard;
+exports.isStaticArticleCard = isStaticArticleCard;
+exports.isMediaPanelCard = isMediaPanelCard;
+exports.isQuietAction = isQuietAction;
+exports.isCompactAction = isCompactAction;
+exports.roleClassSort = roleClassSort;
+exports.deriveUiChildSemanticRole = deriveUiChildSemanticRole;
+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.looksLikeSurfaceContainer = looksLikeSurfaceContainer;
+exports.looksLikePillBadge = looksLikePillBadge;
+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 = [];
+    const mediaBlocks = extractCssAtRuleBlocks(content, 'media');
+    const mediaRanges = mediaBlocks.map((block) => ({ start: block.start, end: block.end }));
+    for (const match of content.matchAll(/([^{}@][^{}]{0,240})\{([^{}]{1,2400})\}/g)) {
+        const matchIndex = match.index ?? 0;
+        if (mediaRanges.some((range) => matchIndex >= range.start && matchIndex <= range.end)) {
+            continue;
+        }
+        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),
+        });
+    }
+    for (const block of mediaBlocks) {
+        for (const match of block.body.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, block.bodyStart + (match.index ?? 0)),
+                media: block.prelude,
+            });
+        }
+    }
+    return (0, utils_1.uniqueBy)(rules, (rule) => `${rule.selector}:${rule.line}:${rule.media ?? ''}`).slice(0, 320);
+}
+function extractCssAtRuleBlocks(content, atRule) {
+    const blocks = [];
+    const pattern = new RegExp(`@${atRule}\\s+([^{}]+)\\{`, 'g');
+    for (const match of content.matchAll(pattern)) {
+        const start = match.index ?? 0;
+        const openIndex = start + match[0].length - 1;
+        let depth = 0;
+        let end = -1;
+        for (let cursor = openIndex; cursor < content.length; cursor += 1) {
+            const char = content[cursor];
+            if (char === '{') {
+                depth += 1;
+            }
+            else if (char === '}') {
+                depth -= 1;
+                if (depth === 0) {
+                    end = cursor;
+                    break;
+                }
+            }
+        }
+        if (end <= openIndex) {
+            continue;
+        }
+        blocks.push({
+            prelude: match[1].trim().replace(/\s+/g, ' '),
+            body: content.slice(openIndex + 1, end),
+            start,
+            end,
+            bodyStart: openIndex + 1,
+        });
+    }
+    return blocks;
+}
+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 helperUsage = readPrimaryClassHelperUsage(classValue);
+                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),
+                    ...(helperUsage ? { styleHelper: helperUsage.name } : {}),
+                    ...(helperUsage && Object.keys(helperUsage.variantProps).length
+                        ? { styleHelperVariants: helperUsage.variantProps }
+                        : {}),
+                });
+            }
+        }
+    }
+    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;
+            const helperUsage = readPrimaryClassHelperUsage(call);
+            if (classes.length || helperUsage) {
+                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,
+                    ...(helperUsage ? { styleHelper: helperUsage.name } : {}),
+                    ...(helperUsage && Object.keys(helperUsage.variantProps).length
+                        ? { styleHelperVariants: helperUsage.variantProps }
+                        : {}),
+                });
+            }
+        }
+    }
+    for (const match of content.matchAll(/\b([A-Za-z_$][\w$]*(?:Variants?|ClassNames?|Styles?))\s*\(/g)) {
+        const helperName = match[1];
+        if (/^(?:cn|clsx|classNames|twMerge|cva)$/i.test(helperName)) {
+            continue;
+        }
+        if (isInsideQuotedString(content, match.index ?? 0)) {
+            continue;
+        }
+        const call = readBalancedCall(content, match.index ?? 0);
+        if (!call) {
+            continue;
+        }
+        const helperUsage = readPrimaryClassHelperUsage(call);
+        if (!helperUsage) {
+            continue;
+        }
+        expressions.push({
+            kind: 'helper',
+            raw: (0, utils_1.truncate)(call, 900),
+            classes: [],
+            defaultClasses: [],
+            conditionalClasses: [],
+            line: (0, utils_1.lineNumberAt)(content, match.index ?? 0),
+            target: helperName,
+            styleHelper: helperUsage.name,
+            ...(Object.keys(helperUsage.variantProps).length
+                ? { styleHelperVariants: helperUsage.variantProps }
+                : {}),
+        });
+    }
+    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 readPrimaryClassHelperUsage(source) {
+    const usages = readClassHelperUsages(source);
+    return (usages.find((usage) => /button|cta|action/i.test(usage.name)) ??
+        usages.find((usage) => Object.keys(usage.variantProps).length > 0) ??
+        usages[0]);
+}
+function readClassHelperUsages(source) {
+    const usages = [];
+    const helperPattern = /\b([A-Za-z_$][\w$]*(?:Variants?|ClassNames?|Styles?))\s*\(/g;
+    for (const match of source.matchAll(helperPattern)) {
+        const name = match[1];
+        if (/^(?:cn|clsx|classNames|twMerge|cva)$/i.test(name)) {
+            continue;
+        }
+        const call = readBalancedCall(source, match.index ?? 0);
+        if (!call) {
+            continue;
+        }
+        usages.push({
+            name,
+            variantProps: parseHelperVariantProps(call),
+            call: (0, utils_1.truncate)(call, 700),
+        });
+    }
+    return (0, utils_1.uniqueBy)(usages, (usage) => `${usage.name}:${JSON.stringify(usage.variantProps)}`).slice(0, 12);
+}
+function parseHelperVariantProps(call) {
+    const props = {};
+    const openIndex = call.indexOf('{');
+    if (openIndex < 0) {
+        return props;
+    }
+    const block = readBalancedBlock(call, openIndex);
+    if (!block) {
+        return props;
+    }
+    for (const entry of parseTopLevelObjectEntries(block)) {
+        const literalValues = readStringLiterals(entry.rawValue)
+            .map((value) => value.trim())
+            .filter(Boolean)
+            .slice(0, 4);
+        const value = literalValues.length > 1
+            ? literalValues.join('|')
+            : (literalValues[0] ?? cleanupBareValue(entry.rawValue));
+        if (value) {
+            props[entry.key] = value;
+        }
+    }
+    return props;
+}
+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, ' ');
+    const withoutArbitraryValues = withoutTemplateExpressions.replace(/\[[^\]]+\]/g, '[arbitrary]');
+    if (/[{}"'`,;]/.test(withoutArbitraryValues)) {
+        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) ||
+        /^(?:btn(?:-.+)?|card(?:-.+)?|badge(?:-.+)?|form(?:-.+)?|input-group(?:-.+)?|navbar(?:-.+)?|nav(?:-.+)?|row|col(?:-.+)?|container(?:-.+)?|d-(?:sm-|md-|lg-|xl-|xxl-)?|justify-content-|align-items-|align-self-|fw-|fs-|lh-|display-|lead|small|list-group(?:-.+)?|modal(?:-.+)?|alert(?:-.+)?|rounded-(?:pill|circle|\d)|shadow(?:-.+)?|w-\d+|h-\d+|mw-\d+|mh-\d+|min-vh-|min-vw-|vw-|vh-)/.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-|container|d-|justify-content-|align-items-|align-self-)/.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-|mw-|mh-|vw-|vh-|min-|max-|size-|aspect-|basis-|grow|shrink)/.test(base)) {
+            addClassGroup(groups, 'sizing', className);
+        }
+        else if (isTypographyScaleBase(base)) {
+            addClassGroup(groups, 'typography', className);
+        }
+        else if (isLayoutSafetyBase(base)) {
+            addClassGroup(groups, 'layout-safety', 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 (/^(list-)/.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|min-[^:]+|max-[^:]+):/.test(className) ||
+        /^(?:d|col|offset|order|m[stebxy]?|p[stebxy]?|gap|text|float|flex|justify-content|align-items|align-self)-(?:sm|md|lg|xl|xxl)-/.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 isLayoutClass(className) {
+    const base = (0, utils_1.classBase)(className);
+    return /^(?:flex|grid|block|inline|hidden|items-|justify-|content-|self-|place-|order-|col-|row-|container|d-|justify-content-|align-items-|align-self-)/.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 isTypographyScaleBase(base);
+}
+function isTypographyScaleBase(base) {
+    return (/^(?:font-|leading-|tracking-|line-clamp|whitespace-|break-|truncate|text-balance|text-pretty|text-nowrap|text-wrap)/.test(base) ||
+        /^(?:fs-|fw-|lh-|display-|lead|small|text-uppercase|text-lowercase|text-capitalize)/.test(base) ||
+        /^text-(?:xs|sm|base|lg|xl|[2-9]xl|\[[^\]]+\])/.test(base) ||
+        /^max-w-\[(?:\d+(?:\.\d+)?)?ch\]/.test(base));
+}
+function isLayoutSafetyBase(base) {
+    return /^(?:overflow-|min-w-|min-h-|max-w-|max-h-|w-fit|h-fit|w-max|h-max|w-min|h-min|basis-|grow|shrink|flex-1|flex-none|self-|whitespace-|break-|truncate|line-clamp|text-ellipsis|text-nowrap|text-balance|text-pretty)/.test(base);
+}
+function isSizingClass(className) {
+    const base = (0, utils_1.classBase)(className);
+    return /^(?:w-|h-|mw-|mh-|vw-|vh-|min-|max-|size-|aspect-|basis-|grow|shrink|flex-1|flex-none)/.test(base);
+}
+function isVisibilityClass(className) {
+    const base = (0, utils_1.classBase)(className);
+    return /^(?:hidden|block|inline|inline-block|flex|inline-flex|grid|inline-grid|table|contents)$/.test(base);
+}
+function isLineHeightClass(className) {
+    return (0, utils_1.classBase)(className).startsWith('leading-');
+}
+function isMaxWidthClass(className) {
+    return (0, utils_1.classBase)(className).startsWith('max-w-');
+}
+function createUiLayoutSafety(classes) {
+    const wrapClasses = filterClasses(classes, (className) => /^(?:whitespace-|break-|truncate|line-clamp|text-ellipsis|text-nowrap|text-balance|text-pretty|text-wrap)/.test((0, utils_1.classBase)(className))).slice(0, 40);
+    const overflowClasses = filterClasses(classes, (className) => /^(?:overflow-|line-clamp|truncate|text-ellipsis)/.test((0, utils_1.classBase)(className))).slice(0, 40);
+    const minSizeClasses = filterClasses(classes, (className) => /^(?:min-w-|min-h-)/.test((0, utils_1.classBase)(className))).slice(0, 40);
+    const maxSizeClasses = filterClasses(classes, (className) => /^(?:max-w-|max-h-)/.test((0, utils_1.classBase)(className))).slice(0, 40);
+    const fitClasses = filterClasses(classes, (className) => /^(?:w-fit|h-fit|w-max|h-max|w-min|h-min|basis-|self-)/.test((0, utils_1.classBase)(className))).slice(0, 40);
+    const flexBehaviorClasses = filterClasses(classes, (className) => /^(?:grow|shrink|flex-1|flex-none|basis-)/.test((0, utils_1.classBase)(className))).slice(0, 40);
+    const layoutSafetyClasses = (0, utils_1.unique)([
+        ...wrapClasses,
+        ...overflowClasses,
+        ...minSizeClasses,
+        ...maxSizeClasses,
+        ...fitClasses,
+        ...flexBehaviorClasses,
+    ]).slice(0, 80);
+    if (!layoutSafetyClasses.length) {
+        return undefined;
+    }
+    return {
+        wrapClasses,
+        overflowClasses,
+        minSizeClasses,
+        maxSizeClasses,
+        fitClasses,
+        flexBehaviorClasses,
+        layoutSafetyClasses,
+    };
+}
+function createUiResponsiveProfile(classes) {
+    const responsiveClasses = filterClasses(classes, isResponsiveClass).slice(0, 120);
+    if (!responsiveClasses.length) {
+        return undefined;
+    }
+    const breakpoints = {};
+    for (const className of responsiveClasses) {
+        const prefix = responsivePrefix(className);
+        if (!prefix) {
+            continue;
+        }
+        breakpoints[prefix] = (0, utils_1.unique)([...(breakpoints[prefix] ?? []), className]).slice(0, 60);
+    }
+    return {
+        breakpoints,
+        layoutClasses: filterClasses(responsiveClasses, isLayoutClass).slice(0, 60),
+        typographyClasses: filterClasses(responsiveClasses, isTypographyClass).slice(0, 60),
+        spacingClasses: filterClasses(responsiveClasses, isSpacingClass).slice(0, 60),
+        sizingClasses: filterClasses(responsiveClasses, isSizingClass).slice(0, 60),
+        visibilityClasses: filterClasses(responsiveClasses, isVisibilityClass).slice(0, 60),
+        stateClasses: filterClasses(responsiveClasses, isStateClass).slice(0, 60),
+    };
+}
+function createUiScaleProfile(classes) {
+    const typographyClasses = filterClasses(classes, isTypographyClass).slice(0, 80);
+    const spacingClasses = filterClasses(classes, isSpacingClass).slice(0, 80);
+    const sizingClasses = filterClasses(classes, isSizingClass).slice(0, 80);
+    const gapClasses = filterClasses(classes, (className) => /^(?:gap-|space-)/.test((0, utils_1.classBase)(className))).slice(0, 60);
+    const maxWidthClasses = filterClasses(classes, isMaxWidthClass).slice(0, 60);
+    const lineHeightClasses = filterClasses(classes, isLineHeightClass).slice(0, 60);
+    if (!typographyClasses.length &&
+        !spacingClasses.length &&
+        !sizingClasses.length &&
+        !gapClasses.length &&
+        !maxWidthClasses.length &&
+        !lineHeightClasses.length) {
+        return undefined;
+    }
+    return {
+        typographyClasses,
+        spacingClasses,
+        sizingClasses,
+        gapClasses,
+        maxWidthClasses,
+        lineHeightClasses,
+    };
+}
+function responsivePrefix(className) {
+    return (className.split(':').find((part) => /^(?:sm|md|lg|xl|2xl|min-|max-)/.test(part)) ??
+        className.match(/^(?:d|col|offset|order|m[stebxy]?|p[stebxy]?|gap|text|float|flex|justify-content|align-items|align-self)-(sm|md|lg|xl|xxl)-/)?.[1]);
+}
+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 (classes.has('section-frame')) {
+        guidance.push('section-frame owns the clipped section-frame::before grid overlay for that surface; do not treat it as a simple border/background token.');
+    }
+    if (classes.has('section-frame') && classes.has('context-surface')) {
+        guidance.push('Keep section-frame and context-surface paired for technical surfaces when child content must sit above the parent grid overlay.');
+    }
+    if (classes.has('sm:section-frame') || classes.has('bg-transparent')) {
+        guidance.push('Preserve transparent mobile surfaces and only add framed behavior at the same responsive breakpoint as the source.');
+    }
+    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-|size-|basis-|grow|shrink|aspect-|overflow-|object-|whitespace-|break-|truncate|line-clamp|text-balance|text-pretty|text-nowrap|rounded|border|bg-|text-|font-|leading-|tracking-|shadow|ring|opacity|transition|duration|ease|hover:|focus:|active:|disabled:|dark:|sm:|md:|lg:|xl:|2xl:|min-[^:]+:|max-[^:]+:|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 styleHelper = classSource ? readPrimaryClassHelperUsage(classSource) : undefined;
+        const classes = classAnalysis?.classes ?? [];
+        const role = (0, utils_1.readAttr)(attrs, 'role');
+        const props = {
+            ...readUiProps(attrs),
+            ...(styleHelper ? { styleHelper: styleHelper.name } : {}),
+        };
+        const variants = {
+            ...readVariantProps(props),
+            ...(styleHelper?.variantProps ?? {}),
+        };
+        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 layoutSafety = createUiLayoutSafety(classes);
+        const responsiveProfile = createUiResponsiveProfile(classes);
+        const scaleProfile = createUiScaleProfile(classes);
+        const childSummary = summarizeDirectUiChildren(content, tags, index);
+        const semanticProfile = createUiSemanticProfile(kind, tagInfo.originalTag, classes, childSummary);
+        const roleSignature = createUiRoleSignature({
+            kind,
+            tag: tagInfo.originalTag,
+            classes,
+            children: childSummary,
+            label,
+            layoutRole,
+            parentKind,
+            parentClasses,
+        });
+        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 } : {}),
+            ...(layoutSafety ? { layoutSafety } : {}),
+            ...(responsiveProfile ? { responsiveProfile } : {}),
+            ...(scaleProfile ? { scaleProfile } : {}),
+            ...(semanticProfile ? { semanticProfile } : {}),
+            ...(roleSignature ? { roleSignature } : {}),
+            ...(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 } : {}),
+            ...(styleHelper ? { styleHelper: styleHelper.name } : {}),
+            ...(styleHelper && Object.keys(styleHelper.variantProps).length
+                ? { styleHelperVariants: styleHelper.variantProps }
+                : {}),
+            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 styleHelper = classSource ? readPrimaryClassHelperUsage(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);
+        const layoutSafety = createUiLayoutSafety(classes);
+        const responsiveProfile = createUiResponsiveProfile(classes);
+        const scaleProfile = createUiScaleProfile(classes);
+        const semanticRole = deriveUiChildSemanticRole(tagInfo.originalTag, kind, classes, label);
+        const roleSignature = createUiRoleSignature({
+            kind,
+            tag: tagInfo.originalTag,
+            classes,
+            label,
+            layoutRole,
+        });
+        const props = {
+            ...readUiProps(tagInfo.attrs),
+            ...(styleHelper ? { styleHelper: styleHelper.name } : {}),
+        };
+        const variants = {
+            ...readVariantProps(props),
+            ...(styleHelper?.variantProps ?? {}),
+        };
+        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) }
+                : {}),
+            ...(layoutSafety ? { layoutSafety } : {}),
+            ...(responsiveProfile ? { responsiveProfile } : {}),
+            ...(scaleProfile ? { scaleProfile } : {}),
+            ...(semanticRole ? { semanticRole } : {}),
+            ...(roleSignature ? { roleSignature } : {}),
+            ...(Object.keys(props).length ? { props } : {}),
+            ...(Object.keys(variants).length ? { variants } : {}),
+            ...(styleHelper ? { styleHelper: styleHelper.name } : {}),
+            ...(styleHelper && Object.keys(styleHelper.variantProps).length
+                ? { styleHelperVariants: styleHelper.variantProps }
+                : {}),
+            ...(label ? { label } : {}),
+        };
+    })
+        .filter((child) => child.kind !== 'unknown' ||
+        child.classes.length ||
+        child.label ||
+        Boolean(child.semanticRole))
+        .slice(0, 16);
+}
+function createUiSemanticProfile(kind, tag, classes, children) {
+    const roles = (0, utils_1.unique)(children.flatMap((child) => child.semanticRole ?? [])).slice(0, 24);
+    const textStyleSignatures = (0, utils_1.unique)(children
+        .filter((child) => ['text', 'heading', 'badge'].includes(child.kind) || child.semanticRole)
+        .map((child) => JSON.stringify(groupTailwindClasses(child.defaultClasses?.length ? child.defaultClasses : child.classes)))).filter(Boolean);
+    const hasIcon = roles.includes('icon') || roles.includes('component-icon') || roles.includes('image');
+    const hasDivider = roles.includes('divider');
+    const hasImage = roles.includes('image');
+    const hasMultipleTextStyles = textStyleSignatures.length > 1;
+    const isCompound = children.length > 1 &&
+        (hasIcon ||
+            hasDivider ||
+            hasMultipleTextStyles ||
+            roles.includes('primary-text') ||
+            roles.includes('secondary-text'));
+    if (!isCompound && !roles.length) {
+        return undefined;
+    }
+    return {
+        roles,
+        isCompound,
+        hasIcon,
+        hasDivider,
+        hasImage,
+        hasMultipleTextStyles,
+        textStyleCount: textStyleSignatures.length,
+        childCount: children.length,
+    };
+}
+function createUiRoleSignature(input) {
+    const { kind, tag, classes } = input;
+    const children = input.children ?? [];
+    const tagName = tag.toLowerCase();
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    const childRoles = (0, utils_1.unique)(children.flatMap((child) => [child.semanticRole, child.roleSignature?.role].filter((value) => typeof value === 'string' && Boolean(value)))).slice(0, 24);
+    const childKinds = (0, utils_1.unique)(children.map((child) => child.kind).filter(Boolean)).slice(0, 24);
+    const hasIcon = childRoles.some((role) => /(?:icon|image|logo|mark)/.test(role));
+    const hasDivider = childRoles.includes('divider');
+    const hasMultipleTextSegments = childRoles.filter((role) => /(?:primary|secondary|text|segment)/.test(role)).length > 1;
+    const exactClassFacts = exactRoleClassFacts(classes);
+    const flags = new Set();
+    const layout = createRoleLayoutKey(kind, tagName, classes, children, input.parentClasses ?? []);
+    const scale = createRoleScaleKey(classes, children);
+    const density = createRoleDensityKey(classes, children);
+    const surface = createRoleSurfaceKey(classes);
+    let roleGroup = kind;
+    let role = `${kind}-${input.layoutRole ?? 'element'}`;
+    if (input.layoutRole) {
+        flags.add(`layout-role:${input.layoutRole}`);
+    }
+    if (hasIcon)
+        flags.add('has-icon');
+    if (hasDivider)
+        flags.add('has-divider');
+    if (hasMultipleTextSegments)
+        flags.add('multiple-text-segments');
+    if (baseSet.has('uppercase'))
+        flags.add('uppercase');
+    if (classes.some((className) => className.includes('hover:')))
+        flags.add('has-hover-state');
+    if (baseSet.has('group'))
+        flags.add('group-context');
+    if (classes.some((className) => (0, utils_1.classBase)(className).startsWith('backdrop-blur'))) {
+        flags.add('backdrop-blur');
+    }
+    if (kind === 'section') {
+        roleGroup = 'section';
+        if (baseSet.has('min-h-screen')) {
+            role = 'hero-section-fullscreen';
+            flags.add('full-screen-hero');
+        }
+        else if (layout === 'split-media-layout') {
+            role = 'split-media-section';
+            flags.add('split-media');
+        }
+        else if (layout === 'card-grid-layout') {
+            role = 'card-grid-section';
+            flags.add('card-grid');
+        }
+        else {
+            role = 'section-shell';
+        }
+    }
+    if (kind === 'layout') {
+        roleGroup = 'layout';
+        if (layout === 'split-media-layout') {
+            role = 'split-media-layout';
+            flags.add('split-media');
+        }
+        else if (layout === 'card-grid-layout') {
+            role = 'card-grid-layout';
+            flags.add('card-grid');
+        }
+        else if (layout === 'hero-content-layout') {
+            role = 'hero-content-layout';
+            flags.add('hero-content');
+        }
+        else {
+            role = `layout-${layout}`;
+        }
+    }
+    if (kind === 'heading') {
+        roleGroup = tagName === 'h1' ? 'hero-heading' : 'heading';
+        if (tagName === 'h1') {
+            if (isOversizedHeadingScale(classes)) {
+                role = 'hero-heading-oversized';
+                flags.add('oversized-heading');
+            }
+            else if (isHeroHeadingScale(classes)) {
+                role = 'hero-heading-standard';
+                flags.add('hero-heading');
+            }
+            else {
+                role = 'page-heading';
+            }
+        }
+        else if (isMetricValueScale(classes)) {
+            role = 'metric-heading';
+            flags.add('metric-value');
+        }
+        else {
+            role = 'section-heading';
+        }
+    }
+    if (kind === 'badge') {
+        roleGroup = 'badge';
+        if (isOverlayPill(classes)) {
+            role = 'overlay-disclaimer-pill';
+            flags.add('overlay-pill');
+        }
+        else if (hasIcon || hasDivider || hasMultipleTextSegments) {
+            role = 'brand-lockup-badge';
+            flags.add('compound-badge');
+        }
+        else if (isCompactHeroEyebrow(classes)) {
+            role = 'hero-eyebrow-compact';
+            flags.add('compact-eyebrow');
+        }
+        else {
+            role = 'badge-pill';
+        }
+    }
+    if (kind === 'card') {
+        roleGroup = 'surface';
+        if (isCompactStatCard(classes, childRoles)) {
+            role = 'hero-stat-card-compact';
+            flags.add('compact-stat-card');
+        }
+        else if (isInteractiveServiceCard(classes)) {
+            role = 'interactive-service-card';
+            flags.add('interactive-card');
+        }
+        else if (isStaticArticleCard(classes)) {
+            role = 'static-article-card';
+            flags.add('static-article-surface');
+        }
+        else if (isMediaPanelCard(classes, childKinds, childRoles)) {
+            role = 'media-panel-card';
+            flags.add('media-panel');
+        }
+        else {
+            role = 'surface-card';
+        }
+    }
+    if (kind === 'text') {
+        roleGroup = 'text';
+        if (isCompactStatValue(classes)) {
+            role = 'compact-stat-value';
+            flags.add('compact-stat-value');
+        }
+        else if (isLargeMetricValue(classes)) {
+            role = 'large-metric-value';
+            flags.add('large-metric-value');
+        }
+        else if (isOverlayPill(classes)) {
+            role = 'overlay-disclaimer-text';
+            flags.add('overlay-pill');
+        }
+        else {
+            role = 'body-copy';
+        }
+    }
+    if (kind === 'button') {
+        roleGroup = 'action';
+        if (isQuietAction(classes)) {
+            role = 'quiet-action';
+            flags.add('low-emphasis-action');
+        }
+        else if (isCompactAction(classes)) {
+            role = 'compact-action-button';
+            flags.add('compact-action');
+        }
+        else {
+            role = 'action-button';
+        }
+    }
+    if (!classes.length && !childRoles.length && role === `${kind}-${input.layoutRole ?? 'element'}`) {
+        return undefined;
+    }
+    return {
+        role,
+        roleGroup,
+        scale,
+        density,
+        surface,
+        layout,
+        flags: Array.from(flags).sort(),
+        exactClassFacts,
+        ...(childRoles.length ? { childRoles } : {}),
+        ...(childKinds.length ? { childKinds } : {}),
+    };
+}
+function exactRoleClassFacts(classes) {
+    return (0, utils_1.unique)(classes.filter((className) => {
+        const base = (0, utils_1.classBase)(className);
+        return (isTypographyClass(className) ||
+            isSpacingClass(className) ||
+            isSizingClass(className) ||
+            isLayoutClass(className) ||
+            isStateClass(className) ||
+            /^(?:bg-|text-|border|rounded|shadow|backdrop|opacity|ring|outline|z-|absolute|relative|fixed|sticky|top-|right-|bottom-|left-|overflow-|object-|aspect-|group|transition|duration|ease)/.test(base));
+    })).slice(0, 120);
+}
+function createRoleScaleKey(classes, children = []) {
+    const scaleClasses = (0, utils_1.unique)([
+        ...classes,
+        ...children.flatMap((child) => child.classes.slice(0, 24)),
+    ].filter((className) => {
+        const base = (0, utils_1.classBase)(className);
+        return (isTypographyClass(className) ||
+            isSizingClass(className) ||
+            /^(?:max-w-|min-w-|leading-|tracking-|text-|font-|h-|w-|min-h-|max-h-)/.test(base));
+    }))
+        .sort(roleClassSort)
+        .slice(0, 40);
+    return scaleClasses.length ? scaleClasses.join(' ') : 'scale-unspecified';
+}
+function createRoleDensityKey(classes, children = []) {
+    const densityClasses = (0, utils_1.unique)([
+        ...classes,
+        ...children.flatMap((child) => child.classes.slice(0, 16)),
+    ].filter((className) => {
+        const base = (0, utils_1.classBase)(className);
+        return /^(?:p[trblxy]?|m[trblxy]?|gap-|space-|h-|min-h-|max-h-|w-|min-w-|max-w-)/.test(base);
+    }))
+        .sort(roleClassSort)
+        .slice(0, 40);
+    if (!densityClasses.length) {
+        return 'density-unspecified';
+    }
+    if (densityClasses.some((className) => /(?:^|:)py-(?:1|1\.5|2)$/.test(className)) ||
+        densityClasses.some((className) => /(?:^|:)h-(?:8|9|10|11|12)$/.test(className))) {
+        return `compact:${densityClasses.join(' ')}`;
+    }
+    if (densityClasses.some((className) => /(?:^|:)p-(?:8|10|12|16|20|24)$/.test(className)) ||
+        densityClasses.some((className) => /(?:^|:)py-(?:8|10|12|16|20|24)$/.test(className))) {
+        return `spacious:${densityClasses.join(' ')}`;
+    }
+    return densityClasses.join(' ');
+}
+function createRoleSurfaceKey(classes) {
+    const surfaceClasses = (0, utils_1.unique)(classes.filter((className) => {
+        const base = (0, utils_1.classBase)(className);
+        return /^(?:bg-|border|rounded|shadow|ring|outline|backdrop|opacity|group|transition|hover:border|hover:bg)/.test(base);
+    }))
+        .sort(roleClassSort)
+        .slice(0, 40);
+    return surfaceClasses.length ? surfaceClasses.join(' ') : 'surface-unspecified';
+}
+function createRoleLayoutKey(kind, tagName, classes, children = [], parentClasses = []) {
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    const childKinds = new Set(children.map((child) => child.kind));
+    const childRoles = new Set(children.flatMap((child) => [child.semanticRole, child.roleSignature?.role].filter(Boolean)));
+    const childClassBases = children.flatMap((child) => child.classes.map(utils_1.classBase));
+    const hasMediaChild = childKinds.has('image') ||
+        childRoles.has('image') ||
+        childRoles.has('media-panel-card') ||
+        childClassBases.some((base) => /^(?:aspect-|object-|h-\[|min-h-\[)/.test(base));
+    const hasCardChildren = children.filter((child) => child.kind === 'card').length >= 2;
+    const hasTextChildren = children.some((child) => ['heading', 'text', 'badge'].includes(child.kind) ||
+        (child.kind === 'layout' &&
+            child.classes.some((className) => /^(?:max-w-|space-y-|prose|flex|grid)/.test((0, utils_1.classBase)(className)))));
+    const parentBaseSet = new Set(parentClasses.map(utils_1.classBase));
+    if (baseSet.has('min-h-screen')) {
+        return 'full-screen-hero-layout';
+    }
+    if (baseSet.has('absolute') &&
+        (baseSet.has('bottom-3') || baseSet.has('bottom-4')) &&
+        (baseSet.has('right-3') || baseSet.has('right-4'))) {
+        return 'absolute-bottom-right-overlay';
+    }
+    if ((baseSet.has('grid') || parentBaseSet.has('grid')) &&
+        hasMediaChild &&
+        hasTextChildren &&
+        classes.some((className) => /(?:^|:)grid-cols-|(?:^|:)lg:grid-cols-/.test(className))) {
+        return 'split-media-layout';
+    }
+    if ((baseSet.has('grid') || parentBaseSet.has('grid')) && hasCardChildren) {
+        return 'card-grid-layout';
+    }
+    if (tagName === 'main' || (kind === 'layout' && baseSet.has('mx-auto'))) {
+        return 'page-content-layout';
+    }
+    if (baseSet.has('flex') || baseSet.has('inline-flex')) {
+        return 'flex-layout';
+    }
+    if (baseSet.has('grid')) {
+        return 'grid-layout';
+    }
+    return 'layout-unspecified';
+}
+function isCompactHeroEyebrow(classes) {
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    return (baseSet.has('inline-flex') &&
+        baseSet.has('rounded-full') &&
+        baseSet.has('uppercase') &&
+        classes.some((className) => /(?:^|:)text-xs$/.test(className)) &&
+        classes.some((className) => /(?:^|:)sm:text-sm$/.test(className)) &&
+        bases.some((base) => /^py-(?:1\.5|2)$/.test(base)) &&
+        bases.some((base) => /^px-(?:3|4|5)$/.test(base)));
+}
+function isOverlayPill(classes) {
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    return (baseSet.has('absolute') &&
+        baseSet.has('rounded-full') &&
+        bases.some((base) => /^bottom-/.test(base)) &&
+        bases.some((base) => /^right-/.test(base)) &&
+        (bases.some((base) => /^text-\[(?:10|11)px\]$/.test(base)) ||
+            classes.some((className) => /(?:^|:)sm:text-\[(?:10|11)px\]$/.test(className))));
+}
+function isHeroHeadingScale(classes) {
+    const classSet = new Set(classes);
+    const bases = classes.map(utils_1.classBase);
+    return (classSet.has('text-4xl') &&
+        classSet.has('sm:text-6xl') &&
+        classSet.has('lg:text-7xl') &&
+        bases.some((base) => /^leading-/.test(base)));
+}
+function isOversizedHeadingScale(classes) {
+    const classSet = new Set(classes);
+    return (classSet.has('text-6xl') ||
+        classSet.has('sm:text-7xl') ||
+        classSet.has('lg:text-8xl') ||
+        classSet.has('xl:text-9xl') ||
+        classes.some((className) => /(?:^|:)text-\[(?:8|9|10)\dpx\]/.test(className)));
+}
+function isMetricValueScale(classes) {
+    return classes.some((className) => /(?:^|:)text-(?:lg|xl|2xl|3xl|4xl)$/.test(className));
+}
+function isCompactStatValue(classes) {
+    const classSet = new Set(classes);
+    const bases = classes.map(utils_1.classBase);
+    return (classSet.has('text-lg') &&
+        bases.some((base) => /^font-(?:bold|extrabold|black)$/.test(base)) &&
+        bases.some((base) => /^text-\[|^text-(?:brand|accent|yellow|amber|gold)/.test(base)));
+}
+function isLargeMetricValue(classes) {
+    const classSet = new Set(classes);
+    return (classSet.has('text-2xl') ||
+        classSet.has('sm:text-3xl') ||
+        classSet.has('text-3xl') ||
+        classSet.has('text-4xl'));
+}
+function isCompactStatCard(classes, childRoles) {
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    return (childRoles.includes('compact-stat-value') ||
+        (baseSet.has('rounded-lg') &&
+            baseSet.has('border') &&
+            bases.some((base) => /^p-(?:4|5)$/.test(base)) &&
+            !baseSet.has('group')));
+}
+function isInteractiveServiceCard(classes) {
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    return (baseSet.has('group') ||
+        classes.some((className) => className.includes('hover:')) ||
+        (baseSet.has('transition') && bases.includes('shadow-2xl')));
+}
+function isStaticArticleCard(classes) {
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    return (baseSet.has('flex') &&
+        baseSet.has('h-full') &&
+        baseSet.has('flex-col') &&
+        baseSet.has('rounded-lg') &&
+        baseSet.has('border') &&
+        bases.includes('p-6') &&
+        !baseSet.has('group') &&
+        !classes.some((className) => className.includes('hover:')));
+}
+function isMediaPanelCard(classes, childKinds, childRoles) {
+    const bases = classes.map(utils_1.classBase);
+    return (childKinds.includes('image') ||
+        childRoles.includes('image') ||
+        bases.some((base) => /^(?:aspect-|object-|overflow-hidden)$/.test(base)));
+}
+function isQuietAction(classes) {
+    const bases = classes.map(utils_1.classBase);
+    return (bases.includes('bg-transparent') &&
+        (bases.includes('border-transparent') ||
+            bases.some((base) => /^text-(?:muted|secondary|slate|gray)/.test(base))));
+}
+function isCompactAction(classes) {
+    const bases = classes.map(utils_1.classBase);
+    return (bases.some((base) => /^h-(?:9|10|11|12)$/.test(base)) &&
+        bases.some((base) => /^px-(?:4|5)$/.test(base)) &&
+        classes.some((className) => /(?:^|:)text-sm$/.test(className)));
+}
+function roleClassSort(a, b) {
+    const priority = (value) => {
+        const base = (0, utils_1.classBase)(value);
+        if (/^(?:max-w-|min-w-|w-|h-|min-h-|max-h-)/.test(base))
+            return 0;
+        if (/^(?:text-|font-|leading-|tracking-)/.test(base))
+            return 1;
+        if (/^(?:p|m|gap|space)-/.test(base))
+            return 2;
+        if (/^(?:bg-|border|rounded|shadow|backdrop)/.test(base))
+            return 3;
+        return 4;
+    };
+    return priority(a) - priority(b) || a.localeCompare(b);
+}
+function deriveUiChildSemanticRole(tag, kind, classes, label) {
+    const tagName = tag.toLowerCase();
+    const tagBase = tag.split('.')[0].split(':').pop() ?? tag;
+    const lowerBase = tagBase.toLowerCase();
+    const classBases = classes.map(utils_1.classBase);
+    const classHaystack = [tagName, lowerBase, ...classBases].join(' ').toLowerCase();
+    const labelHaystack = (label ?? '').toLowerCase();
+    if (kind === 'icon') {
+        return 'icon';
+    }
+    if (kind === 'image') {
+        return 'image';
+    }
+    if (kind === 'divider') {
+        return 'divider';
+    }
+    if (tagName === 'img' ||
+        tagName === 'picture' ||
+        tagName === 'svg' ||
+        /(?:icon|logo|mark|glyph|avatar|image|img)$/.test(lowerBase) ||
+        /\b(?:icon|logo|mark|glyph|avatar)\b/.test(classHaystack)) {
+        return tagName === 'img' || tagName === 'picture' ? 'image' : 'icon';
+    }
+    if (classes.some((className) => /^(?:w-px|h-px|border-l|border-r|border-t|border-b|divide-x|divide-y)$/.test((0, utils_1.classBase)(className))) ||
+        /\b(?:divider|separator|sep|rule)\b/.test(classHaystack)) {
+        return 'divider';
+    }
+    if (kind === 'text' || kind === 'heading' || kind === 'badge') {
+        if (classes.some((className) => /^(?:text-muted|text-muted-foreground|text-secondary|opacity-|font-normal)/.test((0, utils_1.classBase)(className)))) {
+            return 'secondary-text';
+        }
+        if (classes.some((className) => /^(?:font-bold|font-semibold|font-black|text-primary|text-brand|text-accent|text-yellow|text-amber|text-gold|text-\[)/.test((0, utils_1.classBase)(className))) ||
+            (labelHaystack.length > 0 && labelHaystack.length <= 32)) {
+            return 'primary-text';
+        }
+        return 'text-segment';
+    }
+    if (/^[A-Z]/.test(tagBase) && !classes.length && !label) {
+        return 'component-icon';
+    }
+    return undefined;
+}
+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) {
+    const prefixes = className.split(':').slice(0, -1);
+    return prefixes.some((prefix) => /^(?:hover|focus|active|disabled|visited|dark|group|peer|aria|data)/.test(prefix));
+}
+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 (/(?:^|\/)(?:app|pages|src\/app|src\/pages)\/test\//i.test(relPath) ||
+        /(?:^|\/)(?:__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 classHelper = readPrimaryClassHelperUsage(readClassSource(attrs) ?? '');
+    const classHelperName = classHelper?.name.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 (tagName === 'img' ||
+        tagName === 'picture' ||
+        /^(image|img|avatar)$/i.test(tagBase) ||
+        /(?:image|img|avatar)$/.test(lowerBase)) {
+        return 'image';
+    }
+    if (tagName === 'svg' ||
+        /^(icon|logo|mark|glyph)$/i.test(tagBase) ||
+        /(?:icon|logo|mark|glyph)$/.test(lowerBase) ||
+        /\b(icon|logo|mark|glyph)\b/.test(classHaystack)) {
+        return 'icon';
+    }
+    if (/^(divider|separator|rule)$/i.test(tagBase) ||
+        /\b(divider|separator|rule)\b/.test(classHaystack) ||
+        classes.some((className) => /^(?:w-px|h-px|border-l|border-r|border-t|border-b|divide-x|divide-y)$/.test((0, utils_1.classBase)(className)))) {
+        return 'divider';
+    }
+    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 (/(?:button|cta|action)/.test(classHelperName) ||
+        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|status)/.test(classHelperName) ||
+        /^(badge|chip|pill|tag|status|eyebrow)$/i.test(tagBase) ||
+        /\b(badge|chip|pill|tag|status|eyebrow)\b/.test(classHaystack) ||
+        looksLikePillBadge(tagName, classes)) {
+        return 'badge';
+    }
+    if (/^(card|panel|tile|surface|sectionframe|frame|callout)$/i.test(tagBase) ||
+        /\b(card|panel|tile|section-frame|context-surface|frame|callout)\b/.test(classHaystack) ||
+        looksLikeSurfaceContainer(tagName, tagBase, classes)) {
+        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 looksLikeSurfaceContainer(tagName, tagBase, classes) {
+    const bases = classes.map(utils_1.classBase);
+    const isContainerTag = ['div', 'article', 'section', 'aside', 'figure', 'li', 'main', 'header', 'footer'].includes(tagName) ||
+        /^[A-Z]/.test(tagBase);
+    const isTinyIndicator = tagName === 'span' &&
+        bases.includes('rounded-full') &&
+        bases.some((base) => /^(?:h|size)-(?:px|0\.5|1|1\.5|2|2\.5|3)$/.test(base)) &&
+        bases.some((base) => /^(?:w|size)-(?:px|0\.5|1|1\.5|2|2\.5|3)$/.test(base));
+    if (!isContainerTag || isTinyIndicator) {
+        return false;
+    }
+    const hasSurfaceBackground = bases.some((base) => base === 'bg-card' ||
+        base === 'section-frame' ||
+        base === 'context-surface' ||
+        /^bg-/.test(base) ||
+        /^bg-\[var\(--(?:surface|card)-/.test(base));
+    const hasContainerShape = bases.some((base) => /^(?:border|rounded|shadow|ring|outline|overflow-hidden)/.test(base));
+    const hasContainerStructure = bases.some((base) => /^(?:p[trblxy]?|gap-|space-|min-h-|max-w-|w-full|flex|grid|relative)/.test(base));
+    return hasSurfaceBackground && hasContainerShape && hasContainerStructure;
+}
+function looksLikePillBadge(tagName, classes) {
+    const bases = classes.map(utils_1.classBase);
+    const baseSet = new Set(bases);
+    const allowedTag = ['div', 'span', 'small', 'p', 'li'].includes(tagName);
+    const hasPillShape = baseSet.has('rounded-full') || bases.some((base) => /^rounded-\[/.test(base));
+    const hasCompactSpacing = bases.some((base) => /^px-(?:2|2\.5|3|4|5|6)$/.test(base)) &&
+        bases.some((base) => /^py-(?:1|1\.5|2|2\.5|3)$/.test(base));
+    const hasBadgeText = baseSet.has('uppercase') ||
+        classes.some((className) => /(?:^|:)text-(?:xs|sm|\[(?:10|11|12|13|14)px\])$/.test(className));
+    const hasCompoundPillLayout = bases.some((base) => /^gap-/.test(base));
+    const hasBadgeSurface = bases.some((base) => /^bg-/.test(base)) ||
+        bases.some((base) => /^border/.test(base)) ||
+        bases.some((base) => /^shadow/.test(base));
+    const hasInlineLayout = baseSet.has('inline-flex') ||
+        baseSet.has('inline-grid') ||
+        (baseSet.has('absolute') && bases.some((base) => /^bottom-|^top-/.test(base)));
+    return (allowedTag &&
+        hasPillShape &&
+        hasCompactSpacing &&
+        (hasBadgeText || hasCompoundPillLayout) &&
+        hasBadgeSurface &&
+        hasInlineLayout);
+}
+function stripTags(value) {
+    return value.replace(/<[^>]+>/g, ' ').replace(/\{[{%][\s\S]*?[}%]\}/g, ' ');
+}
+//# sourceMappingURL=extractors.js.map