@julien-lin/universal-pwa-core 1.3.1 → 1.3.2

package/dist/index.cjs

@@ -35,13 +35,16 @@ __export(index_exports, {
   STANDARD_SPLASH_SIZES: () => STANDARD_SPLASH_SIZES,
   checkHttps: () => checkHttps,
   checkProjectHttps: () => checkProjectHttps,
+  detectApiType: () => detectApiType,
   detectArchitecture: () => detectArchitecture,
   detectAssets: () => detectAssets,
   detectFramework: () => detectFramework,
   detectProjectUrl: () => detectProjectUrl,
+  detectUnoptimizedImages: () => detectUnoptimizedImages,
   elementExists: () => elementExists,
   findAllElements: () => findAllElements,
   findElement: () => findElement,
+  generateAdaptiveCacheStrategies: () => generateAdaptiveCacheStrategies,
   generateAndWriteManifest: () => generateAndWriteManifest,
   generateAndWriteServiceWorker: () => generateAndWriteServiceWorker,
   generateAppleTouchIcon: () => generateAppleTouchIcon,
@@ -49,40 +52,259 @@ __export(index_exports, {
   generateIcons: () => generateIcons,
   generateIconsOnly: () => generateIconsOnly,
   generateManifest: () => generateManifest,
+  generateOptimalShortName: () => generateOptimalShortName,
   generateReport: () => generateReport,
+  generateResponsiveImageSizes: () => generateResponsiveImageSizes,
   generateServiceWorker: () => generateServiceWorker,
   generateSimpleServiceWorker: () => generateSimpleServiceWorker,
   generateSplashScreensOnly: () => generateSplashScreensOnly,
   injectMetaTags: () => injectMetaTags,
   injectMetaTagsInFile: () => injectMetaTagsInFile,
+  optimizeImage: () => optimizeImage,
+  optimizeProject: () => optimizeProject,
+  optimizeProjectImages: () => optimizeProjectImages,
   parseHTML: () => parseHTML,
   parseHTMLFile: () => parseHTMLFile,
   scanProject: () => scanProject,
   serializeHTML: () => serializeHTML,
+  suggestManifestColors: () => suggestManifestColors,
+  validatePWA: () => validatePWA,
   validateProjectPath: () => validateProjectPath,
   writeManifest: () => writeManifest
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/scanner/index.ts
-var import_fs4 = require("fs");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 
 // src/scanner/framework-detector.ts
 var import_fs = require("fs");
 var import_path = require("path");
+var import_glob = require("glob");
+function calculateConfidenceScore(framework, confidence, indicators) {
+  if (!framework) {
+    return 0;
+  }
+  let baseScore = 0;
+  switch (confidence) {
+    case "high":
+      baseScore = 80;
+      break;
+    case "medium":
+      baseScore = 50;
+      break;
+    case "low":
+      baseScore = 20;
+      break;
+  }
+  const indicatorBonus = Math.min(indicators.length * 2, 20);
+  const specificFrameworkBonus = indicators.some(
+    (ind) => ind.includes("composer.json:") || ind.includes("package.json:") || ind.includes("Gemfile")
+  ) ? 10 : 0;
+  const totalScore = baseScore + indicatorBonus + specificFrameworkBonus;
+  return Math.min(totalScore, 100);
+}
+function scoreToConfidence(score) {
+  if (score >= 70) return "high";
+  if (score >= 40) return "medium";
+  return "low";
+}
+function parseVersion(versionString) {
+  if (!versionString) return null;
+  const cleanVersion = versionString.replace(/^[\^~>=<]+\s*/, "").trim();
+  const parts = cleanVersion.split(".");
+  if (parts.length === 0) return null;
+  const major = parseInt(parts[0], 10);
+  if (isNaN(major)) return null;
+  const minor = parts[1] ? parseInt(parts[1], 10) : null;
+  const patch = parts[2] ? parseInt(parts[2], 10) : null;
+  return {
+    major,
+    minor: isNaN(minor ?? 0) ? null : minor,
+    patch: isNaN(patch ?? 0) ? null : patch,
+    raw: versionString
+  };
+}
+function detectFrameworkVersion(framework, dependencies) {
+  switch (framework) {
+    case "react":
+      if (dependencies.react) {
+        return parseVersion(dependencies.react);
+      }
+      break;
+    case "vue":
+      if (dependencies.vue) {
+        return parseVersion(dependencies.vue);
+      }
+      break;
+    case "angular":
+      if (dependencies["@angular/core"]) {
+        return parseVersion(dependencies["@angular/core"]);
+      }
+      break;
+    default:
+      break;
+  }
+  return null;
+}
+function detectProjectConfiguration(projectPath) {
+  const config = {
+    language: null,
+    cssInJs: [],
+    stateManagement: [],
+    buildTool: null
+  };
+  const tsConfigPath = (0, import_path.join)(projectPath, "tsconfig.json");
+  if ((0, import_fs.existsSync)(tsConfigPath)) {
+    config.language = "typescript";
+  } else {
+    try {
+      const tsFiles = (0, import_glob.globSync)("**/*.{ts,tsx}", {
+        cwd: projectPath,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+        absolute: false,
+        maxDepth: 3
+      });
+      if (tsFiles.length > 0) {
+        config.language = "typescript";
+      } else {
+        config.language = "javascript";
+      }
+    } catch {
+      config.language = "javascript";
+    }
+  }
+  const packageJsonPath = (0, import_path.join)(projectPath, "package.json");
+  if ((0, import_fs.existsSync)(packageJsonPath)) {
+    try {
+      const packageContent = JSON.parse((0, import_fs.readFileSync)(packageJsonPath, "utf-8"));
+      const dependencies = {
+        ...packageContent.dependencies ?? {},
+        ...packageContent.devDependencies ?? {}
+      };
+      if (dependencies["styled-components"]) {
+        config.cssInJs.push("styled-components");
+      }
+      if (dependencies["@emotion/react"] || dependencies["@emotion/styled"]) {
+        config.cssInJs.push("emotion");
+      }
+      if (dependencies["@stitches/react"] || dependencies["@stitches/core"]) {
+        config.cssInJs.push("stitches");
+      }
+      if (dependencies.linaria) {
+        config.cssInJs.push("linaria");
+      }
+      if (dependencies.goober) {
+        config.cssInJs.push("goober");
+      }
+      if (dependencies.aphrodite) {
+        config.cssInJs.push("aphrodite");
+      }
+      if (dependencies.redux || dependencies["@reduxjs/toolkit"]) {
+        config.stateManagement.push("redux");
+      }
+      if (dependencies.zustand) {
+        config.stateManagement.push("zustand");
+      }
+      if (dependencies.pinia || dependencies["@pinia/core"]) {
+        config.stateManagement.push("pinia");
+      }
+      if (dependencies.mobx || dependencies["mobx-react"]) {
+        config.stateManagement.push("mobx");
+      }
+      if (dependencies.recoil) {
+        config.stateManagement.push("recoil");
+      }
+      if (dependencies.jotai) {
+        config.stateManagement.push("jotai");
+      }
+      if (dependencies.valtio) {
+        config.stateManagement.push("valtio");
+      }
+      if (dependencies["@tanstack/react-query"] || dependencies["react-query"]) {
+        config.stateManagement.push("react-query");
+      }
+      if (dependencies.vite || Object.keys(dependencies).some((key) => key.startsWith("vite-plugin-"))) {
+        config.buildTool = "vite";
+      } else if (dependencies.webpack || Object.keys(dependencies).some((key) => key.startsWith("webpack-"))) {
+        config.buildTool = "webpack";
+      } else if (dependencies.rollup || Object.keys(dependencies).some((key) => key.startsWith("rollup-plugin-"))) {
+        config.buildTool = "rollup";
+      } else if (dependencies.esbuild) {
+        config.buildTool = "esbuild";
+      } else if (dependencies.parcel || dependencies["parcel-bundler"]) {
+        config.buildTool = "parcel";
+      } else if (dependencies["@turbo/*"] || dependencies.turbo) {
+        config.buildTool = "turbopack";
+      }
+    } catch {
+    }
+  }
+  return config;
+}
+function createResult(framework, confidence, indicators, version = null, configuration = null) {
+  const confidenceScore = calculateConfidenceScore(framework, confidence, indicators);
+  const finalConfidence = scoreToConfidence(confidenceScore);
+  const finalConfig = configuration ?? {
+    language: null,
+    cssInJs: [],
+    stateManagement: [],
+    buildTool: null
+  };
+  return {
+    framework,
+    confidence: finalConfidence,
+    confidenceScore,
+    indicators,
+    version,
+    configuration: finalConfig
+  };
+}
 function detectFramework(projectPath) {
   const indicators = [];
   let framework = null;
   let confidence = "low";
+  const projectConfig = detectProjectConfiguration(projectPath);
   if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "wp-config.php"))) {
     indicators.push("wp-config.php");
     if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "wp-content"))) {
       indicators.push("wp-content/");
+      if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "wp-content", "plugins", "woocommerce"))) {
+        indicators.push("wp-content/plugins/woocommerce/");
+        framework = "woocommerce";
+        confidence = "high";
+        return createResult(framework, confidence, indicators, null, projectConfig);
+      }
       framework = "wordpress";
       confidence = "high";
-      return { framework, confidence, indicators };
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "sites")) && (0, import_fs.existsSync)((0, import_path.join)(projectPath, "modules"))) {
+    indicators.push("sites/ and modules/ (Drupal)");
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "themes"))) {
+      indicators.push("themes/");
+      framework = "drupal";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "configuration.php"))) {
+    indicators.push("configuration.php (Joomla)");
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "administrator"))) {
+      indicators.push("administrator/");
+      framework = "joomla";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
     }
   }
