@schemyx/mcp 0.1.0 → 0.1.1

package/dist/codebase-scanner/bundle.js

@@ -0,0 +1,2177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBundle = createBundle;
+exports.addEntry = addEntry;
+exports.hasStyleSurface = hasStyleSurface;
+exports.isBackendRouteFile = isBackendRouteFile;
+exports.backendFileContext = backendFileContext;
+exports.findEndpointContract = findEndpointContract;
+exports.createBackendEndpointFlow = createBackendEndpointFlow;
+exports.backendCallDependencies = backendCallDependencies;
+exports.addBackendCallEdges = addBackendCallEdges;
+exports.backendCallKey = backendCallKey;
+exports.uniqueSideEffectsForRecipe = uniqueSideEffectsForRecipe;
+exports.sourceInfo = sourceInfo;
+exports.toGraphNode = toGraphNode;
+exports.toGraphEdge = toGraphEdge;
+exports.addRenderEdges = addRenderEdges;
+exports.addUiPatternRules = addUiPatternRules;
+exports.addUiCompositionRules = addUiCompositionRules;
+exports.addConnectedPatternRules = addConnectedPatternRules;
+exports.buildConnectedPatternClusters = buildConnectedPatternClusters;
+exports.createFrontendPatternInstances = createFrontendPatternInstances;
+exports.createBackendPatternInstances = createBackendPatternInstances;
+exports.createDataPatternInstances = createDataPatternInstances;
+exports.isConnectedUiPatternRoot = isConnectedUiPatternRoot;
+exports.normalizeConnectedChildren = normalizeConnectedChildren;
+exports.withoutConnectedChildSignature = withoutConnectedChildSignature;
+exports.connectedChildKind = connectedChildKind;
+exports.summarizeConnectedChildren = summarizeConnectedChildren;
+exports.compactConnectedPatternInstance = compactConnectedPatternInstance;
+exports.scoreConnectedPatternGroup = scoreConnectedPatternGroup;
+exports.connectedPatternConfidence = connectedPatternConfidence;
+exports.createConnectedPatternScores = createConnectedPatternScores;
+exports.createConnectedPatternDecision = createConnectedPatternDecision;
+exports.createConceptPatternScores = createConceptPatternScores;
+exports.createConceptPatternDecision = createConceptPatternDecision;
+exports.connectedPatternVariants = connectedPatternVariants;
+exports.connectedPatternChildren = connectedPatternChildren;
+exports.derivePatternOwners = derivePatternOwners;
+exports.readablePatternConcept = readablePatternConcept;
+exports.roundPatternScore = roundPatternScore;
+exports.frontendPatternWeight = frontendPatternWeight;
+exports.backendPatternWeight = backendPatternWeight;
+exports.hasBackendPatternSurface = hasBackendPatternSurface;
+exports.backendPatternConcept = backendPatternConcept;
+exports.summarizeModelFieldShape = summarizeModelFieldShape;
+exports.createConnectedPatternGuidance = createConnectedPatternGuidance;
+exports.connectedPatternSlug = connectedPatternSlug;
+exports.classSignature = classSignature;
+exports.normalizeLayoutRole = normalizeLayoutRole;
+exports.normalizeTagForSignature = normalizeTagForSignature;
+exports.normalizeChildTagForSignature = normalizeChildTagForSignature;
+exports.labelSignature = labelSignature;
+exports.addImportEdges = addImportEdges;
+exports.addApiCallEdges = addApiCallEdges;
+exports.addStyleUsageEdges = addStyleUsageEdges;
+exports.addModelUsageEdges = addModelUsageEdges;
+exports.addConceptClusters = addConceptClusters;
+exports.applyUsedBy = applyUsedBy;
+exports.detectProjectFacts = detectProjectFacts;
+exports.detectFrameworkForFile = detectFrameworkForFile;
+const backend_1 = require("./backend");
+const constants_1 = require("./constants");
+const extractors_1 = require("./extractors");
+const utils_1 = require("./utils");
+function createBundle(rootPath, projectType, files) {
+    const entries = [];
+    const usedKeys = new Set();
+    const nodes = [];
+    const edges = [];
+    const reviewItems = [];
+    for (const file of files) {
+        const fileSource = sourceInfo('core.files', 'high', [`path:${file.relPath}`], file);
+        addEntry(entries, usedKeys, {
+            key: file.key,
+            group: 'file',
+            summary: file.summary,
+            tags: file.tags,
+            dependencies: file.dependencies.map((dependency) => (0, utils_1.toRegistryKey)('dep', dependency)),
+            usedBy: [],
+            confidence: 'high',
+            status: 'inferred',
+            path: file.relPath,
+            value: {
+                path: file.relPath,
+                kind: file.kind,
+                layer: file.layer,
+                language: file.language,
+                symbols: file.symbols,
+                functions: file.functions,
+                classes: file.classes,
+                types: file.types,
+                constants: file.constants,
+                exports: file.exports,
+                imports: file.imports,
+                classReferences: file.classReferences.slice(0, 80),
+                cssIds: file.cssIds.slice(0, 80),
+                cssVariableValues: file.cssVariableValues.slice(0, 160),
+                cssRules: file.cssRules.slice(0, 120),
+                classExpressions: file.classExpressions.slice(0, 160),
+                tailwindUtilities: file.tailwindUtilities.slice(0, 80),
+                componentStyleDefinitions: file.componentStyleDefinitions.slice(0, 40),
+                themeTokens: file.themeTokens.slice(0, 200),
+                inlineStyles: file.inlineStyles.slice(0, 80),
+                apiCalls: file.apiCalls,
+                envVars: file.envVars,
+                tests: file.tests,
+                docsHeadings: file.docsHeadings,
+                configKeys: file.configKeys,
+                templateIncludes: file.templateIncludes,
+                authHints: file.authHints,
+                middleware: file.middleware,
+                jobs: file.jobs,
+                events: file.events,
+                uiElements: file.uiElements.slice(0, 40),
+                ...backendFileContext(file),
+                size: file.size,
+                sourceHash: file.sourceHash,
+                source: fileSource,
+            },
+        });
+        nodes.push(toGraphNode(file.key, file.kind, file.relPath, file.relPath, file, 'core.files'));
+        for (const dependency of file.dependencies) {
+            const dependencyKey = (0, utils_1.toRegistryKey)('dep', dependency);
+            addEntry(entries, usedKeys, {
+                key: dependencyKey,
+                group: 'dependency',
+                summary: `Package dependency: ${dependency}.`,
+                tags: ['dependency', 'package'],
+                dependencies: [],
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                value: {
+                    packageName: dependency,
+                    declaredIn: file.relPath,
+                    kind: 'dependency',
+                    source: fileSource,
+                },
+            });
+            nodes.push(toGraphNode(dependencyKey, 'package', dependency, file.relPath, file, 'core.dependencies'));
+            edges.push(toGraphEdge(file.key, dependencyKey, 'depends_on', 'core.dependencies', file));
+        }
+        for (const component of file.components) {
+            const componentKey = (0, utils_1.toRegistryKey)('component', component);
+            const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
+            const compositionRuleKey = (0, utils_1.toRegistryKey)('rule', `ui.composition.${file.relPath.replace(/\.[^.]+$/, '')}`);
+            const dependencies = (0, utils_1.unique)([
+                file.key,
+                ...(hasStyleSurface(file) ? [styleKey] : []),
+                ...(file.uiElements.length ? [compositionRuleKey] : []),
+            ]);
+            addEntry(entries, usedKeys, {
+                key: componentKey,
+                group: 'component',
+                summary: `${component} component in ${file.relPath}.`,
+                tags: ['component', file.layer, file.language],
+                dependencies,
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: component,
+                    path: file.relPath,
+                    exports: file.exports,
+                    imports: file.imports,
+                    props: file.componentProps[component] ?? [],
+                    classReferences: file.classReferences.slice(0, 40),
+                    tailwindUtilities: file.tailwindUtilities.slice(0, 40),
+                    classExpressions: file.classExpressions.slice(0, 80),
+                    componentStyleDefinitions: file.componentStyleDefinitions.slice(0, 20),
+                    themeTokens: file.themeTokens.slice(0, 120),
+                    uiElements: file.uiElements.slice(0, 20),
+                    apiCalls: file.apiCalls,
+                    authHints: file.authHints,
+                    kind: 'component',
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo('react', 'high', [`component:${component}`, `path:${file.relPath}`], file),
+                },
+            });
+            nodes.push(toGraphNode(componentKey, 'component', component, file.relPath, file, 'react', {
+                react: { export: component },
+            }));
+            edges.push(toGraphEdge(file.key, componentKey, 'exports', 'typescript', file));
+        }
+        for (const hook of file.hooks) {
+            const hookKey = (0, utils_1.toRegistryKey)('hook', hook);
+            addEntry(entries, usedKeys, {
+                key: hookKey,
+                group: 'hook',
+                summary: `${hook} hook in ${file.relPath}.`,
+                tags: ['hook', file.layer, file.language],
+                dependencies: [file.key],
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: hook,
+                    path: file.relPath,
+                    imports: file.imports,
+                    kind: 'hook',
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo('react', 'high', [`hook:${hook}`], file),
+                },
+            });
+            nodes.push(toGraphNode(hookKey, 'hook', hook, file.relPath, file, 'react'));
+            edges.push(toGraphEdge(file.key, hookKey, 'exports', 'typescript', file));
+        }
+        for (const route of file.routes) {
+            const routeKey = (0, utils_1.toRegistryKey)('route', route);
+            const routeLayer = isBackendRouteFile(file) ? 'backend' : 'frontend';
+            const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
+            const compositionRuleKey = (0, utils_1.toRegistryKey)('rule', `ui.composition.${file.relPath.replace(/\.[^.]+$/, '')}`);
+            const dependencies = (0, utils_1.unique)([
+                file.key,
+                ...(hasStyleSurface(file) ? [styleKey] : []),
+                ...(file.uiElements.length ? [compositionRuleKey] : []),
+            ]);
+            addEntry(entries, usedKeys, {
+                key: routeKey,
+                group: 'route',
+                summary: `${routeLayer === 'backend' ? 'Backend' : 'Frontend'} route ${route} from ${file.relPath}.`,
+                tags: ['route', routeLayer, file.language],
+                dependencies,
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: route,
+                    route,
+                    path: file.relPath,
+                    kind: file.kind,
+                    uiElements: file.uiElements.slice(0, 40),
+                    classReferences: file.classReferences.slice(0, 80),
+                    tailwindUtilities: file.tailwindUtilities.slice(0, 80),
+                    classExpressions: file.classExpressions.slice(0, 80),
+                    componentStyleDefinitions: file.componentStyleDefinitions.slice(0, 20),
+                    apiCalls: file.apiCalls,
+                    authHints: file.authHints,
+                    templateIncludes: file.templateIncludes,
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo((0, extractors_1.routeExtractorForFile)(file), (0, extractors_1.routeConfidenceForFile)(file), [`route:${route}`, `path:${file.relPath}`], file),
+                },
+            });
+            nodes.push(toGraphNode(routeKey, 'route', route, file.relPath, file, (0, extractors_1.routeExtractorForFile)(file), {
+                route: { segment: route },
+            }));
+            edges.push(toGraphEdge(file.key, routeKey, 'contains', (0, extractors_1.routeExtractorForFile)(file), file, (0, extractors_1.routeConfidenceForFile)(file)));
+        }
+        for (const handler of file.apiHandlers) {
+            const handlerKey = (0, utils_1.toRegistryKey)('api', handler);
+            const endpointContract = findEndpointContract(file, handler);
+            const backendDependencies = endpointContract
+                ? backendCallDependencies(endpointContract.serviceCalls)
+                : [];
+            addEntry(entries, usedKeys, {
+                key: handlerKey,
+                group: 'api',
+                summary: `API handler ${handler} from ${file.relPath}.`,
+                tags: (0, utils_1.unique)([
+                    'api',
+                    'backend',
+                    file.layer,
+                    file.language,
+                    ...(endpointContract?.risk ?? []),
+                    ...(endpointContract?.auth.required ? ['auth-protected'] : []),
+                    ...(endpointContract?.auth.public ? ['public'] : []),
+                ]),
+                dependencies: (0, utils_1.unique)([file.key, ...backendDependencies]),
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: handler,
+                    handler,
+                    path: file.relPath,
+                    imports: file.imports,
+                    envVars: file.envVars,
+                    authHints: file.authHints,
+                    modelReferences: (0, utils_1.matchingNames)(file.models, file.apiHandlers.join(' ')),
+                    contract: endpointContract,
+                    requestContract: endpointContract?.request,
+                    responseContract: endpointContract?.response,
+                    authPolicy: endpointContract?.auth,
+                    validation: endpointContract?.validation,
+                    serviceCalls: endpointContract?.serviceCalls ?? [],
+                    repositoryCalls: endpointContract?.repositoryCalls ?? [],
+                    sideEffects: endpointContract?.sideEffects ?? [],
+                    errors: endpointContract?.errors ?? [],
+                    logging: endpointContract?.logging ?? [],
+                    risk: endpointContract?.risk ?? [],
+                    flow: endpointContract
+                        ? createBackendEndpointFlow(file, handlerKey, endpointContract)
+                        : undefined,
+                    kind: 'api',
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo((0, extractors_1.apiExtractorForFile)(file), 'high', [`handler:${handler}`], file),
+                },
+            });
+            nodes.push(toGraphNode(handlerKey, 'api', handler, file.relPath, file, file.kind.includes('next') ? 'nextjs' : 'api.routes'));
+            edges.push(toGraphEdge(file.key, handlerKey, 'contains', 'api.routes', file));
+            addBackendCallEdges(handlerKey, endpointContract?.serviceCalls ?? [], file, edges);
+        }
+        for (const controller of file.controllers) {
+            const controllerKey = (0, utils_1.toRegistryKey)('controller', controller);
+            const controllerEndpointContracts = file.backendEndpointContracts.filter((contract) => contract.controller === controller);
+            addEntry(entries, usedKeys, {
+                key: controllerKey,
+                group: 'controller',
+                summary: `${controller} backend controller in ${file.relPath}.`,
+                tags: (0, utils_1.unique)([
+                    'controller',
+                    'backend',
+                    file.language,
+                    ...controllerEndpointContracts.flatMap((contract) => contract.risk),
+                ]),
+                dependencies: (0, utils_1.unique)([
+                    file.key,
+                    ...controllerEndpointContracts.flatMap((contract) => backendCallDependencies(contract.serviceCalls)),
+                ]),
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: controller,
+                    path: file.relPath,
+                    imports: file.imports,
+                    apiHandlers: file.apiHandlers,
+                    endpointContracts: controllerEndpointContracts,
+                    operations: file.backendOperations.filter((operation) => operation.owner === controller && operation.ownerKind === 'controller'),
+                    services: file.services,
+                    authHints: file.authHints,
+                    sideEffects: uniqueSideEffectsForRecipe(controllerEndpointContracts.flatMap((contract) => contract.sideEffects)),
+                    errors: controllerEndpointContracts.flatMap((contract) => contract.errors),
+                    logging: controllerEndpointContracts.flatMap((contract) => contract.logging),
+                    kind: 'controller',
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo((0, extractors_1.controllerExtractorForFile)(file), 'high', [`controller:${controller}`], file),
+                },
+            });
+            nodes.push(toGraphNode(controllerKey, 'controller', controller, file.relPath, file, (0, extractors_1.controllerExtractorForFile)(file)));
+            edges.push(toGraphEdge(file.key, controllerKey, 'exports', (0, extractors_1.controllerExtractorForFile)(file), file));
+        }
+        for (const service of file.services) {
+            const serviceKey = (0, utils_1.toRegistryKey)('service', service);
+            const serviceOperations = file.backendOperations.filter((operation) => operation.owner === service && operation.ownerKind === 'service');
+            addEntry(entries, usedKeys, {
+                key: serviceKey,
+                group: 'service',
+                summary: `${service} backend service in ${file.relPath}.`,
+                tags: (0, utils_1.unique)([
+                    'service',
+                    'backend',
+                    file.language,
+                    ...serviceOperations.flatMap((operation) => operation.risk),
+                ]),
+                dependencies: (0, utils_1.unique)([
+                    file.key,
+                    ...backendCallDependencies(serviceOperations.flatMap((operation) => operation.serviceCalls)),
+                ]),
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: service,
+                    path: file.relPath,
+                    imports: file.imports,
+                    envVars: file.envVars,
+                    apiCalls: file.apiCalls,
+                    operations: serviceOperations,
+                    operationNames: serviceOperations.map((operation) => operation.name),
+                    modelReferences: file.models,
+                    events: file.events,
+                    sideEffects: uniqueSideEffectsForRecipe(file.backendSideEffects),
+                    errors: file.backendErrors,
+                    logging: file.backendLogging,
+                    risk: (0, utils_1.unique)(serviceOperations.flatMap((operation) => operation.risk)),
+                    kind: 'service',
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo((0, extractors_1.serviceExtractorForFile)(file), 'high', [`service:${service}`], file),
+                },
+            });
+            nodes.push(toGraphNode(serviceKey, 'service', service, file.relPath, file, (0, extractors_1.serviceExtractorForFile)(file)));
+            edges.push(toGraphEdge(file.key, serviceKey, 'exports', (0, extractors_1.serviceExtractorForFile)(file), file));
+            for (const operation of serviceOperations) {
+                addBackendCallEdges(serviceKey, operation.serviceCalls, file, edges);
+            }
+        }
+        for (const moduleName of file.modules) {
+            const moduleKey = (0, utils_1.toRegistryKey)('module', moduleName);
+            addEntry(entries, usedKeys, {
+                key: moduleKey,
+                group: 'module',
+                summary: `${moduleName} backend module in ${file.relPath}.`,
+                tags: ['module', 'backend', file.language],
+                dependencies: [file.key],
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: moduleName,
+                    path: file.relPath,
+                    imports: file.imports,
+                    middleware: file.middleware,
+                    kind: 'module',
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo((0, extractors_1.moduleExtractorForFile)(file), 'high', [`module:${moduleName}`], file),
+                },
+            });
+            nodes.push(toGraphNode(moduleKey, 'module', moduleName, file.relPath, file, (0, extractors_1.moduleExtractorForFile)(file)));
+            edges.push(toGraphEdge(file.key, moduleKey, 'exports', (0, extractors_1.moduleExtractorForFile)(file), file));
+        }
+        for (const model of file.models) {
+            const modelKey = (0, utils_1.toRegistryKey)('model', model);
+            addEntry(entries, usedKeys, {
+                key: modelKey,
+                group: 'model',
+                summary: `${model} data model in ${file.relPath}.`,
+                tags: ['model', 'schema'],
+                dependencies: [file.key],
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: model,
+                    path: file.relPath,
+                    fields: file.modelFields[model] ?? [],
+                    kind: 'model',
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo((0, extractors_1.modelExtractorForFile)(file), 'high', [`model:${model}`], file),
+                },
+            });
+            nodes.push(toGraphNode(modelKey, 'model', model, file.relPath, file, (0, extractors_1.modelExtractorForFile)(file)));
+            edges.push(toGraphEdge(file.key, modelKey, 'contains', (0, extractors_1.modelExtractorForFile)(file), file));
+        }
+        if (hasStyleSurface(file)) {
+            const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
+            addEntry(entries, usedKeys, {
+                key: styleKey,
+                group: 'style',
+                summary: `Style surface in ${file.relPath}.`,
+                tags: ['style', file.language],
+                dependencies: [file.key],
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    path: file.relPath,
+                    kind: 'style',
+                    cssVariables: file.cssVariables,
+                    cssVariableValues: file.cssVariableValues.slice(0, 200),
+                    cssRules: file.cssRules.slice(0, 160),
+                    cssClasses: file.cssClasses,
+                    classReferences: file.classReferences.slice(0, 120),
+                    classExpressions: file.classExpressions.slice(0, 160),
+                    cssIds: file.cssIds,
+                    cssVariableReferences: file.cssVariableReferences,
+                    tailwindUtilities: file.tailwindUtilities.slice(0, 120),
+                    componentStyleDefinitions: file.componentStyleDefinitions.slice(0, 60),
+                    themeTokens: file.themeTokens.slice(0, 240),
+                    inlineStyles: file.inlineStyles.slice(0, 100),
+                    uiElements: file.uiElements.slice(0, 80),
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo((0, extractors_1.styleExtractorForFile)(file), (0, extractors_1.styleConfidenceForFile)(file), ['selectors, classes, tokens, or template UI elements'], file),
+                },
+            });
+            nodes.push(toGraphNode(styleKey, 'style', file.relPath, file.relPath, file, (0, extractors_1.styleExtractorForFile)(file)));
+            edges.push(toGraphEdge(file.key, styleKey, 'contains', (0, extractors_1.styleExtractorForFile)(file), file, (0, extractors_1.styleConfidenceForFile)(file)));
+        }
+        for (const styleDefinition of file.componentStyleDefinitions) {
+            const styleDefinitionKey = (0, utils_1.toRegistryKey)('style', `${file.relPath.replace(/\.[^.]+$/, '')}.${styleDefinition.name}`);
+            addEntry(entries, usedKeys, {
+                key: styleDefinitionKey,
+                group: 'style',
+                summary: `${styleDefinition.name} component style definition in ${file.relPath}.`,
+                tags: (0, utils_1.unique)([
+                    'style',
+                    'component-style',
+                    styleDefinition.kind,
+                    styleDefinition.name,
+                    ...Object.keys(styleDefinition.variants),
+                    ...Object.values(styleDefinition.variants).flatMap((variant) => Object.keys(variant)),
+                    ...styleDefinition.classes.slice(0, 24),
+                ]),
+                dependencies: [file.key],
+                usedBy: [],
+                confidence: 'high',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    path: file.relPath,
+                    kind: 'component-style-definition',
+                    name: styleDefinition.name,
+                    definitionKind: styleDefinition.kind,
+                    line: styleDefinition.line,
+                    baseClasses: styleDefinition.baseClasses,
+                    variants: styleDefinition.variants,
+                    defaultVariants: styleDefinition.defaultVariants,
+                    classes: styleDefinition.classes,
+                    sourceSnippet: styleDefinition.source,
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo('component-style-definitions', 'high', [`${styleDefinition.kind}:${styleDefinition.name}`, `line:${styleDefinition.line}`], file),
+                },
+            });
+            nodes.push(toGraphNode(styleDefinitionKey, 'style', styleDefinition.name, file.relPath, file, 'component-style-definitions', {
+                styleDefinition: {
+                    kind: styleDefinition.kind,
+                    variants: Object.keys(styleDefinition.variants),
+                    classCount: styleDefinition.classes.length,
+                },
+            }));
+            edges.push(toGraphEdge(file.key, styleDefinitionKey, 'defines_style', 'component-style-definitions', file, 'high'));
+        }
+    }
+    addUiPatternRules(entries, usedKeys, nodes, edges, files);
+    addUiCompositionRules(entries, usedKeys, nodes, edges, files);
+    addConnectedPatternRules(entries, usedKeys, nodes, edges, reviewItems, files);
+    addRenderEdges(entries, files, edges);
+    addImportEdges(entries, files, edges, rootPath);
+    addApiCallEdges(entries, files, edges);
+    addStyleUsageEdges(entries, files, edges);
+    addModelUsageEdges(entries, files, edges);
+    addConceptClusters(entries, usedKeys, nodes, edges, reviewItems);
+    applyUsedBy(entries, edges);
+    return {
+        scanId: `${new Date().toISOString()}:${(0, utils_1.shortHash)(rootPath + entries.length)}`,
+        generatedAt: new Date().toISOString(),
+        rootPath,
+        projectType,
+        files,
+        entries: entries.sort((a, b) => a.key.localeCompare(b.key)),
+        nodes: (0, utils_1.uniqueBy)(nodes, (node) => node.k).sort((a, b) => a.k.localeCompare(b.k)),
+        edges: (0, utils_1.uniqueBy)(edges, (edge) => `${edge.from}:${edge.type}:${edge.to}`).sort((a, b) => `${a.from}:${a.type}:${a.to}`.localeCompare(`${b.from}:${b.type}:${b.to}`)),
+        reviewItems,
+        detected: detectProjectFacts(files),
+    };
+}
+function addEntry(entries, usedKeys, entry) {
+    let key = entry.key;
+    if (usedKeys.has(key)) {
+        key = `${key}.${(0, utils_1.shortHash)(String(entry.value.path ?? entry.summary))}`;
+    }
+    if (usedKeys.has(key)) {
+        return;
+    }
+    usedKeys.add(key);
+    entries.push({ ...entry, key });
+}
+function hasStyleSurface(file) {
+    return Boolean(file.cssVariables.length ||
+        file.cssClasses.length ||
+        file.classReferences.length ||
+        file.cssIds.length ||
+        file.cssVariableReferences.length ||
+        file.tailwindUtilities.length ||
+        file.uiElements.length ||
+        file.cssVariableValues.length ||
+        file.cssRules.length ||
+        file.classExpressions.length ||
+        file.componentStyleDefinitions.length ||
+        file.themeTokens.length ||
+        file.inlineStyles.length);
+}
+function isBackendRouteFile(file) {
+    return Boolean(file.layer === 'backend' ||
+        file.controllers.length ||
+        file.apiHandlers.length ||
+        file.backendEndpointContracts.length);
+}
+function backendFileContext(file) {
+    if (!file.backendEndpointContracts.length &&
+        !file.backendOperations.length &&
+        !file.backendSideEffects.length &&
+        !file.backendErrors.length &&
+        !file.backendLogging.length) {
+        return {};
+    }
+    return {
+        backend: {
+            endpointContracts: file.backendEndpointContracts,
+            operations: file.backendOperations,
+            sideEffects: uniqueSideEffectsForRecipe(file.backendSideEffects),
+            errors: file.backendErrors,
+            logging: file.backendLogging,
+        },
+    };
+}
+function findEndpointContract(file, handler) {
+    const [method, ...pathParts] = handler.split(/\s+/);
+    const handlerPath = pathParts.join(' ');
+    return file.backendEndpointContracts.find((contract) => {
+        if (contract.handler === handler) {
+            return true;
+        }
+        if (`${contract.method} ${contract.path}` === handler) {
+            return true;
+        }
+        return contract.method === method && [contract.path, contract.fullPath].includes(handlerPath);
+    });
+}
+function createBackendEndpointFlow(file, handlerKey, contract) {
+    return {
+        key: handlerKey,
+        framework: contract.framework,
+        endpoint: {
+            method: contract.method,
+            path: contract.fullPath ?? contract.path,
+            handlerName: contract.handlerName,
+            controller: contract.controller,
+        },
+        request: contract.request,
+        response: contract.response,
+        auth: contract.auth,
+        validation: contract.validation,
+        calls: contract.serviceCalls.map((call) => ({
+            ...call,
+            targetKey: backendCallKey(call),
+        })),
+        sideEffects: contract.sideEffects,
+        errors: contract.errors,
+        logging: contract.logging,
+        risk: contract.risk,
+        editScope: {
+            ownerFile: file.relPath,
+            openWhenEditing: (0, utils_1.unique)([
+                file.key,
+                ...backendCallDependencies(contract.serviceCalls),
+                ...file.imports
+                    .filter((item) => /(dto|schema|validator|guard|policy|service|repository)/i.test(item))
+                    .slice(0, 20),
+            ]),
+        },
+    };
+}
+function backendCallDependencies(calls) {
+    return (0, utils_1.unique)(calls
+        .filter((call) => ['service', 'repository', 'provider', 'client'].includes(call.kind))
+        .map(backendCallKey));
+}
+function addBackendCallEdges(fromKey, calls, file, edges) {
+    for (const call of calls) {
+        const targetKey = backendCallKey(call);
+        edges.push({
+            from: fromKey,
+            to: targetKey,
+            type: call.kind === 'repository' ? 'calls_repository' : 'calls',
+            confidence: call.kind === 'unknown' ? 'low' : 'medium',
+            source: sourceInfo('backend.contract.calls', call.kind === 'unknown' ? 'low' : 'medium', [`${fromKey} calls ${call.receiver}.${call.method}`], file),
+        });
+    }
+}
+function backendCallKey(call) {
+    return (0, utils_1.toRegistryKey)('service', (0, backend_1.backendReceiverToClassName)(call.receiver));
+}
+function uniqueSideEffectsForRecipe(sideEffects) {
+    return (0, utils_1.uniqueBy)(sideEffects, (sideEffect) => `${sideEffect.kind}.${sideEffect.target ?? ''}.${sideEffect.operation ?? ''}.${sideEffect.line}`);
+}
+function sourceInfo(extractor, confidence, evidence, file) {
+    return {
+        extractor,
+        confidence,
+        evidence,
+        path: file.relPath,
+        hash: file.sourceHash,
+    };
+}
+function toGraphNode(key, kind, name, relPath, file, extractor, facets) {
+    return {
+        k: key,
+        kind,
+        name,
+        path: relPath,
+        language: file.language,
+        framework: detectFrameworkForFile(file),
+        ...(facets ? { facets } : {}),
+        source: sourceInfo(extractor, 'high', [`path:${relPath}`], file),
+    };
+}
+function toGraphEdge(from, to, type, extractor, file, confidence = 'high') {
+    return {
+        from,
+        to,
+        type,
+        confidence,
+        source: sourceInfo(extractor, confidence, [`${from} ${type} ${to}`], file),
+    };
+}
+function addRenderEdges(entries, files, edges) {
+    const componentKeysByName = new Map();
+    for (const entry of entries.filter((item) => item.group === 'component')) {
+        const name = typeof entry.value.name === 'string' ? entry.value.name : undefined;
+        if (name) {
+            componentKeysByName.set(name, entry.key);
+        }
+    }
+    for (const file of files) {
+        if (!file.routes.length || !file.jsxElements.length) {
+            continue;
+        }
+        for (const route of file.routes) {
+            const routeKey = (0, utils_1.toRegistryKey)('route', route);
+            for (const jsxElement of file.jsxElements) {
+                const componentKey = componentKeysByName.get(jsxElement);
+                if (componentKey) {
+                    edges.push(toGraphEdge(routeKey, componentKey, 'renders', 'react-jsx', file));
+                }
+            }
+        }
+    }
+}
+function addUiPatternRules(entries, usedKeys, nodes, edges, files) {
+    for (const file of files) {
+        const elementsByKind = (0, utils_1.groupBy)(file.uiElements, (element) => element.kind);
+        for (const [kind, elements] of elementsByKind) {
+            if (!elements.length || kind === 'unknown' || kind === 'link') {
+                continue;
+            }
+            const ruleKey = (0, utils_1.toRegistryKey)('rule', `ui.${kind}.${file.relPath.replace(/\.[^.]+$/, '')}`);
+            const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
+            const dependencies = (0, utils_1.unique)([file.key, styleKey]);
+            const classes = (0, utils_1.unique)(elements.flatMap((element) => element.classes)).slice(0, 80);
+            const unconditionalClasses = (0, utils_1.unique)(elements.flatMap((element) => element.defaultClasses ?? element.classes));
+            const conditionalClasses = (0, utils_1.unique)(elements.flatMap((element) => element.conditionalClasses ?? []));
+            const defaultClasses = (0, extractors_1.filterClasses)(unconditionalClasses, (className) => !(0, extractors_1.isDecorativeAccentClass)(className)).slice(0, 80);
+            const decorativeAccentClasses = (0, extractors_1.filterClasses)(classes, extractors_1.isDecorativeAccentClass).slice(0, 40);
+            const classGroups = (0, extractors_1.mergeClassGroups)(elements.map((element) => element.classGroups ?? {}));
+            const variants = (0, extractors_1.mergeVariantProps)(elements.map((element) => element.variants ?? {}));
+            addEntry(entries, usedKeys, {
+                key: ruleKey,
+                group: 'rule',
+                summary: `${(0, utils_1.titleCase)(kind)} UI pattern inferred from ${file.relPath}.`,
+                tags: (0, utils_1.unique)([
+                    'rule',
+                    'ui',
+                    kind,
+                    ...Object.keys(variants),
+                    ...Object.values(variants).flatMap((values) => values),
+                    ...defaultClasses.slice(0, 20),
+                    ...(decorativeAccentClasses.length ? ['decorative-accent', 'highlight-only'] : []),
+                ]),
+                dependencies,
+                usedBy: [],
+                confidence: elements.length > 1 ? 'medium' : 'low',
+                status: 'inferred',
+                path: file.relPath,
+                value: {
+                    name: `${(0, utils_1.titleCase)(kind)} pattern`,
+                    kind: 'rule',
+                    ruleType: 'ui-pattern',
+                    concept: kind,
+                    path: file.relPath,
+                    classes,
+                    defaultClasses,
+                    conditionalClasses,
+                    decorativeAccentClasses,
+                    guidance: (0, extractors_1.createUiPatternGuidance)(kind, decorativeAccentClasses),
+                    classGroups,
+                    variants,
+                    elements: elements.slice(0, 80),
+                    sourceHash: file.sourceHash,
+                    source: sourceInfo('ui.patterns', elements.length > 1 ? 'medium' : 'low', [`${kind}:${elements.length}`], file),
+                },
+            });
+            nodes.push(toGraphNode(ruleKey, 'rule', `${kind} pattern`, file.relPath, file, 'ui.patterns', {
+                ui: {
+                    concept: kind,
+                    classes: defaultClasses,
+                    decorativeAccentClasses,
+                    classGroups,
+                    variants,
+                    count: elements.length,
+                },
+            }));
+            edges.push(toGraphEdge(file.key, ruleKey, 'contains', 'ui.patterns', file, 'medium'));
+        }
+    }
+}
+function addUiCompositionRules(entries, usedKeys, nodes, edges, files) {
+    for (const file of files) {
+        if (!file.uiElements.length && !file.classExpressions.length) {
+            continue;
+        }
+        const ruleKey = (0, utils_1.toRegistryKey)('rule', `ui.composition.${file.relPath.replace(/\.[^.]+$/, '')}`);
+        const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
+        const componentKeys = file.components.map((component) => (0, utils_1.toRegistryKey)('component', component));
+        const routeKeys = file.routes.map((route) => (0, utils_1.toRegistryKey)('route', route));
+        const dependencies = (0, utils_1.unique)([
+            file.key,
+            ...(hasStyleSurface(file) ? [styleKey] : []),
+            ...componentKeys,
+            ...routeKeys,
+        ]);
+        const unconditionalClassReferences = (0, utils_1.unique)([
+            ...file.classExpressions.flatMap((expression) => expression.defaultClasses ?? []),
+            ...file.uiElements.flatMap((element) => element.defaultClasses ?? []),
+        ]);
+        const conditionalClasses = (0, utils_1.unique)([
+            ...file.classExpressions.flatMap((expression) => expression.conditionalClasses ?? []),
+            ...file.uiElements.flatMap((element) => element.conditionalClasses ?? []),
+        ]).slice(0, 120);
+        const baseClassReferences = unconditionalClassReferences.length
+            ? unconditionalClassReferences
+            : file.classReferences;
+        const responsiveClasses = (0, extractors_1.filterClasses)(baseClassReferences, extractors_1.isResponsiveClass).slice(0, 120);
+        const spacingClasses = (0, extractors_1.filterClasses)(baseClassReferences, extractors_1.isSpacingClass).slice(0, 120);
+        const surfaceClasses = (0, extractors_1.filterClasses)(baseClassReferences, (className) => (0, extractors_1.isSurfaceClass)(className) && !(0, extractors_1.isDecorativeAccentClass)(className)).slice(0, 120);
+        const decorativeAccentClasses = (0, extractors_1.filterClasses)(file.classReferences, extractors_1.isDecorativeAccentClass).slice(0, 60);
+        const typographyClasses = (0, extractors_1.filterClasses)(file.classReferences, extractors_1.isTypographyClass).slice(0, 120);
+        const compositionElements = file.uiElements.filter(extractors_1.isCompositionElement).slice(0, 90);
+        const classExpressionsByTarget = (0, extractors_1.groupClassExpressionsByTarget)(file.classExpressions);
+        const layoutRoles = (0, utils_1.unique)(file.uiElements.flatMap((element) => element.layoutRole ?? []));
+        const elementKinds = (0, utils_1.unique)(file.uiElements.map((element) => element.kind));
+        addEntry(entries, usedKeys, {
+            key: ruleKey,
+            group: 'rule',
+            summary: `UI composition contract for ${file.relPath}.`,
+            tags: (0, utils_1.unique)([
+                'rule',
+                'ui',
+                'composition',
+                'layout',
+                'responsive',
+                file.kind,
+                file.layer,
+                file.language,
+                ...(0, utils_1.pathTerms)(file.relPath),
+                ...file.components,
+                ...file.routes,
+                ...elementKinds,
+                ...layoutRoles,
+                ...responsiveClasses.slice(0, 24),
+                ...surfaceClasses.slice(0, 24),
+                ...(decorativeAccentClasses.length ? ['decorative-accent', 'highlight-only'] : []),
+                ...spacingClasses.slice(0, 24),
+                ...typographyClasses.slice(0, 24),
+            ]),
+            dependencies,
+            usedBy: [],
+            confidence: file.components.length || file.routes.length ? 'high' : 'medium',
+            status: 'inferred',
+            path: file.relPath,
+            value: {
+                name: `${file.relPath} UI composition`,
+                kind: 'rule',
+                ruleType: 'ui-composition',
+                path: file.relPath,
+                components: file.components,
+                routes: file.routes,
+                imports: file.imports,
+                layoutRoles,
+                elementKinds,
+                guidance: (0, extractors_1.createUiCompositionGuidance)(file),
+                responsiveClasses,
+                spacingClasses,
+                surfaceClasses,
+                conditionalClasses,
+                decorativeAccentClasses,
+                typographyClasses,
+                componentSlots: (0, extractors_1.buildComponentSlots)(file.uiElements),
+                classExpressionsByTarget,
+                elements: compositionElements,
+                sourceHash: file.sourceHash,
+                source: sourceInfo('ui.composition', file.components.length || file.routes.length ? 'high' : 'medium', [
+                    `path:${file.relPath}`,
+                    `components:${file.components.join(',') || 'none'}`,
+                    `uiElements:${file.uiElements.length}`,
+                ], file),
+            },
+        });
+        nodes.push(toGraphNode(ruleKey, 'rule', `${file.relPath} UI composition`, file.relPath, file, 'ui.composition', {
+            ui: {
+                ruleType: 'ui-composition',
+                components: file.components,
+                routes: file.routes,
+                layoutRoles,
+                elementKinds,
+            },
+        }));
+        edges.push(toGraphEdge(file.key, ruleKey, 'defines_ui_composition', 'ui.composition', file));
+        for (const componentKey of componentKeys) {
+            edges.push(toGraphEdge(componentKey, ruleKey, 'uses_ui_composition', 'ui.composition', file, 'high'));
+        }
+        for (const routeKey of routeKeys) {
+            edges.push(toGraphEdge(routeKey, ruleKey, 'uses_ui_composition', 'ui.composition', file, 'high'));
+        }
+    }
+}
+function addConnectedPatternRules(entries, usedKeys, nodes, edges, reviewItems, files) {
+    const clusters = buildConnectedPatternClusters(files);
+    for (const cluster of clusters) {
+        addEntry(entries, usedKeys, {
+            key: cluster.key,
+            group: 'cluster',
+            summary: cluster.summary,
+            tags: cluster.tags,
+            dependencies: cluster.dependencies,
+            usedBy: [],
+            confidence: cluster.confidence,
+            status: cluster.status,
+            path: cluster.instances[0]?.file.relPath,
+            value: cluster.value,
+        });
+        const first = cluster.instances[0]?.file;
+        nodes.push({
+            k: cluster.key,
+            kind: 'cluster',
+            name: cluster.name,
+            ...(first
+                ? {
+                    path: first.relPath,
+                    language: first.language,
+                    framework: detectFrameworkForFile(first),
+                }
+                : {}),
+            facets: {
+                connectedPattern: {
+                    domain: cluster.domain,
+                    concept: cluster.concept,
+                    score: Number(cluster.score.toFixed(2)),
+                    usageCount: cluster.instances.length,
+                    canonical: cluster.value.canonical,
+                },
+            },
+            source: {
+                extractor: 'connected.patterns',
+                confidence: cluster.confidence,
+                evidence: cluster.instances
+                    .slice(0, 20)
+                    .map((instance) => `${instance.evidence.path}${instance.evidence.line ? `:${instance.evidence.line}` : ''}`),
+                ...(first ? { path: first.relPath, hash: first.sourceHash } : {}),
+            },
+        });
+        for (const instance of cluster.instances.slice(0, 80)) {
+            edges.push(toGraphEdge(instance.file.key, cluster.key, 'contains_connected_pattern', 'connected.patterns', instance.file, cluster.confidence));
+            for (const graphKey of instance.graphKeys.slice(0, 24)) {
+                edges.push(toGraphEdge(graphKey, cluster.key, 'participates_in_connected_pattern', 'connected.patterns', instance.file, cluster.confidence));
+            }
+        }
+    }
+    for (const [conceptKey, conceptClusters] of (0, utils_1.groupBy)(clusters.filter((cluster) => cluster.domain === 'frontend' && cluster.score >= 6), (cluster) => `${cluster.domain}.${cluster.concept}`)) {
+        const ranked = [...conceptClusters].sort((a, b) => b.score - a.score);
+        const top = ranked[0];
+        const second = ranked[1];
+        if (!top || !second) {
+            continue;
+        }
+        const closeEnough = top.score - second.score <= 2.5;
+        const bothEstablished = top.instances.length >= 2 && second.instances.length >= 2;
+        if (closeEnough && bothEstablished) {
+            reviewItems.push({
+                id: `review.pattern.${conceptKey}.canonical`,
+                type: 'role_collision',
+                status: 'open',
+                group: 'cluster',
+                s: `Multiple ${top.concept} connected patterns look plausible. Name or choose the canonical roles after scan.`,
+                candidates: ranked.slice(0, 6).map((cluster) => cluster.key),
+            });
+        }
+    }
+}
+function buildConnectedPatternClusters(files) {
+    const instances = [
+        ...files.flatMap(createFrontendPatternInstances),
+        ...createBackendPatternInstances(files),
+        ...createDataPatternInstances(files),
+    ];
+    const grouped = (0, utils_1.groupBy)(instances, (instance) => `${instance.domain}:${instance.concept}:${instance.signature}`);
+    const clusters = [];
+    for (const group of grouped.values()) {
+        const first = group[0];
+        if (!first) {
+            continue;
+        }
+        const score = scoreConnectedPatternGroup(group);
+        const confidence = connectedPatternConfidence(score, group.length);
+        const dependencies = (0, utils_1.unique)(group.flatMap((instance) => [instance.file.key, ...instance.graphKeys])).slice(0, 160);
+        const examples = group.map((instance) => instance.evidence).slice(0, 24);
+        const defaultClasses = (0, utils_1.unique)(group.flatMap((instance) => instance.root?.defaultClasses ?? [])).slice(0, 120);
+        const conditionalClasses = (0, utils_1.unique)(group.flatMap((instance) => instance.root?.conditionalClasses ?? [])).slice(0, 80);
+        const decorativeAccentClasses = (0, utils_1.unique)(group.flatMap((instance) => instance.root?.decorativeAccentClasses ?? [])).slice(0, 60);
+        const classGroups = (0, extractors_1.mergeClassGroups)(group
+            .map((instance) => instance.root?.classGroups)
+            .filter((value) => Boolean(value)));
+        const childStructure = summarizeConnectedChildren(group);
+        const key = (0, utils_1.toRegistryKey)('cluster', `pattern.${first.domain}.${first.concept}.${connectedPatternSlug(first)}.${(0, utils_1.shortHash)(first.signature)}`);
+        const fileCount = new Set(group.map((instance) => instance.file.relPath)).size;
+        clusters.push({
+            domain: first.domain,
+            concept: first.concept,
+            signature: first.signature,
+            key,
+            name: `${(0, utils_1.titleCase)(first.concept)} connected pattern`,
+            summary: `${(0, utils_1.titleCase)(first.concept)} connected ${first.domain} pattern seen ${group.length} time${group.length === 1 ? '' : 's'} across ${fileCount} file${fileCount === 1 ? '' : 's'}.`,
+            score,
+            confidence,
+            status: 'inferred',
+            instances: group,
+            tags: (0, utils_1.unique)([
+                'cluster',
+                'pattern',
+                'connected-pattern',
+                first.domain,
+                first.concept,
+                `usage-${group.length}`,
+                confidence,
+                ...group.flatMap((instance) => instance.tags).slice(0, 80),
+                ...defaultClasses.slice(0, 24),
+                ...(decorativeAccentClasses.length ? ['decorative-accent', 'highlight-only'] : []),
+            ]),
+            dependencies,
+            value: {
+                name: `${(0, utils_1.titleCase)(first.concept)} connected pattern`,
+                kind: 'connected-pattern-cluster',
+                patternKind: 'pattern_cluster',
+                ruleType: 'connected-pattern',
+                domain: first.domain,
+                concept: first.concept,
+                signature: first.signature,
+                usageCount: group.length,
+                fileCount,
+                score: Number(score.toFixed(2)),
+                confidence,
+                canonical: false,
+                defaultClasses,
+                conditionalClasses,
+                decorativeAccentClasses,
+                classGroups,
+                childStructure,
+                examples,
+                graphKeys: (0, utils_1.unique)(group.flatMap((instance) => instance.graphKeys)).slice(0, 80),
+                guidance: createConnectedPatternGuidance(first, group, decorativeAccentClasses),
+                variants: connectedPatternVariants(first.domain, group),
+                children: connectedPatternChildren(first.domain, first.concept, group, dependencies),
+                instances: group.map(compactConnectedPatternInstance).slice(0, 20),
+                source: {
+                    extractor: 'connected.patterns',
+                    confidence,
+                    evidence: examples.map((example) => `${example.path}${example.line ? `:${example.line}` : ''}`),
+                },
+            },
+        });
+    }
+    for (const sameConcept of (0, utils_1.groupBy)(clusters, (cluster) => `${cluster.domain}:${cluster.concept}`).values()) {
+        const ranked = [...sameConcept].sort((a, b) => b.score - a.score);
+        ranked.forEach((cluster, index) => {
+            const canonical = index === 0;
+            const nearestSibling = ranked[index === 0 ? 1 : 0];
+            const conflictRisk = Boolean(nearestSibling &&
+                Math.abs(cluster.score - nearestSibling.score) <= 2.5 &&
+                cluster.instances.length >= 2 &&
+                nearestSibling.instances.length >= 2);
+            const scores = createConnectedPatternScores(cluster, index, ranked.length, conflictRisk);
+            const decision = createConnectedPatternDecision(cluster, scores, index, ranked.length, conflictRisk);
+            cluster.value.canonical = canonical;
+            cluster.value.scores = scores;
+            cluster.value.decision = decision;
+            cluster.value.variants = connectedPatternVariants(cluster.domain, cluster.instances);
+            cluster.value.children = connectedPatternChildren(cluster.domain, cluster.concept, cluster.instances, cluster.dependencies);
+            if (canonical) {
+                cluster.tags = (0, utils_1.unique)([...cluster.tags, 'canonical', 'highest-scoring']);
+                cluster.value.guidance = (0, utils_1.unique)([
+                    ...(Array.isArray(cluster.value.guidance) ? cluster.value.guidance.map(String) : []),
+                    'Prefer this pattern for new generation unless the task asks for a different named role or variant.',
+                ]);
+            }
+            if (conflictRisk) {
+                cluster.tags = (0, utils_1.unique)([...cluster.tags, 'needs-review', 'canonical-candidate']);
+                cluster.value.review = 'canonical_conflict';
+            }
+        });
+    }
+    return clusters.sort((a, b) => b.score - a.score || a.key.localeCompare(b.key));
+}
+function createFrontendPatternInstances(file) {
+    const instances = [];
+    for (const element of file.uiElements) {
+        if (!isConnectedUiPatternRoot(element)) {
+            continue;
+        }
+        const defaultClasses = (0, extractors_1.filterClasses)(element.defaultClasses?.length ? element.defaultClasses : element.classes, (className) => !(0, extractors_1.isDecorativeAccentClass)(className)).slice(0, 100);
+        const conditionalClasses = (0, utils_1.unique)(element.conditionalClasses ?? []).slice(0, 80);
+        const decorativeAccentClasses = (0, utils_1.unique)([
+            ...(element.decorativeAccentClasses ?? []),
+            ...(0, extractors_1.filterClasses)(element.classes, extractors_1.isDecorativeAccentClass),
+        ]).slice(0, 60);
+        const classGroups = (0, extractors_1.groupTailwindClasses)(defaultClasses.length ? defaultClasses : element.classes);
+        const children = normalizeConnectedChildren(element.childSummary ?? []);
+        const component = file.components[0];
+        const route = file.routes[0];
+        const graphKeys = (0, utils_1.unique)([
+            ...(component ? [(0, utils_1.toRegistryKey)('component', component)] : []),
+            ...(route ? [(0, utils_1.toRegistryKey)('route', route)] : []),
+            file.key,
+            ...(hasStyleSurface(file)
+                ? [(0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''))]
+                : []),
+            (0, utils_1.toRegistryKey)('rule', `ui.${element.kind}.${file.relPath.replace(/\.[^.]+$/, '')}`),
+            (0, utils_1.toRegistryKey)('rule', `ui.composition.${file.relPath.replace(/\.[^.]+$/, '')}`),
+        ]);
+        const signature = [
+            'frontend',
+            element.kind,
+            normalizeLayoutRole(element.layoutRole),
+            normalizeTagForSignature(element),
+            classSignature(defaultClasses),
+            children.map((child) => child.signature).join('|'),
+        ].join(';');
+        instances.push({
+            domain: 'frontend',
+            concept: element.kind,
+            signature,
+            summary: `${(0, utils_1.titleCase)(element.kind)} UI structure in ${file.relPath}.`,
+            file,
+            root: {
+                kind: element.kind,
+                tag: element.originalTag,
+                layoutRole: element.layoutRole,
+                classes: element.classes.slice(0, 120),
+                defaultClasses,
+                conditionalClasses,
+                decorativeAccentClasses,
+                classGroups,
+            },
+            children: children.map(withoutConnectedChildSignature),
+            graphKeys,
+            tags: (0, utils_1.unique)([
+                'ui',
+                'frontend',
+                element.kind,
+                normalizeLayoutRole(element.layoutRole),
+                normalizeTagForSignature(element),
+                ...(0, utils_1.pathTerms)(file.relPath),
+                ...file.components,
+                ...file.routes,
+                ...Object.keys(classGroups),
+            ]),
+            evidence: {
+                path: file.relPath,
+                line: element.line,
+                ...(component ? { component } : {}),
+                ...(route ? { route } : {}),
+                label: element.label,
+                sourceHash: file.sourceHash,
+            },
+            value: {
+                root: {
+                    kind: element.kind,
+                    tag: element.originalTag,
+                    layoutRole: element.layoutRole,
+                    defaultClasses,
+                    conditionalClasses,
+                    decorativeAccentClasses,
+                    classGroups,
+                },
+                children: children.map(withoutConnectedChildSignature),
+            },
+            baseWeight: frontendPatternWeight(file, element, children.length, defaultClasses),
+        });
+    }
+    return instances;
+}
+function createBackendPatternInstances(files) {
+    return files.flatMap((file) => {
+        if ((0, extractors_1.isTestFile)(file.relPath) || /\.(md|mdx)$/i.test(file.relPath)) {
+            return [];
+        }
+        if (!hasBackendPatternSurface(file)) {
+            return [];
+        }
+        const concept = backendPatternConcept(file);
+        const methodShapes = (0, utils_1.unique)(file.apiHandlers.map((handler) => handler.split(/\s+/)[0])).sort();
+        const graphKeys = (0, utils_1.unique)([
+            file.key,
+            ...file.apiHandlers.map((handler) => (0, utils_1.toRegistryKey)('api', handler)),
+            ...file.controllers.map((controller) => (0, utils_1.toRegistryKey)('controller', controller)),
+            ...file.services.map((service) => (0, utils_1.toRegistryKey)('service', service)),
+            ...file.modules.map((moduleName) => (0, utils_1.toRegistryKey)('module', moduleName)),
+            ...file.models.map((model) => (0, utils_1.toRegistryKey)('model', model)),
+            ...file.routes.map((route) => (0, utils_1.toRegistryKey)('route', route)),
+        ]);
+        const signature = [
+            'backend',
+            concept,
+            detectFrameworkForFile(file) ?? file.language,
+            file.kind,
+            `methods:${methodShapes.join(',') || 'none'}`,
+            `controller:${Boolean(file.controllers.length)}`,
+            `service:${Boolean(file.services.length)}`,
+            `model:${Boolean(file.models.length)}`,
+            `auth:${Boolean(file.authHints.length || file.middleware.length)}`,
+            `events:${Boolean(file.events.length || file.jobs.length)}`,
+            `calls:${Boolean(file.apiCalls.length)}`,
+        ].join(';');
+        return [
+            {
+                domain: 'backend',
+                concept,
+                signature,
+                summary: `${(0, utils_1.titleCase)(concept)} backend flow in ${file.relPath}.`,
+                file,
+                graphKeys,
+                tags: (0, utils_1.unique)([
+                    'backend',
+                    concept,
+                    file.language,
+                    detectFrameworkForFile(file) ?? '',
+                    ...methodShapes,
+                    ...(file.authHints.length ? ['auth'] : []),
+                    ...(file.middleware.length ? ['middleware'] : []),
+                    ...(file.events.length ? ['event'] : []),
+                    ...(file.jobs.length ? ['job'] : []),
+                    ...(0, utils_1.pathTerms)(file.relPath),
+                ]),
+                evidence: {
+                    path: file.relPath,
+                    key: file.key,
+                    sourceHash: file.sourceHash,
+                },
+                value: {
+                    contracts: file.backendEndpointContracts,
+                    operations: file.backendOperations,
+                    apiHandlers: file.apiHandlers,
+                    controllers: file.controllers,
+                    services: file.services,
+                    modules: file.modules,
+                    routes: file.routes,
+                    models: file.models,
+                    apiCalls: file.apiCalls,
+                    envVars: file.envVars,
+                    authHints: file.authHints,
+                    middleware: file.middleware,
+                    jobs: file.jobs,
+                    events: file.events,
+                    sideEffects: uniqueSideEffectsForRecipe(file.backendSideEffects),
+                    errors: file.backendErrors,
+                    logging: file.backendLogging,
+                    risk: (0, utils_1.unique)([
+                        ...file.backendEndpointContracts.flatMap((contract) => contract.risk),
+                        ...file.backendOperations.flatMap((operation) => operation.risk),
+                    ]),
+                    imports: file.imports.slice(0, 60),
+                },
+                baseWeight: backendPatternWeight(file),
+            },
+        ];
+    });
+}
+function createDataPatternInstances(files) {
+    const instances = [];
+    for (const file of files) {
+        for (const model of file.models) {
+            const fields = file.modelFields[model] ?? [];
+            const fieldShape = summarizeModelFieldShape(fields);
+            const signature = [
+                'data',
+                'model',
+                detectFrameworkForFile(file) ?? file.language,
+                fieldShape.signature,
+            ].join(';');
+            instances.push({
+                domain: 'data',
+                concept: 'model',
+                signature,
+                summary: `${model} data model shape in ${file.relPath}.`,
+                file,
+                graphKeys: (0, utils_1.unique)([file.key, (0, utils_1.toRegistryKey)('model', model)]),
+                tags: (0, utils_1.unique)(['data', 'model', 'schema', model, file.language, ...fieldShape.tags]),
+                evidence: {
+                    path: file.relPath,
+                    key: (0, utils_1.toRegistryKey)('model', model),
+                    sourceHash: file.sourceHash,
+                },
+                value: {
+                    model,
+                    fields,
+                    fieldShape,
+                    framework: detectFrameworkForFile(file),
+                },
+                baseWeight: 3 + Math.min(fields.length / 2, 8),
+            });
+        }
+    }
+    return instances;
+}
+function isConnectedUiPatternRoot(element) {
+    if (element.kind === 'unknown' || element.kind === 'link' || element.kind === 'text') {
+        return false;
+    }
+    if (['button', 'input', 'badge'].includes(element.kind)) {
+        return Boolean(element.classes.length || element.defaultClasses?.length || element.variants);
+    }
+    return (0, extractors_1.isCompositionElement)(element) || Boolean(element.childSummary?.length);
+}
+function normalizeConnectedChildren(children) {
+    return children
+        .filter((child) => child.kind !== 'unknown' || child.classes.length || child.label)
+        .slice(0, 10)
+        .map((child) => {
+        const defaultClasses = (0, extractors_1.filterClasses)(child.defaultClasses?.length ? child.defaultClasses : child.classes, (className) => !(0, extractors_1.isDecorativeAccentClass)(className)).slice(0, 48);
+        const classGroups = (0, extractors_1.groupTailwindClasses)(defaultClasses);
+        const normalizedKind = connectedChildKind(child);
+        const signature = [
+            normalizedKind,
+            normalizeLayoutRole(child.layoutRole),
+            normalizeChildTagForSignature(child),
+            classSignature(defaultClasses),
+        ].join(':');
+        return {
+            signature,
+            kind: normalizedKind,
+            sourceKind: child.kind,
+            tag: child.originalTag,
+            layoutRole: child.layoutRole,
+            defaultClasses,
+            conditionalClasses: child.conditionalClasses?.slice(0, 32) ?? [],
+            classGroups,
+            labelHint: child.label ? labelSignature(child.label) : undefined,
+        };
+    });
+}
+function withoutConnectedChildSignature(child) {
+    return Object.fromEntries(Object.entries(child).filter(([key]) => key !== 'signature'));
+}
+function connectedChildKind(child) {
+    if (child.layoutRole === 'eyebrow-or-badge') {
+        return 'badge';
+    }
+    return child.kind;
+}
+function summarizeConnectedChildren(instances) {
+    const childValues = instances.flatMap((instance) => instance.children ?? []);
+    const grouped = (0, utils_1.groupBy)(childValues, (child) => [
+        String(child.kind ?? ''),
+        String(child.layoutRole ?? ''),
+        JSON.stringify(child.classGroups ?? {}),
+    ].join(':'));
+    return Array.from(grouped.values())
+        .map((children) => {
+        const first = children[0] ?? {};
+        return {
+            kind: first.kind,
+            tag: first.tag,
+            layoutRole: first.layoutRole,
+            count: children.length,
+            defaultClasses: (0, utils_1.unique)(children.flatMap((child) => Array.isArray(child.defaultClasses)
+                ? child.defaultClasses.filter((item) => typeof item === 'string')
+                : [])).slice(0, 60),
+            classGroups: (0, extractors_1.mergeClassGroups)(children
+                .map((child) => child.classGroups)
+                .filter((value) => Boolean(value))),
+        };
+    })
+        .sort((a, b) => Number(b.count) - Number(a.count))
+        .slice(0, 16);
+}
+function compactConnectedPatternInstance(instance) {
+    return {
+        path: instance.file.relPath,
+        evidence: instance.evidence,
+        graphKeys: instance.graphKeys.slice(0, 24),
+        ...instance.value,
+    };
+}
+function scoreConnectedPatternGroup(instances) {
+    const usage = instances.length;
+    const fileCount = new Set(instances.map((instance) => instance.file.relPath)).size;
+    const componentCount = new Set(instances.flatMap((instance) => instance.file.components)).size;
+    const routeCount = new Set(instances.flatMap((instance) => instance.file.routes)).size;
+    const componentSourceBonus = instances.some((instance) => /(^|\/)(components|ui|shared|lib)\//.test(instance.file.relPath))
+        ? 2
+        : 0;
+    const averageWeight = instances.reduce((total, instance) => total + instance.baseWeight, 0) / Math.max(usage, 1);
+    return (usage * 3 +
+        fileCount * 2 +
+        componentCount * 1.5 +
+        routeCount +
+        componentSourceBonus +
+        averageWeight);
+}
+function connectedPatternConfidence(score, usage) {
+    if (usage >= 3 || score >= 16) {
+        return 'high';
+    }
+    if (usage >= 2 || score >= 10) {
+        return 'medium';
+    }
+    return 'low';
+}
+function createConnectedPatternScores(cluster, rank, siblingCount, conflictRisk) {
+    const appearances = cluster.instances.length;
+    const filePaths = (0, utils_1.unique)(cluster.instances.map((instance) => instance.file.relPath));
+    const routeKeys = (0, utils_1.unique)(cluster.instances.flatMap((instance) => [
+        ...instance.file.routes,
+        ...(instance.evidence.route ? [instance.evidence.route] : []),
+        ...instance.graphKeys.filter((key) => key.startsWith('route.')),
+    ]));
+    const componentKeys = (0, utils_1.unique)(cluster.instances.flatMap((instance) => [
+        ...instance.file.components,
+        ...(instance.evidence.component ? [instance.evidence.component] : []),
+        ...instance.graphKeys.filter((key) => key.startsWith('component.')),
+    ]));
+    const classGroupCount = (0, utils_1.unique)(cluster.instances.flatMap((instance) => Object.keys(instance.root?.classGroups ?? {}))).length;
+    const childKindCount = (0, utils_1.unique)(cluster.instances.flatMap((instance) => (instance.children ?? []).map((child) => String(child.kind ?? '')).filter(Boolean))).length;
+    const repetition = (0, utils_1.clampPatternScore)(Math.log2(appearances + 1) / 4);
+    const fileSpread = (0, utils_1.clampPatternScore)(Math.log2(filePaths.length + 1) / 3.5);
+    const routeSpread = (0, utils_1.clampPatternScore)(Math.log2(routeKeys.length + 1) / 3);
+    const dependencySpread = (0, utils_1.clampPatternScore)(Math.log2(cluster.dependencies.length + 1) / 5);
+    const componentSpread = (0, utils_1.clampPatternScore)(Math.log2(componentKeys.length + 1) / 3.5);
+    const scoreStrength = (0, utils_1.clampPatternScore)(cluster.score / 28);
+    const rankSignal = rank === 0 ? 0.18 : Math.max(0, 0.1 - rank * 0.035) + (siblingCount <= 1 ? 0.05 : 0);
+    const structuralSimilarity = roundPatternScore((0, utils_1.clampPatternScore)(0.52 +
+        repetition * 0.2 +
+        fileSpread * 0.12 +
+        scoreStrength * 0.11 +
+        (appearances > 1 ? 0.05 : 0)));
+    const styleSimilarity = roundPatternScore((0, utils_1.clampPatternScore)(cluster.domain === 'frontend'
+        ? 0.36 +
+            (0, utils_1.clampPatternScore)(classGroupCount / 9) * 0.24 +
+            repetition * 0.2 +
+            fileSpread * 0.12 +
+            componentSpread * 0.08
+        : 0.5 + repetition * 0.18 + fileSpread * 0.12 + scoreStrength * 0.08));
+    const behaviorSimilarity = roundPatternScore((0, utils_1.clampPatternScore)(cluster.domain === 'frontend'
+        ? 0.38 +
+            (0, utils_1.clampPatternScore)(childKindCount / 6) * 0.2 +
+            routeSpread * 0.16 +
+            componentSpread * 0.14 +
+            repetition * 0.12
+        : 0.48 +
+            routeSpread * 0.2 +
+            dependencySpread * 0.18 +
+            repetition * 0.12 +
+            scoreStrength * 0.1));
+    const canonical = roundPatternScore((0, utils_1.clampPatternScore)(scoreStrength * 0.34 +
+        repetition * 0.22 +
+        fileSpread * 0.16 +
+        routeSpread * 0.06 +
+        dependencySpread * 0.08 +
+        rankSignal -
+        (appearances === 1 ? 0.18 : 0) -
+        (conflictRisk ? 0.12 : 0)));
+    const oneOffRisk = roundPatternScore((0, utils_1.clampPatternScore)((appearances === 1 ? 0.82 : 0.5) -
+        canonical * 0.36 -
+        repetition * 0.18 -
+        fileSpread * 0.12 +
+        (rank > 0 && siblingCount > 1 ? 0.12 : 0) +
+        (conflictRisk ? 0.12 : 0)));
+    return {
+        appearances,
+        files: filePaths.length,
+        routes: routeKeys.length,
+        owners: derivePatternOwners(filePaths),
+        structuralSimilarity,
+        styleSimilarity,
+        behaviorSimilarity,
+        canonical,
+        oneOffRisk,
+    };
+}
+function createConnectedPatternDecision(cluster, scores, rank, siblingCount, conflictRisk) {
+    let reuse = 'allow';
+    if (conflictRisk) {
+        reuse = 'review';
+    }
+    else if (rank === 0 && scores.canonical >= 0.7 && scores.oneOffRisk <= 0.3) {
+        reuse = 'prefer';
+    }
+    else if (siblingCount > 1 && scores.oneOffRisk >= 0.6) {
+        reuse = 'avoid';
+    }
+    const readableConcept = readablePatternConcept(cluster.concept);
+    const ownerScope = scores.owners.length ? scores.owners.slice(0, 3).join(', ') : cluster.domain;
+    const scope = `${ownerScope} ${readableConcept} ${cluster.domain} pattern`;
+    const reason = reuse === 'review'
+        ? `This ${readableConcept} pattern is close to another established candidate, so a human should name or choose the canonical role.`
+        : reuse === 'prefer'
+            ? `Repeated ${scores.appearances} time${scores.appearances === 1 ? '' : 's'} across ${scores.files} file${scores.files === 1 ? '' : 's'} with low one-off risk.`
+            : reuse === 'avoid'
+                ? `Lower canonical score with high one-off risk; use only when editing this exact path or named variant.`
+                : `Usable as a local variant; prefer a higher-scoring sibling when the request is broad.`;
+    return { reuse, scope, reason };
+}
+function createConceptPatternScores(members, roleCandidates, shouldReview) {
+    const appearances = members.length;
+    const filePaths = (0, utils_1.unique)(members.flatMap((entry) => (entry.path ? [entry.path] : [])));
+    const routeKeys = (0, utils_1.unique)(members.flatMap((entry) => [
+        ...(entry.group === 'route' ? [entry.key] : []),
+        ...(0, utils_1.stringArrayValue)(entry.value.routes),
+        ...(0, utils_1.stringArrayValue)(entry.value.route ? [entry.value.route] : []),
+    ]));
+    const repetition = (0, utils_1.clampPatternScore)(Math.log2(appearances + 1) / 5);
+    const fileSpread = (0, utils_1.clampPatternScore)(Math.log2(filePaths.length + 1) / 4);
+    const routeSpread = (0, utils_1.clampPatternScore)(Math.log2(routeKeys.length + 1) / 3);
+    const roleSpread = (0, utils_1.clampPatternScore)(Math.log2(roleCandidates.length + 1) / 3.5);
+    const reviewPenalty = shouldReview ? 0.16 : 0;
+    const canonical = roundPatternScore((0, utils_1.clampPatternScore)(0.34 +
+        repetition * 0.24 +
+        fileSpread * 0.18 +
+        routeSpread * 0.08 +
+        roleSpread * 0.1 -
+        reviewPenalty));
+    const oneOffRisk = roundPatternScore((0, utils_1.clampPatternScore)((appearances <= 1 ? 0.78 : 0.42) -
+        repetition * 0.2 -
+        fileSpread * 0.14 -
+        canonical * 0.22 +
+        (shouldReview ? 0.16 : 0)));
+    return {
+        appearances,
+        files: filePaths.length,
+        routes: routeKeys.length,
+        owners: derivePatternOwners(filePaths),
+        structuralSimilarity: roundPatternScore((0, utils_1.clampPatternScore)(0.45 + repetition * 0.26 + fileSpread * 0.16)),
+        styleSimilarity: roundPatternScore((0, utils_1.clampPatternScore)(0.42 + roleSpread * 0.2 + repetition * 0.16)),
+        behaviorSimilarity: roundPatternScore((0, utils_1.clampPatternScore)(0.38 + routeSpread * 0.22 + repetition * 0.18)),
+        canonical,
+        oneOffRisk,
+    };
+}
+function createConceptPatternDecision(name, scores, shouldReview, roleCandidateCount) {
+    const reuse = shouldReview
+        ? 'review'
+        : scores.canonical >= 0.68 && scores.oneOffRisk <= 0.3
+            ? 'prefer'
+            : scores.oneOffRisk >= 0.6
+                ? 'avoid'
+                : 'allow';
+    const readableName = name.toLowerCase();
+    const ownerScope = scores.owners.length ? scores.owners.slice(0, 3).join(', ') : 'codebase';
+    const scope = `${ownerScope} ${readableName} lookup cluster`;
+    const reason = reuse === 'review'
+        ? `${roleCandidateCount} candidate ${readableName} recipes matched this lookup cluster; name or approve the canonical role before broad generation.`
+        : reuse === 'prefer'
+            ? `This lookup cluster has repeated evidence across ${scores.files} file${scores.files === 1 ? '' : 's'} with low one-off risk.`
+            : reuse === 'avoid'
+                ? `Too little repeated evidence; avoid for broad generation unless the task names this exact cluster.`
+                : `Useful as a lookup cluster, but fetch the top connected pattern before generating new code.`;
+    return { reuse, scope, reason };
+}
+function connectedPatternVariants(domain, instances) {
+    const preferredPrefixes = domain === 'frontend'
+        ? ['component.', 'route.', 'style.', 'rule.']
+        : ['api.', 'controller.', 'service.', 'module.', 'model.', 'route.'];
+    return (0, utils_1.unique)(instances.flatMap((instance) => [
+        ...instance.file.components.map((component) => (0, utils_1.toRegistryKey)('component', component)),
+        ...instance.file.routes.map((route) => (0, utils_1.toRegistryKey)('route', route)),
+        ...instance.file.apiHandlers.map((handler) => (0, utils_1.toRegistryKey)('api', handler)),
+        ...instance.file.controllers.map((controller) => (0, utils_1.toRegistryKey)('controller', controller)),
+        ...instance.file.services.map((service) => (0, utils_1.toRegistryKey)('service', service)),
+        ...instance.file.modules.map((moduleName) => (0, utils_1.toRegistryKey)('module', moduleName)),
+        ...instance.file.models.map((model) => (0, utils_1.toRegistryKey)('model', model)),
+        ...instance.graphKeys.filter((key) => preferredPrefixes.some((prefix) => key.startsWith(prefix))),
+    ])).slice(0, 80);
+}
+function connectedPatternChildren(domain, concept, instances, dependencies) {
+    if (domain === 'frontend') {
+        const semanticChildren = (0, utils_1.unique)([
+            `ui.${concept}`,
+            ...instances.flatMap((instance) => (instance.children ?? [])
+                .map((child) => String(child.kind ?? ''))
+                .filter(Boolean)
+                .map((kind) => `ui.${kind}`)),
+        ]);
+        const graphChildren = dependencies.filter((key) => ['component.', 'style.', 'rule.', 'route.'].some((prefix) => key.startsWith(prefix)));
+        return (0, utils_1.unique)([...semanticChildren, ...graphChildren]).slice(0, 80);
+    }
+    return (0, utils_1.unique)(dependencies.filter((key) => ['api.', 'controller.', 'service.', 'module.', 'model.', 'route.', 'file.'].some((prefix) => key.startsWith(prefix)))).slice(0, 80);
+}
+function derivePatternOwners(filePaths) {
+    const owners = new Set();
+    for (const filePath of filePaths) {
+        const lower = filePath.toLowerCase();
+        if (/(^|\/)(admin|dashboard)(\/|$)/.test(lower))
+            owners.add('admin');
+        if (/auth|login|signin|signup|password|session|middleware/.test(lower))
+            owners.add('auth');
+        if (/contact|beta|sales|plans|pricing|about|learn|docs|updates|product|landing|home|marketing/.test(lower)) {
+            owners.add('marketing');
+        }
+        if (/theme|theme-forge|tokens|color|font|radius/.test(lower))
+            owners.add('theme');
+        if (/component|component-forge|ui|design-system/.test(lower))
+            owners.add('components');
+        if (/mcp|codebase|scanner|recipe|manifest|graph/.test(lower))
+            owners.add('mcp');
+        if (/api|controller|service|module|prisma|database|schema|model|backend/.test(lower))
+            owners.add('backend');
+        if (!owners.size) {
+            const firstSegment = lower.split('/').find(Boolean);
+            if (firstSegment) {
+                owners.add(firstSegment.replace(/[^a-z0-9-]+/g, '-'));
+            }
+        }
+    }
+    return Array.from(owners).sort().slice(0, 8);
+}
+function readablePatternConcept(value) {
+    return value.replace(/[-_.]+/g, ' ').trim() || 'codebase';
+}
+function roundPatternScore(value) {
+    return Number((0, utils_1.clampPatternScore)(value).toFixed(2));
+}
+function frontendPatternWeight(file, element, childCount, defaultClasses) {
+    let weight = 1;
+    if (file.components.length) {
+        weight += 2;
+    }
+    if (file.routes.length) {
+        weight += 1;
+    }
+    if (/(^|\/)(components|ui|shared|lib)\//.test(file.relPath)) {
+        weight += 2;
+    }
+    if (['card', 'section', 'form', 'nav', 'button', 'input'].includes(element.kind)) {
+        weight += 2;
+    }
+    if (element.layoutRole) {
+        weight += 1;
+    }
+    weight += Math.min(childCount * 0.5, 3);
+    weight += Math.min(Object.keys((0, extractors_1.groupTailwindClasses)(defaultClasses)).length * 0.3, 2);
+    return weight;
+}
+function backendPatternWeight(file) {
+    return (1 +
+        file.apiHandlers.length * 1.2 +
+        file.controllers.length * 2 +
+        file.services.length * 2 +
+        file.models.length * 1.5 +
+        file.authHints.length * 0.5 +
+        file.events.length * 0.5 +
+        file.jobs.length * 0.5);
+}
+function hasBackendPatternSurface(file) {
+    return Boolean(file.apiHandlers.length ||
+        file.controllers.length ||
+        file.services.length ||
+        file.modules.length ||
+        file.apiCalls.length ||
+        file.middleware.length ||
+        file.jobs.length ||
+        file.events.length);
+}
+function backendPatternConcept(file) {
+    if (file.controllers.length) {
+        return file.services.length || file.models.length ? 'api-controller-flow' : 'api-controller';
+    }
+    if (file.apiHandlers.length) {
+        return file.models.length || file.authHints.length ? 'api-data-flow' : 'api-route';
+    }
+    if (file.services.length) {
+        return file.models.length ? 'service-data-flow' : 'service';
+    }
+    if (file.jobs.length || file.events.length) {
+        return 'async-flow';
+    }
+    if (file.apiCalls.length) {
+        return 'client-api-flow';
+    }
+    return 'backend-flow';
+}
+function summarizeModelFieldShape(fields) {
+    const counts = {
+        id: 0,
+        unique: 0,
+        relation: 0,
+        optional: 0,
+        datetime: 0,
+        json: 0,
+        string: 0,
+        number: 0,
+        boolean: 0,
+        enum: 0,
+    };
+    for (const field of fields) {
+        const lower = field.toLowerCase();
+        if (/\b(?:id|uuid)\b|@id/.test(lower))
+            counts.id += 1;
+        if (/@unique|unique/.test(lower))
+            counts.unique += 1;
+        if (/@relation|\[\]|\bbelongs_to\b|\bhas_many\b|\bforeign\b/.test(lower))
+            counts.relation += 1;
+        if (/\?|\bnullable\b|null/.test(lower))
+            counts.optional += 1;
+        if (/\b(datetime|timestamp|date)\b/.test(lower))
+            counts.datetime += 1;
+        if (/\b(json|jsonb)\b/.test(lower))
+            counts.json += 1;
+        if (/\b(string|varchar|text|char)\b/.test(lower))
+            counts.string += 1;
+        if (/\b(int|integer|float|decimal|number|bigint)\b/.test(lower))
+            counts.number += 1;
+        if (/\b(bool|boolean)\b/.test(lower))
+            counts.boolean += 1;
+        if (/\benum\b/.test(lower))
+            counts.enum += 1;
+    }
+    const tags = Object.entries(counts)
+        .filter(([, count]) => count > 0)
+        .map(([name]) => name);
+    const signature = Object.entries(counts)
+        .filter(([, count]) => count > 0)
+        .map(([name, count]) => `${name}:${count}`)
+        .join('|') || 'empty';
+    return { signature, tags, counts };
+}
+function createConnectedPatternGuidance(first, instances, decorativeAccentClasses) {
+    const guidance = [
+        'This is a connected pattern: preserve the root, child roles, default classes, and relationships together instead of copying isolated class tokens.',
+        `Pattern score is based on usage count, file spread, component/route evidence, and structural specificity.`,
+    ];
+    if (first.domain === 'frontend') {
+        guidance.push('Use defaultClasses for normal generation. Use childStructure to keep spacing, hierarchy, and slots aligned with the source pattern.');
+    }
+    if (decorativeAccentClasses.length) {
+        guidance.push('decorativeAccentClasses are opt-in highlight treatments. They must not become default card/surface styling.');
+    }
+    if (instances.length === 1) {
+        guidance.push('This pattern has one evidence instance; prefer higher-scoring sibling clusters when they answer the same lookup.');
+    }
+    if (first.domain === 'backend') {
+        guidance.push('Follow graphKeys to see which API handlers, controllers, services, modules, and models participate in this backend flow.');
+    }
+    if (first.domain === 'data') {
+        guidance.push('Use fieldShape for model-role lookup, then fetch the exact model recipe before writing migrations or queries.');
+    }
+    return guidance;
+}
+function connectedPatternSlug(instance) {
+    const parts = [
+        instance.concept,
+        instance.root?.layoutRole,
+        instance.root?.tag,
+        ...Object.keys(instance.root?.classGroups ?? {}).slice(0, 3),
+    ];
+    return (parts
+        .filter((part) => Boolean(part))
+        .map((part) => part
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, ''))
+        .filter(Boolean)
+        .slice(0, 5)
+        .join('.') || instance.concept);
+}
+function classSignature(classes) {
+    if (!classes.length) {
+        return 'no-classes';
+    }
+    const grouped = (0, extractors_1.groupTailwindClasses)(classes);
+    return Object.entries(grouped)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([group, values]) => `${group}=${values.slice(0, 16).sort().join(',')}`)
+        .join('|');
+}
+function normalizeLayoutRole(value) {
+    return value || 'unspecified-role';
+}
+function normalizeTagForSignature(element) {
+    if (['card', 'button', 'input', 'form', 'nav', 'section', 'table', 'dialog', 'badge'].includes(element.kind)) {
+        return element.kind;
+    }
+    return element.originalTag.toLowerCase();
+}
+function normalizeChildTagForSignature(child) {
+    if (['button', 'input', 'badge', 'heading', 'text', 'link'].includes(child.kind)) {
+        return child.kind;
+    }
+    return child.originalTag.toLowerCase();
+}
+function labelSignature(label) {
+    return label
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .split(/\s+/)
+        .filter((part) => part.length > 2 && !constants_1.classTokenStopWords.has(part))
+        .slice(0, 4)
+        .join('-');
+}
+function addImportEdges(entries, files, edges, rootPath) {
+    const fileEntries = new Map(entries.filter((entry) => entry.group === 'file').map((entry) => [entry.path, entry]));
+    const relPaths = new Set(files.map((file) => file.relPath));
+    for (const file of files) {
+        for (const importValue of file.imports) {
+            if (!(0, utils_1.isRelativeImport)(importValue)) {
+                continue;
+            }
+            const targetRelPath = (0, utils_1.resolveImportPath)(file.relPath, importValue, relPaths, rootPath);
+            const targetEntry = targetRelPath ? fileEntries.get(targetRelPath) : undefined;
+            if (targetEntry && targetEntry.key !== file.key) {
+                edges.push(toGraphEdge(file.key, targetEntry.key, 'imports', 'core.imports', file, 'high'));
+            }
+        }
+    }
+}
+function addApiCallEdges(entries, files, edges) {
+    const apiEntriesByPath = new Map();
+    for (const entry of entries.filter((item) => item.group === 'api')) {
+        const handler = typeof entry.value.handler === 'string' ? entry.value.handler : '';
+        const pathPart = handler.replace(/^[A-Z]+\s+/, '');
+        if (pathPart) {
+            apiEntriesByPath.set(pathPart, [...(apiEntriesByPath.get(pathPart) ?? []), entry]);
+        }
+    }
+    for (const file of files) {
+        for (const apiCall of file.apiCalls) {
+            const targets = apiEntriesByPath.get(apiCall) ?? [];
+            for (const target of targets) {
+                if (target.path !== file.relPath) {
+                    edges.push(toGraphEdge(file.key, target.key, 'calls', 'api.calls', file, 'medium'));
+                }
+            }
+        }
+    }
+}
+function addStyleUsageEdges(entries, files, edges) {
+    const styleEntries = entries.filter((entry) => entry.group === 'style');
+    for (const file of files) {
+        if (!file.classReferences.length && !file.tailwindUtilities.length) {
+            continue;
+        }
+        const fileClasses = new Set(file.classReferences);
+        for (const style of styleEntries) {
+            const styleClasses = Array.isArray(style.value.cssClasses)
+                ? style.value.cssClasses.filter((item) => typeof item === 'string')
+                : [];
+            const intersects = styleClasses.some((className) => fileClasses.has(className));
+            const sameFile = style.path === file.relPath;
+            if ((intersects || sameFile) && style.key !== file.key) {
+                edges.push(toGraphEdge(file.key, style.key, 'styles', 'styles.usage', file, intersects ? 'high' : 'medium'));
+            }
+        }
+    }
+}
+function addModelUsageEdges(entries, files, edges) {
+    const modelEntries = entries.filter((entry) => entry.group === 'model');
+    for (const file of files) {
+        const haystack = [
+            file.relPath,
+            ...file.imports,
+            ...file.exports,
+            ...file.symbols,
+            ...file.classes,
+            ...file.functions,
+            ...file.apiHandlers,
+            ...file.services,
+            ...file.controllers,
+        ]
+            .join(' ')
+            .toLowerCase();
+        for (const model of modelEntries) {
+            const modelName = typeof model.value.name === 'string' ? model.value.name : '';
+            if (!modelName || model.path === file.relPath) {
+                continue;
+            }
+            if (new RegExp(`\\b${(0, utils_1.escapeRegExp)(modelName.toLowerCase())}\\b`).test(haystack)) {
+                const type = /\b(create|insert|update|delete|save|write)\b/.test(haystack)
+                    ? 'writes'
+                    : 'reads';
+                edges.push(toGraphEdge(file.key, model.key, type, 'dataflow.model-reference', file, 'low'));
+            }
+        }
+    }
+}
+function addConceptClusters(entries, usedKeys, nodes, edges, reviewItems) {
+    const concepts = [
+        {
+            key: 'cluster.ui.button',
+            name: 'Buttons',
+            terms: ['button', 'buttons', 'btn', 'cta', 'submit', 'primary action'],
+            reviewId: 'review.ui.button.primary',
+            reviewSummary: 'Multiple button-like patterns found. Canonical button roles need review.',
+        },
+        {
+            key: 'cluster.ui.form',
+            name: 'Forms',
+            terms: ['form', 'forms', 'fieldset', 'form-field', 'textarea', 'select'],
+            reviewId: 'review.ui.form.canonical',
+            reviewSummary: 'Multiple form patterns found. Canonical form roles need review.',
+        },
+        {
+            key: 'cluster.ui.input',
+            name: 'Inputs',
+            terms: ['input', 'textarea', 'select', 'checkbox', 'switch', 'slider', 'field', 'label'],
+            reviewId: 'review.ui.input.canonical',
+            reviewSummary: 'Multiple input patterns found. Canonical input roles need review.',
+        },
+        {
+            key: 'cluster.ui.nav',
+            name: 'Navigation',
+            terms: ['nav', 'navbar', 'navigation', 'menu', 'sidebar', 'breadcrumb'],
+            reviewId: 'review.ui.nav.canonical',
+            reviewSummary: 'Multiple navigation patterns found. Canonical nav roles need review.',
+        },
+        {
+            key: 'cluster.ui.card',
+            name: 'Cards',
+            terms: ['card', 'panel', 'tile', 'surface', 'section-frame', 'frame'],
+            reviewId: 'review.ui.card.canonical',
+            reviewSummary: 'Multiple card or panel patterns found. Canonical card roles need review.',
+        },
+        {
+            key: 'cluster.ui.badge',
+            name: 'Badges',
+            terms: ['badge', 'chip', 'pill', 'status', 'tag', 'eyebrow'],
+            reviewId: 'review.ui.badge.canonical',
+            reviewSummary: 'Multiple badge-like patterns found. Canonical badge roles need review.',
+        },
+        {
+            key: 'cluster.ui.dialog',
+            name: 'Dialogs',
+            terms: ['dialog', 'modal', 'popover', 'drawer', 'sheet'],
+            reviewId: 'review.ui.dialog.canonical',
+            reviewSummary: 'Multiple dialog-like patterns found. Canonical overlay roles need review.',
+        },
+        {
+            key: 'cluster.ui.table',
+            name: 'Tables',
+            terms: ['table', 'thead', 'tbody', 'row', 'cell', 'data-grid', 'grid-table'],
+            reviewId: 'review.ui.table.canonical',
+            reviewSummary: 'Multiple table patterns found. Canonical table roles need review.',
+        },
+        {
+            key: 'cluster.theme.tokens',
+            name: 'Theme Tokens',
+            terms: [
+                'theme',
+                'token',
+                'tokens',
+                'color',
+                'radius',
+                'spacing',
+                'font',
+                'surface',
+                'border',
+                'ring',
+                'shadow',
+            ],
+            reviewId: 'review.theme.tokens.canonical',
+            reviewSummary: 'Multiple theme token sources found. Canonical theme source needs review.',
+        },
+        {
+            key: 'cluster.domain.auth',
+            name: 'Auth',
+            terms: ['auth', 'login', 'signin', 'signup', 'session', 'permission', 'guard', 'middleware'],
+        },
+        {
+            key: 'cluster.domain.user',
+            name: 'Users',
+            terms: ['user', 'users', 'account', 'profile', 'member'],
+        },
+        {
+            key: 'cluster.domain.billing',
+            name: 'Billing',
+            terms: ['billing', 'invoice', 'payment', 'stripe', 'subscription', 'plan'],
+        },
+        {
+            key: 'cluster.domain.settings',
+            name: 'Settings',
+            terms: ['settings', 'preferences', 'configuration', 'config'],
+        },
+    ];
+    for (const concept of concepts) {
+        const members = entries.filter((entry) => (0, extractors_1.entryMatchesConcept)(entry, concept.terms));
+        if (!members.length) {
+            continue;
+        }
+        const roleCandidates = members.filter((entry) => ['component', 'rule', 'style'].includes(entry.group));
+        const dependencies = (0, utils_1.unique)(members.map((entry) => entry.key)).slice(0, 80);
+        const shouldReview = Boolean(concept.reviewId && roleCandidates.length > 1);
+        const status = shouldReview ? 'needs_review' : 'inferred';
+        const scores = createConceptPatternScores(members, roleCandidates, shouldReview);
+        const decision = createConceptPatternDecision(concept.name, scores, shouldReview, roleCandidates.length);
+        addEntry(entries, usedKeys, {
+            key: concept.key,
+            group: 'cluster',
+            summary: `${concept.name} patterns, rules, and related codebase facts.`,
+            tags: (0, utils_1.unique)([...concept.terms, 'cluster', decision.reuse]),
+            dependencies,
+            usedBy: [],
+            confidence: roleCandidates.length ? 'medium' : 'low',
+            status,
+            value: {
+                name: concept.name,
+                kind: 'cluster',
+                patternKind: 'pattern_cluster',
+                terms: concept.terms,
+                members: dependencies,
+                scores,
+                decision,
+                variants: roleCandidates.map((entry) => entry.key).slice(0, 40),
+                children: dependencies,
+                status,
+                ...(shouldReview ? { reviewItem: concept.reviewId } : {}),
+            },
+        });
+        nodes.push({
+            k: concept.key,
+            kind: 'cluster',
+            name: concept.name,
+            facets: {
+                concept: {
+                    terms: concept.terms,
+                    members: dependencies.length,
+                    scores,
+                    decision,
+                },
+            },
+            source: {
+                extractor: 'concept.cluster',
+                confidence: roleCandidates.length ? 'medium' : 'low',
+                evidence: dependencies.slice(0, 30),
+            },
+        });
+        for (const member of members.slice(0, 120)) {
+            edges.push({
+                from: concept.key,
+                to: member.key,
+                type: 'contains',
+                confidence: 'medium',
+                source: {
+                    extractor: 'concept.cluster',
+                    confidence: 'medium',
+                    evidence: [`terms:${concept.terms.join(',')}`],
+                },
+            });
+        }
+        if (shouldReview && concept.reviewId && concept.reviewSummary) {
+            reviewItems.push({
+                id: concept.reviewId,
+                type: 'role_collision',
+                status: 'open',
+                group: 'cluster',
+                s: concept.reviewSummary,
+                candidates: (0, utils_1.unique)([concept.key, ...roleCandidates.map((entry) => entry.key)]).slice(0, 40),
+            });
+        }
+    }
+}
+function applyUsedBy(entries, edges) {
+    const entriesByKey = new Map(entries.map((entry) => [entry.key, entry]));
+    for (const entry of entries) {
+        for (const dependency of entry.dependencies) {
+            const dependencyEntry = entriesByKey.get(dependency);
+            if (dependencyEntry && !dependencyEntry.usedBy.includes(entry.key)) {
+                dependencyEntry.usedBy.push(entry.key);
+            }
+        }
+    }
+    for (const edge of edges) {
+        const targetEntry = entriesByKey.get(edge.to);
+        if (targetEntry && !targetEntry.usedBy.includes(edge.from)) {
+            targetEntry.usedBy.push(edge.from);
+        }
+    }
+    for (const entry of entries) {
+        entry.usedBy = (0, utils_1.unique)(entry.usedBy).sort();
+    }
+}
+function detectProjectFacts(files) {
+    const languages = (0, utils_1.unique)(files.map((file) => file.language)).sort();
+    const dependencies = new Set(files.flatMap((file) => file.dependencies));
+    const frameworks = new Set();
+    if (dependencies.has('react') || files.some((file) => file.components.length)) {
+        frameworks.add('react');
+    }
+    if (dependencies.has('next') ||
+        files.some((file) => file.routes.length || file.kind.includes('next'))) {
+        frameworks.add('nextjs');
+    }
+    if (Array.from(dependencies).some((dependency) => dependency.startsWith('@nestjs/')) ||
+        files.some((file) => file.controllers.length || file.services.length || file.modules.length)) {
+        frameworks.add('nestjs');
+    }
+    if (dependencies.has('prisma') ||
+        dependencies.has('@prisma/client') ||
+        files.some((file) => file.models.length)) {
+        frameworks.add('prisma');
+    }
+    if (files.some((file) => file.language === 'css' || file.language === 'scss')) {
+        frameworks.add('css');
+    }
+    if (files.some((file) => file.language === 'php' || file.language === 'blade.php')) {
+        frameworks.add('php');
+    }
+    if (dependencies.has('laravel/framework') ||
+        files.some((file) => file.relPath.startsWith('routes/') || file.relPath.includes('/Http/Controllers/'))) {
+        frameworks.add('laravel');
+    }
+    if (files.some((file) => file.language === 'html' || file.kind === 'web-page')) {
+        frameworks.add('raw-web');
+    }
+    if (files.some((file) => file.language === 'vue')) {
+        frameworks.add('vue');
+    }
+    if (files.some((file) => file.language === 'svelte')) {
+        frameworks.add('svelte');
+    }
+    if (files.some((file) => file.language === 'astro')) {
+        frameworks.add('astro');
+    }
+    if (dependencies.has('express') || dependencies.has('fastify') || dependencies.has('hono')) {
+        frameworks.add('node-http');
+    }
+    if (files.some((file) => file.language === 'py')) {
+        frameworks.add('python');
+    }
+    if (files.some((file) => file.language === 'rb')) {
+        frameworks.add('ruby');
+    }
+    if (files.some((file) => file.language === 'go')) {
+        frameworks.add('go');
+    }
+    if (files.some((file) => file.language === 'sql')) {
+        frameworks.add('sql');
+    }
+    return {
+        languages,
+        frameworks: Array.from(frameworks).sort(),
+    };
+}
+function detectFrameworkForFile(file) {
+    if (file.routes.length || file.kind.includes('next')) {
+        return 'nextjs';
+    }
+    if (file.components.length || file.hooks.length) {
+        return 'react';
+    }
+    if (file.controllers.length || file.services.length || file.modules.length) {
+        return 'nestjs';
+    }
+    if (file.models.length) {
+        return 'prisma';
+    }
+    if (file.kind.includes('style') || file.kind.includes('css')) {
+        return 'css';
+    }
+    if (file.language === 'php' || file.language === 'blade.php') {
+        return file.relPath.startsWith('routes/') || file.relPath.includes('/Http/')
+            ? 'laravel'
+            : 'php';
+    }
+    if (file.language === 'html' || file.kind === 'web-page') {
+        return 'raw-web';
+    }
+    if (file.language === 'vue') {
+        return 'vue';
+    }
+    if (file.language === 'svelte') {
+        return 'sveltekit';
+    }
+    if (file.language === 'astro') {
+        return 'astro';
+    }
+    if (file.language === 'py') {
+        return 'python';
+    }
+    if (file.language === 'rb') {
+        return 'ruby';
+    }
+    if (file.language === 'go') {
+        return 'go';
+    }
+    if (file.language === 'sql') {
+        return 'sql';
+    }
+    return undefined;
+}
+//# sourceMappingURL=bundle.js.map