@djangocfg/nextjs 2.1.6 → 2.1.8

package/dist/index.mjs

@@ -0,0 +1,2565 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@djangocfg/nextjs",
+      version: "2.1.8",
+      description: "Next.js server utilities: sitemap, health, OG images, contact forms, navigation, config",
+      keywords: [
+        "nextjs",
+        "sitemap",
+        "health",
+        "og-image",
+        "contact",
+        "navigation",
+        "config",
+        "react",
+        "typescript"
+      ],
+      author: {
+        name: "DjangoCFG",
+        url: "https://djangocfg.com"
+      },
+      homepage: "https://djangocfg.com",
+      repository: {
+        type: "git",
+        url: "https://github.com/markolofsen/django-cfg.git",
+        directory: "packages/nextjs"
+      },
+      bugs: {
+        url: "https://github.com/markolofsen/django-cfg/issues"
+      },
+      license: "MIT",
+      main: "./src/index.ts",
+      types: "./src/index.ts",
+      exports: {
+        ".": {
+          types: "./src/index.ts",
+          import: "./src/index.ts",
+          default: "./src/index.ts"
+        },
+        "./sitemap": {
+          types: "./src/sitemap/index.ts",
+          import: "./src/sitemap/index.ts",
+          default: "./src/sitemap/index.ts"
+        },
+        "./health": {
+          types: "./src/health/index.ts",
+          import: "./src/health/index.ts",
+          default: "./src/health/index.ts"
+        },
+        "./og-image": {
+          types: "./src/og-image/index.ts",
+          import: "./src/og-image/index.ts",
+          default: "./src/og-image/index.ts"
+        },
+        "./og-image/utils": {
+          types: "./src/og-image/utils/index.ts",
+          import: "./src/og-image/utils/index.ts",
+          default: "./src/og-image/utils/index.ts"
+        },
+        "./og-image/components": {
+          types: "./src/og-image/components/index.ts",
+          import: "./src/og-image/components/index.ts",
+          default: "./src/og-image/components/index.ts"
+        },
+        "./contact": {
+          types: "./src/contact/index.ts",
+          import: "./src/contact/index.ts",
+          default: "./src/contact/index.ts"
+        },
+        "./navigation": {
+          types: "./src/navigation/index.ts",
+          import: "./src/navigation/index.ts",
+          default: "./src/navigation/index.ts"
+        },
+        "./config": {
+          types: "./src/config/index.ts",
+          import: "./src/config/index.ts",
+          default: "./src/config/index.ts"
+        },
+        "./scripts": {
+          types: "./src/scripts/index.ts",
+          import: "./src/scripts/index.ts",
+          default: "./src/scripts/index.ts"
+        },
+        "./ai": {
+          types: "./src/ai/index.ts",
+          import: "./src/ai/index.ts",
+          default: "./src/ai/index.ts"
+        }
+      },
+      files: [
+        "dist",
+        "src",
+        "README.md",
+        "LICENSE"
+      ],
+      bin: {
+        "djangocfg-docs": "./dist/ai/cli.mjs"
+      },
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        clean: "rm -rf dist",
+        lint: "eslint .",
+        check: "tsc --noEmit",
+        "check-links": "tsx src/scripts/check-links.ts",
+        "ai-docs": "tsx src/ai/cli.ts"
+      },
+      peerDependencies: {
+        "@djangocfg/api": "workspace:*",
+        next: "^15.5.7"
+      },
+      devDependencies: {
+        "@djangocfg/imgai": "workspace:*",
+        "@djangocfg/layouts": "workspace:*",
+        "@djangocfg/typescript-config": "workspace:*",
+        "@types/node": "^24.7.2",
+        "@types/react": "19.2.2",
+        "@types/react-dom": "19.2.1",
+        "@types/semver": "^7.7.1",
+        "@types/webpack": "^5.28.5",
+        "@vercel/og": "^0.8.5",
+        eslint: "^9.37.0",
+        linkinator: "^7.5.0",
+        "lucide-react": "^0.545.0",
+        picocolors: "^1.1.1",
+        prompts: "^2.4.2",
+        tsup: "^8.0.1",
+        tsx: "^4.19.2",
+        typescript: "^5.9.3"
+      },
+      publishConfig: {
+        access: "public"
+      },
+      dependencies: {
+        chalk: "^5.3.0",
+        conf: "^15.0.2",
+        consola: "^3.4.2",
+        semver: "^7.7.3"
+      }
+    };
+  }
+});
+
+// src/sitemap/route.ts
+import { NextResponse } from "next/server";
+
+// src/sitemap/generator.ts
+function generateSitemapXml(urls) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
+        http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
+${urls.map(
+    ({ loc, lastmod, changefreq, priority }) => `  <url>
+    <loc>${escapeXml(loc)}</loc>
+    ${lastmod ? `<lastmod>${formatDate(lastmod)}</lastmod>` : ""}
+    ${changefreq ? `<changefreq>${changefreq}</changefreq>` : ""}
+    ${priority !== void 0 ? `<priority>${priority.toFixed(1)}</priority>` : ""}
+  </url>`
+  ).join("\n")}
+</urlset>`;
+}
+function formatDate(date) {
+  if (typeof date === "string") {
+    return date;
+  }
+  return date.toISOString().split("T")[0];
+}
+function escapeXml(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function normalizeUrl(url, siteUrl) {
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  const baseUrl = siteUrl.endsWith("/") ? siteUrl.slice(0, -1) : siteUrl;
+  const path = url.startsWith("/") ? url : `/${url}`;
+  return `${baseUrl}${path}`;
+}
+
+// src/sitemap/route.ts
+function createSitemapHandler(options) {
+  const {
+    siteUrl,
+    staticPages = [],
+    dynamicPages = [],
+    cacheControl = "public, s-maxage=86400, stale-while-revalidate"
+  } = options;
+  return async function GET() {
+    const urls = [...staticPages];
+    if (dynamicPages) {
+      if (typeof dynamicPages === "function") {
+        const dynamicUrls = await dynamicPages();
+        urls.push(...dynamicUrls);
+      } else {
+        urls.push(...dynamicPages);
+      }
+    }
+    const normalizedUrls = urls.map((url) => ({
+      ...url,
+      loc: normalizeUrl(url.loc, siteUrl)
+    }));
+    const sitemap = generateSitemapXml(normalizedUrls);
+    return new NextResponse(sitemap, {
+      status: 200,
+      headers: {
+        "Content-Type": "application/xml",
+        "Cache-Control": cacheControl
+      }
+    });
+  };
+}
+
+// src/health/route.ts
+import { NextResponse as NextResponse2 } from "next/server";
+function createHealthHandler(config = {}) {
+  const { version, checks = [], customData = {} } = config;
+  return async function GET() {
+    const startTime = Date.now();
+    let status = "ok";
+    const checkResults = {};
+    if (checks.length > 0) {
+      for (const check of checks) {
+        try {
+          const result = await check.check();
+          checkResults[check.name] = result;
+          if (!result) {
+            status = "error";
+          }
+        } catch (error) {
+          checkResults[check.name] = false;
+          status = "error";
+        }
+      }
+    }
+    const response = {
+      status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: process.uptime(),
+      ...version && { version },
+      ...Object.keys(checkResults).length > 0 && { checks: checkResults },
+      ...customData
+    };
+    const statusCode = status === "ok" ? 200 : 503;
+    return NextResponse2.json(response, { status: statusCode });
+  };
+}
+
+// src/og-image/route.tsx
+import { ImageResponse } from "next/og";
+import { NextRequest } from "next/server";
+
+// src/og-image/utils/fonts.ts
+async function loadGoogleFont(font, text, weight = 700) {
+  let url = `https://fonts.googleapis.com/css2?family=${font}:wght@${weight}`;
+  if (text) {
+    url += `&text=${encodeURIComponent(text)}`;
+  }
+  try {
+    const css = await fetch(url, {
+      headers: {
+        // Required to get TTF format instead of WOFF2
+        "User-Agent": "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; de-at) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1"
+      }
+    }).then((res) => res.text());
+    const resource = css.match(/src: url\((.+)\) format\('(opentype|truetype)'\)/);
+    if (!resource || !resource[1]) {
+      throw new Error(`Failed to parse font URL from CSS for font: ${font}`);
+    }
+    const response = await fetch(resource[1]);
+    if (response.status !== 200) {
+      throw new Error(`Failed to fetch font data: HTTP ${response.status}`);
+    }
+    return await response.arrayBuffer();
+  } catch (error) {
+    console.error(`Error loading Google Font "${font}":`, error);
+    throw new Error(`Failed to load font "${font}": ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function loadGoogleFonts(fonts) {
+  const fontConfigs = await Promise.all(
+    fonts.map(async ({ family, weight = 700, style = "normal", text }) => {
+      const data = await loadGoogleFont(family, text, weight);
+      return {
+        name: family,
+        weight,
+        style,
+        data
+      };
+    })
+  );
+  return fontConfigs;
+}
+function createFontLoader() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    /**
+     * Load a font with caching
+     */
+    async load(family, weight = 700, text) {
+      const cacheKey = `${family}-${weight}-${text || "all"}`;
+      if (!cache.has(cacheKey)) {
+        cache.set(cacheKey, loadGoogleFont(family, text, weight));
+      }
+      return cache.get(cacheKey);
+    },
+    /**
+     * Clear the cache
+     */
+    clear() {
+      cache.clear();
+    },
+    /**
+     * Get cache size
+     */
+    size() {
+      return cache.size;
+    }
+  };
+}
+
+// src/og-image/utils/url.ts
+var DEFAULT_OG_IMAGE_BASE_URL = "https://djangocfg.com/api/og";
+function encodeBase64(str) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "utf-8").toString("base64");
+  }
+  return btoa(unescape(encodeURIComponent(str)));
+}
+function decodeBase64(str) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "base64").toString("utf-8");
+  }
+  try {
+    const binaryString = atob(str);
+    return decodeURIComponent(
+      binaryString.split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join("")
+    );
+  } catch (error) {
+    return decodeURIComponent(escape(atob(str)));
+  }
+}
+function generateOgImageUrl(params, options = {}) {
+  const {
+    baseUrl = DEFAULT_OG_IMAGE_BASE_URL,
+    useBase64 = true
+  } = options;
+  if (useBase64) {
+    const cleanParams = {};
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null && value !== "") {
+        cleanParams[key] = value;
+      }
+    });
+    const jsonString = JSON.stringify(cleanParams);
+    const base64Data = encodeBase64(jsonString);
+    return `${baseUrl}/${base64Data}`;
+  } else {
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null && value !== "") {
+        searchParams.append(key, String(value));
+      }
+    });
+    const query = searchParams.toString();
+    return query ? `${baseUrl}?${query}` : baseUrl;
+  }
+}
+function getAbsoluteOgImageUrl(relativePath, siteUrl) {
+  if (relativePath.startsWith("http://") || relativePath.startsWith("https://")) {
+    return relativePath;
+  }
+  const cleanSiteUrl = siteUrl.replace(/\/$/, "");
+  const cleanPath = relativePath.startsWith("/") ? relativePath : `/${relativePath}`;
+  return `${cleanSiteUrl}${cleanPath}`;
+}
+function createOgImageUrlBuilder(defaults = {}, options = {}) {
+  return (params) => {
+    return generateOgImageUrl(
+      { ...defaults, ...params },
+      options
+    );
+  };
+}
+function parseOgImageUrl(url) {
+  try {
+    const urlObj = new URL(url, "http://dummy.com");
+    const params = {};
+    urlObj.searchParams.forEach((value, key) => {
+      params[key] = value;
+    });
+    return params;
+  } catch {
+    return {};
+  }
+}
+function parseOgImageData(searchParams) {
+  try {
+    let params;
+    if (searchParams instanceof URLSearchParams) {
+      params = {};
+      for (const [key, value] of searchParams.entries()) {
+        params[key] = value;
+      }
+    } else {
+      params = searchParams;
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.log("[parseOgImageData] Input params keys:", Object.keys(params));
+      console.log("[parseOgImageData] Input params:", params);
+    }
+    const dataParam = params.data;
+    if (dataParam && typeof dataParam === "string" && dataParam.trim() !== "") {
+      if (process.env.NODE_ENV === "development") {
+        console.log("[parseOgImageData] Found data param, length:", dataParam.length);
+      }
+      try {
+        const decoded = decodeBase64(dataParam);
+        if (process.env.NODE_ENV === "development") {
+          console.log("[parseOgImageData] Decoded string:", decoded.substring(0, 100));
+        }
+        const parsed = JSON.parse(decoded);
+        if (process.env.NODE_ENV === "development") {
+          console.log("[parseOgImageData] Parsed JSON:", parsed);
+        }
+        const result2 = {};
+        for (const [key, value] of Object.entries(parsed)) {
+          if (value !== void 0 && value !== null) {
+            result2[key] = String(value);
+          }
+        }
+        if (process.env.NODE_ENV === "development") {
+          console.log("[parseOgImageData] Result:", result2);
+        }
+        return result2;
+      } catch (decodeError) {
+        console.error("[parseOgImageData] Error decoding/parsing data param:", decodeError);
+        if (decodeError instanceof Error) {
+          console.error("[parseOgImageData] Error message:", decodeError.message);
+        }
+      }
+    } else {
+      if (process.env.NODE_ENV === "development") {
+        console.log("[parseOgImageData] No data param found or empty");
+      }
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(params)) {
+      if (key !== "data" && value !== void 0 && value !== null) {
+        result[key] = Array.isArray(value) ? value[0] : String(value);
+      }
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.log("[parseOgImageData] Fallback result:", result);
+    }
+    return result;
+  } catch (error) {
+    console.error("[parseOgImageData] Unexpected error:", error);
+    return {};
+  }
+}
+
+// src/og-image/utils/metadata.ts
+function extractTitle(metadata) {
+  if (typeof metadata.title === "string") {
+    return metadata.title;
+  }
+  if (metadata.title) {
+    if ("default" in metadata.title) {
+      return metadata.title.default;
+    }
+    if ("absolute" in metadata.title) {
+      return metadata.title.absolute;
+    }
+  }
+  return "";
+}
+function extractDescription(metadata) {
+  if (typeof metadata.description === "string") {
+    return metadata.description;
+  }
+  return "";
+}
+function getSiteUrl() {
+  if (typeof process !== "undefined" && process.env.NEXT_PUBLIC_SITE_URL) {
+    return process.env.NEXT_PUBLIC_SITE_URL;
+  }
+  return "";
+}
+function generateOgImageMetadata(metadata, ogImageParams, options = {}) {
+  const {
+    ogImageBaseUrl = "https://djangocfg.com/api/og",
+    siteUrl: providedSiteUrl,
+    defaultParams = {},
+    useBase64 = true
+  } = options;
+  const siteUrl = providedSiteUrl && providedSiteUrl !== "undefined" ? providedSiteUrl : getSiteUrl();
+  const extractedTitle = extractTitle(metadata);
+  const extractedDescription = extractDescription(metadata);
+  const finalOgImageParams = {
+    ...defaultParams,
+    title: ogImageParams?.title || extractedTitle || defaultParams.title || "",
+    description: ogImageParams?.description || extractedDescription || defaultParams.description || "",
+    ...ogImageParams
+  };
+  const imageAlt = finalOgImageParams.title || finalOgImageParams.siteName;
+  const relativeOgImageUrl = generateOgImageUrl(
+    finalOgImageParams,
+    { baseUrl: ogImageBaseUrl, useBase64 }
+  );
+  const ogImageUrl = siteUrl ? getAbsoluteOgImageUrl(relativeOgImageUrl, siteUrl) : relativeOgImageUrl;
+  const existingOgImages = metadata.openGraph?.images ? Array.isArray(metadata.openGraph.images) ? metadata.openGraph.images : [metadata.openGraph.images] : [];
+  const existingTwitterImages = metadata.twitter?.images ? Array.isArray(metadata.twitter.images) ? metadata.twitter.images : [metadata.twitter.images] : [];
+  const finalMetadata = {
+    ...metadata,
+    openGraph: {
+      ...metadata.openGraph,
+      images: [
+        ...existingOgImages,
+        {
+          url: ogImageUrl,
+          width: 1200,
+          height: 630,
+          alt: imageAlt
+        }
+      ]
+    },
+    twitter: {
+      ...metadata.twitter,
+      card: "summary_large_image",
+      images: [
+        ...existingTwitterImages,
+        {
+          url: ogImageUrl,
+          alt: imageAlt
+        }
+      ]
+    }
+  };
+  if (!finalMetadata.metadataBase && siteUrl) {
+    if (siteUrl.startsWith("http://") || siteUrl.startsWith("https://")) {
+      try {
+        finalMetadata.metadataBase = new URL(siteUrl);
+      } catch (e) {
+      }
+    }
+  }
+  return finalMetadata;
+}
+function createOgImageMetadataGenerator(options) {
+  return (metadata, ogImageParams) => {
+    return generateOgImageMetadata(metadata, ogImageParams, options);
+  };
+}
+
+// src/og-image/components/DefaultTemplate.tsx
+function DefaultTemplate({
+  title,
+  description,
+  siteName,
+  logo,
+  // Visibility flags
+  showLogo = true,
+  showSiteName = true,
+  // Background customization
+  backgroundType = "gradient",
+  gradientStart = "#667eea",
+  gradientEnd = "#764ba2",
+  backgroundColor = "#ffffff",
+  // Typography - Title
+  titleSize,
+  titleWeight = 800,
+  titleColor = "white",
+  // Typography - Description
+  descriptionSize = 32,
+  descriptionColor = "rgba(255, 255, 255, 0.85)",
+  // Typography - Site Name
+  siteNameSize = 28,
+  siteNameColor = "rgba(255, 255, 255, 0.95)",
+  // Layout
+  padding = 80,
+  logoSize = 48,
+  // Dev mode
+  devMode = false
+}) {
+  const calculatedTitleSize = titleSize || (title.length > 60 ? 56 : 72);
+  const backgroundStyle = backgroundType === "gradient" ? `linear-gradient(135deg, ${gradientStart} 0%, ${gradientEnd} 100%)` : backgroundColor;
+  const gridOverlay = devMode ? /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundImage: `
+          linear-gradient(rgba(0, 0, 0, 0.1) 1px, transparent 1px),
+          linear-gradient(90deg, rgba(0, 0, 0, 0.1) 1px, transparent 1px)
+        `,
+        backgroundSize: "20px 20px",
+        pointerEvents: "none",
+        zIndex: 10
+      }
+    }
+  ) : null;
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        height: "100%",
+        width: "100%",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "flex-start",
+        justifyContent: "space-between",
+        background: backgroundStyle,
+        padding: `${padding}px`,
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        position: "relative"
+      }
+    },
+    gridOverlay,
+    (showLogo && logo || showSiteName && siteName) && /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: "16px"
+        }
+      },
+      showLogo && logo && // eslint-disable-next-line @next/next/no-img-element
+      /* @__PURE__ */ React.createElement(
+        "img",
+        {
+          src: logo,
+          alt: "Logo",
+          width: logoSize,
+          height: logoSize,
+          style: {
+            borderRadius: "8px"
+          }
+        }
+      ),
+      showSiteName && siteName && /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: {
+            fontSize: siteNameSize,
+            fontWeight: 600,
+            color: siteNameColor,
+            letterSpacing: "-0.02em"
+          }
+        },
+        siteName
+      )
+    ),
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          gap: "24px",
+          flex: 1,
+          justifyContent: "center"
+        }
+      },
+      /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: {
+            fontSize: calculatedTitleSize,
+            fontWeight: titleWeight,
+            color: titleColor,
+            lineHeight: 1.1,
+            letterSpacing: "-0.03em",
+            textShadow: backgroundType === "gradient" ? "0 2px 20px rgba(0, 0, 0, 0.2)" : "none",
+            maxWidth: "100%",
+            wordWrap: "break-word"
+          }
+        },
+        title
+      ),
+      description && /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: {
+            fontSize: descriptionSize,
+            fontWeight: 400,
+            color: descriptionColor,
+            lineHeight: 1.5,
+            letterSpacing: "-0.01em",
+            maxWidth: "90%",
+            display: "-webkit-box",
+            WebkitLineClamp: 2,
+            WebkitBoxOrient: "vertical",
+            overflow: "hidden"
+          }
+        },
+        description
+      )
+    ),
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          width: "100%",
+          height: "4px",
+          background: backgroundType === "gradient" ? `linear-gradient(90deg, ${gradientStart} 0%, ${gradientEnd} 100%)` : gradientStart,
+          borderRadius: "2px"
+        }
+      }
+    )
+  );
+}
+function LightTemplate({
+  title,
+  description,
+  siteName,
+  logo,
+  // Visibility flags
+  showLogo = true,
+  showSiteName = true,
+  // Background customization (defaults to light theme)
+  backgroundType = "solid",
+  gradientStart = "#667eea",
+  gradientEnd = "#764ba2",
+  backgroundColor = "#ffffff",
+  // Typography - Title
+  titleSize,
+  titleWeight = 800,
+  titleColor = "#111",
+  // Typography - Description
+  descriptionSize = 32,
+  descriptionColor = "#666",
+  // Typography - Site Name
+  siteNameSize = 28,
+  siteNameColor = "#111",
+  // Layout
+  padding = 80,
+  logoSize = 48,
+  // Dev mode
+  devMode = false
+}) {
+  const calculatedTitleSize = titleSize || (title.length > 60 ? 56 : 72);
+  const backgroundStyle = backgroundType === "gradient" ? `linear-gradient(135deg, ${gradientStart} 0%, ${gradientEnd} 100%)` : backgroundColor;
+  const gridOverlay = devMode ? /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundImage: `
+          linear-gradient(rgba(0, 0, 0, 0.1) 1px, transparent 1px),
+          linear-gradient(90deg, rgba(0, 0, 0, 0.1) 1px, transparent 1px)
+        `,
+        backgroundSize: "20px 20px",
+        pointerEvents: "none",
+        zIndex: 10
+      }
+    }
+  ) : null;
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        height: "100%",
+        width: "100%",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "flex-start",
+        justifyContent: "space-between",
+        background: backgroundStyle,
+        padding: `${padding}px`,
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        position: "relative"
+      }
+    },
+    gridOverlay,
+    (showLogo && logo || showSiteName && siteName) && /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: "16px"
+        }
+      },
+      showLogo && logo && // eslint-disable-next-line @next/next/no-img-element
+      /* @__PURE__ */ React.createElement(
+        "img",
+        {
+          src: logo,
+          alt: "Logo",
+          width: logoSize,
+          height: logoSize,
+          style: {
+            borderRadius: "8px"
+          }
+        }
+      ),
+      showSiteName && siteName && /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: {
+            fontSize: siteNameSize,
+            fontWeight: 600,
+            color: siteNameColor,
+            letterSpacing: "-0.02em"
+          }
+        },
+        siteName
+      )
+    ),
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          gap: "24px",
+          flex: 1,
+          justifyContent: "center"
+        }
+      },
+      /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: {
+            fontSize: calculatedTitleSize,
+            fontWeight: titleWeight,
+            color: titleColor,
+            lineHeight: 1.1,
+            letterSpacing: "-0.03em",
+            maxWidth: "100%",
+            wordWrap: "break-word"
+          }
+        },
+        title
+      ),
+      description && /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          style: {
+            fontSize: descriptionSize,
+            fontWeight: 400,
+            color: descriptionColor,
+            lineHeight: 1.5,
+            letterSpacing: "-0.01em",
+            maxWidth: "90%"
+          }
+        },
+        description
+      )
+    ),
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        style: {
+          display: "flex",
+          width: "100%",
+          height: "4px",
+          background: backgroundType === "gradient" ? `linear-gradient(90deg, ${gradientStart} 0%, ${gradientEnd} 100%)` : gradientStart,
+          borderRadius: "2px"
+        }
+      }
+    )
+  );
+}
+
+// src/og-image/route.tsx
+function createOgImageHandler(config) {
+  const {
+    template: Template = DefaultTemplate,
+    defaultProps = {},
+    fonts: fontConfig = [],
+    size = { width: 1200, height: 630 },
+    debug = false
+  } = config;
+  async function GET(req) {
+    let searchParams = new URLSearchParams();
+    if (req.nextUrl?.searchParams && req.nextUrl.searchParams.size > 0) {
+      searchParams = req.nextUrl.searchParams;
+    } else if (req.nextUrl?.search && req.nextUrl.search.length > 1) {
+      searchParams = new URLSearchParams(req.nextUrl.search);
+    } else {
+      try {
+        const url = new URL(req.url);
+        if (url.searchParams.size > 0) {
+          searchParams = url.searchParams;
+        }
+      } catch (error) {
+      }
+      if (searchParams.size === 0 && req.url) {
+        const queryIndex = req.url.indexOf("?");
+        if (queryIndex !== -1) {
+          const queryString = req.url.substring(queryIndex + 1);
+          searchParams = new URLSearchParams(queryString);
+        }
+      }
+      if (searchParams.size === 0) {
+        const customParams = req.headers.get("x-og-search-params");
+        if (customParams) {
+          searchParams = new URLSearchParams(customParams);
+        }
+      }
+    }
+    let title = defaultProps.title || "Untitled";
+    let subtitle = defaultProps.subtitle || "";
+    let description = defaultProps.description || subtitle;
+    const dataParam = searchParams.get("data");
+    let decodedParams = {};
+    if (dataParam) {
+      try {
+        const paramsObj = { data: dataParam };
+        for (const [key, value] of searchParams.entries()) {
+          if (key !== "data") {
+            paramsObj[key] = value;
+          }
+        }
+        decodedParams = parseOgImageData(paramsObj);
+        if (decodedParams.title && typeof decodedParams.title === "string" && decodedParams.title.trim() !== "") {
+          title = decodedParams.title.trim();
+        }
+        if (decodedParams.subtitle && typeof decodedParams.subtitle === "string" && decodedParams.subtitle.trim() !== "") {
+          subtitle = decodedParams.subtitle.trim();
+        }
+        if (decodedParams.description && typeof decodedParams.description === "string" && decodedParams.description.trim() !== "") {
+          description = decodedParams.description.trim();
+        }
+      } catch (error) {
+      }
+    }
+    if (!title || title === "Untitled") {
+      const titleParam = searchParams.get("title");
+      if (titleParam) {
+        title = titleParam;
+      }
+    }
+    if (!subtitle) {
+      const subtitleParam = searchParams.get("subtitle");
+      if (subtitleParam) {
+        subtitle = subtitleParam;
+      }
+    }
+    if (!description || description === subtitle) {
+      const descParam = searchParams.get("description");
+      if (descParam) {
+        description = descParam;
+      }
+    }
+    let fonts = [];
+    if (fontConfig.length > 0) {
+      fonts = await loadGoogleFonts(fontConfig);
+    }
+    const parseValue = (value, type = "string") => {
+      if (value === void 0 || value === null || value === "") {
+        return void 0;
+      }
+      if (type === "number") {
+        const num = Number(value);
+        return isNaN(num) ? void 0 : num;
+      }
+      if (type === "boolean") {
+        if (typeof value === "boolean") return value;
+        if (typeof value === "string") {
+          return value.toLowerCase() === "true" || value === "1";
+        }
+        return Boolean(value);
+      }
+      return String(value);
+    };
+    const templateProps = {
+      ...defaultProps,
+      // Content
+      title,
+      subtitle,
+      description,
+      // Override with decoded params if present
+      siteName: decodedParams.siteName || defaultProps.siteName,
+      logo: decodedParams.logo || defaultProps.logo,
+      // Background
+      backgroundType: decodedParams.backgroundType || defaultProps.backgroundType,
+      gradientStart: decodedParams.gradientStart || defaultProps.gradientStart,
+      gradientEnd: decodedParams.gradientEnd || defaultProps.gradientEnd,
+      backgroundColor: decodedParams.backgroundColor || defaultProps.backgroundColor,
+      // Typography - Title
+      titleSize: parseValue(decodedParams.titleSize, "number") ?? defaultProps.titleSize,
+      titleWeight: parseValue(decodedParams.titleWeight, "number") ?? defaultProps.titleWeight,
+      titleColor: decodedParams.titleColor || defaultProps.titleColor,
+      // Typography - Description
+      descriptionSize: parseValue(decodedParams.descriptionSize, "number") ?? defaultProps.descriptionSize,
+      descriptionColor: decodedParams.descriptionColor || defaultProps.descriptionColor,
+      // Typography - Site Name
+      siteNameSize: parseValue(decodedParams.siteNameSize, "number") ?? defaultProps.siteNameSize,
+      siteNameColor: decodedParams.siteNameColor || defaultProps.siteNameColor,
+      // Layout
+      padding: parseValue(decodedParams.padding, "number") ?? defaultProps.padding,
+      logoSize: parseValue(decodedParams.logoSize, "number") ?? defaultProps.logoSize,
+      // Visibility flags
+      showLogo: parseValue(decodedParams.showLogo, "boolean") ?? defaultProps.showLogo,
+      showSiteName: parseValue(decodedParams.showSiteName, "boolean") ?? defaultProps.showSiteName
+    };
+    return new ImageResponse(
+      /* @__PURE__ */ React.createElement(Template, { ...templateProps }),
+      {
+        width: size.width,
+        height: size.height,
+        fonts,
+        debug: debug || process.env.NODE_ENV === "development"
+      }
+    );
+  }
+  return {
+    GET,
+    runtime: "edge"
+  };
+}
+function createOgImageDynamicRoute(config) {
+  const handler = createOgImageHandler(config);
+  const isStaticBuild2 = typeof process !== "undefined" && process.env.NEXT_PUBLIC_STATIC_BUILD === "true";
+  async function GET(request, context) {
+    if (isStaticBuild2) {
+      return new Response("OG Image generation is not available in static export mode", {
+        status: 404,
+        headers: { "Content-Type": "text/plain" }
+      });
+    }
+    const params = await context.params;
+    const dataParam = params.data;
+    const url = new URL(request.url);
+    url.searchParams.set("data", dataParam);
+    const modifiedRequest = new NextRequest(url.toString(), {
+      method: request.method,
+      headers: request.headers
+    });
+    return handler.GET(modifiedRequest);
+  }
+  async function generateStaticParams() {
+    return [];
+  }
+  return {
+    GET,
+    generateStaticParams
+  };
+}
+
+// src/contact/submit.ts
+import { API, MemoryStorageAdapter, Fetchers } from "@djangocfg/api/server";
+async function submitContactForm({
+  data,
+  apiUrl,
+  siteUrl
+}) {
+  if (!data.name || !data.email || !data.message) {
+    throw new Error("Missing required fields: name, email, message");
+  }
+  if (!apiUrl) {
+    throw new Error("API URL is required");
+  }
+  const serverApi = new API(apiUrl, {
+    storage: new MemoryStorageAdapter()
+  });
+  const submissionData = {
+    ...data,
+    site_url: data.site_url || siteUrl
+  };
+  try {
+    const result = await Fetchers.createLeadsSubmitCreate(submissionData, serverApi);
+    return {
+      success: result.success ?? true,
+      message: result.message || "Contact form submitted successfully",
+      lead_id: result.lead_id
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to submit contact form: ${error.message}`);
+    }
+    throw new Error("An unexpected error occurred while submitting the contact form");
+  }
+}
+
+// src/contact/route.ts
+import { NextResponse as NextResponse3 } from "next/server";
+function createContactRoute(options) {
+  return async function POST2(request) {
+    try {
+      const body = await request.json();
+      const apiUrl = body._apiUrl && body._apiUrl !== "" ? body._apiUrl : options?.apiUrl || process.env.NEXT_PUBLIC_API_URL || "";
+      if (!apiUrl) {
+        return NextResponse3.json(
+          {
+            success: false,
+            message: "API URL not configured. Set NEXT_PUBLIC_API_URL, provide apiUrl option, or pass _apiUrl in request body."
+          },
+          { status: 500 }
+        );
+      }
+      const { _apiUrl, ...submissionData } = body;
+      const response = await submitContactForm({
+        data: submissionData,
+        apiUrl,
+        siteUrl: request.headers.get("origin") || void 0
+      });
+      return NextResponse3.json(response);
+    } catch (error) {
+      console.error("Contact form submission error:", error);
+      if (error instanceof Error && error.message.includes("Missing required fields")) {
+        return NextResponse3.json(
+          {
+            success: false,
+            message: error.message
+          },
+          { status: 400 }
+        );
+      }
+      if (error instanceof Error) {
+        return NextResponse3.json(
+          {
+            success: false,
+            message: error.message || "Failed to submit contact form"
+          },
+          { status: 500 }
+        );
+      }
+      return NextResponse3.json(
+        {
+          success: false,
+          message: "An unexpected error occurred"
+        },
+        { status: 500 }
+      );
+    }
+  };
+}
+async function POST(request) {
+  const handler = createContactRoute();
+  return handler(request);
+}
+
+// src/navigation/utils.ts
+function defineRoute(path, metadata) {
+  return {
+    path,
+    metadata
+  };
+}
+function getUnauthenticatedRedirect(path, authPath = "/auth") {
+  if (path.startsWith("/private") || path.startsWith("/admin")) {
+    return authPath;
+  }
+  return null;
+}
+function redirectToAuth(authPath = "/auth") {
+  return authPath;
+}
+function findRoute(routes, path) {
+  return routes.find((r) => r.path === path);
+}
+function findRouteByPattern(routes, path) {
+  const exact = findRoute(routes, path);
+  if (exact) return exact;
+  const segments = path.split("/").filter(Boolean);
+  for (let i = segments.length; i > 0; i--) {
+    const parentPath = "/" + segments.slice(0, i).join("/");
+    const parent = findRoute(routes, parentPath);
+    if (parent) return parent;
+  }
+  return void 0;
+}
+function getPageTitle(routes, path, fallback = "Dashboard") {
+  const route = findRouteByPattern(routes, path);
+  return route?.metadata.label || fallback;
+}
+function isActive(current, target, allRoutes) {
+  const matches = current === target || target !== "/" && current.startsWith(target + "/");
+  if (matches && allRoutes) {
+    return !allRoutes.some(
+      (otherRoute) => otherRoute.path !== target && otherRoute.path.startsWith(target + "/") && (current === otherRoute.path || current.startsWith(otherRoute.path + "/"))
+    );
+  }
+  return matches;
+}
+function routesToMenuItems(routes, groupName) {
+  return routes.filter(
+    (r) => r.metadata.group === groupName && r.metadata.icon && (r.metadata.show === void 0 || r.metadata.show === true)
+  ).sort((a, b) => (a.metadata.order || 0) - (b.metadata.order || 0)).map((r) => ({
+    path: r.path,
+    label: r.metadata.label,
+    icon: r.metadata.icon
+  }));
+}
+
+// src/config/constants.ts
+var PACKAGE_NAME = "@djangocfg/nextjs";
+var VERSION_CACHE_TTL_MS = 60 * 60 * 1e3;
+var DJANGO_CFG_BANNER = `
+\u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557      \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557    \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
+\u2588\u2588\u2551  \u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551    \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551  \u2588\u2588\u2588\u2557
+\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588   \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551    \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551   \u2588\u2588\u2551
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D    \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551     \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+\u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D      \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D      \u255A\u2550\u2550\u2550\u2550\u2550\u255D
+`;
+var DJANGOCFG_PACKAGES = [
+  "@djangocfg/ui-core",
+  "@djangocfg/ui-nextjs",
+  "@djangocfg/layouts",
+  "@djangocfg/nextjs",
+  "@djangocfg/api",
+  "@djangocfg/centrifugo",
+  "@djangocfg/eslint-config",
+  "@djangocfg/typescript-config"
+];
+var DEFAULT_TRANSPILE_PACKAGES = [
+  "@djangocfg/ui-core",
+  "@djangocfg/ui-nextjs",
+  "@djangocfg/layouts",
+  "@djangocfg/nextjs",
+  "@djangocfg/api",
+  "@djangocfg/centrifugo"
+];
+var DEFAULT_OPTIMIZE_PACKAGES = [
+  "@djangocfg/ui-core",
+  "@djangocfg/ui-nextjs",
+  "@djangocfg/layouts",
+  "lucide-react",
+  "recharts"
+];
+
+// src/config/utils/deepMerge.ts
+function deepMerge(target, source) {
+  const output = { ...target };
+  for (const key in source) {
+    if (source[key] === void 0) continue;
+    if (Array.isArray(source[key])) {
+      output[key] = source[key];
+    } else if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      const targetValue = output[key];
+      if (targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        output[key] = deepMerge(targetValue, source[key]);
+      } else {
+        output[key] = source[key];
+      }
+    } else {
+      output[key] = source[key];
+    }
+  }
+  return output;
+}
+
+// src/config/utils/env.ts
+var isStaticBuild = process.env.NEXT_PUBLIC_STATIC_BUILD === "true";
+var isDev = process.env.NODE_ENV === "development";
+var isProduction = process.env.NODE_ENV === "production";
+var isCI = process.env.CI === "true";
+function getBasePath(isDefaultCfgAdmin) {
+  if (!isStaticBuild) return "";
+  return isDefaultCfgAdmin ? "/cfg/admin" : "/cfg/nextjs-admin";
+}
+function getApiUrl() {
+  return isStaticBuild ? "" : process.env.NEXT_PUBLIC_API_URL || "";
+}
+function getSiteUrl2() {
+  return isStaticBuild ? "" : process.env.NEXT_PUBLIC_SITE_URL || "";
+}
+
+// src/config/plugins/devStartup.ts
+import chalk4 from "chalk";
+
+// src/ai/constants.ts
+var MCP_BASE_URL = "https://mcp.djangocfg.com";
+var MCP_SERVER_URL = `${MCP_BASE_URL}/mcp`;
+var MCP_API_URL = `${MCP_BASE_URL}/api/search`;
+var API_SEARCH_ENDPOINT = "/api/search";
+var API_INFO_ENDPOINT = "/api/info";
+var DEFAULT_TIMEOUT = 1e4;
+var AI_DOCS_HINT = `\u{1F916} AI Docs: ${MCP_SERVER_URL} | pnpm ai-docs search "query"`;
+var AI_HINT = `
+DjangoCFG Documentation is available via MCP server.
+
+To get help with DjangoCFG configuration:
+1. Use the MCP server: ${MCP_SERVER_URL}
+2. Or search directly: ${MCP_API_URL}?q=YOUR_QUERY&limit=5
+
+Example queries:
+- "How to configure PostgreSQL database?"
+- "What is DatabaseConfig?"
+- "How to setup Redis cache?"
+- "Email configuration with SMTP"
+`;
+
+// src/config/utils/version.ts
+import chalk from "chalk";
+import semver from "semver";
+import consola from "consola";
+import Conf from "conf";
+var versionCache = new Conf({
+  projectName: "djangocfg-nextjs",
+  projectVersion: "1.0.0"
+});
+function getCurrentVersion() {
+  try {
+    const packageJson = require_package();
+    return packageJson.version || null;
+  } catch {
+    return null;
+  }
+}
+async function fetchLatestVersion() {
+  const lastCheck = versionCache.get("lastCheck") || 0;
+  const cachedVersion = versionCache.get("latestVersion");
+  if (cachedVersion && Date.now() - lastCheck < VERSION_CACHE_TTL_MS) {
+    return cachedVersion;
+  }
+  try {
+    const https = await import("https");
+    return new Promise((resolve) => {
+      const req = https.get(
+        `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
+        { timeout: 5e3 },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            try {
+              const json = JSON.parse(data);
+              const version = json.version || null;
+              if (version) {
+                versionCache.set("latestVersion", version);
+                versionCache.set("lastCheck", Date.now());
+              }
+              resolve(version);
+            } catch {
+              resolve(cachedVersion || null);
+            }
+          });
+        }
+      );
+      req.on("error", () => resolve(cachedVersion || null));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(cachedVersion || null);
+      });
+    });
+  } catch {
+    return cachedVersion || null;
+  }
+}
+async function checkForUpdate() {
+  const currentVersion = getCurrentVersion();
+  if (!currentVersion) {
+    return { hasUpdate: false, currentVersion: null, latestVersion: null };
+  }
+  const latestVersion = await fetchLatestVersion();
+  const hasUpdate = !!(latestVersion && semver.gt(latestVersion, currentVersion));
+  return { hasUpdate, currentVersion, latestVersion };
+}
+function getUpdateCommand() {
+  return `pnpm add ${DJANGOCFG_PACKAGES.map((p) => `${p}@latest`).join(" ")}`;
+}
+async function printVersionInfo() {
+  const { hasUpdate, currentVersion, latestVersion } = await checkForUpdate();
+  if (!currentVersion) return;
+  consola.box(`\u{1F4E6} @djangocfg/nextjs v${currentVersion}`);
+  if (hasUpdate && latestVersion) {
+    consola.warn(`Update Available! ${chalk.red(currentVersion)} \u2192 ${chalk.green(latestVersion)}`);
+    consola.info(`Run: ${chalk.cyan(getUpdateCommand())}`);
+    console.log("");
+  }
+}
+
+// src/config/packages/installer.ts
+import { execSync, spawn } from "child_process";
+import { createInterface } from "readline";
+import chalk2 from "chalk";
+import consola2 from "consola";
+import Conf2 from "conf";
+
+// src/config/packages/checker.ts
+import { createRequire } from "module";
+import { join } from "path";
+
+// src/config/packages/definitions.ts
+var OPTIONAL_PACKAGES = [
+  {
+    name: "compression-webpack-plugin",
+    description: "Gzip and Brotli compression for static builds",
+    condition: "static-build",
+    devDependency: true
+  },
+  {
+    name: "@next/bundle-analyzer",
+    description: "Bundle analyzer for analyzing build output",
+    condition: "dev",
+    devDependency: true,
+    featureFlag: "ANALYZE"
+  }
+];
+var PEER_DEPENDENCIES = [
+  "next",
+  "react",
+  "react-dom"
+];
+function getPackagesForContext(options) {
+  return OPTIONAL_PACKAGES.filter((pkg) => {
+    switch (pkg.condition) {
+      case "static-build":
+        return options.isStaticBuild;
+      case "dev":
+        return options.isDev;
+      case "always":
+        return true;
+      default:
+        return false;
+    }
+  });
+}
+
+// src/config/packages/checker.ts
+function isPackageInstalled(packageName) {
+  try {
+    const consumerRequire = createRequire(join(process.cwd(), "package.json"));
+    consumerRequire.resolve(packageName);
+    return true;
+  } catch {
+    try {
+      __require.resolve(packageName);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function getMissingPackages() {
+  const neededPackages = getPackagesForContext({ isStaticBuild, isDev });
+  const missing = [];
+  for (const pkg of neededPackages) {
+    if (!isPackageInstalled(pkg.name)) {
+      missing.push({
+        ...pkg,
+        reason: getReasonText(pkg)
+      });
+    }
+  }
+  return missing;
+}
+function checkPackages(packageNames) {
+  const missing = [];
+  for (const name of packageNames) {
+    if (!isPackageInstalled(name)) {
+      const definition = OPTIONAL_PACKAGES.find((p) => p.name === name);
+      missing.push({
+        name,
+        description: definition?.description || "Optional package",
+        condition: definition?.condition || "always",
+        devDependency: definition?.devDependency ?? true,
+        reason: definition ? getReasonText(definition) : "Requested by configuration"
+      });
+    }
+  }
+  return missing;
+}
+function getReasonText(pkg) {
+  switch (pkg.condition) {
+    case "static-build":
+      return "Required for static build (NEXT_PUBLIC_STATIC_BUILD=true)";
+    case "dev":
+      return "Required for development mode";
+    case "always":
+      return "Required for all builds";
+    default:
+      return "Optional feature";
+  }
+}
+
+// src/config/packages/installer.ts
+var installerCache = new Conf2({
+  projectName: "djangocfg-nextjs-installer",
+  projectVersion: "1.0.0"
+});
+var PROMPT_COOLDOWN_MS = 60 * 60 * 1e3;
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function detectPackageManager() {
+  try {
+    const fs = __require("fs");
+    const path = __require("path");
+    const cwd = process.cwd();
+    if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+    if (fs.existsSync(path.join(cwd, "package-lock.json"))) return "npm";
+    try {
+      execSync("pnpm --version", { stdio: "ignore" });
+      return "pnpm";
+    } catch {
+      try {
+        execSync("yarn --version", { stdio: "ignore" });
+        return "yarn";
+      } catch {
+        return "npm";
+      }
+    }
+  } catch {
+    return "npm";
+  }
+}
+function buildSingleInstallCommand(packageName, isDev2, pm) {
+  const devFlag = isDev2 ? "-D " : "";
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add ${devFlag}${packageName}`;
+    case "yarn":
+      return `yarn add ${devFlag}${packageName}`;
+    case "npm":
+      return `npm install ${devFlag}${packageName}`;
+  }
+}
+function buildInstallCommand(packages, pm) {
+  const devPackages = packages.filter((p) => p.devDependency).map((p) => p.name);
+  const prodPackages = packages.filter((p) => !p.devDependency).map((p) => p.name);
+  const commands = [];
+  if (devPackages.length > 0) {
+    switch (pm) {
+      case "pnpm":
+        commands.push(`pnpm add -D ${devPackages.join(" ")}`);
+        break;
+      case "yarn":
+        commands.push(`yarn add -D ${devPackages.join(" ")}`);
+        break;
+      case "npm":
+        commands.push(`npm install -D ${devPackages.join(" ")}`);
+        break;
+    }
+  }
+  if (prodPackages.length > 0) {
+    switch (pm) {
+      case "pnpm":
+        commands.push(`pnpm add ${prodPackages.join(" ")}`);
+        break;
+      case "yarn":
+        commands.push(`yarn add ${prodPackages.join(" ")}`);
+        break;
+      case "npm":
+        commands.push(`npm install ${prodPackages.join(" ")}`);
+        break;
+    }
+  }
+  return commands.join(" && ");
+}
+async function askConfirmation(question) {
+  if (isCI || !process.stdin.isTTY) {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.toLowerCase().trim();
+      resolve(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+  });
+}
+function createSpinner(text) {
+  let frameIndex = 0;
+  let interval = null;
+  let currentText = text;
+  const render = () => {
+    const frame = SPINNER_FRAMES[frameIndex];
+    process.stdout.write(`\r${chalk2.cyan(frame)} ${currentText}`);
+    frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+  };
+  return {
+    start() {
+      if (process.stdout.isTTY) {
+        interval = setInterval(render, 80);
+        render();
+      } else {
+        console.log(`  ${currentText}`);
+      }
+      return this;
+    },
+    text(newText) {
+      currentText = newText;
+      if (!process.stdout.isTTY) {
+        console.log(`  ${newText}`);
+      }
+      return this;
+    },
+    succeed(text2) {
+      if (interval) clearInterval(interval);
+      if (process.stdout.isTTY) {
+        process.stdout.write(`\r${chalk2.green("\u2713")} ${text2 || currentText}
+`);
+      } else {
+        console.log(`  ${chalk2.green("\u2713")} ${text2 || currentText}`);
+      }
+      return this;
+    },
+    fail(text2) {
+      if (interval) clearInterval(interval);
+      if (process.stdout.isTTY) {
+        process.stdout.write(`\r${chalk2.red("\u2717")} ${text2 || currentText}
+`);
+      } else {
+        console.log(`  ${chalk2.red("\u2717")} ${text2 || currentText}`);
+      }
+      return this;
+    },
+    stop() {
+      if (interval) clearInterval(interval);
+      if (process.stdout.isTTY) {
+        process.stdout.write("\r\x1B[K");
+      }
+      return this;
+    }
+  };
+}
+async function installSinglePackage(pkg, pm, index, total) {
+  const command = buildSingleInstallCommand(pkg.name, pkg.devDependency, pm);
+  const progress = `[${index + 1}/${total}]`;
+  const spinner = createSpinner(`${chalk2.dim(progress)} Installing ${chalk2.cyan(pkg.name)}...`);
+  spinner.start();
+  return new Promise((resolve) => {
+    const [cmd, ...args] = command.split(" ");
+    const proc = spawn(cmd, args, {
+      shell: true,
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed(`${chalk2.dim(progress)} ${chalk2.cyan(pkg.name)} ${chalk2.green("installed")}`);
+        resolve(true);
+      } else {
+        spinner.fail(`${chalk2.dim(progress)} ${chalk2.cyan(pkg.name)} ${chalk2.red("failed")}`);
+        if (stderr) {
+          console.log(chalk2.dim(`    ${stderr.split("\n")[0]}`));
+        }
+        resolve(false);
+      }
+    });
+    proc.on("error", () => {
+      spinner.fail(`${chalk2.dim(progress)} ${chalk2.cyan(pkg.name)} ${chalk2.red("failed")}`);
+      resolve(false);
+    });
+  });
+}
+async function installPackagesWithProgress(packages) {
+  if (packages.length === 0) return true;
+  const pm = detectPackageManager();
+  const total = packages.length;
+  console.log("");
+  console.log(chalk2.bold(`  Installing ${total} package${total > 1 ? "s" : ""}...`));
+  console.log("");
+  let successCount = 0;
+  let failedPackages = [];
+  for (let i = 0; i < packages.length; i++) {
+    const success = await installSinglePackage(packages[i], pm, i, total);
+    if (success) {
+      successCount++;
+    } else {
+      failedPackages.push(packages[i].name);
+    }
+  }
+  console.log("");
+  if (failedPackages.length === 0) {
+    consola2.success(`All ${total} packages installed successfully!`);
+    return true;
+  } else if (successCount > 0) {
+    consola2.warn(`${successCount}/${total} packages installed. Failed: ${failedPackages.join(", ")}`);
+    return false;
+  } else {
+    consola2.error(`Failed to install packages: ${failedPackages.join(", ")}`);
+    return false;
+  }
+}
+async function installPackages(packages) {
+  if (packages.length > 1 && process.stdout.isTTY) {
+    return installPackagesWithProgress(packages);
+  }
+  if (packages.length === 0) return true;
+  const pm = detectPackageManager();
+  const command = buildInstallCommand(packages, pm);
+  consola2.info(`Installing: ${chalk2.cyan(packages.map((p) => p.name).join(", "))}`);
+  const spinner = createSpinner("Installing packages...");
+  spinner.start();
+  return new Promise((resolve) => {
+    const proc = spawn(command, {
+      shell: true,
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed("Packages installed successfully!");
+        resolve(true);
+      } else {
+        spinner.fail("Failed to install packages");
+        resolve(false);
+      }
+    });
+    proc.on("error", () => {
+      spinner.fail("Installation failed");
+      resolve(false);
+    });
+  });
+}
+async function checkAndInstallPackages(options = {}) {
+  const missing = getMissingPackages();
+  const skipList = options.skipPackages || installerCache.get("skipPackages") || [];
+  const toInstall = missing.filter((p) => !skipList.includes(p.name));
+  if (toInstall.length === 0) {
+    return true;
+  }
+  const lastPrompt = installerCache.get("lastPrompt") || 0;
+  if (!options.force && Date.now() - lastPrompt < PROMPT_COOLDOWN_MS) {
+    printMissingPackagesInfo(toInstall);
+    return false;
+  }
+  if (options.autoInstall || installerCache.get("autoInstall")) {
+    return installPackages(toInstall);
+  }
+  console.log("");
+  consola2.box("\u{1F4E6} Missing Optional Packages");
+  console.log("");
+  for (const pkg of toInstall) {
+    console.log(`  ${chalk2.yellow("\u2022")} ${chalk2.bold(pkg.name)}`);
+    console.log(`    ${chalk2.dim(pkg.description)}`);
+    console.log(`    ${chalk2.dim(pkg.reason)}`);
+    console.log("");
+  }
+  const pm = detectPackageManager();
+  const command = buildInstallCommand(toInstall, pm);
+  console.log(`  ${chalk2.cyan("Command:")} ${command}`);
+  console.log("");
+  installerCache.set("lastPrompt", Date.now());
+  const shouldInstall = await askConfirmation(
+    `${chalk2.green("?")} Install these packages now? ${chalk2.dim("[Y/n]")} `
+  );
+  if (shouldInstall) {
+    const success = await installPackages(toInstall);
+    if (success) {
+      const enableAuto = await askConfirmation(
+        `${chalk2.green("?")} Enable auto-install for future? ${chalk2.dim("[y/N]")} `
+      );
+      if (enableAuto) {
+        installerCache.set("autoInstall", true);
+        consola2.info("Auto-install enabled. Run with --no-auto-install to disable.");
+      }
+    }
+    return success;
+  }
+  const skipPermanently = await askConfirmation(
+    `${chalk2.green("?")} Skip these packages in future prompts? ${chalk2.dim("[y/N]")} `
+  );
+  if (skipPermanently) {
+    const currentSkip = installerCache.get("skipPackages") || [];
+    installerCache.set("skipPackages", [...currentSkip, ...toInstall.map((p) => p.name)]);
+    consola2.info("Packages added to skip list.");
+  }
+  return false;
+}
+function printMissingPackagesInfo(packages) {
+  if (packages.length === 0) return;
+  const pm = detectPackageManager();
+  const command = buildInstallCommand(packages, pm);
+  consola2.warn(`Missing optional packages: ${packages.map((p) => p.name).join(", ")}`);
+  consola2.info(`Install with: ${chalk2.cyan(command)}`);
+}
+function resetInstallerPreferences() {
+  installerCache.clear();
+  consola2.success("Installer preferences reset");
+}
+
+// src/config/packages/updater.ts
+import { spawn as spawn2 } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+import { createRequire as createRequire2 } from "module";
+import { join as join2 } from "path";
+import chalk3 from "chalk";
+import consola3 from "consola";
+import Conf3 from "conf";
+import semver2 from "semver";
+var updaterCache = new Conf3({
+  projectName: "djangocfg-nextjs-updater",
+  projectVersion: "1.0.0"
+});
+var UPDATE_CHECK_COOLDOWN_MS = 60 * 60 * 1e3;
+var SPINNER_FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function isWorkspacePackage(packageName) {
+  try {
+    const fs = __require("fs");
+    const pkgJsonPath = join2(process.cwd(), "package.json");
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+    const deps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    const version = deps[packageName];
+    return version?.startsWith("workspace:") || false;
+  } catch {
+    return false;
+  }
+}
+function getInstalledVersion(packageName) {
+  const fs = __require("fs");
+  const cwd = process.cwd();
+  try {
+    const directPath = join2(cwd, "node_modules", packageName, "package.json");
+    if (fs.existsSync(directPath)) {
+      const pkg = JSON.parse(fs.readFileSync(directPath, "utf-8"));
+      return pkg.version || null;
+    }
+  } catch {
+  }
+  try {
+    const consumerRequire = createRequire2(join2(cwd, "package.json"));
+    const pkgPath = consumerRequire.resolve(`${packageName}/package.json`);
+    const pkg = __require(pkgPath);
+    return pkg.version || null;
+  } catch {
+  }
+  try {
+    const pkgPath = __require.resolve(`${packageName}/package.json`);
+    const pkg = __require(pkgPath);
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+function shouldCheckUpdates(packageName) {
+  return !isWorkspacePackage(packageName);
+}
+async function fetchLatestVersion2(packageName) {
+  try {
+    const https = await import("https");
+    return new Promise((resolve) => {
+      const req = https.get(
+        `https://registry.npmjs.org/${packageName}/latest`,
+        { timeout: 5e3 },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            try {
+              const json = JSON.parse(data);
+              resolve(json.version || null);
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on("error", () => resolve(null));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(null);
+      });
+    });
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdates(options = {}) {
+  const results = [];
+  const masterLatest = await fetchLatestVersion2(PACKAGE_NAME);
+  if (!masterLatest) {
+    return results;
+  }
+  const checks = DJANGOCFG_PACKAGES.map(async (name) => {
+    const isWorkspace = !shouldCheckUpdates(name);
+    if (!options.forceCheckWorkspace && isWorkspace) {
+      return null;
+    }
+    const current = getInstalledVersion(name);
+    if (!current) {
+      return null;
+    }
+    const hasUpdate = !!(masterLatest && current && semver2.gt(masterLatest, current));
+    return { name, current, latest: masterLatest, hasUpdate };
+  });
+  const checkResults = await Promise.all(checks);
+  for (const result of checkResults) {
+    if (result) {
+      results.push(result);
+    }
+  }
+  return results;
+}
+async function getOutdatedPackages(options = {}) {
+  const all = await checkForUpdates(options);
+  const skipped = updaterCache.get("skippedVersions") || {};
+  return all.filter((pkg) => {
+    if (!pkg.hasUpdate) return false;
+    if (skipped[pkg.name] === pkg.latest) return false;
+    return true;
+  });
+}
+function createSpinner2(text) {
+  let frameIndex = 0;
+  let interval = null;
+  let currentText = text;
+  const render = () => {
+    const frame = SPINNER_FRAMES2[frameIndex];
+    process.stdout.write(`\r${chalk3.cyan(frame)} ${currentText}`);
+    frameIndex = (frameIndex + 1) % SPINNER_FRAMES2.length;
+  };
+  return {
+    start() {
+      if (process.stdout.isTTY) {
+        interval = setInterval(render, 80);
+        render();
+      } else {
+        console.log(`  ${currentText}`);
+      }
+      return this;
+    },
+    text(newText) {
+      currentText = newText;
+      return this;
+    },
+    succeed(text2) {
+      if (interval) clearInterval(interval);
+      if (process.stdout.isTTY) {
+        process.stdout.write(`\r${chalk3.green("\u2713")} ${text2 || currentText}
+`);
+      } else {
+        console.log(`  ${chalk3.green("\u2713")} ${text2 || currentText}`);
+      }
+      return this;
+    },
+    fail(text2) {
+      if (interval) clearInterval(interval);
+      if (process.stdout.isTTY) {
+        process.stdout.write(`\r${chalk3.red("\u2717")} ${text2 || currentText}
+`);
+      } else {
+        console.log(`  ${chalk3.red("\u2717")} ${text2 || currentText}`);
+      }
+      return this;
+    },
+    stop() {
+      if (interval) clearInterval(interval);
+      if (process.stdout.isTTY) {
+        process.stdout.write("\r\x1B[K");
+      }
+      return this;
+    }
+  };
+}
+async function askConfirmation2(question) {
+  if (isCI || !process.stdin.isTTY) {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const rl = createInterface2({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.toLowerCase().trim();
+      resolve(normalized === "" || normalized === "y" || normalized === "yes");
+    });
+  });
+}
+async function updateSinglePackage(pkg, pm, index, total) {
+  const progress = `[${index + 1}/${total}]`;
+  const versionInfo = `${chalk3.red(pkg.current)} \u2192 ${chalk3.green(pkg.latest)}`;
+  const spinner = createSpinner2(
+    `${chalk3.dim(progress)} Updating ${chalk3.cyan(pkg.name)} ${versionInfo}`
+  );
+  spinner.start();
+  const command = pm === "pnpm" ? `pnpm add ${pkg.name}@latest` : pm === "yarn" ? `yarn add ${pkg.name}@latest` : `npm install ${pkg.name}@latest`;
+  return new Promise((resolve) => {
+    const proc = spawn2(command, {
+      shell: true,
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        spinner.succeed(
+          `${chalk3.dim(progress)} ${chalk3.cyan(pkg.name)} ${chalk3.green(pkg.latest)}`
+        );
+        resolve(true);
+      } else {
+        spinner.fail(
+          `${chalk3.dim(progress)} ${chalk3.cyan(pkg.name)} ${chalk3.red("failed")}`
+        );
+        resolve(false);
+      }
+    });
+    proc.on("error", () => {
+      spinner.fail(`${chalk3.dim(progress)} ${chalk3.cyan(pkg.name)} ${chalk3.red("failed")}`);
+      resolve(false);
+    });
+  });
+}
+async function updatePackagesWithProgress(packages) {
+  if (packages.length === 0) return true;
+  const pm = detectPackageManager();
+  const total = packages.length;
+  console.log("");
+  console.log(chalk3.bold(`  Updating ${total} package${total > 1 ? "s" : ""}...`));
+  console.log("");
+  let successCount = 0;
+  const failedPackages = [];
+  for (let i = 0; i < packages.length; i++) {
+    const success = await updateSinglePackage(packages[i], pm, i, total);
+    if (success) {
+      successCount++;
+    } else {
+      failedPackages.push(packages[i].name);
+    }
+  }
+  console.log("");
+  if (failedPackages.length === 0) {
+    consola3.success(`All ${total} packages updated successfully!`);
+    return true;
+  } else if (successCount > 0) {
+    consola3.warn(`${successCount}/${total} packages updated. Failed: ${failedPackages.join(", ")}`);
+    return false;
+  } else {
+    consola3.error(`Failed to update packages: ${failedPackages.join(", ")}`);
+    return false;
+  }
+}
+async function checkAndUpdatePackages(options = {}) {
+  const lastCheck = updaterCache.get("lastCheck") || 0;
+  if (!options.force && Date.now() - lastCheck < UPDATE_CHECK_COOLDOWN_MS) {
+    return true;
+  }
+  updaterCache.set("lastCheck", Date.now());
+  const spinner = createSpinner2("Checking for updates...");
+  spinner.start();
+  const outdated = await getOutdatedPackages({
+    forceCheckWorkspace: options.forceCheckWorkspace
+  });
+  spinner.stop();
+  console.log(chalk3.dim(`  Found ${outdated.length} outdated package(s)`));
+  if (outdated.length === 0) {
+    console.log(chalk3.green("  \u2713 All packages are up to date"));
+    return true;
+  }
+  if (options.autoUpdate || updaterCache.get("autoUpdate")) {
+    return updatePackagesWithProgress(outdated);
+  }
+  console.log("");
+  consola3.box("\u{1F4E6} Updates Available");
+  console.log("");
+  for (const pkg of outdated) {
+    console.log(
+      `  ${chalk3.yellow("\u2022")} ${chalk3.bold(pkg.name)}  ${chalk3.red(pkg.current)} \u2192 ${chalk3.green(pkg.latest)}`
+    );
+  }
+  console.log("");
+  const shouldUpdate = await askConfirmation2(
+    `${chalk3.green("?")} Update these packages now? ${chalk3.dim("[Y/n]")} `
+  );
+  if (shouldUpdate) {
+    const success = await updatePackagesWithProgress(outdated);
+    if (success) {
+      const enableAuto = await askConfirmation2(
+        `${chalk3.green("?")} Enable auto-update for future? ${chalk3.dim("[y/N]")} `
+      );
+      if (enableAuto) {
+        updaterCache.set("autoUpdate", true);
+        consola3.info("Auto-update enabled.");
+      }
+    }
+    return success;
+  }
+  const skipVersions = await askConfirmation2(
+    `${chalk3.green("?")} Skip these versions in future? ${chalk3.dim("[y/N]")} `
+  );
+  if (skipVersions) {
+    const skipped = updaterCache.get("skippedVersions") || {};
+    for (const pkg of outdated) {
+      if (pkg.latest) {
+        skipped[pkg.name] = pkg.latest;
+      }
+    }
+    updaterCache.set("skippedVersions", skipped);
+    consola3.info("Versions skipped. Will prompt again for newer versions.");
+  }
+  return false;
+}
+function resetUpdaterPreferences() {
+  updaterCache.clear();
+  consola3.success("Updater preferences reset");
+}
+
+// src/config/plugins/devStartup.ts
+var startupDone = false;
+var browserOpened = false;
+var DevStartupPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    compiler.hooks.done.tapPromise("DevStartupPlugin", async () => {
+      if (!startupDone) {
+        startupDone = true;
+        await this.runStartupTasks();
+      }
+      if (this.options.openBrowser && !browserOpened) {
+        browserOpened = true;
+        this.openBrowser();
+      }
+    });
+  }
+  async runStartupTasks() {
+    console.log("\n" + chalk4.yellowBright.bold(DJANGO_CFG_BANNER));
+    const version = getCurrentVersion();
+    if (version) {
+      console.log(chalk4.dim(`  \u{1F4E6} @djangocfg/nextjs v${version}`));
+    }
+    console.log(chalk4.magenta(`  ${AI_DOCS_HINT}
+`));
+    if (this.options.checkUpdates !== false) {
+      try {
+        await checkAndUpdatePackages({
+          autoUpdate: this.options.autoUpdate,
+          forceCheckWorkspace: this.options.forceCheckWorkspace,
+          force: true
+          // Force check ignoring cooldown
+        });
+      } catch (err) {
+        console.log(chalk4.red("  Update check failed:"), err);
+      }
+    }
+    if (this.options.checkPackages !== false) {
+      await checkAndInstallPackages({
+        autoInstall: this.options.autoInstall
+      });
+    }
+  }
+  openBrowser() {
+    setTimeout(async () => {
+      try {
+        const { exec } = await import("child_process");
+        const port = process.env.PORT || "3000";
+        const url = `http://localhost:${port}`;
+        const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        exec(`${command} ${url}`, (error) => {
+          if (error) {
+            console.warn(`Failed to open browser: ${error.message}`);
+          }
+        });
+      } catch (error) {
+        console.warn("Failed to open browser");
+      }
+    }, 2e3);
+  }
+};
+function resetDevStartupState() {
+  startupDone = false;
+  browserOpened = false;
+}
+
+// src/config/plugins/compression.ts
+var DEFAULT_OPTIONS = {
+  gzip: true,
+  brotli: true,
+  threshold: 8192,
+  minRatio: 0.8,
+  brotliLevel: 8
+};
+function addCompressionPlugins(config, options = {}) {
+  if (!isPackageInstalled("compression-webpack-plugin")) {
+    return false;
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  try {
+    const CompressionPlugin = __require("compression-webpack-plugin");
+    if (!config.plugins) {
+      config.plugins = [];
+    }
+    if (opts.gzip) {
+      config.plugins.push(
+        new CompressionPlugin({
+          filename: "[path][base].gz",
+          algorithm: "gzip",
+          test: /\.(js|css|html|svg|json)$/,
+          threshold: opts.threshold,
+          minRatio: opts.minRatio
+        })
+      );
+    }
+    if (opts.brotli) {
+      config.plugins.push(
+        new CompressionPlugin({
+          filename: "[path][base].br",
+          algorithm: "brotliCompress",
+          test: /\.(js|css|html|svg|json)$/,
+          threshold: opts.threshold,
+          minRatio: opts.minRatio,
+          compressionOptions: {
+            level: opts.brotliLevel
+          }
+        })
+      );
+    }
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function isCompressionAvailable() {
+  return isPackageInstalled("compression-webpack-plugin");
+}
+
+// src/config/createNextConfig.ts
+function createBaseNextConfig(options = {}) {
+  const basePath = getBasePath(options.isDefaultCfgAdmin);
+  const apiUrl = getApiUrl();
+  const siteUrl = getSiteUrl2();
+  const baseConfig = {
+    reactStrictMode: true,
+    trailingSlash: true,
+    // Static export configuration
+    ...isStaticBuild && {
+      output: "export",
+      distDir: "out",
+      basePath,
+      // Fix for Next.js 15.5.4: prevent 500.html generation issue
+      generateBuildId: async () => {
+        return "static-build";
+      }
+    },
+    // Standalone output for Docker (only in production, not dev)
+    ...!isStaticBuild && !isDev && {
+      output: "standalone"
+    },
+    // Environment variables
+    env: {
+      NEXT_PUBLIC_BASE_PATH: basePath,
+      NEXT_PUBLIC_API_URL: apiUrl,
+      NEXT_PUBLIC_SITE_URL: siteUrl,
+      ...options.env
+    },
+    // Images configuration
+    images: {
+      unoptimized: true
+    },
+    // CORS headers for static files and iframe embedding
+    async headers() {
+      const headers = [
+        {
+          source: "/static/:path*",
+          headers: [
+            { key: "Access-Control-Allow-Origin", value: "*" },
+            { key: "Access-Control-Allow-Methods", value: "GET, OPTIONS" },
+            { key: "Access-Control-Allow-Headers", value: "Origin, Content-Type, Accept" }
+          ]
+        }
+      ];
+      if (options.allowIframeFrom && options.allowIframeFrom.length > 0) {
+        const frameAncestors = options.allowIframeFrom.includes("*") ? "*" : `'self' ${options.allowIframeFrom.join(" ")}`;
+        headers.push({
+          source: "/:path*",
+          headers: [
+            // Content-Security-Policy frame-ancestors directive
+            { key: "Content-Security-Policy", value: `frame-ancestors ${frameAncestors}` },
+            // X-Frame-Options for older browsers (ALLOW-FROM is deprecated, use CSP instead)
+            // Only set SAMEORIGIN if allowing all, otherwise browsers will use CSP
+            ...options.allowIframeFrom.includes("*") ? [] : [{ key: "X-Frame-Options", value: "SAMEORIGIN" }]
+          ]
+        });
+      }
+      return headers;
+    },
+    // Transpile packages (merge with user-provided)
+    transpilePackages: [
+      ...DEFAULT_TRANSPILE_PACKAGES,
+      ...options.transpilePackages || []
+    ],
+    // Experimental features
+    experimental: {
+      // Optimize package imports (only in production)
+      ...!isDev && {
+        optimizePackageImports: [
+          ...DEFAULT_OPTIMIZE_PACKAGES,
+          ...options.optimizePackageImports || []
+        ]
+      },
+      // Dev mode optimizations
+      ...isDev && {
+        optimizeCss: false
+      },
+      // User experimental options applied last (can override base settings)
+      ...options.experimental
+    },
+    // Webpack configuration
+    webpack: (config, webpackOptions) => {
+      const { isServer, dev } = webpackOptions;
+      if (dev && !isServer) {
+        if (!config.plugins) {
+          config.plugins = [];
+        }
+        config.plugins.push(
+          new DevStartupPlugin({
+            openBrowser: options.openBrowser,
+            checkUpdates: options.checkUpdates,
+            autoUpdate: options.autoUpdate,
+            forceCheckWorkspace: options.forceCheckWorkspace,
+            checkPackages: options.checkPackages,
+            autoInstall: options.autoInstall
+          })
+        );
+      }
+      if (dev) {
+        config.optimization = {
+          ...config.optimization,
+          removeAvailableModules: false,
+          removeEmptyChunks: false,
+          splitChunks: false
+          // Disable code splitting in dev for faster compilation
+        };
+      }
+      config.cache = {
+        type: "filesystem",
+        buildDependencies: {}
+      };
+      if (!isServer && isStaticBuild && !dev) {
+        addCompressionPlugins(config);
+      }
+      if (options.webpack) {
+        return options.webpack(config, webpackOptions);
+      }
+      return config;
+    }
+  };
+  const finalConfig = deepMerge(baseConfig, options);
+  delete finalConfig.optimizePackageImports;
+  delete finalConfig.isDefaultCfgAdmin;
+  delete finalConfig.openBrowser;
+  delete finalConfig.checkUpdates;
+  delete finalConfig.autoUpdate;
+  delete finalConfig.forceCheckWorkspace;
+  delete finalConfig.checkPackages;
+  delete finalConfig.autoInstall;
+  delete finalConfig.allowIframeFrom;
+  return finalConfig;
+}
+
+// src/ai/client.ts
+var DjangoCfgDocsClient = class {
+  constructor(baseUrl = MCP_BASE_URL, timeout = DEFAULT_TIMEOUT) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.timeout = timeout;
+  }
+  async makeRequest(endpoint, params) {
+    let url = `${this.baseUrl}${endpoint}`;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(params)) {
+        searchParams.set(key, String(value));
+      }
+      url = `${url}?${searchParams.toString()}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          "User-Agent": "DjangoCFG-AI-Client/1.0"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP Error ${response.status}: ${response.statusText}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Search documentation.
+   */
+  async search(query, options = {}) {
+    const { limit = 5, category } = options;
+    const params = { q: query, limit };
+    if (category) {
+      params.category = category;
+    }
+    const data = await this.makeRequest(API_SEARCH_ENDPOINT, params);
+    const results = data.results || (Array.isArray(data) ? data : []);
+    return results.map((item) => ({
+      title: item.title || "",
+      content: item.content || item.snippet || "",
+      url: item.url || "",
+      score: item.score || 0,
+      category: item.category || ""
+    }));
+  }
+  /**
+   * Get detailed info about a specific topic.
+   */
+  async getInfo(topic) {
+    return this.makeRequest(API_INFO_ENDPOINT, { topic });
+  }
+  /**
+   * Get MCP server configuration for AI assistants.
+   */
+  getMcpConfig() {
+    return {
+      mcpServers: {
+        "djangocfg-docs": {
+          url: `${this.baseUrl}/mcp`
+        }
+      }
+    };
+  }
+};
+var defaultClient = null;
+function getClient() {
+  if (!defaultClient) {
+    defaultClient = new DjangoCfgDocsClient();
+  }
+  return defaultClient;
+}
+async function search(query, options = {}) {
+  return getClient().search(query, options);
+}
+async function getDocs(query, limit = 3) {
+  const results = await search(query, { limit });
+  if (results.length === 0) {
+    return `No documentation found for: ${query}`;
+  }
+  const output = [];
+  results.forEach((r, i) => {
+    output.push(`## ${i + 1}. ${r.title}`);
+    output.push(r.content);
+    if (r.url) {
+      output.push(`\u{1F4D6} Read more: ${r.url}`);
+    }
+    output.push("");
+  });
+  return output.join("\n");
+}
+async function getInfo(topic) {
+  return getClient().getInfo(topic);
+}
+function getMcpConfig() {
+  return getClient().getMcpConfig();
+}
+export {
+  AI_DOCS_HINT,
+  AI_HINT,
+  DEFAULT_OPTIMIZE_PACKAGES,
+  DEFAULT_TRANSPILE_PACKAGES,
+  DJANGOCFG_PACKAGES,
+  DJANGO_CFG_BANNER,
+  DefaultTemplate,
+  DevStartupPlugin,
+  DjangoCfgDocsClient,
+  LightTemplate,
+  MCP_API_URL,
+  MCP_BASE_URL,
+  MCP_SERVER_URL,
+  OPTIONAL_PACKAGES,
+  PACKAGE_NAME,
+  PEER_DEPENDENCIES,
+  POST,
+  addCompressionPlugins,
+  buildInstallCommand,
+  buildSingleInstallCommand,
+  checkAndInstallPackages,
+  checkAndUpdatePackages,
+  checkForUpdate,
+  checkForUpdates,
+  checkPackages,
+  createBaseNextConfig,
+  createContactRoute,
+  createFontLoader,
+  createHealthHandler,
+  createOgImageDynamicRoute,
+  createOgImageHandler,
+  createOgImageMetadataGenerator,
+  createOgImageUrlBuilder,
+  createSitemapHandler,
+  decodeBase64,
+  deepMerge,
+  defineRoute,
+  detectPackageManager,
+  encodeBase64,
+  fetchLatestVersion,
+  findRoute,
+  findRouteByPattern,
+  generateOgImageMetadata,
+  generateOgImageUrl,
+  generateSitemapXml,
+  getAbsoluteOgImageUrl,
+  getApiUrl,
+  getBasePath,
+  getCurrentVersion,
+  getDocs,
+  getInfo,
+  getInstalledVersion,
+  getMcpConfig,
+  getMissingPackages,
+  getOutdatedPackages,
+  getPackagesForContext,
+  getPageTitle,
+  getSiteUrl2 as getSiteUrl,
+  getUnauthenticatedRedirect,
+  getUpdateCommand,
+  installPackages,
+  installPackagesWithProgress,
+  isActive,
+  isCI,
+  isCompressionAvailable,
+  isDev,
+  isPackageInstalled,
+  isProduction,
+  isStaticBuild,
+  loadGoogleFont,
+  loadGoogleFonts,
+  normalizeUrl,
+  parseOgImageData,
+  parseOgImageUrl,
+  printVersionInfo,
+  redirectToAuth,
+  resetDevStartupState,
+  resetInstallerPreferences,
+  resetUpdaterPreferences,
+  routesToMenuItems,
+  search,
+  submitContactForm,
+  updatePackagesWithProgress
+};
+//# sourceMappingURL=index.mjs.map