+  if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "theme.liquid")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "config", "settings_schema.json"))) {
+    indicators.push("theme.liquid or config/settings_schema.json (Shopify)");
+    framework = "shopify";
+    confidence = "high";
+    return createResult(framework, confidence, indicators, null, projectConfig);
+  }
   const composerPath = (0, import_path.join)(projectPath, "composer.json");
   if ((0, import_fs.existsSync)(composerPath)) {
     try {
@@ -91,13 +313,31 @@ function detectFramework(projectPath) {
         ...composerContent.require ?? {},
         ...composerContent["require-dev"] ?? {}
       };
+      if (dependencies["magento/product-community-edition"] || dependencies["magento/product-enterprise-edition"]) {
+        indicators.push("composer.json: magento/*");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "app")) && (0, import_fs.existsSync)((0, import_path.join)(projectPath, "pub"))) {
+          indicators.push("app/ and pub/");
+          framework = "magento";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies["prestashop/prestashop"]) {
+        indicators.push("composer.json: prestashop/prestashop");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "config")) && (0, import_fs.existsSync)((0, import_path.join)(projectPath, "themes"))) {
+          indicators.push("config/ and themes/");
+          framework = "prestashop";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
       if (dependencies["symfony/symfony"] || dependencies["symfony/framework-bundle"]) {
         indicators.push("composer.json: symfony/*");
         if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "public"))) {
           indicators.push("public/");
           framework = "symfony";
           confidence = "high";
-          return { framework, confidence, indicators };
+          return createResult(framework, confidence, indicators, null, projectConfig);
         }
       }
       if (dependencies["laravel/framework"]) {
@@ -106,7 +346,43 @@ function detectFramework(projectPath) {
           indicators.push("public/");
           framework = "laravel";
           confidence = "high";
-          return { framework, confidence, indicators };
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies["codeigniter4/framework"]) {
+        indicators.push("composer.json: codeigniter4/framework");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "public"))) {
+          indicators.push("public/");
+          framework = "codeigniter";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies["cakephp/cakephp"]) {
+        indicators.push("composer.json: cakephp/cakephp");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "webroot")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "public"))) {
+          indicators.push("webroot/ or public/");
+          framework = "cakephp";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies["yiisoft/yii2"] || dependencies["yiisoft/yii"]) {
+        indicators.push("composer.json: yiisoft/*");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "web")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "public"))) {
+          indicators.push("web/ or public/");
+          framework = "yii";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies["laminas/laminas-mvc"] || dependencies["laminas/laminas-component-installer"]) {
+        indicators.push("composer.json: laminas/*");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "public"))) {
+          indicators.push("public/");
+          framework = "laminas";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
         }
       }
     } catch {
@@ -126,7 +402,7 @@ function detectFramework(projectPath) {
           indicators.push(".next/");
           framework = "nextjs";
           confidence = "high";
-          return { framework, confidence, indicators };
+          return createResult(framework, confidence, indicators, null, projectConfig);
         }
       }
       if (dependencies.nuxt) {
@@ -135,19 +411,27 @@ function detectFramework(projectPath) {
           indicators.push(".nuxt/");
           framework = "nuxt";
           confidence = "high";
-          return { framework, confidence, indicators };
+          return createResult(framework, confidence, indicators, null, projectConfig);
         }
       }
       if (dependencies.react) {
         indicators.push("package.json: react");
         framework = "react";
         confidence = framework ? "high" : "medium";
+        const version = detectFrameworkVersion("react", dependencies);
+        if (version) {
+          indicators.push(`React version: ${version.major}.${version.minor ?? "x"}.${version.patch ?? "x"}`);
+        }
       }
       if (dependencies.vue) {
         indicators.push("package.json: vue");
         if (!framework) {
           framework = "vue";
           confidence = "high";
+          const version = detectFrameworkVersion("vue", dependencies);
+          if (version) {
+            indicators.push(`Vue version: ${version.major}.${version.minor ?? "x"}.${version.patch ?? "x"}`);
+          }
         }
       }
       if (dependencies["@angular/core"]) {
@@ -155,11 +439,274 @@ function detectFramework(projectPath) {
         if (!framework) {
           framework = "angular";
           confidence = "high";
+          const version = detectFrameworkVersion("angular", dependencies);
+          if (version) {
+            indicators.push(`Angular version: ${version.major}.${version.minor ?? "x"}.${version.patch ?? "x"}`);
+          }
+        }
+      }
+      if (dependencies["@sveltejs/kit"]) {
+        indicators.push("package.json: @sveltejs/kit");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, ".svelte-kit"))) {
+          indicators.push(".svelte-kit/");
+          framework = "sveltekit";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies.svelte && !dependencies["@sveltejs/kit"]) {
+        indicators.push("package.json: svelte");
+        if (!framework) {
+          framework = "svelte";
+          confidence = "high";
+        }
+      }
+      if (dependencies["@remix-run/node"] || dependencies["@remix-run/react"]) {
+        indicators.push("package.json: @remix-run/*");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "app"))) {
+          indicators.push("app/");
+          framework = "remix";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies.astro) {
+        indicators.push("package.json: astro");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, ".astro"))) {
+          indicators.push(".astro/");
+          framework = "astro";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      }
+      if (dependencies["solid-js"]) {
+        indicators.push("package.json: solid-js");
+        if (!framework) {
+          framework = "solidjs";
+          confidence = "high";
+        }
+      }
+    } catch {
+    }
+  }
+  if (!framework) {
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "manage.py")) && (0, import_fs.existsSync)((0, import_path.join)(projectPath, "settings.py"))) {
+      indicators.push("manage.py and settings.py (Django)");
+      framework = "django";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "manage.py")) && (0, import_fs.existsSync)((0, import_path.join)(projectPath, "django"))) {
+      indicators.push("manage.py and django/ (Django)");
+      framework = "django";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+    const requirementsPath = (0, import_path.join)(projectPath, "requirements.txt");
+    if ((0, import_fs.existsSync)(requirementsPath)) {
+      try {
+        const requirementsContent = (0, import_fs.readFileSync)(requirementsPath, "utf-8");
+        if (requirementsContent.includes("Flask") || requirementsContent.includes("flask")) {
+          indicators.push("requirements.txt: Flask");
+          if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "app.py")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "application.py"))) {
+            indicators.push("app.py or application.py");
+            framework = "flask";
+            confidence = "high";
+            return createResult(framework, confidence, indicators, null, projectConfig);
+          }
+        }
+        if (requirementsContent.includes("fastapi") || requirementsContent.includes("FastAPI")) {
+          indicators.push("requirements.txt: FastAPI");
+          framework = "fastapi";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      } catch {
+      }
+    }
+  }
+  if (!framework) {
+    const gemfilePath = (0, import_path.join)(projectPath, "Gemfile");
+    if ((0, import_fs.existsSync)(gemfilePath)) {
+      try {
+        const gemfileContent = (0, import_fs.readFileSync)(gemfilePath, "utf-8");
+        if (gemfileContent.includes("gem 'rails'") || gemfileContent.includes('gem "rails"')) {
+          indicators.push("Gemfile: rails");
+          if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "config", "application.rb")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "config", "routes.rb"))) {
+            indicators.push("config/application.rb or config/routes.rb");
+            framework = "rails";
+            confidence = "high";
+            return createResult(framework, confidence, indicators, null, projectConfig);
+          }
+        }
+        if (gemfileContent.includes("gem 'sinatra'") || gemfileContent.includes('gem "sinatra"')) {
+          indicators.push("Gemfile: sinatra");
+          if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "app.rb")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "main.rb"))) {
+            indicators.push("app.rb or main.rb");
+            framework = "sinatra";
+            confidence = "high";
+            return createResult(framework, confidence, indicators, null, projectConfig);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (!framework) {
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "go.mod"))) {
+      try {
+        const goModContent = (0, import_fs.readFileSync)((0, import_path.join)(projectPath, "go.mod"), "utf-8");
+        if (goModContent.includes("net/http") || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "main.go")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "server.go"))) {
+          const mainGoPath = (0, import_path.join)(projectPath, "main.go");
+          if ((0, import_fs.existsSync)(mainGoPath)) {
+            try {
+              const mainGoContent = (0, import_fs.readFileSync)(mainGoPath, "utf-8");
+              if (mainGoContent.includes("http.ListenAndServe") || mainGoContent.includes("http.Server")) {
+                indicators.push("go.mod and main.go with HTTP server");
+                framework = "go";
+                confidence = "high";
+                return createResult(framework, confidence, indicators, null, projectConfig);
+              }
+            } catch {
+            }
+          }
+          const serverGoPath = (0, import_path.join)(projectPath, "server.go");
+          if ((0, import_fs.existsSync)(serverGoPath)) {
+            try {
+              const serverGoContent = (0, import_fs.readFileSync)(serverGoPath, "utf-8");
+              if (serverGoContent.includes("http.ListenAndServe") || serverGoContent.includes("http.Server")) {
+                indicators.push("go.mod and server.go with HTTP server");
+                framework = "go";
+                confidence = "high";
+                return createResult(framework, confidence, indicators, null, projectConfig);
+              }
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (!framework) {
+    const pomXmlPath = (0, import_path.join)(projectPath, "pom.xml");
+    const buildGradlePath = (0, import_path.join)(projectPath, "build.gradle");
+    if ((0, import_fs.existsSync)(pomXmlPath)) {
+      try {
+        const pomContent = (0, import_fs.readFileSync)(pomXmlPath, "utf-8");
+        if (pomContent.includes("spring-boot-starter") || pomContent.includes("org.springframework.boot")) {
+          indicators.push("pom.xml: spring-boot");
+          framework = "spring";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      } catch {
+      }
+    }
+    if ((0, import_fs.existsSync)(buildGradlePath)) {
+      try {
+        const gradleContent = (0, import_fs.readFileSync)(buildGradlePath, "utf-8");
+        if (gradleContent.includes("spring-boot") || gradleContent.includes("org.springframework.boot")) {
+          indicators.push("build.gradle: spring-boot");
+          framework = "spring";
+          confidence = "high";
+          return createResult(framework, confidence, indicators, null, projectConfig);
+        }
+      } catch {
+      }
+    }
+  }
+  if (!framework) {
+    try {
+      const csprojMatches = (0, import_glob.globSync)("*.csproj", { cwd: projectPath, absolute: false });
+      if (csprojMatches.length > 0) {
+        const firstCsproj = (0, import_path.join)(projectPath, csprojMatches[0]);
+        try {
+          const csprojContent = (0, import_fs.readFileSync)(firstCsproj, "utf-8");
+          if (csprojContent.includes("Microsoft.AspNetCore") || csprojContent.includes("Microsoft.NET.Sdk.Web")) {
+            indicators.push(`${csprojMatches[0]}: ASP.NET Core`);
+            if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "Program.cs")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "Startup.cs"))) {
+              indicators.push("Program.cs or Startup.cs");
+              framework = "aspnet";
+              confidence = "high";
+              return createResult(framework, confidence, indicators, null, projectConfig);
+            }
+          }
+        } catch {
         }
       }
     } catch {
     }
   }
+  if (!framework) {
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "_config.yml"))) {
+      indicators.push("_config.yml (Jekyll)");
+      if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "_posts"))) {
+        indicators.push("_posts/");
+        framework = "jekyll";
+        confidence = "high";
+        return createResult(framework, confidence, indicators, null, projectConfig);
+      }
+      framework = "jekyll";
+      confidence = "medium";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+    const hugoConfigFiles = ["config.toml", "config.yaml", "config.yml", "hugo.toml", "hugo.yaml", "hugo.yml"];
+    const hasHugoConfig = hugoConfigFiles.some((file) => (0, import_fs.existsSync)((0, import_path.join)(projectPath, file)));
+    if (hasHugoConfig) {
+      indicators.push("Hugo config file found");
+      if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "content")) && (0, import_fs.existsSync)((0, import_path.join)(projectPath, "layouts"))) {
+        indicators.push("content/ and layouts/");
+        framework = "hugo";
+        confidence = "high";
+        return createResult(framework, confidence, indicators, null, projectConfig);
+      }
+      if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "content"))) {
+        indicators.push("content/");
+        framework = "hugo";
+        confidence = "high";
+        return createResult(framework, confidence, indicators, null, projectConfig);
+      }
+    }
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "gatsby-config.js")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "gatsby-config.ts"))) {
+      indicators.push("gatsby-config.js/ts (Gatsby)");
+      framework = "gatsby";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+    const eleventyFiles = [".eleventy.js", ".eleventy.cjs", "eleventy.config.js", "eleventy.config.cjs"];
+    const hasEleventyConfig = eleventyFiles.some((file) => (0, import_fs.existsSync)((0, import_path.join)(projectPath, file)));
+    if (hasEleventyConfig) {
+      indicators.push("Eleventy config file found");
+      if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "_data"))) {
+        indicators.push("_data/");
+        framework = "eleventy";
+        confidence = "high";
+        return createResult(framework, confidence, indicators, null, projectConfig);
+      }
+      framework = "eleventy";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "vitepress.config.js")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "vitepress.config.ts"))) {
+      indicators.push("vitepress.config.js/ts (VitePress)");
+      framework = "vitepress";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "docs", ".vitepress", "config.js")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "docs", ".vitepress", "config.ts"))) {
+      indicators.push("docs/.vitepress/config.js/ts (VitePress)");
+      framework = "vitepress";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "docusaurus.config.js")) || (0, import_fs.existsSync)((0, import_path.join)(projectPath, "docusaurus.config.ts"))) {
+      indicators.push("docusaurus.config.js/ts (Docusaurus)");
+      framework = "docusaurus";
+      confidence = "high";
+      return createResult(framework, confidence, indicators, null, projectConfig);
+    }
+  }
   if (!framework) {
     const htmlFiles = ["index.html", "index.htm"];
     const hasHtml = htmlFiles.some((file) => (0, import_fs.existsSync)((0, import_path.join)(projectPath, file)));
@@ -169,11 +716,38 @@ function detectFramework(projectPath) {
       confidence = "medium";
     }
   }
