uilint 0.2.17 → 0.2.20

package/dist/{install-ui-VNIKF2YT.js → install-ui-FE5AA75P.js}

@@ -20,8 +20,8 @@ import {
 import { render } from "ink";
 
 // src/commands/install/components/InstallApp.tsx
-import { useState as useState5, useEffect as useEffect2 } from "react";
-import { Box as Box4, Text as Text5, useApp as useApp4, useInput as useInput4 } from "ink";
+import { useState as useState6, useEffect as useEffect2 } from "react";
+import { Box as Box5, Text as Text6, useApp as useApp5, useInput as useInput5 } from "ink";
 
 // src/commands/install/components/Spinner.tsx
 import { useState, useEffect } from "react";
@@ -512,6 +512,69 @@ function RuleSelector({
   ] });
 }
 
+// src/commands/install/components/InjectionPointSelector.tsx
+import { useState as useState5 } from "react";
+import { Box as Box4, Text as Text5, useInput as useInput4, useApp as useApp4 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function InjectionPointSelector({
+  points,
+  onSubmit,
+  onBack,
+  onCancel
+}) {
+  const { exit } = useApp4();
+  const recommendedIndex = points.findIndex((p) => p.recommended);
+  const [cursor, setCursor] = useState5(recommendedIndex >= 0 ? recommendedIndex : 0);
+  useInput4((input, key) => {
+    if (key.upArrow) {
+      setCursor((prev) => prev > 0 ? prev - 1 : points.length - 1);
+    } else if (key.downArrow) {
+      setCursor((prev) => prev < points.length - 1 ? prev + 1 : 0);
+    } else if (key.return) {
+      const selected = points[cursor];
+      if (selected) {
+        onSubmit(selected);
+      }
+    } else if (input === "b" || key.leftArrow) {
+      onBack?.();
+    } else if (input === "q" || key.escape) {
+      onCancel?.();
+      exit();
+    }
+  });
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Where should the devtools component be injected?" }) }),
+    points.map((point, index) => {
+      const isCursor = index === cursor;
+      return /* @__PURE__ */ jsxs4(Box4, { paddingLeft: 1, children: [
+        /* @__PURE__ */ jsx5(Text5, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u203A " : "  " }),
+        /* @__PURE__ */ jsx5(Box4, { width: 2, children: /* @__PURE__ */ jsx5(Text5, { color: isCursor ? "cyan" : void 0, children: isCursor ? "\u25C9" : "\u25CB" }) }),
+        /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx5(Text5, { color: isCursor ? "cyan" : void 0, children: point.label }),
+          point.hint && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+            " (",
+            point.hint,
+            ")"
+          ] })
+        ] })
+      ] }, point.id);
+    }),
+    /* @__PURE__ */ jsx5(Box4, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "\u2191\u2193" }),
+      " navigate",
+      "  ",
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "enter" }),
+      " select",
+      "  ",
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "b" }),
+      " back",
+      "  ",
+      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "q" }),
+      " quit"
+    ] }) })
+  ] });
+}
+
 // src/commands/install/installers/registry.ts
 var installers = [];
 function registerInstaller(installer) {
@@ -525,8 +588,315 @@ function getAllInstallers() {
   return installers;
 }
 
+// src/utils/client-boundary-tracer.ts
+import { existsSync, readFileSync } from "fs";
+import { join, dirname, relative } from "path";
+import { parseModule } from "magicast";
+function hasUseClientDirective(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const mod = parseModule(content);
+    const program = mod.$ast;
+    if (!program || program.type !== "Program") return false;
+    const directives = program.directives ?? [];
+    for (const directive of directives) {
+      if (directive?.type === "Directive" && directive.value?.type === "DirectiveLiteral" && directive.value.value === "use client") {
+        return true;
+      }
+    }
+    const firstStmt = program.body?.[0];
+    if (firstStmt?.type === "ExpressionStatement" && (firstStmt.expression?.type === "StringLiteral" || firstStmt.expression?.type === "Literal") && firstStmt.expression.value === "use client") {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function extractImports(program) {
+  const imports = [];
+  if (!program || program.type !== "Program") return imports;
+  for (const stmt of program.body ?? []) {
+    if (stmt?.type !== "ImportDeclaration") continue;
+    const source = stmt.source?.value;
+    if (typeof source !== "string") continue;
+    if (!source.startsWith(".") && !source.startsWith("@/") && !source.startsWith("~/")) {
+      continue;
+    }
+    const specifiers = [];
+    for (const spec of stmt.specifiers ?? []) {
+      if (spec.type === "ImportDefaultSpecifier") {
+        specifiers.push("default");
+      } else if (spec.type === "ImportSpecifier") {
+        const name = spec.imported?.name ?? spec.imported?.value;
+        if (name) specifiers.push(name);
+      } else if (spec.type === "ImportNamespaceSpecifier") {
+        specifiers.push("*");
+      }
+    }
+    imports.push({ source, specifiers });
+  }
+  return imports;
+}
+function resolveImportPath(importSource, fromFile, projectPath) {
+  const fromDir = dirname(fromFile);
+  let basePath;
+  if (importSource.startsWith("@/")) {
+    const withoutAlias = importSource.slice(2);
+    const srcPath = join(projectPath, "src", withoutAlias);
+    const rootPath = join(projectPath, withoutAlias);
+    basePath = existsSync(dirname(srcPath)) ? srcPath : rootPath;
+  } else if (importSource.startsWith("~/")) {
+    basePath = join(projectPath, importSource.slice(2));
+  } else if (importSource.startsWith(".")) {
+    basePath = join(fromDir, importSource);
+  } else {
+    return null;
+  }
+  const extensions = [".tsx", ".ts", ".jsx", ".js"];
+  for (const ext of extensions) {
+    const fullPath = basePath + ext;
+    if (existsSync(fullPath)) return fullPath;
+  }
+  for (const ext of extensions) {
+    const indexPath = join(basePath, `index${ext}`);
+    if (existsSync(indexPath)) return indexPath;
+  }
+  if (existsSync(basePath)) return basePath;
+  return null;
+}
+function findLayoutFile(projectPath, appRoot) {
+  const extensions = [".tsx", ".jsx", ".ts", ".js"];
+  for (const ext of extensions) {
+    const layoutPath = join(projectPath, appRoot, `layout${ext}`);
+    if (existsSync(layoutPath)) return layoutPath;
+  }
+  return null;
+}
+function traceClientBoundaries(projectPath, appRoot) {
+  const layoutFile = findLayoutFile(projectPath, appRoot);
+  if (!layoutFile) {
+    return null;
+  }
+  const layoutIsClient = hasUseClientDirective(layoutFile);
+  const layoutRelative = relative(projectPath, layoutFile);
+  if (layoutIsClient) {
+    return {
+      layoutIsClient: true,
+      clientBoundaries: [],
+      layoutFile,
+      layoutRelative
+    };
+  }
+  let program;
+  try {
+    const content = readFileSync(layoutFile, "utf-8");
+    const mod = parseModule(content);
+    program = mod.$ast;
+  } catch {
+    return {
+      layoutIsClient: false,
+      clientBoundaries: [],
+      layoutFile,
+      layoutRelative
+    };
+  }
+  const imports = extractImports(program);
+  const clientBoundaries = [];
+  for (const imp of imports) {
+    const resolvedPath = resolveImportPath(imp.source, layoutFile, projectPath);
+    if (!resolvedPath) continue;
+    if (hasUseClientDirective(resolvedPath)) {
+      clientBoundaries.push({
+        filePath: resolvedPath,
+        relativePath: relative(projectPath, resolvedPath),
+        componentNames: imp.specifiers,
+        importSource: imp.source
+      });
+    }
+  }
+  return {
+    layoutIsClient: false,
+    clientBoundaries,
+    layoutFile,
+    layoutRelative
+  };
+}
+function providersFileExists(projectPath, appRoot) {
+  const extensions = [".tsx", ".jsx", ".ts", ".js"];
+  const names = ["providers", "Providers"];
+  for (const name of names) {
+    for (const ext of extensions) {
+      const providersPath = join(projectPath, appRoot, `${name}${ext}`);
+      if (existsSync(providersPath)) return providersPath;
+    }
+  }
+  return null;
+}
+
+// src/commands/install/installers/next-overlay.ts
+function getInjectionPoints(projectPath, appRoot) {
+  const points = [];
+  const traceResult = traceClientBoundaries(projectPath, appRoot);
+  if (!traceResult) {
+    points.push({
+      id: "create-providers",
+      label: "Create providers.tsx",
+      hint: "Recommended",
+      createProviders: true,
+      recommended: true
+    });
+    return points;
+  }
+  if (traceResult.layoutIsClient) {
+    points.push({
+      id: "layout",
+      label: "Root layout",
+      hint: "Already a client component",
+      filePath: traceResult.layoutFile,
+      recommended: true
+    });
+    return points;
+  }
+  const existingProviders = providersFileExists(projectPath, appRoot);
+  if (!existingProviders) {
+    points.push({
+      id: "create-providers",
+      label: "Create providers.tsx",
+      hint: "Recommended",
+      createProviders: true,
+      recommended: true
+    });
+  }
+  for (const boundary of traceResult.clientBoundaries) {
+    const componentNames = boundary.componentNames.length > 0 ? boundary.componentNames.join(", ") : "default";
+    points.push({
+      id: boundary.relativePath,
+      label: boundary.relativePath,
+      hint: componentNames,
+      filePath: boundary.filePath,
+      // Mark existing providers as recommended if it exists
+      recommended: existingProviders === boundary.filePath
+    });
+  }
+  if (existingProviders) {
+    const relativePath = existingProviders.replace(projectPath + "/", "").replace(projectPath, "");
+    const alreadyListed = traceResult.clientBoundaries.some(
+      (b) => b.filePath === existingProviders
+    );
+    if (!alreadyListed) {
+      points.push({
+        id: "existing-providers",
+        label: relativePath,
+        hint: "Existing providers",
+        filePath: existingProviders,
+        recommended: true
+      });
+    }
+  }
+  if (points.length === 0) {
+    points.push({
+      id: "create-providers",
+      label: "Create providers.tsx",
+      hint: "Recommended",
+      createProviders: true,
+      recommended: true
+    });
+  }
+  return points;
+}
+var nextOverlayInstaller = {
+  id: "next",
+  name: "Next.js overlay",
+  description: "Alt+Click UI inspector for Next.js App Router",
+  icon: "\u{1F537}",
+  isApplicable(project) {
+    return project.nextApps.length > 0;
+  },
+  getTargets(project) {
+    return project.nextApps.map((app) => ({
+      id: `next-${app.projectPath}`,
+      label: app.projectPath.split("/").pop() || app.projectPath,
+      path: app.projectPath,
+      hint: "App Router",
+      isInstalled: false
+    }));
+  },
+  plan(targets, config, project) {
+    const actions = [];
+    const dependencies = [];
+    if (targets.length === 0) return { actions, dependencies };
+    const target = targets[0];
+    const appInfo = project.nextApps.find(
+      (app) => app.projectPath === target.path
+    );
+    if (!appInfo) return { actions, dependencies };
+    const { projectPath, detection } = appInfo;
+    const nextConfig = config;
+    const targetFile = nextConfig.selectedTargetFile;
+    const createProviders = nextConfig.createProviders;
+    actions.push({
+      type: "install_next_routes",
+      projectPath,
+      appRoot: detection.appRoot
+    });
+    dependencies.push({
+      packagePath: projectPath,
+      packageManager: project.packageManager,
+      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
+    });
+    actions.push({
+      type: "inject_react",
+      projectPath,
+      appRoot: detection.appRoot,
+      mode: "next",
+      targetFile,
+      createProviders
+    });
+    actions.push({
+      type: "inject_next_config",
+      projectPath
+    });
+    return { actions, dependencies };
+  },
+  async *execute(targets, config, project) {
+    if (targets.length === 0) return;
+    const target = targets[0];
+    const nextConfig = config;
+    yield {
+      type: "start",
+      message: "Installing Next.js overlay"
+    };
+    yield {
+      type: "progress",
+      message: `Installing in ${target.label}`,
+      detail: "\u2192 Adding API routes"
+    };
+    yield {
+      type: "progress",
+      message: "Installing dependencies",
+      detail: "\u2192 uilint-react, uilint-core, jsx-loc-plugin"
+    };
+    const injectDetail = nextConfig.createProviders ? "\u2192 Creating providers.tsx" : nextConfig.selectedTargetFile ? `\u2192 ${nextConfig.selectedTargetFile.split("/").pop() || "client component"}` : "\u2192 <uilint-devtools /> in root layout";
+    yield {
+      type: "progress",
+      message: "Injecting devtools component",
+      detail: injectDetail
+    };
+    yield {
+      type: "progress",
+      message: "Configuring jsx-loc-plugin",
+      detail: "\u2192 next.config.js"
+    };
+    yield {
+      type: "complete",
+      message: "Next.js overlay installed"
+    };
+  }
+};
+
 // src/commands/install/components/InstallApp.tsx
-import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 function getTargetStatus(target) {
   if (!target.isInstalled) {
     return "not_installed";
@@ -597,10 +967,10 @@ function buildGlobalConfigItems(selections) {
   return items;
 }
 function Header({ subtitle }) {
-  return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs4(Box4, { children: [
-    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: "\u25C6 UILint" }),
-    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " v0.5.0" }),
-    subtitle && /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+  return /* @__PURE__ */ jsx6(Box5, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs5(Box5, { children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: "\u25C6 UILint" }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: " v0.5.0" }),
+    subtitle && /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
       " \xB7 ",
       subtitle
     ] })
@@ -614,22 +984,22 @@ function FeatureConfig({
   onBack,
   onCancel
 }) {
-  useInput4((input, key) => {
+  useInput5((input, key) => {
     if ((input === "b" || key.leftArrow) && canGoBack) {
       onBack();
     }
   });
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-    selectedProject && /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Project: " }),
-      /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: selectedProject.name }),
-      /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    selectedProject && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Project: " }),
+      /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: selectedProject.name }),
+      /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
         " (",
         selectedProject.hint,
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx6(
       ConfigSelector,
       {
         items: configItems,
@@ -637,11 +1007,11 @@ function FeatureConfig({
         onCancel
       }
     ),
-    canGoBack && /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text5, { dimColor: true, children: [
+    canGoBack && /* @__PURE__ */ jsx6(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
       "Press ",
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "b" }),
+      /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "b" }),
       " or ",
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "\u2190" }),
+      /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: "\u2190" }),
       " to select a different project"
     ] }) })
   ] });