-  return { framework, confidence, indicators };
+  let detectedVersion = null;
+  if (framework && (framework === "react" || framework === "vue" || framework === "angular")) {
+    const packageJsonPath2 = (0, import_path.join)(projectPath, "package.json");
+    if ((0, import_fs.existsSync)(packageJsonPath2)) {
+      try {
+        const packageContent = JSON.parse((0, import_fs.readFileSync)(packageJsonPath2, "utf-8"));
+        const dependencies = {
+          ...packageContent.dependencies ?? {},
+          ...packageContent.devDependencies ?? {}
+        };
+        detectedVersion = detectFrameworkVersion(framework, dependencies);
+      } catch {
+      }
+    }
+  }
+  if (projectConfig.language === "typescript") {
+    indicators.push("TypeScript detected");
+  }
+  if (projectConfig.cssInJs.length > 0) {
+    indicators.push(`CSS-in-JS: ${projectConfig.cssInJs.join(", ")}`);
+  }
+  if (projectConfig.stateManagement.length > 0) {
+    indicators.push(`State Management: ${projectConfig.stateManagement.join(", ")}`);
+  }
+  if (projectConfig.buildTool) {
+    indicators.push(`Build Tool: ${projectConfig.buildTool}`);
+  }
+  return createResult(framework, confidence, indicators, detectedVersion, projectConfig);
 }
 
 // src/scanner/asset-detector.ts
-var import_glob = require("glob");
+var import_glob2 = require("glob");
 var import_path2 = require("path");
 var import_fs2 = require("fs");
 var IGNORED_PATTERNS = [
@@ -208,13 +782,13 @@ async function detectAssets(projectPath) {
   const jsPattern = `**/*.{${jsExtensionsStr}}`;
   const jsRootPattern = `*.{${jsExtensionsStr}}`;
   const [jsFiles, jsRootFiles] = await Promise.all([
-    (0, import_glob.glob)(jsPattern, {
+    (0, import_glob2.glob)(jsPattern, {
       cwd: projectPath,
       ignore: IGNORED_PATTERNS,
       absolute: true,
       nodir: true
     }),
-    (0, import_glob.glob)(jsRootPattern, {
+    (0, import_glob2.glob)(jsRootPattern, {
       cwd: projectPath,
       ignore: IGNORED_PATTERNS,
       absolute: true,
@@ -225,14 +799,14 @@ async function detectAssets(projectPath) {
   result.javascript.push(...allJsFiles);
   const cssExtensionsStr = CSS_EXTENSIONS.map((ext) => ext.slice(1)).join(",");
   const cssPattern = `**/*.{${cssExtensionsStr}}`;
-  const cssFiles = await (0, import_glob.glob)(cssPattern, {
+  const cssFiles = await (0, import_glob2.glob)(cssPattern, {
     cwd: projectPath,
     ignore: IGNORED_PATTERNS,
     absolute: false,
     nodir: true
   });
   const cssRootPattern = `*.{${cssExtensionsStr}}`;
-  const cssRootFiles = await (0, import_glob.glob)(cssRootPattern, {
+  const cssRootFiles = await (0, import_glob2.glob)(cssRootPattern, {
     cwd: projectPath,
     ignore: IGNORED_PATTERNS,
     absolute: false,
@@ -243,7 +817,7 @@ async function detectAssets(projectPath) {
   const imagePatterns = IMAGE_EXTENSIONS.flatMap((ext) => [`**/*${ext}`, `*${ext}`]);
   const allImageFiles = /* @__PURE__ */ new Set();
   for (const pattern of imagePatterns) {
-    const files = await (0, import_glob.glob)(pattern, {
+    const files = await (0, import_glob2.glob)(pattern, {
       cwd: projectPath,
       ignore: IGNORED_PATTERNS,
       absolute: false,
@@ -255,7 +829,7 @@ async function detectAssets(projectPath) {
   const fontPatterns = FONT_EXTENSIONS.flatMap((ext) => [`**/*${ext}`, `*${ext}`]);
   const allFontFiles = /* @__PURE__ */ new Set();
   for (const pattern of fontPatterns) {
-    const files = await (0, import_glob.glob)(pattern, {
+    const files = await (0, import_glob2.glob)(pattern, {
       cwd: projectPath,
       ignore: IGNORED_PATTERNS,
       absolute: false,
@@ -264,7 +838,7 @@ async function detectAssets(projectPath) {
     files.forEach((f) => allFontFiles.add(f));
   }
   result.fonts.push(...Array.from(allFontFiles).map((f) => (0, import_path2.join)(projectPath, f)));
-  const routeFiles = await (0, import_glob.glob)(`**/*{route,api,graphql}*.{js,ts,json}`, {
+  const routeFiles = await (0, import_glob2.glob)(`**/*{route,api,graphql}*.{js,ts,json}`, {
     cwd: projectPath,
     ignore: IGNORED_PATTERNS,
     absolute: false,
@@ -307,7 +881,7 @@ async function detectAssets(projectPath) {
 // src/scanner/architecture-detector.ts
 var import_fs3 = require("fs");
 var import_path3 = require("path");
-var import_glob2 = require("glob");
+var import_glob3 = require("glob");
 async function detectArchitecture(projectPath) {
   const indicators = [];
   let architecture = "static";
@@ -354,6 +928,26 @@ async function detectArchitecture(projectPath) {
         architecture = "ssr";
         confidence = "high";
         indicators.push("Nuxt detected \u2192 SSR");
+      } else if (dependencies["@sveltejs/kit"] || packageContent.dependencies?.["@sveltejs/kit"] || packageContent.devDependencies?.["@sveltejs/kit"]) {
+        architecture = "ssr";
+        confidence = "high";
+        indicators.push("SvelteKit detected \u2192 SSR");
+      } else if (dependencies["@remix-run/node"] || dependencies["@remix-run/react"] || packageContent.dependencies?.["@remix-run/node"] || packageContent.devDependencies?.["@remix-run/node"]) {
+        architecture = "ssr";
+        confidence = "high";
+        indicators.push("Remix detected \u2192 SSR");
+      } else if (dependencies.astro || packageContent.dependencies?.["astro"] || packageContent.devDependencies?.["astro"]) {
+        architecture = "ssr";
+        confidence = "high";
+        indicators.push("Astro detected \u2192 SSR");
+      } else if (dependencies.svelte && !dependencies["@sveltejs/kit"]) {
+        architecture = "spa";
+        confidence = "high";
+        indicators.push("Svelte detected \u2192 SPA");
+      } else if (dependencies["solid-js"] || packageContent.dependencies?.["solid-js"] || packageContent.devDependencies?.["solid-js"]) {
+        architecture = "spa";
+        confidence = "high";
+        indicators.push("SolidJS detected \u2192 SPA");
       }
     } catch {
     }
@@ -361,7 +955,7 @@ async function detectArchitecture(projectPath) {
   const htmlPatterns = ["**/*.html", "*.html", "index.html"];
   const allHtmlFiles = /* @__PURE__ */ new Set();
   for (const pattern of htmlPatterns) {
-    const files = await (0, import_glob2.glob)(pattern, {
+    const files = await (0, import_glob3.glob)(pattern, {
       cwd: projectPath,
       ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**"],
       absolute: false,
@@ -443,68 +1037,638 @@ async function detectArchitecture(projectPath) {
     } catch {
     }
   }
-  const jsFiles = await (0, import_glob2.glob)("**/*.{js,ts,tsx,jsx}", {
-    cwd: projectPath,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**", "**/*.test.*", "**/*.spec.*"],
-    absolute: false,
-    nodir: true
-  });
-  if (jsFiles.length > 0 && architecture === "static") {
-    let routerFilesFound = 0;
-    for (const jsFile of jsFiles.slice(0, 10)) {
-      try {
-        const jsPath = (0, import_path3.join)(projectPath, jsFile);
-        const jsContent = (0, import_fs3.readFileSync)(jsPath, "utf-8").toLowerCase();
-        const routerPatterns = [
-          /react-router/i,
-          /vue-router/i,
-          /@angular\/router/i,
-          /next\/router/i,
-          /nuxt/i,
-          /createBrowserRouter/i,
-          /BrowserRouter/i,
-          /Router/i
-        ];
-        if (routerPatterns.some((pattern) => pattern.test(jsContent))) {
-          routerFilesFound++;
-        }
-      } catch {
+  const jsFiles = await (0, import_glob3.glob)("**/*.{js,ts,tsx,jsx}", {
+    cwd: projectPath,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**", "**/*.test.*", "**/*.spec.*"],
+    absolute: false,
+    nodir: true
+  });
+  if (jsFiles.length > 0 && architecture === "static") {
+    let routerFilesFound = 0;
+    for (const jsFile of jsFiles.slice(0, 10)) {
+      try {
+        const jsPath = (0, import_path3.join)(projectPath, jsFile);
+        const jsContent = (0, import_fs3.readFileSync)(jsPath, "utf-8").toLowerCase();
+        const routerPatterns = [
+          /react-router/i,
+          /vue-router/i,
+          /@angular\/router/i,
+          /next\/router/i,
+          /nuxt/i,
+          /createBrowserRouter/i,
+          /BrowserRouter/i,
+          /Router/i
+        ];
+        if (routerPatterns.some((pattern) => pattern.test(jsContent))) {
+          routerFilesFound++;
+        }
+      } catch {
+      }
+    }
+    if (routerFilesFound > 0) {
+      indicators.push(`JS: router patterns found (${routerFilesFound} files)`);
+      if (architecture === "static") {
+        architecture = "spa";
+        confidence = confidence === "low" ? "medium" : confidence;
+      }
+    }
+  }
+  return { architecture, buildTool, confidence, indicators };
+}
+
+// src/scanner/cache.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_crypto = require("crypto");
+var DEFAULT_TTL = 24 * 60 * 60;
+var CACHE_VERSION = "1.0.0";
+var DEFAULT_CACHE_FILE = ".universal-pwa-cache.json";
+function hashFile(filePath) {
+  try {
+    if (!(0, import_fs4.existsSync)(filePath)) {
+      return null;
+    }
+    const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
+    return (0, import_crypto.createHash)("md5").update(content).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function hashDirectory(projectPath) {
+  const hashes = {};
+  const keyFiles = [
+    "package.json",
+    "composer.json",
+    "tsconfig.json",
+    "vite.config.js",
+    "vite.config.ts",
+    "webpack.config.js",
+    "rollup.config.js",
+    "next.config.js",
+    "nuxt.config.js",
+    "angular.json",
+    "wp-config.php",
+    "composer.lock",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml"
+  ];
+  for (const file of keyFiles) {
+    const filePath = (0, import_path4.join)(projectPath, file);
+    const hash = hashFile(filePath);
+    if (hash) {
+      hashes[file] = hash;
+    }
+  }
+  return hashes;
+}
+function loadCache(cacheFile = DEFAULT_CACHE_FILE) {
+  try {
+    if (!(0, import_fs4.existsSync)(cacheFile)) {
+      return null;
+    }
+    const content = (0, import_fs4.readFileSync)(cacheFile, "utf-8");
+    const parsed = JSON.parse(content);
+    const cache = parsed;
+    if (cache.version !== CACHE_VERSION) {
+      return null;
+    }
+    return cache;
+  } catch {
+    return null;
+  }
+}
+function saveCache(cache, cacheFile = DEFAULT_CACHE_FILE) {
+  try {
+    (0, import_fs4.writeFileSync)(cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(`Failed to save cache: ${message}`);
+  }
+}
+function generateCacheKey(projectPath) {
+  const normalizedPath = projectPath.replace(/\/$/, "");
+  return (0, import_crypto.createHash)("md5").update(normalizedPath).digest("hex");
+}
+function isCacheValid(projectPath, cache, options = {}) {
+  if (!cache || options.force) {
+    return false;
+  }
+  const cacheKey = generateCacheKey(projectPath);
+  const entry = cache.entries[cacheKey];
+  if (!entry) {
+    return false;
+  }
+  const entryTimestamp = new Date(entry.timestamp).getTime();
+  const now = Date.now();
+  const age = (now - entryTimestamp) / 1e3;
+  if (age > (options.ttl ?? entry.ttl ?? DEFAULT_TTL)) {
+    return false;
+  }
+  const currentHashes = hashDirectory(projectPath);
+  const cachedHashes = entry.fileHashes;
+  for (const [file, hash] of Object.entries(currentHashes)) {
+    if (cachedHashes[file] !== hash) {
+      return false;
+    }
+  }
+  for (const file of Object.keys(cachedHashes)) {
+    if (!(file in currentHashes) && (0, import_fs4.existsSync)((0, import_path4.join)(projectPath, file))) {
+      return false;
+    }
+  }
+  return true;
+}
+function getCachedResult(projectPath, cache) {
+  if (!cache) {
+    return null;
+  }
+  const cacheKey = generateCacheKey(projectPath);
+  const entry = cache.entries[cacheKey];
+  if (!entry) {
+    return null;
+  }
+  return entry.result;
+}
+function updateCache(projectPath, result, cache, options = {}) {
+  const cacheKey = generateCacheKey(projectPath);
+  const fileHashes = hashDirectory(projectPath);
+  const ttl = options.ttl ?? DEFAULT_TTL;
+  const newEntry = {
+    result,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    fileHashes,
+    ttl
+  };
+  const updatedCache = cache || {
+    version: CACHE_VERSION,
+    entries: {}
+  };
+  updatedCache.entries[cacheKey] = newEntry;
+  return updatedCache;
+}
+function cleanCache(cache, ttl = DEFAULT_TTL) {
+  if (!cache) {
+    return null;
+  }
+  const now = Date.now();
+  const cleanedEntries = {};
+  for (const [key, entry] of Object.entries(cache.entries)) {
+    const entryTimestamp = new Date(entry.timestamp).getTime();
+    const age = (now - entryTimestamp) / 1e3;
+    if (age <= (entry.ttl ?? ttl)) {
+      cleanedEntries[key] = entry;
+    }
+  }
+  if (Object.keys(cleanedEntries).length === 0) {
+    return null;
+  }
+  return {
+    version: cache.version,
+    entries: cleanedEntries
+  };
+}
+
+// src/scanner/optimizer.ts
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+var import_sharp = __toESM(require("sharp"), 1);
+function detectApiType(projectPath, assets) {
+  const indicators = [];
+  let hasRest = false;
+  let hasGraphQL = false;
+  const graphqlIndicators = [
+    "graphql",
+    "gql",
+    "apollo",
+    "relay",
+    "urql"
+  ];
+  const packageJsonPath = (0, import_path5.join)(projectPath, "package.json");
+  if ((0, import_fs5.existsSync)(packageJsonPath)) {
+    try {
+      const packageContent = JSON.parse((0, import_fs5.readFileSync)(packageJsonPath, "utf-8"));
+      const dependencies = {
+        ...packageContent.dependencies ?? {},
+        ...packageContent.devDependencies ?? {}
+      };
+      if (dependencies["graphql"] || dependencies["apollo-client"] || dependencies["@apollo/client"] || dependencies["relay-runtime"] || dependencies["urql"]) {
+        hasGraphQL = true;
+        indicators.push("GraphQL library detected");
+      }
+    } catch {
+    }
+  }
+  if (assets.apiRoutes.length > 0) {
+    hasRest = assets.apiRoutes.some((route) => route.includes("/api/") || route.includes("/rest/"));
+    if (assets.apiRoutes.some((route) => route.includes("/graphql"))) {
+      hasGraphQL = true;
+    }
+  }
+  if (assets.javascript.length > 0) {
+    const jsContent = assets.javascript.slice(0, 10).map((file) => {
+      try {
+        return (0, import_fs5.readFileSync)(file, "utf-8").toLowerCase();
+      } catch {
+        return "";
+      }
+    }).join(" ");
+    if (graphqlIndicators.some((ind) => jsContent.includes(ind))) {
+      hasGraphQL = true;
+      indicators.push("GraphQL usage in code");
+    }
+    if (jsContent.includes("/api/") || jsContent.includes("fetch(") || jsContent.includes("axios")) {
+      hasRest = true;
+      indicators.push("REST API usage in code");
+    }
+  }
+  if (hasGraphQL && hasRest) {
+    return "Mixed";
+  }
+  if (hasGraphQL) {
+    return "GraphQL";
+  }
+  if (hasRest) {
+    return "REST";
+  }
+  return "None";
+}
+function generateAdaptiveCacheStrategies(apiType, assets, configuration) {
+  const strategies = [];
+  if (apiType === "REST" || apiType === "Mixed") {
+    strategies.push({
+      urlPattern: "/api/.*",
+      handler: "NetworkFirst",
+      options: {
+        cacheName: "api-rest-cache",
+        expiration: {
+          maxEntries: 50,
+          maxAgeSeconds: 5 * 60
+          // 5 minutes pour REST
+        },
+        networkTimeoutSeconds: 3
+      }
+    });
+  }
+  if (apiType === "GraphQL" || apiType === "Mixed") {
+    strategies.push({
+      urlPattern: "/graphql",
+      handler: "NetworkFirst",
+      options: {
+        cacheName: "api-graphql-cache",
+        expiration: {
+          maxEntries: 30,
+          maxAgeSeconds: 2 * 60
+          // 2 minutes pour GraphQL (plus court car souvent mutations)
+        },
+        networkTimeoutSeconds: 5
+        // Plus long pour GraphQL
+      }
+    });
+  }
+  if (configuration.buildTool === "vite") {
+    strategies.push({
+      urlPattern: "/assets/.*",
+      handler: "CacheFirst",
+      options: {
+        cacheName: "vite-assets-cache",
+        expiration: {
+          maxEntries: 100,
+          maxAgeSeconds: 30 * 24 * 60 * 60
+          // 30 jours
+        }
+      }
+    });
+  } else if (configuration.buildTool === "webpack") {
+    strategies.push({
+      urlPattern: "/(static|_next|assets)/.*",
+      handler: "StaleWhileRevalidate",
+      options: {
+        cacheName: "webpack-assets-cache",
+        expiration: {
+          maxEntries: 100,
+          maxAgeSeconds: 7 * 24 * 60 * 60
+          // 7 jours
+        }
+      }
+    });
+  }
+  if (configuration.cssInJs.length > 0) {
+    strategies.push({
+      urlPattern: "/.*\\.css",
+      handler: "StaleWhileRevalidate",
+      options: {
+        cacheName: "css-cache",
+        expiration: {
+          maxEntries: 50,
+          maxAgeSeconds: 7 * 24 * 60 * 60
+          // 7 jours
+        }
+      }
+    });
+  }
+  return strategies;
+}
+function detectUnoptimizedImages(assets) {
+  const suggestions = [];
+  for (const imagePath of assets.images) {
+    try {
+      const stats = (0, import_fs5.statSync)(imagePath);
+      const sizeInMB = stats.size / (1024 * 1024);
+      const ext = imagePath.toLowerCase().split(".").pop();
+      if (sizeInMB > 1) {
+        suggestions.push({
+          file: imagePath,
+          suggestion: `Image > 1MB (${sizeInMB.toFixed(2)}MB). Consid\xE9rer compression ou conversion WebP.`,
+          priority: "high"
+        });
+      } else if (sizeInMB > 0.5) {
+        suggestions.push({
+          file: imagePath,
+          suggestion: `Image > 500KB (${sizeInMB.toFixed(2)}MB). Consid\xE9rer optimisation.`,
+          priority: "medium"
+        });
+      }
+      if (ext === "png" && sizeInMB > 0.1) {
+        suggestions.push({
+          file: imagePath,
+          suggestion: "PNG volumineux. Consid\xE9rer conversion WebP ou JPEG si pas de transparence.",
+          priority: "medium"
+        });
+      }
+      if (ext === "jpg" || ext === "jpeg") {
+        suggestions.push({
+          file: imagePath,
+          suggestion: "JPEG d\xE9tect\xE9. Consid\xE9rer conversion WebP pour meilleure compression.",
+          priority: "low"
+        });
+      }
+    } catch {
+    }
+  }
+  return suggestions;
+}
+async function generateResponsiveImageSizes(imagePath, outputDir, sizes = [320, 640, 768, 1024, 1280, 1920]) {
+  if (!(0, import_fs5.existsSync)(imagePath)) {
+    throw new Error(`Image not found: ${imagePath}`);
+  }
+  (0, import_fs5.mkdirSync)(outputDir, { recursive: true });
+  const generatedFiles = [];
+  const ext = (0, import_path5.extname)(imagePath);
+  const baseName = (0, import_path5.basename)(imagePath, ext);
+  const image = (0, import_sharp.default)(imagePath);
+  const metadata = await image.metadata();
+  if (!metadata.width || !metadata.height) {
+    throw new Error("Unable to read image dimensions");
+  }
+  const aspectRatio = metadata.width / metadata.height;
+  for (const width of sizes) {
+    if (width > metadata.width) {
+      continue;
+    }
+    const height = Math.round(width / aspectRatio);
+    const outputPath = (0, import_path5.join)(outputDir, `${baseName}-${width}w${ext}`);
+    try {
+      await image.clone().resize(width, height, {
+        fit: "cover",
+        position: "center"
+      }).toFile(outputPath);
+      generatedFiles.push(outputPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`Failed to generate responsive size ${width}w for ${imagePath}: ${message}`);
+    }
+  }
+  return generatedFiles;
+}
+async function optimizeImage(imagePath, options = {}) {
+  if (!(0, import_fs5.existsSync)(imagePath)) {
+    return null;
+  }
+  const {
+    convertToWebP = false,
+    quality = 85,
+    maxWidth,
+    outputDir = (0, import_path5.dirname)(imagePath)
+  } = options;
+  try {
+    const originalStats = (0, import_fs5.statSync)(imagePath);
+    const originalSize = originalStats.size;
+    const ext = (0, import_path5.extname)(imagePath).toLowerCase();
+    const baseName = (0, import_path5.basename)(imagePath, ext);
+    const image = (0, import_sharp.default)(imagePath);
+    const metadata = await image.metadata();
+    if (!metadata.width || !metadata.height) {
+      return null;
+    }
+    const optimizedFiles = [];
+    let totalOptimizedSize = 0;
+    const outputFormat = convertToWebP && ext !== ".webp" ? "webp" : ext.slice(1);
+    const outputExt = outputFormat === "webp" ? ".webp" : ext;
+    const outputPath = (0, import_path5.join)(outputDir, `${baseName}${outputExt}`);
+    (0, import_fs5.mkdirSync)(outputDir, { recursive: true });
+    let pipeline = image.clone();
+    if (maxWidth && metadata.width > maxWidth) {
+      const aspectRatio = metadata.width / metadata.height;
+      const newHeight = Math.round(maxWidth / aspectRatio);
+      pipeline = pipeline.resize(maxWidth, newHeight, {
+        fit: "cover",
+        position: "center"
+      });
+    }
+    if (outputFormat === "webp") {
+      pipeline = pipeline.webp({ quality });
+    } else if (outputFormat === "png") {
+      pipeline = pipeline.png({ quality, compressionLevel: 9 });
+    } else if (outputFormat === "jpg" || outputFormat === "jpeg") {
+      pipeline = pipeline.jpeg({ quality, mozjpeg: true });
+    }
+    await pipeline.toFile(outputPath);
+    optimizedFiles.push(outputPath);
+    const optimizedStats = (0, import_fs5.statSync)(outputPath);
+    totalOptimizedSize = optimizedStats.size;
+    const savings = (originalSize - totalOptimizedSize) / originalSize * 100;
+    return {
+      original: imagePath,
+      optimized: optimizedFiles,
+      format: outputFormat,
+      originalSize,
+      optimizedSize: totalOptimizedSize,
+      savings: Math.max(0, savings)
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.warn(`Failed to optimize image ${imagePath}: ${message}`);
+    return null;
+  }
+}
+async function optimizeProjectImages(assets, options = {}) {
+  const results = [];
+  const highPriorityImages = detectUnoptimizedImages(assets).filter((s) => s.priority === "high");
+  const imagesToOptimize = highPriorityImages.length > 0 ? highPriorityImages.map((s) => s.file) : assets.images.slice(0, 10);
+  for (const imagePath of imagesToOptimize) {
+    try {
+      const result = await optimizeImage(imagePath, {
+        ...options,
+        convertToWebP: true,
+        // Par défaut, convertir en WebP
+        quality: 85
+      });
+      if (result && result.savings > 0) {
+        results.push(result);
       }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`Skipped optimization for ${imagePath}: ${message}`);
     }
-    if (routerFilesFound > 0) {
-      indicators.push(`JS: router patterns found (${routerFilesFound} files)`);
-      if (architecture === "static") {
-        architecture = "spa";
-        confidence = confidence === "low" ? "medium" : confidence;
+  }
+  return results;
+}
+function generateOptimalShortName(name) {
+  if (!name || name.trim().length === 0) {
+    return "PWA";
+  }
+  const cleanName = name.trim();
+  if (cleanName.length <= 12) {
+    return cleanName;
+  }
+  const words = cleanName.split(/[\s\-_]+/).filter((w) => w.length > 0);
+  if (words.length > 1) {
+    const initials = words.map((w) => w[0].toUpperCase()).join("");
+    if (initials.length <= 12) {
+      return initials;
+    }
+  }
+  const stopWords = ["the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "by"];
+  const significantWords = words.filter((w) => !stopWords.includes(w.toLowerCase()));
+  if (significantWords.length > 0) {
+    const firstWord = significantWords[0];
+    if (firstWord.length <= 12) {
+      return firstWord.substring(0, 12);
+    }
+    return firstWord.substring(0, 12);
+  }
+  return cleanName.substring(0, 12);
+}
+function detectDominantColors(_imagePath) {
+  return null;
+}
+function suggestManifestColors(projectPath, framework, iconSource) {
+  if (iconSource) {
+    const iconPath = (0, import_fs5.existsSync)(iconSource) ? iconSource : (0, import_path5.join)(projectPath, iconSource);
+    if ((0, import_fs5.existsSync)(iconPath)) {
+      const colors = detectDominantColors(iconPath);
+      if (colors) {
+        return colors;
       }
     }
   }
-  return { architecture, buildTool, confidence, indicators };
+  const frameworkColors = {
+    react: { themeColor: "#61dafb", backgroundColor: "#282c34" },
+    vue: { themeColor: "#42b983", backgroundColor: "#ffffff" },
+    angular: { themeColor: "#dd0031", backgroundColor: "#ffffff" },
+    nextjs: { themeColor: "#000000", backgroundColor: "#ffffff" },
+    nuxt: { themeColor: "#00dc82", backgroundColor: "#ffffff" },
+    svelte: { themeColor: "#ff3e00", backgroundColor: "#ffffff" },
+    wordpress: { themeColor: "#21759b", backgroundColor: "#ffffff" },
+    symfony: { themeColor: "#000000", backgroundColor: "#ffffff" },
+    laravel: { themeColor: "#ff2d20", backgroundColor: "#ffffff" }
+  };
+  if (framework && frameworkColors[framework.toLowerCase()]) {
+    return frameworkColors[framework.toLowerCase()];
+  }
+  return { themeColor: "#ffffff", backgroundColor: "#000000" };
+}
+async function optimizeProject(projectPath, assets, configuration, framework, iconSource, autoOptimizeImages = false) {
+  const apiType = detectApiType(projectPath, assets);
+  const cacheStrategies = generateAdaptiveCacheStrategies(apiType, assets, configuration);
+  const assetSuggestions = detectUnoptimizedImages(assets);
+  let optimizedImages;
+  if (autoOptimizeImages && assets.images.length > 0) {
+    optimizedImages = await optimizeProjectImages(assets, {
+      convertToWebP: true,
+      quality: 85
+    });
+  }
+  const manifestColors = suggestManifestColors(projectPath, framework, iconSource);
+  return {
+    cacheStrategies,
+    manifestConfig: {
+      themeColor: manifestColors.themeColor,
+      backgroundColor: manifestColors.backgroundColor
+    },
+    assetSuggestions,
+    apiType,
+    optimizedImages
+  };
 }
 
 // src/scanner/index.ts
 async function scanProject(options) {
-  const { projectPath, includeAssets = true, includeArchitecture = true } = options;
+  const {
+    projectPath,
+    includeAssets = true,
+    includeArchitecture = true,
+    useCache = true,
+    cacheFile,
+    forceScan = false
+  } = options;
+  const cacheFilePath = cacheFile ?? (0, import_path6.join)(projectPath, ".universal-pwa-cache.json");
+  let cache = useCache ? loadCache(cacheFilePath) : null;
+  if (cache) {
+    cache = cleanCache(cache) ?? null;
+    if (cache) {
+      saveCache(cache, cacheFilePath);
+    }
+  }
+  if (useCache && !forceScan && cache) {
+    const cacheOptions = {
+      force: forceScan
+    };
+    if (isCacheValid(projectPath, cache, cacheOptions)) {
+      const cachedResult = getCachedResult(projectPath, cache);
+      if (cachedResult) {
+        return cachedResult;
+      }
+    }
+  }
   const frameworkCandidate = detectFramework(projectPath);
-  const framework = isFrameworkDetectionResult(frameworkCandidate) ? frameworkCandidate : { framework: null, confidence: "low", indicators: [] };
+  const framework = isFrameworkDetectionResult(frameworkCandidate) ? frameworkCandidate : {
+    framework: null,
+    confidence: "low",
+    confidenceScore: 0,
+    indicators: [],
+    version: null,
+    configuration: {
+      language: null,
+      cssInJs: [],
+      stateManagement: [],
+      buildTool: null
+    }
+  };
   const assetsCandidate = includeAssets ? await detectAssets(projectPath) : getEmptyAssets();
   const assets = isAssetDetectionResult(assetsCandidate) ? assetsCandidate : getEmptyAssets();
   const architectureCandidate = includeArchitecture ? await detectArchitecture(projectPath) : getEmptyArchitecture();
   const architecture = isArchitectureDetectionResult(architectureCandidate) ? architectureCandidate : getEmptyArchitecture();
-  return {
+  const result = {
     framework,
     assets,
     architecture,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     projectPath
   };
+  if (useCache) {
+    const updatedCache = updateCache(projectPath, result, cache);
+    saveCache(updatedCache, cacheFilePath);
+  }
+  return result;
 }
 function generateReport(result) {
   return JSON.stringify(result, null, 2);
 }
 function validateProjectPath(projectPath) {
   try {
-    return (0, import_fs4.existsSync)(projectPath);
+    return (0, import_fs6.existsSync)(projectPath);
   } catch {
     return false;
   }
@@ -512,7 +1676,18 @@ function validateProjectPath(projectPath) {
 function isFrameworkDetectionResult(value) {
   if (!value || typeof value !== "object") return false;
   const v = value;
-  return (v.framework === null || typeof v.framework === "string") && (v.confidence === "low" || v.confidence === "medium" || v.confidence === "high") && Array.isArray(v.indicators);
+  const isValidVersion = (ver) => {
+    if (ver === null) return true;
+    if (typeof ver !== "object") return false;
+    const vv = ver;
+    return typeof vv.major === "number" && (vv.minor === null || typeof vv.minor === "number") && (vv.patch === null || typeof vv.patch === "number") && typeof vv.raw === "string";
+  };
+  const isValidConfiguration = (config) => {
+    if (!config || typeof config !== "object") return false;
+    const cfg = config;
+    return (cfg.language === null || cfg.language === "typescript" || cfg.language === "javascript") && Array.isArray(cfg.cssInJs) && Array.isArray(cfg.stateManagement) && (cfg.buildTool === null || typeof cfg.buildTool === "string");
+  };
+  return (v.framework === null || typeof v.framework === "string") && (v.confidence === "low" || v.confidence === "medium" || v.confidence === "high") && (typeof v.confidenceScore === "number" && v.confidenceScore >= 0 && v.confidenceScore <= 100) && Array.isArray(v.indicators) && (v.version === null || isValidVersion(v.version)) && (v.configuration !== void 0 && isValidConfiguration(v.configuration));
 }
 function isAssetDetectionResult(value) {
   if (!value || typeof value !== "object") return false;
@@ -548,8 +1723,8 @@ function getEmptyArchitecture() {
 
 // src/generator/manifest-generator.ts
 var import_zod = require("zod");
-var import_fs5 = require("fs");
-var import_path4 = require("path");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 var ManifestIconSchema = import_zod.z.object({
   src: import_zod.z.string(),
   sizes: import_zod.z.string(),
@@ -584,7 +1759,7 @@ function generateManifest(options) {
   if (options.shortName && typeof options.shortName === "string" && options.shortName.trim().length > 0) {
     shortName = options.shortName.trim().substring(0, 12);
   } else if (options.name && typeof options.name === "string" && options.name.length > 0) {
-    shortName = options.name.substring(0, 12);
+    shortName = generateOptimalShortName(options.name);
   }
   if (!shortName || shortName.trim().length === 0) {
     shortName = "PWA";
@@ -627,10 +1802,10 @@ function generateManifest(options) {
   return ManifestSchema.parse(manifest);
 }
 function writeManifest(manifest, outputDir) {
-  const manifestPath = (0, import_path4.join)(outputDir, "manifest.json");
+  const manifestPath = (0, import_path7.join)(outputDir, "manifest.json");
   const validatedManifest = ManifestSchema.parse(manifest);
   const manifestJson = JSON.stringify(validatedManifest, null, 2);
-  (0, import_fs5.writeFileSync)(manifestPath, manifestJson, { encoding: "utf8" });
+  (0, import_fs7.writeFileSync)(manifestPath, manifestJson, { encoding: "utf8" });
   return manifestPath;
 }
 function generateAndWriteManifest(options, outputDir) {
@@ -639,9 +1814,9 @@ function generateAndWriteManifest(options, outputDir) {
 }
 
 // src/generator/icon-generator.ts
-var import_sharp = __toESM(require("sharp"), 1);
-var import_fs6 = require("fs");
-var import_path5 = require("path");
+var import_sharp2 = __toESM(require("sharp"), 1);
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 var STANDARD_ICON_SIZES = [
   { width: 72, height: 72, name: "icon-72x72.png" },
   { width: 96, height: 96, name: "icon-96x96.png" },
@@ -677,20 +1852,20 @@ async function generateIcons(options) {
     format = "png",
     quality = 90
   } = options;
-  if (!(0, import_fs6.existsSync)(sourceImage)) {
+  if (!(0, import_fs8.existsSync)(sourceImage)) {
     throw new Error(`Source image not found: ${sourceImage}`);
   }
-  (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
+  (0, import_fs8.mkdirSync)(outputDir, { recursive: true });
   const generatedFiles = [];
   const icons = [];
   const splashScreens = [];
-  const image = (0, import_sharp.default)(sourceImage);
+  const image = (0, import_sharp2.default)(sourceImage);
   const metadata = await image.metadata();
   if (!metadata.width || !metadata.height) {
     throw new Error("Unable to read image dimensions");
   }
   for (const size of iconSizes) {
-    const outputPath = (0, import_path5.join)(outputDir, size.name);
+    const outputPath = (0, import_path8.join)(outputDir, size.name);
     try {
       let pipeline = image.clone().resize(size.width, size.height, {
         fit: "cover",
@@ -715,7 +1890,7 @@ async function generateIcons(options) {
     }
   }
   for (const size of splashSizes) {
-    const outputPath = (0, import_path5.join)(outputDir, size.name);
+    const outputPath = (0, import_path8.join)(outputDir, size.name);
     try {
       let pipeline = image.clone().resize(size.width, size.height, {
         fit: "cover",
@@ -740,7 +1915,7 @@ async function generateIcons(options) {
   }
   if (format === "png") {
     try {
-      const appleIconPath = (0, import_path5.join)(outputDir, "apple-touch-icon.png");
+      const appleIconPath = (0, import_path8.join)(outputDir, "apple-touch-icon.png");
       await image.clone().resize(180, 180, {
         fit: "cover",
         position: "center"
@@ -778,13 +1953,13 @@ async function generateSplashScreensOnly(options) {
   };
 }
 async function generateFavicon(sourceImage, outputDir) {
-  if (!(0, import_fs6.existsSync)(sourceImage)) {
+  if (!(0, import_fs8.existsSync)(sourceImage)) {
     throw new Error(`Source image not found: ${sourceImage}`);
   }
-  (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
-  const faviconPath = (0, import_path5.join)(outputDir, "favicon.ico");
+  (0, import_fs8.mkdirSync)(outputDir, { recursive: true });
+  const faviconPath = (0, import_path8.join)(outputDir, "favicon.ico");
   try {
-    await (0, import_sharp.default)(sourceImage).resize(32, 32, {
+    await (0, import_sharp2.default)(sourceImage).resize(32, 32, {
       fit: "cover",
       position: "center"
     }).png().toFile(faviconPath);
@@ -795,13 +1970,13 @@ async function generateFavicon(sourceImage, outputDir) {
   }
 }
 async function generateAppleTouchIcon(sourceImage, outputDir) {
-  if (!(0, import_fs6.existsSync)(sourceImage)) {
+  if (!(0, import_fs8.existsSync)(sourceImage)) {
     throw new Error(`Source image not found: ${sourceImage}`);
   }
-  (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
-  const appleIconPath = (0, import_path5.join)(outputDir, "apple-touch-icon.png");
+  (0, import_fs8.mkdirSync)(outputDir, { recursive: true });
+  const appleIconPath = (0, import_path8.join)(outputDir, "apple-touch-icon.png");
   try {
-    await (0, import_sharp.default)(sourceImage).resize(180, 180, {
+    await (0, import_sharp2.default)(sourceImage).resize(180, 180, {
       fit: "cover",
       position: "center"
     }).png({ quality: 90, compressionLevel: 9 }).toFile(appleIconPath);
@@ -814,8 +1989,8 @@ async function generateAppleTouchIcon(sourceImage, outputDir) {
 
 // src/generator/service-worker-generator.ts
 var import_workbox_build = require("workbox-build");
-var import_fs7 = require("fs");
-var import_path6 = require("path");
+var import_fs9 = require("fs");
+var import_path9 = require("path");
 var import_universal_pwa_templates = require("@julien-lin/universal-pwa-templates");
 async function generateServiceWorker(options) {
   const {
@@ -829,12 +2004,12 @@ async function generateServiceWorker(options) {
     swDest = "sw.js",
     offlinePage
   } = options;
-  (0, import_fs7.mkdirSync)(outputDir, { recursive: true });
+  (0, import_fs9.mkdirSync)(outputDir, { recursive: true });
   const finalTemplateType = templateType ?? (0, import_universal_pwa_templates.determineTemplateType)(architecture, framework ?? null);
   const template = (0, import_universal_pwa_templates.getServiceWorkerTemplate)(finalTemplateType);
-  const swSrcPath = (0, import_path6.join)(outputDir, "sw-src.js");
-  (0, import_fs7.writeFileSync)(swSrcPath, template.content, "utf-8");
-  const swDestPath = (0, import_path6.join)(outputDir, swDest);
+  const swSrcPath = (0, import_path9.join)(outputDir, "sw-src.js");
+  (0, import_fs9.writeFileSync)(swSrcPath, template.content, "utf-8");
+  const swDestPath = (0, import_path9.join)(outputDir, swDest);
   const workboxConfig = {
     globDirectory: globDirectory ?? projectPath,
     globPatterns,
@@ -849,7 +2024,7 @@ async function generateServiceWorker(options) {
   try {
     const result = await (0, import_workbox_build.injectManifest)(workboxConfig);
     try {
-      if ((0, import_fs7.existsSync)(swSrcPath)) {
+      if ((0, import_fs9.existsSync)(swSrcPath)) {
       }
     } catch {
     }
@@ -879,8 +2054,8 @@ async function generateSimpleServiceWorker(options) {
     clientsClaim = true,
     runtimeCaching
   } = options;
-  (0, import_fs7.mkdirSync)(outputDir, { recursive: true });
-  const swDestPath = (0, import_path6.join)(outputDir, swDest);
+  (0, import_fs9.mkdirSync)(outputDir, { recursive: true });
+  const swDestPath = (0, import_path9.join)(outputDir, swDest);
   const workboxConfig = {
     globDirectory: globDirectory ?? projectPath,
     globPatterns,
@@ -934,8 +2109,8 @@ async function generateAndWriteServiceWorker(options) {
 }
 
 // src/generator/https-checker.ts
-var import_fs8 = require("fs");
-var import_path7 = require("path");
+var import_fs10 = require("fs");
+var import_path10 = require("path");
 function checkHttps(url, allowHttpLocalhost = true) {
   let parsedUrl;
   try {
@@ -990,30 +2165,30 @@ function detectProjectUrl(projectPath) {
     { file: "next.config.ts", pattern: /baseUrl.*["'](.+)["']/ }
   ];
   for (const config of configFiles) {
-    const filePath = (0, import_path7.join)(projectPath, config.file);
-    if ((0, import_fs8.existsSync)(filePath)) {
+    const filePath = (0, import_path10.join)(projectPath, config.file);
+    if ((0, import_fs10.existsSync)(filePath)) {
       try {
         if (config.file.endsWith(".json") && config.key) {
-          const parsed = JSON.parse((0, import_fs8.readFileSync)(filePath, "utf-8"));
+          const parsed = JSON.parse((0, import_fs10.readFileSync)(filePath, "utf-8"));
           const content = parsed;
           const value = content[config.key];
           if (value && typeof value === "string") {
             return value;
           }
         } else if (config.file.endsWith(".toml") && config.pattern) {
-          const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+          const content = (0, import_fs10.readFileSync)(filePath, "utf-8");
           const match = config.pattern ? content.match(config.pattern) : null;
           if (match && match[1]) {
             return match[1];
           }
         } else if ((config.file.endsWith(".js") || config.file.endsWith(".ts")) && config.pattern) {
-          const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+          const content = (0, import_fs10.readFileSync)(filePath, "utf-8");
           const match = config.pattern ? content.match(config.pattern) : null;
           if (match && match[1]) {
             return match[1];
           }
         } else if (config.file.startsWith(".env") && config.pattern) {
-          const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+          const content = (0, import_fs10.readFileSync)(filePath, "utf-8");
           const lines = content.split("\n");
           for (const line of lines) {
             const match = config.pattern ? line.match(config.pattern) : null;
@@ -1052,9 +2227,9 @@ function checkProjectHttps(options = {}) {
 
 // src/injector/html-parser.ts
 var import_htmlparser2 = require("htmlparser2");
-var import_fs9 = require("fs");
+var import_fs11 = require("fs");
 function parseHTMLFile(filePath, options = {}) {
-  const content = (0, import_fs9.readFileSync)(filePath, "utf-8");
+  const content = (0, import_fs11.readFileSync)(filePath, "utf-8");
   return parseHTML(content, options);
 }
 function parseHTML(htmlContent, options = {}) {
@@ -1188,7 +2363,7 @@ function serializeHTML(parsed) {
 }
 
 // src/injector/meta-injector.ts
-var import_fs10 = require("fs");
+var import_fs12 = require("fs");
 var import_dom_serializer = require("dom-serializer");
 function injectMetaTags(htmlContent, options = {}) {
   const parsed = parseHTML(htmlContent);
@@ -1283,6 +2458,31 @@ function injectMetaTags(htmlContent, options = {}) {
       result.skipped.push("apple-mobile-web-app-title (already exists)");
     }
   }
+  let body = parsed.body;
+  const originalBodyExists = !!body;
+  if (!body) {
+    if (parsed.html) {
+      const bodyElement = {
+        type: "tag",
+        name: "body",
+        tagName: "body",
+        attribs: {},
+        children: [],
+        parent: parsed.html,
+        next: null,
+        prev: null
+      };
+      if (parsed.html.children) {
+        parsed.html.children.push(bodyElement);
+      } else {
+        parsed.html.children = [bodyElement];
+      }
+      body = bodyElement;
+      result.warnings.push("Created <body> tag (was missing)");
+    } else {
+      result.warnings.push("No <html> or <body> tag found, scripts may not be injected correctly");
+    }
+  }
   let modifiedHtml = (0, import_dom_serializer.render)(parsed.document, { decodeEntities: false });
   if (options.serviceWorkerPath) {
     const swPath = options.serviceWorkerPath.startsWith("/") ? options.serviceWorkerPath : `/${options.serviceWorkerPath}`;
@@ -1304,7 +2504,9 @@ let deferredPrompt = null;
 let isInstalled = false;
 
 // Check if app is already installed
-if (window.matchMedia('(display-mode: standalone)').matches || window.navigator.standalone === true) {
+if (typeof window.matchMedia === 'function' && window.matchMedia('(display-mode: standalone)').matches) {
+  isInstalled = true;
+} else if (window.navigator.standalone === true) {
   isInstalled = true;
 }
 
@@ -1352,7 +2554,14 @@ window.installPWA = function() {
 
 // Expose global check function
 window.isPWAInstalled = function() {
-  return isInstalled || window.matchMedia('(display-mode: standalone)').matches || window.navigator.standalone === true;
+  if (isInstalled) return true;
+  if (typeof window.matchMedia === 'function' && window.matchMedia('(display-mode: standalone)').matches) {
+    return true;
+  }
+  if (window.navigator.standalone === true) {
+    return true;
+  }
+  return false;
 };
 
 // Expose global check if installable
@@ -1360,11 +2569,16 @@ window.isPWAInstallable = function() {
   return deferredPrompt !== null;
 };
 </script>`;
-      if (modifiedHtml.includes("</body>")) {
-        modifiedHtml = modifiedHtml.replace("</body>", `${swScript}
-</body>`);
+      const lastBodyIndex = modifiedHtml.lastIndexOf("</body>");
+      if (lastBodyIndex !== -1 && originalBodyExists) {
+        modifiedHtml = modifiedHtml.slice(0, lastBodyIndex) + swScript + "\n" + modifiedHtml.slice(lastBodyIndex);
+      } else if (modifiedHtml.includes("</html>")) {
+        const htmlIndex = modifiedHtml.lastIndexOf("</html>");
+        modifiedHtml = modifiedHtml.slice(0, htmlIndex) + swScript + "\n</body>\n" + modifiedHtml.slice(htmlIndex);
+        result.warnings.push("Injected script before </html> (no </body> found)");
       } else {
-        modifiedHtml = `${modifiedHtml}${swScript}`;
+        modifiedHtml = modifiedHtml + swScript;
+        result.warnings.push("Injected script at end of file (no </body> or </html> found)");
       }
       result.injected.push("Service Worker registration script");
       result.injected.push("PWA install handler script");
@@ -1377,7 +2591,9 @@ let deferredPrompt = null;
 let isInstalled = false;
 
 // Check if app is already installed
-if (window.matchMedia('(display-mode: standalone)').matches || window.navigator.standalone === true) {
+if (typeof window.matchMedia === 'function' && window.matchMedia('(display-mode: standalone)').matches) {
+  isInstalled = true;
+} else if (window.navigator.standalone === true) {
   isInstalled = true;
 }
 
@@ -1410,18 +2626,30 @@ window.installPWA = function() {
 };
 
 window.isPWAInstalled = function() {
-  return isInstalled || window.matchMedia('(display-mode: standalone)').matches || window.navigator.standalone === true;
+  if (isInstalled) return true;
+  if (typeof window.matchMedia === 'function' && window.matchMedia('(display-mode: standalone)').matches) {
+    return true;
+  }
+  if (window.navigator.standalone === true) {
+    return true;
+  }
+  return false;
 };
 
 window.isPWAInstallable = function() {
   return deferredPrompt !== null;
 };
 </script>`;
-        if (modifiedHtml.includes("</body>")) {
-          modifiedHtml = modifiedHtml.replace("</body>", `${installScript}
-</body>`);
+        const lastBodyIndex = modifiedHtml.lastIndexOf("</body>");
+        if (lastBodyIndex !== -1 && originalBodyExists) {
+          modifiedHtml = modifiedHtml.slice(0, lastBodyIndex) + installScript + "\n" + modifiedHtml.slice(lastBodyIndex);
+        } else if (modifiedHtml.includes("</html>")) {
+          const htmlIndex = modifiedHtml.lastIndexOf("</html>");
+          modifiedHtml = modifiedHtml.slice(0, htmlIndex) + installScript + "\n</body>\n" + modifiedHtml.slice(htmlIndex);
+          result.warnings.push("Injected install script before </html> (no </body> found)");
         } else {
           modifiedHtml = `${modifiedHtml}${installScript}`;
+          result.warnings.push("Injected install script at end of file (no </body> or </html> found)");
         }
         result.injected.push("PWA install handler script");
       } else {
@@ -1483,7 +2711,436 @@ function escapeJavaScriptString(str) {
 function injectMetaTagsInFile(filePath, options = {}) {
   const parsed = parseHTMLFile(filePath);
   const { html, result } = injectMetaTags(parsed.originalContent, options);
-  (0, import_fs10.writeFileSync)(filePath, html, "utf-8");
+  (0, import_fs12.writeFileSync)(filePath, html, "utf-8");
+  return result;
+}
+
+// src/validator/pwa-validator.ts
+var import_fs13 = require("fs");
+var import_path11 = require("path");
+var import_promises = require("fs/promises");
+function validateManifest(projectPath, outputDir) {
+  const errors = [];
+  const manifestPath = (0, import_path11.join)(outputDir, "manifest.json");
+  if (!(0, import_fs13.existsSync)(manifestPath)) {
+    return {
+      exists: false,
+      valid: false,
+      errors: [
+        {
+          code: "MANIFEST_MISSING",
+          message: "manifest.json is missing",
+          severity: "error",
+          file: manifestPath,
+          suggestion: "Generate manifest.json using universal-pwa init"
+        }
+      ]
+    };
+  }
+  try {
+    const manifestContent = (0, import_fs13.readFileSync)(manifestPath, "utf-8");
+    const manifest = JSON.parse(manifestContent);
+    if (!manifest.name || manifest.name.trim().length === 0) {
+      errors.push({
+        code: "MANIFEST_NAME_MISSING",
+        message: 'manifest.json: "name" field is required',
+        severity: "error",
+        file: manifestPath
+      });
+    }
+    if (!manifest.short_name || manifest.short_name.trim().length === 0) {
+      errors.push({
+        code: "MANIFEST_SHORT_NAME_MISSING",
+        message: 'manifest.json: "short_name" field is required',
+        severity: "error",
+        file: manifestPath
+      });
+    } else if (manifest.short_name.length > 12) {
+      errors.push({
+        code: "MANIFEST_SHORT_NAME_TOO_LONG",
+        message: `manifest.json: "short_name" must be \u2264 12 characters (current: ${manifest.short_name.length})`,
+        severity: "error",
+        file: manifestPath,
+        suggestion: "Shorten the short_name to 12 characters or less"
+      });
+    }
+    if (!manifest.icons || manifest.icons.length === 0) {
+      errors.push({
+        code: "MANIFEST_ICONS_MISSING",
+        message: 'manifest.json: "icons" array is required and must contain at least one icon',
+        severity: "error",
+        file: manifestPath,
+        suggestion: "Generate icons using universal-pwa init --icon-source <path>"
+      });
+    }
+    if (!manifest.start_url) {
+      errors.push({
+        code: "MANIFEST_START_URL_MISSING",
+        message: 'manifest.json: "start_url" field is required',
+        severity: "error",
+        file: manifestPath
+      });
+    }
+    if (!manifest.display) {
+      errors.push({
+        code: "MANIFEST_DISPLAY_MISSING",
+        message: 'manifest.json: "display" field is required',
+        severity: "error",
+        file: manifestPath
+      });
+    }
+    if (!manifest.theme_color) {
+      errors.push({
+        code: "MANIFEST_THEME_COLOR_MISSING",
+        message: 'manifest.json: "theme_color" is recommended for PWA installability',
+        severity: "warning",
+        file: manifestPath,
+        suggestion: "Add theme_color to manifest.json"
+      });
+    }
+    if (!manifest.background_color) {
+      errors.push({
+        code: "MANIFEST_BACKGROUND_COLOR_MISSING",
+        message: 'manifest.json: "background_color" is recommended for PWA installability',
+        severity: "warning",
+        file: manifestPath,
+        suggestion: "Add background_color to manifest.json"
+      });
+    }
+    return {
+      exists: true,
+      valid: errors.filter((e) => e.severity === "error").length === 0,
+      manifest,
+      errors
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      exists: true,
+      valid: false,
+      errors: [
+        {
+          code: "MANIFEST_INVALID_JSON",
+          message: `manifest.json is invalid JSON: ${errorMessage}`,
+          severity: "error",
+          file: manifestPath,
+          suggestion: "Fix JSON syntax errors in manifest.json"
+        }
+      ]
+    };
+  }
+}
+function validateIcons(projectPath, outputDir, manifest) {
+  const errors = [];
+  let has192x192 = false;
+  let has512x512 = false;
+  if (!manifest || !manifest.icons || manifest.icons.length === 0) {
+    return {
+      exists: false,
+      valid: false,
+      has192x192: false,
+      has512x512: false,
+      errors: [
+        {
+          code: "ICONS_MANIFEST_MISSING",
+          message: "Icons cannot be validated: manifest.json icons array is missing",
+          severity: "error"
+        }
+      ]
+    };
+  }
+  for (const icon of manifest.icons) {
+    const iconPath = icon.src.startsWith("/") ? icon.src.substring(1) : icon.src;
+    const fullIconPath = (0, import_path11.join)(outputDir, iconPath);
+    if (!(0, import_fs13.existsSync)(fullIconPath)) {
+      errors.push({
+        code: "ICON_FILE_MISSING",
+        message: `Icon file not found: ${iconPath}`,
+        severity: "error",
+        file: fullIconPath,
+        suggestion: `Ensure ${iconPath} exists in ${outputDir}`
+      });
+      continue;
+    }
+    if (icon.sizes.includes("192x192") || icon.sizes === "192x192") {
+      has192x192 = true;
+    }
+    if (icon.sizes.includes("512x512") || icon.sizes === "512x512") {
+      has512x512 = true;
+    }
+  }
+  if (!has192x192) {
+    errors.push({
+      code: "ICON_192X192_MISSING",
+      message: "Icon 192x192 is required for PWA installability",
+      severity: "error",
+      suggestion: "Generate a 192x192 icon using universal-pwa init --icon-source <path>"
+    });
+  }
+  if (!has512x512) {
+    errors.push({
+      code: "ICON_512X512_MISSING",
+      message: "Icon 512x512 is required for PWA installability",
+      severity: "error",
+      suggestion: "Generate a 512x512 icon using universal-pwa init --icon-source <path>"
+    });
+  }
+  return {
+    exists: manifest.icons.length > 0,
+    valid: errors.filter((e) => e.severity === "error").length === 0 && has192x192 && has512x512,
+    has192x192,
+    has512x512,
+    errors
+  };
+}
+function validateServiceWorker(projectPath, outputDir) {
+  const errors = [];
+  const swPath = (0, import_path11.join)(outputDir, "sw.js");
+  if (!(0, import_fs13.existsSync)(swPath)) {
+    return {
+      exists: false,
+      valid: false,
+      errors: [
+        {
+          code: "SERVICE_WORKER_MISSING",
+          message: "Service worker (sw.js) is missing",
+          severity: "error",
+          file: swPath,
+          suggestion: "Generate service worker using universal-pwa init"
+        }
+      ]
+    };
+  }
+  try {
+    const swContent = (0, import_fs13.readFileSync)(swPath, "utf-8");
+    if (!swContent.includes("workbox") && !swContent.includes("serviceWorker")) {
+      errors.push({
+        code: "SERVICE_WORKER_INVALID",
+        message: "Service worker does not appear to be a valid Workbox service worker",
+        severity: "warning",
+        file: swPath,
+        suggestion: "Ensure service worker is generated using Workbox"
+      });
+    }
+    if (!swContent.includes("precache") && !swContent.includes("precacheAndRoute")) {
+      errors.push({
+        code: "SERVICE_WORKER_NO_PRECACHE",
+        message: "Service worker does not appear to have precaching configured",
+        severity: "warning",
+        file: swPath,
+        suggestion: "Ensure service worker includes precaching for offline support"
+      });
+    }
+    return {
+      exists: true,
+      valid: errors.filter((e) => e.severity === "error").length === 0,
+      errors
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      exists: true,
+      valid: false,
+      errors: [
+        {
+          code: "SERVICE_WORKER_READ_ERROR",
+          message: `Failed to read service worker: ${errorMessage}`,
+          severity: "error",
+          file: swPath
+        }
+      ]
+    };
+  }
+}
+async function validateMetaTags(htmlFiles, manifestPath, serviceWorkerPath, maxHtmlFiles) {
+  const errors = [];
+  if (htmlFiles.length === 0) {
+    errors.push({
+      code: "HTML_FILES_MISSING",
+      message: "No HTML files found to validate",
+      severity: "warning",
+      suggestion: "Ensure HTML files exist in the project"
+    });
+    return { valid: false, errors };
+  }
+  const maxHtmlFilesLimit = typeof maxHtmlFiles === "number" && maxHtmlFiles > 0 ? maxHtmlFiles : void 0;
+  const htmlFilesToProcess = maxHtmlFilesLimit ? htmlFiles.slice(0, maxHtmlFilesLimit) : htmlFiles;
+  for (const htmlFile of htmlFilesToProcess) {
+    try {
+      const htmlContent = await (0, import_promises.readFile)(htmlFile, "utf-8");
+      const hasManifestLink = htmlContent.includes("manifest.json") || htmlContent.includes('rel="manifest"');
+      if (!hasManifestLink) {
+        errors.push({
+          code: "META_MANIFEST_MISSING",
+          message: `HTML file missing manifest link: ${htmlFile}`,
+          severity: "error",
+          file: htmlFile,
+          suggestion: 'Add <link rel="manifest" href="/manifest.json"> to <head>'
+        });
+      }
+      if (!htmlContent.includes("theme-color") && !htmlContent.includes("theme_color")) {
+        errors.push({
+          code: "META_THEME_COLOR_MISSING",
+          message: `HTML file missing theme-color meta tag: ${htmlFile}`,
+          severity: "warning",
+          file: htmlFile,
+          suggestion: 'Add <meta name="theme-color" content="#..."> to <head>'
+        });
+      }
+      if (!htmlContent.includes("apple-mobile-web-app-capable")) {
+        errors.push({
+          code: "META_APPLE_MOBILE_MISSING",
+          message: `HTML file missing apple-mobile-web-app-capable meta tag: ${htmlFile}`,
+          severity: "warning",
+          file: htmlFile,
+          suggestion: 'Add <meta name="apple-mobile-web-app-capable" content="yes"> to <head>'
+        });
+      }
+      if (serviceWorkerPath && !htmlContent.includes("serviceWorker") && !htmlContent.includes("navigator.serviceWorker")) {
+        errors.push({
+          code: "META_SERVICE_WORKER_REGISTRATION_MISSING",
+          message: `HTML file missing service worker registration: ${htmlFile}`,
+          severity: "warning",
+          file: htmlFile,
+          suggestion: "Add service worker registration script to HTML"
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push({
+        code: "HTML_READ_ERROR",
+        message: `Failed to read HTML file ${htmlFile}: ${errorMessage}`,
+        severity: "error",
+        file: htmlFile
+      });
+    }
+  }
+  return {
+    // Considérer la section invalide dès qu'au moins une anomalie est détectée
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateHttps(_projectPath) {
+  return {
+    isSecure: false,
+    // Par défaut, on assume que ce n'est pas HTTPS (sera vérifié en production)
+    isLocalhost: false,
+    errors: [
+      {
+        code: "HTTPS_NOT_VERIFIED",
+        message: "HTTPS cannot be verified in local environment. Ensure HTTPS is enabled in production.",
+        severity: "warning",
+        suggestion: "PWA requires HTTPS in production. Use a service like Let's Encrypt or a hosting provider with HTTPS."
+      }
+    ]
+  };
+}
+function calculatePWAScore(result) {
+  let score = 100;
+  for (const error of result.errors) {
+    if (error.severity === "error") {
+      score -= 10;
+    } else if (error.severity === "warning") {
+      score -= 5;
+    }
+  }
+  score -= result.warnings.length * 3;
+  if (!result.details.manifest.exists) {
+    score -= 20;
+  } else if (!result.details.manifest.valid) {
+    score -= 15;
+  }
+  if (!result.details.icons.exists) {
+    score -= 20;
+  } else if (!result.details.icons.has192x192 || !result.details.icons.has512x512) {
+    score -= 15;
+  }
+  if (!result.details.serviceWorker.exists) {
+    score -= 20;
+  } else if (!result.details.serviceWorker.valid) {
+    score -= 10;
+  }
+  if (!result.details.metaTags.valid) {
+    score -= 10;
+  }
+  return Math.max(0, Math.min(100, score));
+}
+async function validatePWA(options) {
+  const { projectPath, outputDir = "public", htmlFiles = [], strict = false } = options;
+  const finalOutputDir = outputDir.startsWith("/") ? outputDir : (0, import_path11.join)(projectPath, outputDir);
+  const manifestValidation = validateManifest(projectPath, finalOutputDir);
+  const iconsValidation = validateIcons(projectPath, finalOutputDir, manifestValidation.manifest);
+  const serviceWorkerValidation = validateServiceWorker(projectPath, finalOutputDir);
+  const manifestPath = manifestValidation.exists ? (0, import_path11.join)(finalOutputDir, "manifest.json") : void 0;
+  const serviceWorkerPath = serviceWorkerValidation.exists ? (0, import_path11.join)(finalOutputDir, "sw.js") : void 0;
+  const metaTagsValidation = await validateMetaTags(htmlFiles, manifestPath, serviceWorkerPath, options.maxHtmlFiles);
+  const httpsValidation = validateHttps(projectPath);
+  const allErrors = [
+    ...manifestValidation.errors,
+    ...iconsValidation.errors,
+    ...serviceWorkerValidation.errors,
+    ...metaTagsValidation.errors,
+    ...httpsValidation.errors
+  ];
+  const errors = allErrors.filter((e) => e.severity === "error" || e.code.startsWith("META_"));
+  const warnings = allErrors.filter((e) => e.severity === "warning" || e.severity === "info").map((error) => ({
+    code: error.code,
+    message: error.message,
+    file: error.file,
+    suggestion: error.suggestion
+  }));
+  const suggestions = [];
+  if (!manifestValidation.exists) {
+    suggestions.push("Generate manifest.json using: universal-pwa init");
+  }
+  if (!iconsValidation.has192x192 || !iconsValidation.has512x512) {
+    suggestions.push("Generate icons using: universal-pwa init --icon-source <path>");
+  }
+  if (!serviceWorkerValidation.exists) {
+    suggestions.push("Generate service worker using: universal-pwa init");
+  }
+  if (errors.length > 0) {
+    suggestions.push("Fix all errors to achieve PWA compliance");
+  }
+  const isValid = errors.length === 0 && (strict ? warnings.length === 0 : true);
+  const result = {
+    isValid,
+    score: 0,
+    // Sera calculé après
+    errors,
+    warnings,
+    suggestions,
+    details: {
+      manifest: {
+        exists: manifestValidation.exists,
+        valid: manifestValidation.valid,
+        errors: manifestValidation.errors
+      },
+      icons: {
+        exists: iconsValidation.exists,
+        valid: iconsValidation.valid,
+        has192x192: iconsValidation.has192x192,
+        has512x512: iconsValidation.has512x512,
+        errors: iconsValidation.errors
+      },
+      serviceWorker: {
+        exists: serviceWorkerValidation.exists,
+        valid: serviceWorkerValidation.valid,
+        errors: serviceWorkerValidation.errors
+      },
+      metaTags: {
+        valid: metaTagsValidation.valid,
+        errors: metaTagsValidation.errors
+      },
+      https: {
+        isSecure: httpsValidation.isSecure,
+        isLocalhost: httpsValidation.isLocalhost,
+        errors: httpsValidation.errors
+      }
+    }
+  };
+  result.score = calculatePWAScore(result);
   return result;
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -1493,13 +3150,16 @@ function injectMetaTagsInFile(filePath, options = {}) {
   STANDARD_SPLASH_SIZES,
   checkHttps,
   checkProjectHttps,
+  detectApiType,
   detectArchitecture,
   detectAssets,
   detectFramework,
   detectProjectUrl,
+  detectUnoptimizedImages,
   elementExists,
   findAllElements,
   findElement,
+  generateAdaptiveCacheStrategies,
   generateAndWriteManifest,
   generateAndWriteServiceWorker,
   generateAppleTouchIcon,
@@ -1507,16 +3167,23 @@ function injectMetaTagsInFile(filePath, options = {}) {
   generateIcons,
   generateIconsOnly,
   generateManifest,
+  generateOptimalShortName,
   generateReport,
+  generateResponsiveImageSizes,
   generateServiceWorker,
   generateSimpleServiceWorker,
   generateSplashScreensOnly,
   injectMetaTags,
   injectMetaTagsInFile,
+  optimizeImage,
+  optimizeProject,
+  optimizeProjectImages,
   parseHTML,
   parseHTMLFile,
   scanProject,
   serializeHTML,
+  suggestManifestColors,
+  validatePWA,
   validateProjectPath,
   writeManifest
 });