@@ -651,16 +1021,19 @@ function InstallApp({
   onComplete,
   onError
 }) {
-  const { exit } = useApp4();
-  const [phase, setPhase] = useState5("scanning");
-  const [project, setProject] = useState5(null);
-  const [detectedProjects, setDetectedProjects] = useState5([]);
-  const [selectedProject, setSelectedProject] = useState5(null);
-  const [selections, setSelections] = useState5([]);
-  const [configItems, setConfigItems] = useState5([]);
-  const [selectedFeatureIds, setSelectedFeatureIds] = useState5([]);
-  const [error, setError] = useState5(null);
+  const { exit } = useApp5();
+  const [phase, setPhase] = useState6("scanning");
+  const [project, setProject] = useState6(null);
+  const [detectedProjects, setDetectedProjects] = useState6([]);
+  const [selectedProject, setSelectedProject] = useState6(null);
+  const [selections, setSelections] = useState6([]);
+  const [configItems, setConfigItems] = useState6([]);
+  const [selectedFeatureIds, setSelectedFeatureIds] = useState6([]);
+  const [error, setError] = useState6(null);
+  const [injectionPoints, setInjectionPoints] = useState6([]);
+  const [selectedInjectionPoint, setSelectedInjectionPoint] = useState6(void 0);
   const isEslintSelected = selectedFeatureIds.some((id) => id.startsWith("eslint:"));
+  const isNextSelected = selectedFeatureIds.some((id) => id.startsWith("next:"));
   useEffect2(() => {
     if (phase !== "scanning") return;
     projectPromise.then((proj) => {
@@ -713,22 +1086,62 @@ function InstallApp({
       setPhase("select-project");
     }
   };
-  const handleFeatureSubmit = (selectedIds) => {
-    setSelectedFeatureIds(selectedIds);
+  const handleFeatureSubmit = (selectedIds) => {
+    setSelectedFeatureIds(selectedIds);
+    const nextSelected = selectedIds.some((id) => id.startsWith("next:"));
+    if (nextSelected && project && selectedProject) {
+      const appInfo = project.nextApps.find(
+        (app) => app.projectPath === selectedProject.path
+      );
+      if (appInfo) {
+        const points = getInjectionPoints(appInfo.projectPath, appInfo.detection.appRoot);
+        if (points.length === 1) {
+          const point = points[0];
+          setSelectedInjectionPoint({
+            targetFile: point.filePath,
+            createProviders: point.createProviders
+          });
+          proceedAfterInjectionPoint(selectedIds, {
+            targetFile: point.filePath,
+            createProviders: point.createProviders
+          });
+          return;
+        }
+        if (points.length > 1) {
+          setInjectionPoints(points);
+          setPhase("configure-injection-point");
+          return;
+        }
+      }
+    }
+    proceedAfterInjectionPoint(selectedIds, void 0);
+  };
+  const proceedAfterInjectionPoint = (selectedIds, injectionConfig) => {
     const eslintSelected = selectedIds.some((id) => id.startsWith("eslint:"));
     if (eslintSelected) {
       setPhase("configure-eslint");
     } else {
-      finishInstallation(selectedIds, void 0);
+      finishInstallation(selectedIds, void 0, injectionConfig);
     }
   };
+  const handleInjectionPointSubmit = (point) => {
+    const config = {
+      targetFile: point.filePath,
+      createProviders: point.createProviders
+    };
+    setSelectedInjectionPoint(config);
+    proceedAfterInjectionPoint(selectedFeatureIds, config);
+  };
+  const handleBackFromInjectionPoint = () => {
+    setPhase("configure-features");
+  };
   const handleRuleSubmit = (configuredRules) => {
-    finishInstallation(selectedFeatureIds, configuredRules);
+    finishInstallation(selectedFeatureIds, configuredRules, selectedInjectionPoint);
   };
   const handleBackToFeatures = () => {
     setPhase("configure-features");
   };
-  const finishInstallation = (selectedIds, eslintRules) => {
+  const finishInstallation = (selectedIds, eslintRules, injectionConfig) => {
     const selectedSet = new Set(selectedIds);
     const updatedSelections = selections.map((sel) => {
       const selectedTargets = sel.targets.filter(
@@ -741,33 +1154,33 @@ function InstallApp({
       };
     });
     setSelections(updatedSelections);
-    onComplete(updatedSelections, eslintRules);
+    onComplete(updatedSelections, eslintRules, injectionConfig);
   };
   const handleCancel = () => {
     exit();
   };
   if (phase === "scanning") {
-    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(Header, { subtitle: "Install" }),
-      /* @__PURE__ */ jsxs4(Box4, { children: [
-        /* @__PURE__ */ jsx5(Spinner, {}),
-        /* @__PURE__ */ jsx5(Text5, { children: " Scanning project..." })
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { subtitle: "Install" }),
+      /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsx6(Spinner, {}),
+        /* @__PURE__ */ jsx6(Text6, { children: " Scanning project..." })
       ] })
     ] });
   }
   if (phase === "error") {
-    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(Header, {}),
-      /* @__PURE__ */ jsxs4(Box4, { children: [
-        /* @__PURE__ */ jsx5(Text5, { color: "red", children: "\u2717 " }),
-        /* @__PURE__ */ jsx5(Text5, { color: "red", children: error?.message || "An unknown error occurred" })
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, {}),
+      /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "red", children: "\u2717 " }),
+        /* @__PURE__ */ jsx6(Text6, { color: "red", children: error?.message || "An unknown error occurred" })
       ] })
     ] });
   }
   if (phase === "select-project") {
-    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(Header, { subtitle: "Install" }),
-      /* @__PURE__ */ jsx5(
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { subtitle: "Install" }),
+      /* @__PURE__ */ jsx6(
         ProjectSelector,
         {
           projects: detectedProjects,
@@ -778,9 +1191,9 @@ function InstallApp({
     ] });
   }
   if (phase === "configure-features" && project && configItems.length > 0) {
-    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(Header, { subtitle: "Features" }),
-      /* @__PURE__ */ jsx5(
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { subtitle: "Features" }),
+      /* @__PURE__ */ jsx6(
         FeatureConfig,
         {
           selectedProject,
@@ -793,14 +1206,32 @@ function InstallApp({
       )
     ] });
   }
+  if (phase === "configure-injection-point" && injectionPoints.length > 0) {
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { subtitle: "Injection Point" }),
+      selectedProject && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Project: " }),
+        /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: selectedProject.name })
+      ] }),
+      /* @__PURE__ */ jsx6(
+        InjectionPointSelector,
+        {
+          points: injectionPoints,
+          onSubmit: handleInjectionPointSubmit,
+          onBack: handleBackFromInjectionPoint,
+          onCancel: handleCancel
+        }
+      )
+    ] });
+  }
   if (phase === "configure-eslint") {
-    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx5(Header, { subtitle: "ESLint Rules" }),
-      selectedProject && /* @__PURE__ */ jsxs4(Box4, { marginBottom: 1, children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Project: " }),
-        /* @__PURE__ */ jsx5(Text5, { bold: true, color: "cyan", children: selectedProject.name })
+    return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx6(Header, { subtitle: "ESLint Rules" }),
+      selectedProject && /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Project: " }),
+        /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: selectedProject.name })
       ] }),
-      /* @__PURE__ */ jsx5(
+      /* @__PURE__ */ jsx6(
         RuleSelector,
         {
           onSubmit: handleRuleSubmit,
@@ -810,33 +1241,33 @@ function InstallApp({
       )
     ] });
   }
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx5(Header, {}),
-    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Loading..." })
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Header, {}),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Loading..." })
   ] });
 }
 
 // src/commands/install/analyze.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
 import { findWorkspaceRoot as findWorkspaceRoot2 } from "uilint-core/node";
 
 // src/utils/vite-detect.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 var VITE_CONFIG_EXTS = [".ts", ".mjs", ".js", ".cjs"];
 function findViteConfigFile(projectPath) {
   for (const ext of VITE_CONFIG_EXTS) {
     const rel = `vite.config${ext}`;
-    if (existsSync(join(projectPath, rel))) return rel;
+    if (existsSync2(join2(projectPath, rel))) return rel;
   }
   return null;
 }
 function looksLikeReactPackage(projectPath) {
   try {
-    const pkgPath = join(projectPath, "package.json");
-    if (!existsSync(pkgPath)) return false;
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkgPath = join2(projectPath, "package.json");
+    if (!existsSync2(pkgPath)) return false;
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
     return "react" in deps || "react-dom" in deps;
   } catch {
@@ -844,7 +1275,7 @@ function looksLikeReactPackage(projectPath) {
   }
 }
 function fileExists(projectPath, relPath) {
-  return existsSync(join(projectPath, relPath));
+  return existsSync2(join2(projectPath, relPath));
 }
 function detectViteReact(projectPath) {
   const configFile = findViteConfigFile(projectPath);
@@ -853,17 +1284,17 @@ function detectViteReact(projectPath) {
   const entryRoot = "src";
   const candidates = [];
   const entryCandidates = [
-    join(entryRoot, "main.tsx"),
-    join(entryRoot, "main.jsx"),
-    join(entryRoot, "main.ts"),
-    join(entryRoot, "main.js")
+    join2(entryRoot, "main.tsx"),
+    join2(entryRoot, "main.jsx"),
+    join2(entryRoot, "main.ts"),
+    join2(entryRoot, "main.js")
   ];
   for (const rel of entryCandidates) {
     if (fileExists(projectPath, rel)) candidates.push(rel);
   }
   const fallbackCandidates = [
-    join(entryRoot, "App.tsx"),
-    join(entryRoot, "App.jsx")
+    join2(entryRoot, "App.tsx"),
+    join2(entryRoot, "App.jsx")
   ];
   for (const rel of fallbackCandidates) {
     if (!candidates.includes(rel) && fileExists(projectPath, rel)) {
@@ -872,7 +1303,7 @@ function detectViteReact(projectPath) {
   }
   return {
     configFile,
-    configFileAbs: join(projectPath, configFile),
+    configFileAbs: join2(projectPath, configFile),
     entryRoot,
     candidates
   };
@@ -917,7 +1348,7 @@ function findViteReactProjects(rootDir, options) {
       if (!ent.isDirectory) continue;
       if (ignoreDirs.has(ent.name)) continue;
       if (ent.name.startsWith(".") && ent.name !== ".") continue;
-      walk(join(dir, ent.name), depth + 1);
+      walk(join2(dir, ent.name), depth + 1);
     }
   }
   walk(rootDir, 0);
@@ -925,8 +1356,8 @@ function findViteReactProjects(rootDir, options) {
 }
 
 // src/utils/package-detect.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2, relative } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3, relative as relative2 } from "path";
 var DEFAULT_IGNORE_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -971,7 +1402,7 @@ function isFrontendPackage(pkgJson) {
   return FRONTEND_INDICATORS.some((pkg) => pkg in deps);
 }
 function isTypeScriptPackage(dir, pkgJson) {
-  if (existsSync2(join2(dir, "tsconfig.json"))) {
+  if (existsSync3(join3(dir, "tsconfig.json"))) {
     return true;
   }
   const deps = {
@@ -982,7 +1413,7 @@ function isTypeScriptPackage(dir, pkgJson) {
     return true;
   }
   for (const configFile of ESLINT_CONFIG_FILES) {
-    if (configFile.endsWith(".ts") && existsSync2(join2(dir, configFile))) {
+    if (configFile.endsWith(".ts") && existsSync3(join3(dir, configFile))) {
       return true;
     }
   }
@@ -990,14 +1421,14 @@ function isTypeScriptPackage(dir, pkgJson) {
 }
 function hasEslintConfig(dir) {
   for (const file of ESLINT_CONFIG_FILES) {
-    if (existsSync2(join2(dir, file))) {
+    if (existsSync3(join3(dir, file))) {
       return true;
     }
   }
   try {
-    const pkgPath = join2(dir, "package.json");
-    if (existsSync2(pkgPath)) {
-      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const pkgPath = join3(dir, "package.json");
+    if (existsSync3(pkgPath)) {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
       if (pkg.eslintConfig) return true;
     }
   } catch {
@@ -1010,14 +1441,14 @@ function findPackages(rootDir, options) {
   const results = [];
   const visited = /* @__PURE__ */ new Set();
   function processPackage(dir, isRoot) {
-    const pkgPath = join2(dir, "package.json");
-    if (!existsSync2(pkgPath)) return null;
+    const pkgPath = join3(dir, "package.json");
+    if (!existsSync3(pkgPath)) return null;
     try {
-      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-      const name = pkg.name || relative(rootDir, dir) || ".";
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      const name = pkg.name || relative2(rootDir, dir) || ".";
       return {
         path: dir,
-        displayPath: relative(rootDir, dir) || ".",
+        displayPath: relative2(rootDir, dir) || ".",
         name,
         hasEslintConfig: hasEslintConfig(dir),
         isFrontend: isFrontendPackage(pkg),
@@ -1049,7 +1480,7 @@ function findPackages(rootDir, options) {
       if (!ent.isDirectory) continue;
       if (ignoreDirs.has(ent.name)) continue;
       if (ent.name.startsWith(".")) continue;
-      walk(join2(dir, ent.name), depth + 1);
+      walk(join3(dir, ent.name), depth + 1);
     }
   }
   walk(rootDir, 0);
@@ -1063,15 +1494,15 @@ function findPackages(rootDir, options) {
 }
 
 // src/utils/eslint-config-inject.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { join as join3, relative as relative2, dirname } from "path";
-import { parseExpression, parseModule, generateCode } from "magicast";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { join as join4, relative as relative3, dirname as dirname2 } from "path";
+import { parseExpression, parseModule as parseModule2, generateCode } from "magicast";
 import { findWorkspaceRoot } from "uilint-core/node";
 var CONFIG_EXTENSIONS = [".ts", ".mjs", ".js", ".cjs"];
 function findEslintConfigFile(projectPath) {
   for (const ext of CONFIG_EXTENSIONS) {
-    const configPath = join3(projectPath, `eslint.config${ext}`);
-    if (existsSync3(configPath)) {
+    const configPath = join4(projectPath, `eslint.config${ext}`);
+    if (existsSync4(configPath)) {
       return configPath;
     }
   }
@@ -1294,9 +1725,9 @@ function chooseUniqueIdentifier(base, used) {
 function addLocalRuleImportsAst(mod, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
   const importNames = /* @__PURE__ */ new Map();
   let changed = false;
-  const configDir = dirname(configPath);
-  const rulesDir = join3(rulesRoot, ".uilint", "rules");
-  const relativeRulesPath = relative2(configDir, rulesDir).replace(/\\/g, "/");
+  const configDir = dirname2(configPath);
+  const rulesDir = join4(rulesRoot, ".uilint", "rules");
+  const relativeRulesPath = relative3(configDir, rulesDir).replace(/\\/g, "/");
   const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
   const used = collectTopLevelBindings(mod.$ast);
   for (const rule of selectedRules) {
@@ -1322,9 +1753,9 @@ function addLocalRuleRequiresAst(program, selectedRules, configPath, rulesRoot,
   if (!program || program.type !== "Program") {
     return { importNames, changed };
   }
-  const configDir = dirname(configPath);
-  const rulesDir = join3(rulesRoot, ".uilint", "rules");
-  const relativeRulesPath = relative2(configDir, rulesDir).replace(/\\/g, "/");
+  const configDir = dirname2(configPath);
+  const rulesDir = join4(rulesRoot, ".uilint", "rules");
+  const relativeRulesPath = relative3(configDir, rulesDir).replace(/\\/g, "/");
   const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
   const used = collectTopLevelBindings(program);
   for (const rule of selectedRules) {
@@ -1335,7 +1766,7 @@ function addLocalRuleRequiresAst(program, selectedRules, configPath, rulesRoot,
     importNames.set(rule.id, importName);
     used.add(importName);
     const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
-    const stmtMod = parseModule(
+    const stmtMod = parseModule2(
       `const ${importName} = require("${rulePath}");`
     );
     const stmt = stmtMod.$ast.body?.[0];
@@ -1384,7 +1815,7 @@ ${rulesPropsCode}
 }
 function getUilintEslintConfigInfoFromSourceAst(source) {
   try {
-    const mod = parseModule(source);
+    const mod = parseModule2(source);
     const found = findExportedConfigArrayExpression(mod);
     if (!found) {
       return {
@@ -1482,7 +1913,7 @@ async function installEslintPlugin(opts) {
     };
   }
   const configFilename = getEslintConfigFilename(configPath);
-  const original = readFileSync3(configPath, "utf-8");
+  const original = readFileSync4(configPath, "utf-8");
   const isCommonJS = configPath.endsWith(".cjs");
   const ast = getUilintEslintConfigInfoFromSourceAst(original);
   if ("error" in ast) {
@@ -1534,10 +1965,10 @@ async function installEslintPlugin(opts) {
     };
   }
   let modifiedAst = false;
-  const localRulesDir = join3(opts.projectPath, ".uilint", "rules");
+  const localRulesDir = join4(opts.projectPath, ".uilint", "rules");
   const workspaceRoot = findWorkspaceRoot(opts.projectPath);
-  const workspaceRulesDir = join3(workspaceRoot, ".uilint", "rules");
-  const rulesRoot = existsSync3(localRulesDir) ? opts.projectPath : workspaceRoot;
+  const workspaceRulesDir = join4(workspaceRoot, ".uilint", "rules");
+  const rulesRoot = existsSync4(localRulesDir) ? opts.projectPath : workspaceRoot;
   const isTypeScriptConfig = configPath.endsWith(".ts");
   let fileExtension = isTypeScriptConfig ? "" : ".js";
   let ruleImportNames;
@@ -1575,7 +2006,7 @@ async function installEslintPlugin(opts) {
       });
       modifiedAst = true;
     } else {
-      const stmtMod = parseModule(
+      const stmtMod = parseModule2(
         `const { createRule } = require("uilint-eslint");`
       );
       const stmt = stmtMod.$ast.body?.[0];
@@ -1612,12 +2043,12 @@ async function installEslintPlugin(opts) {
 async function analyze(projectPath = process.cwd()) {
   const workspaceRoot = findWorkspaceRoot2(projectPath);
   const packageManager = detectPackageManager(projectPath);
-  const cursorDir = join4(projectPath, ".cursor");
-  const cursorDirExists = existsSync4(cursorDir);
-  const styleguidePath = join4(projectPath, ".uilint", "styleguide.md");
-  const styleguideExists = existsSync4(styleguidePath);
-  const commandsDir = join4(cursorDir, "commands");
-  const genstyleguideExists = existsSync4(join4(commandsDir, "genstyleguide.md"));
+  const cursorDir = join5(projectPath, ".cursor");
+  const cursorDirExists = existsSync5(cursorDir);
+  const styleguidePath = join5(projectPath, ".uilint", "styleguide.md");
+  const styleguideExists = existsSync5(styleguidePath);
+  const commandsDir = join5(cursorDir, "commands");
+  const genstyleguideExists = existsSync5(join5(commandsDir, "genstyleguide.md"));
   const nextApps = [];
   const directDetection = detectNextAppRouter(projectPath);
   if (directDetection) {
@@ -1653,7 +2084,7 @@ async function analyze(projectPath = process.cwd()) {
     if (eslintConfigPath) {
       eslintConfigFilename = getEslintConfigFilename(eslintConfigPath);
       try {
-        const source = readFileSync4(eslintConfigPath, "utf-8");
+        const source = readFileSync5(eslintConfigPath, "utf-8");
         const info = getUilintEslintConfigInfoFromSource(source);
         hasRules = info.configuredRuleIds.size > 0;
         configuredRuleIds = Array.from(info.configuredRuleIds);
@@ -1691,49 +2122,49 @@ async function analyze(projectPath = process.cwd()) {
 
 // src/commands/install/execute.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   mkdirSync,
   writeFileSync as writeFileSync5,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   unlinkSync,
   chmodSync
 } from "fs";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 
 // src/utils/react-inject.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5, relative as relative3 } from "path";
-import { parseModule as parseModule2, generateCode as generateCode2 } from "magicast";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6, relative as relative4 } from "path";
+import { parseModule as parseModule3, generateCode as generateCode2 } from "magicast";
 function getDefaultCandidates(projectPath, appRoot) {
   const viteMainCandidates = [
-    join5(appRoot, "main.tsx"),
-    join5(appRoot, "main.jsx"),
-    join5(appRoot, "main.ts"),
-    join5(appRoot, "main.js")
+    join6(appRoot, "main.tsx"),
+    join6(appRoot, "main.jsx"),
+    join6(appRoot, "main.ts"),
+    join6(appRoot, "main.js")
   ];
   const existingViteMain = viteMainCandidates.filter(
-    (rel) => existsSync5(join5(projectPath, rel))
+    (rel) => existsSync6(join6(projectPath, rel))
   );
   if (existingViteMain.length > 0) return existingViteMain;
-  const viteAppCandidates = [join5(appRoot, "App.tsx"), join5(appRoot, "App.jsx")];
+  const viteAppCandidates = [join6(appRoot, "App.tsx"), join6(appRoot, "App.jsx")];
   const existingViteApp = viteAppCandidates.filter(
-    (rel) => existsSync5(join5(projectPath, rel))
+    (rel) => existsSync6(join6(projectPath, rel))
   );
   if (existingViteApp.length > 0) return existingViteApp;
   const layoutCandidates = [
-    join5(appRoot, "layout.tsx"),
-    join5(appRoot, "layout.jsx"),
-    join5(appRoot, "layout.ts"),
-    join5(appRoot, "layout.js")
+    join6(appRoot, "layout.tsx"),
+    join6(appRoot, "layout.jsx"),
+    join6(appRoot, "layout.ts"),
+    join6(appRoot, "layout.js")
   ];
   const existingLayouts = layoutCandidates.filter(
-    (rel) => existsSync5(join5(projectPath, rel))
+    (rel) => existsSync6(join6(projectPath, rel))
   );
   if (existingLayouts.length > 0) {
     return existingLayouts;
   }
-  const pageCandidates = [join5(appRoot, "page.tsx"), join5(appRoot, "page.jsx")];
-  return pageCandidates.filter((rel) => existsSync5(join5(projectPath, rel)));
+  const pageCandidates = [join6(appRoot, "page.tsx"), join6(appRoot, "page.jsx")];
+  return pageCandidates.filter((rel) => existsSync6(join6(projectPath, rel)));
 }
 function isUseClientDirective(stmt) {
   return stmt?.type === "ExpressionStatement" && stmt.expression?.type === "StringLiteral" && stmt.expression.value === "use client";
@@ -1767,12 +2198,12 @@ function ensureNamedImport(program, from, name) {
       (s) => s?.type === "ImportSpecifier" && (s.imported?.name === name || s.imported?.value === name)
     );
     if (has) return { changed: false };
-    const spec = parseModule2(`import { ${name} } from "${from}";`).$ast.body?.[0]?.specifiers?.[0];
+    const spec = parseModule3(`import { ${name} } from "${from}";`).$ast.body?.[0]?.specifiers?.[0];
     if (!spec) return { changed: false };
     existing.specifiers = [...existing.specifiers ?? [], spec];
     return { changed: true };
   }
-  const importDecl = parseModule2(`import { ${name} } from "${from}";`).$ast.body?.[0];
+  const importDecl = parseModule3(`import { ${name} } from "${from}";`).$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -1802,7 +2233,7 @@ function hasUILintDevtoolsJsx(program) {
 function addDevtoolsElementNextJs(program) {
   if (!program || program.type !== "Program") return { changed: false };
   if (hasUILintDevtoolsJsx(program)) return { changed: false };
-  const devtoolsMod = parseModule2(
+  const devtoolsMod = parseModule3(
     "const __uilint_devtools = <uilint-devtools />;"
   );
   const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -1840,12 +2271,12 @@ function addDevtoolsElementVite(program) {
     const arg0 = node.arguments?.[0];
     if (!arg0) return;
     if (arg0.type !== "JSXElement" && arg0.type !== "JSXFragment") return;
-    const devtoolsMod = parseModule2(
+    const devtoolsMod = parseModule3(
       "const __uilint_devtools = <uilint-devtools />;"
     );
     const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
     if (!devtoolsJsx) return;
-    const fragmentMod = parseModule2(
+    const fragmentMod = parseModule3(
       "const __fragment = <></>;"
     );
     const fragmentJsx = fragmentMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -1865,7 +2296,7 @@ function ensureSideEffectImport(program, from) {
   if (!program || program.type !== "Program") return { changed: false };
   const existing = findImportDeclaration(program, from);
   if (existing) return { changed: false };
-  const importDecl = parseModule2(`import "${from}";`).$ast.body?.[0];
+  const importDecl = parseModule3(`import "${from}";`).$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -1881,7 +2312,7 @@ function ensureSideEffectImport(program, from) {
 function addDevtoolsToClientComponent(program) {
   if (!program || program.type !== "Program") return { changed: false };
   if (hasUILintDevtoolsJsx(program)) return { changed: false };
-  const devtoolsMod = parseModule2(
+  const devtoolsMod = parseModule3(
     "const __uilint_devtools = <uilint-devtools />;"
   );
   const devtoolsJsx = devtoolsMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -1907,7 +2338,7 @@ function addDevtoolsToClientComponent(program) {
     const arg = node.argument;
     if (!arg) return;
     if (arg.type !== "JSXElement" && arg.type !== "JSXFragment") return;
-    const fragmentMod = parseModule2("const __fragment = <></>;");
+    const fragmentMod = parseModule3("const __fragment = <></>;");
     const fragmentJsx = fragmentMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
     if (!fragmentJsx) return;
     fragmentJsx.children = [arg, devtoolsJsx];
@@ -1962,7 +2393,7 @@ function wrapChildrenWithProviders(program, providersImportPath) {
       (child) => child?.type === "JSXExpressionContainer" && child.expression?.type === "Identifier" && child.expression.name === "children"
     );
     if (childrenIndex === -1) return;
-    const providersMod = parseModule2(
+    const providersMod = parseModule3(
       "const __providers = <Providers>{children}</Providers>;"
     );
     const providersJsx = providersMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
@@ -1977,36 +2408,36 @@ function wrapChildrenWithProviders(program, providersImportPath) {
   }
   return { changed: true };
 }
-function findLayoutFile(projectPath, appRoot) {
+function findLayoutFile2(projectPath, appRoot) {
   const extensions = [".tsx", ".jsx", ".ts", ".js"];
   for (const ext of extensions) {
-    const layoutPath = join5(projectPath, appRoot, `layout${ext}`);
-    if (existsSync5(layoutPath)) return layoutPath;
+    const layoutPath = join6(projectPath, appRoot, `layout${ext}`);
+    if (existsSync6(layoutPath)) return layoutPath;
   }
   return null;
 }
 async function createProvidersAndModifyLayout(projectPath, appRoot) {
-  const layoutPath = findLayoutFile(projectPath, appRoot);
+  const layoutPath = findLayoutFile2(projectPath, appRoot);
   if (!layoutPath) {
     throw new Error(`Could not find layout file in ${appRoot}`);
   }
   const isTypeScript = layoutPath.endsWith(".tsx") || layoutPath.endsWith(".ts");
   const providersExt = isTypeScript ? ".tsx" : ".jsx";
-  const providersPath = join5(projectPath, appRoot, `providers${providersExt}`);
-  if (existsSync5(providersPath)) {
+  const providersPath = join6(projectPath, appRoot, `providers${providersExt}`);
+  if (existsSync6(providersPath)) {
     throw new Error(
       `providers${providersExt} already exists. Please select it from the list instead.`
     );
   }
   const providersContent = generateProvidersContent(isTypeScript);
   writeFileSync2(providersPath, providersContent, "utf-8");
-  const layoutContent = readFileSync5(layoutPath, "utf-8");
+  const layoutContent = readFileSync6(layoutPath, "utf-8");
   let layoutMod;
   try {
-    layoutMod = parseModule2(layoutContent);
+    layoutMod = parseModule3(layoutContent);
   } catch {
     throw new Error(
-      `Unable to parse ${relative3(projectPath, layoutPath)} as JavaScript/TypeScript.`
+      `Unable to parse ${relative4(projectPath, layoutPath)} as JavaScript/TypeScript.`
     );
   }
   const layoutProgram = layoutMod.$ast;
@@ -2016,8 +2447,8 @@ async function createProvidersAndModifyLayout(projectPath, appRoot) {
     writeFileSync2(layoutPath, updatedLayout, "utf-8");
   }
   return {
-    providersFile: relative3(projectPath, providersPath),
-    layoutFile: relative3(projectPath, layoutPath),
+    providersFile: relative4(projectPath, providersPath),
+    layoutFile: relative4(projectPath, layoutPath),
     modified: true
   };
 }
@@ -2036,14 +2467,14 @@ async function installReactUILintOverlay(opts) {
   }
   if (opts.targetFile) {
     const absTarget2 = opts.targetFile;
-    const relTarget = relative3(opts.projectPath, absTarget2);
-    if (!existsSync5(absTarget2)) {
+    const relTarget = relative4(opts.projectPath, absTarget2);
+    if (!existsSync6(absTarget2)) {
       throw new Error(`Target file not found: ${relTarget}`);
     }
-    const original2 = readFileSync5(absTarget2, "utf-8");
+    const original2 = readFileSync6(absTarget2, "utf-8");
     let mod2;
     try {
-      mod2 = parseModule2(original2);
+      mod2 = parseModule3(original2);
     } catch {
       throw new Error(
         `Unable to parse ${relTarget} as JavaScript/TypeScript. Please update it manually.`
@@ -2088,11 +2519,11 @@ async function installReactUILintOverlay(opts) {
   } else {
     chosen = candidates[0];
   }
-  const absTarget = join5(opts.projectPath, chosen);
-  const original = readFileSync5(absTarget, "utf-8");
+  const absTarget = join6(opts.projectPath, chosen);
+  const original = readFileSync6(absTarget, "utf-8");
   let mod;
   try {
-    mod = parseModule2(original);
+    mod = parseModule3(original);
   } catch {
     throw new Error(
       `Unable to parse ${chosen} as JavaScript/TypeScript. Please update it manually.`
@@ -2121,14 +2552,14 @@ async function installReactUILintOverlay(opts) {
 }
 
 // src/utils/next-config-inject.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
-import { parseModule as parseModule3, generateCode as generateCode3 } from "magicast";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+import { parseModule as parseModule4, generateCode as generateCode3 } from "magicast";
 var CONFIG_EXTENSIONS2 = [".ts", ".mjs", ".js", ".cjs"];
 function findNextConfigFile(projectPath) {
   for (const ext of CONFIG_EXTENSIONS2) {
-    const configPath = join6(projectPath, `next.config${ext}`);
-    if (existsSync6(configPath)) {
+    const configPath = join7(projectPath, `next.config${ext}`);
+    if (existsSync7(configPath)) {
       return configPath;
     }
   }
@@ -2154,12 +2585,12 @@ function ensureEsmWithJsxLocImport(program) {
       (sp) => sp?.type === "ImportSpecifier" && (sp.imported?.name === "withJsxLoc" || sp.imported?.value === "withJsxLoc")
     );
     if (has) return { changed: false };
-    const spec = parseModule3('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0]?.specifiers?.[0];
+    const spec = parseModule4('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0]?.specifiers?.[0];
     if (!spec) return { changed: false };
     existing.specifiers = [...existing.specifiers ?? [], spec];
     return { changed: true };
   }
-  const importDecl = parseModule3('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0];
+  const importDecl = parseModule4('import { withJsxLoc } from "jsx-loc-plugin";').$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -2182,7 +2613,7 @@ function ensureCjsWithJsxLocRequire(program) {
             return isIdentifier2(p.key, "withJsxLoc");
           });
           if (has) return { changed: false };
-          const prop = parseModule3('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
+          const prop = parseModule4('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
           if (!prop) return { changed: false };
           decl.id.properties = [...decl.id.properties ?? [], prop];
           return { changed: true };
@@ -2191,7 +2622,7 @@ function ensureCjsWithJsxLocRequire(program) {
       }
     }
   }
-  const reqDecl = parseModule3('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0];
+  const reqDecl = parseModule4('const { withJsxLoc } = require("jsx-loc-plugin");').$ast.body?.[0];
   if (!reqDecl) return { changed: false };
   program.body.unshift(reqDecl);
   return { changed: true };
@@ -2241,10 +2672,10 @@ async function installJsxLocPlugin(opts) {
     return { configFile: null, modified: false };
   }
   const configFilename = getNextConfigFilename(configPath);
-  const original = readFileSync6(configPath, "utf-8");
+  const original = readFileSync7(configPath, "utf-8");
   let mod;
   try {
-    mod = parseModule3(original);
+    mod = parseModule4(original);
   } catch {
     return { configFile: configFilename, modified: false };
   }
@@ -2271,14 +2702,14 @@ async function installJsxLocPlugin(opts) {
 }
 
 // src/utils/vite-config-inject.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
-import { parseModule as parseModule4, generateCode as generateCode4 } from "magicast";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
+import { parseModule as parseModule5, generateCode as generateCode4 } from "magicast";
 var CONFIG_EXTENSIONS3 = [".ts", ".mjs", ".js", ".cjs"];
 function findViteConfigFile2(projectPath) {
   for (const ext of CONFIG_EXTENSIONS3) {
-    const configPath = join7(projectPath, `vite.config${ext}`);
-    if (existsSync7(configPath)) return configPath;
+    const configPath = join8(projectPath, `vite.config${ext}`);
+    if (existsSync8(configPath)) return configPath;
   }
   return null;
 }
@@ -2372,12 +2803,12 @@ function ensureEsmJsxLocImport(program) {
       (sp) => sp?.type === "ImportSpecifier" && (sp.imported?.name === "jsxLoc" || sp.imported?.value === "jsxLoc")
     );
     if (has) return { changed: false };
-    const spec = parseModule4('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0]?.specifiers?.[0];
+    const spec = parseModule5('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0]?.specifiers?.[0];
     if (!spec) return { changed: false };
     existing.specifiers = [...existing.specifiers ?? [], spec];
     return { changed: true };
   }
-  const importDecl = parseModule4('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0];
+  const importDecl = parseModule5('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0];
   if (!importDecl) return { changed: false };
   const body = program.body ?? [];
   let insertAt = 0;
@@ -2400,7 +2831,7 @@ function ensureCjsJsxLocRequire(program) {
             return isIdentifier3(p.key, "jsxLoc");
           });
           if (has) return { changed: false };
-          const prop = parseModule4('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
+          const prop = parseModule5('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
           if (!prop) return { changed: false };
           decl.id.properties = [...decl.id.properties ?? [], prop];
           return { changed: true };
@@ -2409,7 +2840,7 @@ function ensureCjsJsxLocRequire(program) {
       }
     }
   }
-  const reqDecl = parseModule4('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0];
+  const reqDecl = parseModule5('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0];
   if (!reqDecl) return { changed: false };
   program.body.unshift(reqDecl);
   return { changed: true };
@@ -2426,7 +2857,7 @@ function pluginsHasJsxLoc(arr) {
 function ensurePluginsContainsJsxLoc(configObj) {
   const pluginsProp = getObjectProperty(configObj, "plugins");
   if (!pluginsProp) {
-    const prop = parseModule4("export default { plugins: [jsxLoc()] };").$ast.body?.find((s) => s.type === "ExportDefaultDeclaration")?.declaration?.properties?.find((p) => {
+    const prop = parseModule5("export default { plugins: [jsxLoc()] };").$ast.body?.find((s) => s.type === "ExportDefaultDeclaration")?.declaration?.properties?.find((p) => {
       const k = p?.key;
       return k?.type === "Identifier" && k.name === "plugins" || isStringLiteral3(k) && k.value === "plugins";
     });
@@ -2438,12 +2869,12 @@ function ensurePluginsContainsJsxLoc(configObj) {
   if (!value) return { changed: false };
   if (value.type === "ArrayExpression") {
     if (pluginsHasJsxLoc(value)) return { changed: false };
-    const jsxLocCall2 = parseModule4("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
+    const jsxLocCall2 = parseModule5("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
     if (!jsxLocCall2) return { changed: false };
     value.elements.push(jsxLocCall2);
     return { changed: true };
   }
-  const jsxLocCall = parseModule4("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
+  const jsxLocCall = parseModule5("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
   if (!jsxLocCall) return { changed: false };
   const spread = { type: "SpreadElement", argument: value };
   pluginsProp.value = { type: "ArrayExpression", elements: [spread, jsxLocCall] };
@@ -2453,11 +2884,11 @@ async function installViteJsxLocPlugin(opts) {
   const configPath = findViteConfigFile2(opts.projectPath);
   if (!configPath) return { configFile: null, modified: false };
   const configFilename = getViteConfigFilename(configPath);
-  const original = readFileSync7(configPath, "utf-8");
+  const original = readFileSync8(configPath, "utf-8");
   const isCjs = configPath.endsWith(".cjs");
   let mod;
   try {
-    mod = parseModule4(original);
+    mod = parseModule5(original);
   } catch {
     return { configFile: configFilename, modified: false };
   }
@@ -2482,9 +2913,9 @@ async function installViteJsxLocPlugin(opts) {
 }
 
 // src/utils/next-routes.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var DEV_SOURCE_ROUTE_TS = `/**
  * Dev-only API route for fetching source files
  *
@@ -2940,40 +3371,40 @@ export async function GET(request: NextRequest) {
 }
 `;
 async function writeRouteFile(absPath, relPath, content, opts) {
-  if (existsSync8(absPath) && !opts.force) return;
+  if (existsSync9(absPath) && !opts.force) return;
   await writeFile(absPath, content, "utf-8");
 }
 async function installNextUILintRoutes(opts) {
-  const baseRel = join8(opts.appRoot, "api", ".uilint");
-  const baseAbs = join8(opts.projectPath, baseRel);
-  await mkdir(join8(baseAbs, "source"), { recursive: true });
+  const baseRel = join9(opts.appRoot, "api", ".uilint");
+  const baseAbs = join9(opts.projectPath, baseRel);
+  await mkdir(join9(baseAbs, "source"), { recursive: true });
   await writeRouteFile(
-    join8(baseAbs, "source", "route.ts"),
-    join8(baseRel, "source", "route.ts"),
+    join9(baseAbs, "source", "route.ts"),
+    join9(baseRel, "source", "route.ts"),
     DEV_SOURCE_ROUTE_TS,
     opts
   );
-  await mkdir(join8(baseAbs, "screenshots"), { recursive: true });
+  await mkdir(join9(baseAbs, "screenshots"), { recursive: true });
   await writeRouteFile(
-    join8(baseAbs, "screenshots", "route.ts"),
-    join8(baseRel, "screenshots", "route.ts"),
+    join9(baseAbs, "screenshots", "route.ts"),
+    join9(baseRel, "screenshots", "route.ts"),
     SCREENSHOT_ROUTE_TS,
     opts
   );
 }
 
 // src/utils/prettier.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { spawn } from "child_process";
-import { join as join9, dirname as dirname3 } from "path";
+import { join as join10, dirname as dirname4 } from "path";
 function getPrettierPath(projectPath) {
-  const localPath = join9(projectPath, "node_modules", ".bin", "prettier");
-  if (existsSync9(localPath)) return localPath;
+  const localPath = join10(projectPath, "node_modules", ".bin", "prettier");
+  if (existsSync10(localPath)) return localPath;
   let dir = projectPath;
   for (let i = 0; i < 10; i++) {
-    const binPath = join9(dir, "node_modules", ".bin", "prettier");
-    if (existsSync9(binPath)) return binPath;
-    const parent = dirname3(dir);
+    const binPath = join10(dir, "node_modules", ".bin", "prettier");
+    if (existsSync10(binPath)) return binPath;
+    const parent = dirname4(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -3114,7 +3545,7 @@ async function executeAction(action, options) {
             wouldDo: `Create directory: ${action.path}`
           };
         }
-        if (!existsSync10(action.path)) {
+        if (!existsSync11(action.path)) {
           mkdirSync(action.path, { recursive: true });
         }
         return { action, success: true };
@@ -3127,8 +3558,8 @@ async function executeAction(action, options) {
             wouldDo: `Create file: ${action.path}${action.permissions ? ` (mode: ${action.permissions.toString(8)})` : ""}`
           };
         }
-        const dir = dirname4(action.path);
-        if (!existsSync10(dir)) {
+        const dir = dirname5(action.path);
+        if (!existsSync11(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, action.content, "utf-8");
@@ -3146,15 +3577,15 @@ async function executeAction(action, options) {
           };
         }
         let existing = {};
-        if (existsSync10(action.path)) {
+        if (existsSync11(action.path)) {
           try {
-            existing = JSON.parse(readFileSync8(action.path, "utf-8"));
+            existing = JSON.parse(readFileSync9(action.path, "utf-8"));
           } catch {
           }
         }
         const merged = deepMerge(existing, action.merge);
-        const dir = dirname4(action.path);
-        if (!existsSync10(dir)) {
+        const dir = dirname5(action.path);
+        if (!existsSync11(dir)) {
           mkdirSync(dir, { recursive: true });
         }
         writeFileSync5(action.path, JSON.stringify(merged, null, 2), "utf-8");
@@ -3168,7 +3599,7 @@ async function executeAction(action, options) {
             wouldDo: `Delete file: ${action.path}`
           };
         }
-        if (existsSync10(action.path)) {
+        if (existsSync11(action.path)) {
           unlinkSync(action.path);
         }
         return { action, success: true };
@@ -3181,8 +3612,8 @@ async function executeAction(action, options) {
             wouldDo: `Append to file: ${action.path}`
           };
         }
-        if (existsSync10(action.path)) {
-          const content = readFileSync8(action.path, "utf-8");
+        if (existsSync11(action.path)) {
+          const content = readFileSync9(action.path, "utf-8");
           if (action.ifNotContains && content.includes(action.ifNotContains)) {
             return { action, success: true };
           }
@@ -3549,7 +3980,7 @@ async function execute(plan, options = {}) {
 import { ruleRegistry as ruleRegistry3 } from "uilint-eslint";
 
 // src/commands/install/installers/genstyleguide.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var genstyleguideInstaller = {
   id: "genstyleguide",
   name: "/genstyleguide command",
@@ -3559,7 +3990,7 @@ var genstyleguideInstaller = {
     return true;
   },
   getTargets(project) {
-    const commandPath = join10(project.cursorDir.path, "commands", "genstyleguide.md");
+    const commandPath = join11(project.cursorDir.path, "commands", "genstyleguide.md");
     const isInstalled = project.commands.genstyleguide;
     return [
       {
@@ -3572,7 +4003,7 @@ var genstyleguideInstaller = {
   },
   plan(targets, config, project) {
     const actions = [];
-    const commandsDir = join10(project.cursorDir.path, "commands");
+    const commandsDir = join11(project.cursorDir.path, "commands");
     if (!project.cursorDir.exists) {
       actions.push({
         type: "create_directory",
@@ -3585,7 +4016,7 @@ var genstyleguideInstaller = {
     });
     actions.push({
       type: "create_file",
-      path: join10(commandsDir, "genstyleguide.md"),
+      path: join11(commandsDir, "genstyleguide.md"),
       content: GENSTYLEGUIDE_COMMAND_MD
     });
     return {
@@ -3615,8 +4046,8 @@ var genstyleguideInstaller = {
 };
 
 // src/commands/install/installers/skill.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
 var skillInstaller = {
   id: "skill",
   name: "UI Consistency Agent skill",
@@ -3626,9 +4057,9 @@ var skillInstaller = {
     return true;
   },
   getTargets(project) {
-    const skillsDir = join11(project.cursorDir.path, "skills", "ui-consistency-enforcer");
-    const skillMdPath = join11(skillsDir, "SKILL.md");
-    const isInstalled = existsSync11(skillMdPath);
+    const skillsDir = join12(project.cursorDir.path, "skills", "ui-consistency-enforcer");
+    const skillMdPath = join12(skillsDir, "SKILL.md");
+    const isInstalled = existsSync12(skillMdPath);
     return [
       {
         id: "ui-consistency-skill",
@@ -3647,21 +4078,21 @@ var skillInstaller = {
         path: project.cursorDir.path
       });
     }
-    const skillsDir = join11(project.cursorDir.path, "skills");
+    const skillsDir = join12(project.cursorDir.path, "skills");
     actions.push({
       type: "create_directory",
       path: skillsDir
     });
     try {
       const skill = loadSkill("ui-consistency-enforcer");
-      const skillDir = join11(skillsDir, skill.name);
+      const skillDir = join12(skillsDir, skill.name);
       actions.push({
         type: "create_directory",
         path: skillDir
       });
       for (const file of skill.files) {
-        const filePath = join11(skillDir, file.relativePath);
-        const fileDir = join11(
+        const filePath = join12(skillDir, file.relativePath);
+        const fileDir = join12(
           skillDir,
           file.relativePath.split("/").slice(0, -1).join("/")
         );
@@ -3718,7 +4149,7 @@ var skillInstaller = {
 };
 
 // src/commands/install/installers/eslint.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { ruleRegistry as ruleRegistry2, getRulesByCategory as getRulesByCategory2 } from "uilint-eslint";
 function getUpgradeInfo(configuredRuleIds) {
   const configuredSet = new Set(configuredRuleIds);
@@ -3894,7 +4325,7 @@ var eslintInstaller = {
     for (const target of targets) {
       const pkgInfo = project.packages.find((p) => p.path === target.path);
       if (!pkgInfo || !pkgInfo.eslintConfigPath) continue;
-      const rulesDir = join12(target.path, ".uilint", "rules");
+      const rulesDir = join13(target.path, ".uilint", "rules");
       actions.push({
         type: "create_directory",
         path: rulesDir
@@ -3912,7 +4343,7 @@ var eslintInstaller = {
         hasExistingRules: pkgInfo.hasUilintRules
       });
     }
-    const gitignorePath = join12(project.workspaceRoot, ".gitignore");
+    const gitignorePath = join13(project.workspaceRoot, ".gitignore");
     actions.push({
       type: "append_to_file",
       path: gitignorePath,
@@ -3946,312 +4377,6 @@ var eslintInstaller = {
   }
 };
 
-// src/utils/client-boundary-tracer.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { join as join13, dirname as dirname5, relative as relative4 } from "path";
-import { parseModule as parseModule5 } from "magicast";
-function hasUseClientDirective(filePath) {
-  try {
-    const content = readFileSync9(filePath, "utf-8");
-    const mod = parseModule5(content);
-    const program = mod.$ast;
-    if (!program || program.type !== "Program") return false;
-    const directives = program.directives ?? [];
-    for (const directive of directives) {
-      if (directive?.type === "Directive" && directive.value?.type === "DirectiveLiteral" && directive.value.value === "use client") {
-        return true;
-      }
-    }
-    const firstStmt = program.body?.[0];
-    if (firstStmt?.type === "ExpressionStatement" && (firstStmt.expression?.type === "StringLiteral" || firstStmt.expression?.type === "Literal") && firstStmt.expression.value === "use client") {
-      return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function extractImports(program) {
-  const imports = [];
-  if (!program || program.type !== "Program") return imports;
-  for (const stmt of program.body ?? []) {
-    if (stmt?.type !== "ImportDeclaration") continue;
-    const source = stmt.source?.value;
-    if (typeof source !== "string") continue;
-    if (!source.startsWith(".") && !source.startsWith("@/") && !source.startsWith("~/")) {
-      continue;
-    }
-    const specifiers = [];
-    for (const spec of stmt.specifiers ?? []) {
-      if (spec.type === "ImportDefaultSpecifier") {
-        specifiers.push("default");
-      } else if (spec.type === "ImportSpecifier") {
-        const name = spec.imported?.name ?? spec.imported?.value;
-        if (name) specifiers.push(name);
-      } else if (spec.type === "ImportNamespaceSpecifier") {
-        specifiers.push("*");
-      }
-    }
-    imports.push({ source, specifiers });
-  }
-  return imports;
-}
-function resolveImportPath(importSource, fromFile, projectPath) {
-  const fromDir = dirname5(fromFile);
-  let basePath;
-  if (importSource.startsWith("@/")) {
-    const withoutAlias = importSource.slice(2);
-    const srcPath = join13(projectPath, "src", withoutAlias);
-    const rootPath = join13(projectPath, withoutAlias);
-    basePath = existsSync12(dirname5(srcPath)) ? srcPath : rootPath;
-  } else if (importSource.startsWith("~/")) {
-    basePath = join13(projectPath, importSource.slice(2));
-  } else if (importSource.startsWith(".")) {
-    basePath = join13(fromDir, importSource);
-  } else {
-    return null;
-  }
-  const extensions = [".tsx", ".ts", ".jsx", ".js"];
-  for (const ext of extensions) {
-    const fullPath = basePath + ext;
-    if (existsSync12(fullPath)) return fullPath;
-  }
-  for (const ext of extensions) {
-    const indexPath = join13(basePath, `index${ext}`);
-    if (existsSync12(indexPath)) return indexPath;
-  }
-  if (existsSync12(basePath)) return basePath;
-  return null;
-}
-function findLayoutFile2(projectPath, appRoot) {
-  const extensions = [".tsx", ".jsx", ".ts", ".js"];
-  for (const ext of extensions) {
-    const layoutPath = join13(projectPath, appRoot, `layout${ext}`);
-    if (existsSync12(layoutPath)) return layoutPath;
-  }
-  return null;
-}
-function traceClientBoundaries(projectPath, appRoot) {
-  const layoutFile = findLayoutFile2(projectPath, appRoot);
-  if (!layoutFile) {
-    return null;
-  }
-  const layoutIsClient = hasUseClientDirective(layoutFile);
-  const layoutRelative = relative4(projectPath, layoutFile);
-  if (layoutIsClient) {
-    return {
-      layoutIsClient: true,
-      clientBoundaries: [],
-      layoutFile,
-      layoutRelative
-    };
-  }
-  let program;
-  try {
-    const content = readFileSync9(layoutFile, "utf-8");
-    const mod = parseModule5(content);
-    program = mod.$ast;
-  } catch {
-    return {
-      layoutIsClient: false,
-      clientBoundaries: [],
-      layoutFile,
-      layoutRelative
-    };
-  }
-  const imports = extractImports(program);
-  const clientBoundaries = [];
-  for (const imp of imports) {
-    const resolvedPath = resolveImportPath(imp.source, layoutFile, projectPath);
-    if (!resolvedPath) continue;
-    if (hasUseClientDirective(resolvedPath)) {
-      clientBoundaries.push({
-        filePath: resolvedPath,
-        relativePath: relative4(projectPath, resolvedPath),
-        componentNames: imp.specifiers,
-        importSource: imp.source
-      });
-    }
-  }
-  return {
-    layoutIsClient: false,
-    clientBoundaries,
-    layoutFile,
-    layoutRelative
-  };
-}
-function providersFileExists(projectPath, appRoot) {
-  const extensions = [".tsx", ".jsx", ".ts", ".js"];
-  const names = ["providers", "Providers"];
-  for (const name of names) {
-    for (const ext of extensions) {
-      const providersPath = join13(projectPath, appRoot, `${name}${ext}`);
-      if (existsSync12(providersPath)) return providersPath;
-    }
-  }
-  return null;
-}
-
-// src/commands/install/installers/next-overlay.ts
-var nextOverlayInstaller = {
-  id: "next",
-  name: "Next.js overlay",
-  description: "Alt+Click UI inspector for Next.js App Router",
-  icon: "\u{1F537}",
-  isApplicable(project) {
-    return project.nextApps.length > 0;
-  },
-  getTargets(project) {
-    const targets = [];
-    for (const app of project.nextApps) {
-      const traceResult = traceClientBoundaries(
-        app.projectPath,
-        app.detection.appRoot
-      );
-      if (!traceResult) {
-        targets.push({
-          id: `next-${app.projectPath}`,
-          label: app.projectPath.split("/").pop() || app.projectPath,
-          path: app.projectPath,
-          hint: "App Router (no layout found)",
-          isInstalled: false
-        });
-        continue;
-      }
-      if (traceResult.layoutIsClient) {
-        targets.push({
-          id: `next-${app.projectPath}`,
-          label: app.projectPath.split("/").pop() || app.projectPath,
-          path: app.projectPath,
-          hint: "App Router",
-          isInstalled: false,
-          targetFile: traceResult.layoutFile
-        });
-        continue;
-      }
-      const existingProviders = providersFileExists(
-        app.projectPath,
-        app.detection.appRoot
-      );
-      if (!existingProviders) {
-        targets.push({
-          id: `next-${app.projectPath}-create-providers`,
-          label: `${app.projectPath.split("/").pop() || app.projectPath}`,
-          path: app.projectPath,
-          hint: "Create providers.tsx (Recommended)",
-          isInstalled: false,
-          createProviders: true
-        });
-      }
-      for (const boundary of traceResult.clientBoundaries) {
-        const componentNames = boundary.componentNames.length > 0 ? boundary.componentNames.join(", ") : "default";
-        targets.push({
-          id: `next-${app.projectPath}-${boundary.relativePath}`,
-          label: `${app.projectPath.split("/").pop() || app.projectPath}`,
-          path: app.projectPath,
-          hint: `${boundary.relativePath} (${componentNames})`,
-          isInstalled: false,
-          targetFile: boundary.filePath
-        });
-      }
-      if (existingProviders) {
-        const relativePath = existingProviders.replace(app.projectPath + "/", "").replace(app.projectPath, "");
-        const alreadyListed = traceResult.clientBoundaries.some(
-          (b) => b.filePath === existingProviders
-        );
-        if (!alreadyListed) {
-          targets.push({
-            id: `next-${app.projectPath}-existing-providers`,
-            label: `${app.projectPath.split("/").pop() || app.projectPath}`,
-            path: app.projectPath,
-            hint: `${relativePath} (existing)`,
-            isInstalled: false,
-            targetFile: existingProviders
-          });
-        }
-      }
-      if (targets.filter((t) => t.path === app.projectPath).length === 0) {
-        targets.push({
-          id: `next-${app.projectPath}-create-providers`,
-          label: `${app.projectPath.split("/").pop() || app.projectPath}`,
-          path: app.projectPath,
-          hint: "Create providers.tsx",
-          isInstalled: false,
-          createProviders: true
-        });
-      }
-    }
-    return targets;
-  },
-  plan(targets, config, project) {
-    const actions = [];
-    const dependencies = [];
-    if (targets.length === 0) return { actions, dependencies };
-    const target = targets[0];
-    const appInfo = project.nextApps.find(
-      (app) => app.projectPath === target.path
-    );
-    if (!appInfo) return { actions, dependencies };
-    const { projectPath, detection } = appInfo;
-    actions.push({
-      type: "install_next_routes",
-      projectPath,
-      appRoot: detection.appRoot
-    });
-    dependencies.push({
-      packagePath: projectPath,
-      packageManager: project.packageManager,
-      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
-    });
-    actions.push({
-      type: "inject_react",
-      projectPath,
-      appRoot: detection.appRoot,
-      mode: "next",
-      targetFile: target.targetFile,
-      createProviders: target.createProviders
-    });
-    actions.push({
-      type: "inject_next_config",
-      projectPath
-    });
-    return { actions, dependencies };
-  },
-  async *execute(targets, config, project) {
-    if (targets.length === 0) return;
-    const target = targets[0];
-    yield {
-      type: "start",
-      message: "Installing Next.js overlay"
-    };
-    yield {
-      type: "progress",
-      message: `Installing in ${target.label}`,
-      detail: "\u2192 Adding API routes"
-    };
-    yield {
-      type: "progress",
-      message: "Installing dependencies",
-      detail: "\u2192 uilint-react, uilint-core, jsx-loc-plugin"
-    };
-    const injectDetail = target.createProviders ? "\u2192 Creating providers.tsx" : target.targetFile ? `\u2192 ${target.hint || "client component"}` : "\u2192 <uilint-devtools /> in root layout";
-    yield {
-      type: "progress",
-      message: "Injecting devtools component",
-      detail: injectDetail
-    };
-    yield {
-      type: "progress",
-      message: "Configuring jsx-loc-plugin",
-      detail: "\u2192 next.config.js"
-    };
-    yield {
-      type: "complete",
-      message: "Next.js overlay installed"
-    };
-  }
-};
-
 // src/commands/install/installers/vite-overlay.ts
 var viteOverlayInstaller = {
   id: "vite",
@@ -4338,8 +4463,8 @@ registerInstaller(nextOverlayInstaller);
 registerInstaller(viteOverlayInstaller);
 
 // src/commands/install-ui.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
-function selectionsToUserChoices(selections, project, eslintRules) {
+import { jsx as jsx7 } from "react/jsx-runtime";
+function selectionsToUserChoices(selections, project, eslintRules, injectionPointConfig) {
   const items = [];
   const choices = { items };
   for (const selection of selections) {
@@ -4371,9 +4496,9 @@ function selectionsToUserChoices(selections, project, eslintRules) {
         choices.next = {
           projectPath: appInfo.projectPath,
           detection: appInfo.detection,
-          // Pass through targetFile and createProviders from the selected target
-          targetFile: target?.targetFile,
-          createProviders: target?.createProviders
+          // Use injection point from follow-up UI selection
+          targetFile: injectionPointConfig?.targetFile,
+          createProviders: injectionPointConfig?.createProviders
         };
       }
     } else if (installer.id === "vite") {
@@ -4404,18 +4529,18 @@ async function installUI(options = {}, executeOptions = {}) {
   }
   const projectPromise = analyze(projectPath);
   const { waitUntilExit } = render(
-    /* @__PURE__ */ jsx6(
+    /* @__PURE__ */ jsx7(
       InstallApp,
       {
         projectPromise,
-        onComplete: async (selections, eslintRules) => {
+        onComplete: async (selections, eslintRules, injectionPointConfig) => {
           const project = await projectPromise;
-          const choices = selectionsToUserChoices(selections, project, eslintRules);
+          const choices = selectionsToUserChoices(selections, project, eslintRules, injectionPointConfig);
           if (choices.items.length === 0) {
             console.log("\nNo items selected for installation");
             process.exit(0);
           }
-          const { createPlan } = await import("./plan-2YRYL4YC.js");
+          const { createPlan } = await import("./plan-SIXVCXCK.js");
           const plan = createPlan(project, choices, { force: options.force });
           const result = await execute(plan, {
             ...executeOptions,
@@ -4440,4 +4565,4 @@ async function installUI(options = {}, executeOptions = {}) {
 export {
   installUI
 };
-//# sourceMappingURL=install-ui-VNIKF2YT.js.map
+//# sourceMappingURL=install-ui-FE5AA75P.js.map