vite-plugin-smart-prefetch 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1783 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  smartPrefetch: () => smartPrefetch
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin/analytics/bigquery-connector.ts
+var import_bigquery = require("@google-cloud/bigquery");
+var import_fs = require("fs");
+var import_path = require("path");
+var BigQueryAnalyticsConnector = class {
+  constructor(projectId, datasetId, debug = false) {
+    this.projectId = projectId;
+    this.datasetId = datasetId;
+    this.debug = debug;
+    this.bigquery = new import_bigquery.BigQuery({
+      projectId
+    });
+    if (this.debug) {
+      console.log("\u2705 BigQuery Analytics connector initialized");
+      console.log(`   Project ID: ${projectId}`);
+      console.log(`   Dataset ID: ${datasetId}`);
+    }
+  }
+  /**
+   * Fetch real navigation transitions from BigQuery GA4 export
+   * Queries the events table for page_view events with previous_page_path parameter
+   */
+  async fetchNavigationSequences(config = {}) {
+    const { days = 30 } = config;
+    const minSessions = 1;
+    console.log(`\u{1F4CA} Fetching navigation data from BigQuery...`);
+    console.log(`   Dataset: ${this.datasetId}`);
+    console.log(`   Date range: Last ${days} days`);
+    try {
+      const query = `
+        WITH page_sessions AS (
+          SELECT
+            user_id,
+            (SELECT value.int_value FROM UNNEST(event_params) WHERE KEY = 'ga_session_id' LIMIT 1) as session_id,
+            (SELECT value.string_value FROM UNNEST(event_params) WHERE KEY = 'page_location' LIMIT 1) as page_location,
+            (SELECT value.string_value FROM UNNEST(event_params) WHERE KEY = 'page_path' LIMIT 1) as page_path,
+            event_timestamp,
+            ROW_NUMBER() OVER (
+              PARTITION BY user_id, (SELECT value.int_value FROM UNNEST(event_params) WHERE KEY = 'ga_session_id' LIMIT 1)
+              ORDER BY event_timestamp
+            ) as page_sequence
+          FROM \`${this.projectId}.${this.datasetId}.events_*\`
+          WHERE
+            event_name = 'page_view'
+            AND _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL ${days} DAY))
+              AND FORMAT_DATE('%Y%m%d', CURRENT_DATE())
+            AND (SELECT value.string_value FROM UNNEST(event_params) WHERE KEY = 'page_path' LIMIT 1) IS NOT NULL
+        ),
+        transitions AS (
+          SELECT
+            COALESCE(curr.page_path, '(direct)') as from_page,
+            LEAD(curr.page_path) OVER (
+              PARTITION BY curr.user_id, curr.session_id
+              ORDER BY curr.page_sequence
+            ) as to_page
+          FROM page_sessions curr
+          WHERE curr.page_sequence > 0
+        )
+        SELECT
+          from_page as previous_page_path,
+          to_page as page_path,
+          COUNT(*) as transition_count
+        FROM transitions
+        WHERE to_page IS NOT NULL
+        GROUP BY from_page, to_page
+        ORDER BY transition_count DESC
+        LIMIT 10000
+      `;
+      if (this.debug) {
+        console.log(`\u{1F4E4} BigQuery Query:`);
+        console.log(query);
+      }
+      const [rows] = await this.bigquery.query({
+        query,
+        location: "US"
+      });
+      if (this.debug) {
+        console.log(`\u2705 Query executed successfully`);
+        console.log(`   Rows returned: ${rows.length}`);
+      }
+      const navigationData = [];
+      const rawData = rows.map((row) => ({
+        previous_page_path: row.previous_page_path,
+        page_path: row.page_path,
+        transition_count: row.transition_count
+      }));
+      rows.forEach((row) => {
+        const previousPage = row.previous_page_path || "(direct)";
+        const currentPage = row.page_path || "";
+        const transitionCount = parseInt(row.transition_count || "0");
+        const normalizedPrevious = previousPage === "(direct)" || previousPage === "(not set)" ? "(direct)" : this.normalizeRoute(previousPage);
+        const normalizedCurrent = this.normalizeRoute(currentPage);
+        if (normalizedCurrent && transitionCount >= minSessions) {
+          navigationData.push({
+            from: normalizedPrevious,
+            to: normalizedCurrent,
+            count: transitionCount
+          });
+        }
+      });
+      this.saveDataForInspection(rawData, navigationData);
+      if (this.debug) {
+        console.log(`\u2705 Processed ${navigationData.length} navigation transitions`);
+        if (navigationData.length > 0) {
+          console.log(`
+   Top 5 transitions:`);
+          navigationData.slice(0, 5).forEach((nav, i) => {
+            console.log(`   ${i + 1}. ${nav.from} \u2192 ${nav.to} (${nav.count} transitions)`);
+          });
+        }
+        const uniqueRoutes = /* @__PURE__ */ new Set();
+        navigationData.forEach((nav) => {
+          if (nav.from !== "(direct)") uniqueRoutes.add(nav.from);
+          uniqueRoutes.add(nav.to);
+        });
+        console.log(`
+   \u{1F4CA} Unique routes: ${uniqueRoutes.size}`);
+        console.log(`   Routes: ${Array.from(uniqueRoutes).sort().join(", ")}`);
+        console.log(`
+   \u{1F4C1} Raw data saved to: .bigquery-raw-data/`);
+      }
+      return navigationData;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (errorMessage.includes("bigquery.jobs.create") || errorMessage.includes("PERMISSION_DENIED")) {
+        console.error("\u274C Failed to fetch BigQuery data: Permission Denied");
+        console.error("   Service account needs BigQuery Job User role in the project");
+        console.error("   Error details:", errorMessage);
+      } else {
+        console.error("\u274C Failed to fetch BigQuery data:", error);
+      }
+      throw new Error(
+        `BigQuery Analytics error: ${errorMessage}`
+      );
+    }
+  }
+  /**
+   * Map friendly page names (with spaces/capitals) back to route paths
+   * GA4 may log display names instead of URL paths
+   * Examples: "Audit Logs" → "/audit-logs", "API Documentation" → "/api-docs", "Home" → "/"
+   */
+  friendlyNameToRoute(name) {
+    const friendlyToRoute = {
+      // Exact matches (with spaces and capitals)
+      "API Documentation": "/api-docs",
+      "Audit Logs": "/audit-logs",
+      "/Home": "/",
+      "/home": "/",
+      "Home": "/",
+      "/Dashboard": "/dashboard",
+      "Dashboard": "/dashboard",
+      // PascalCase variants (all 27 routes)
+      "Profile": "/profile",
+      "Settings": "/settings",
+      "Preferences": "/preferences",
+      "Privacy": "/privacy",
+      "Security": "/security",
+      "Analytics": "/analytics",
+      "Reports": "/reports",
+      "Metrics": "/metrics",
+      "Projects": "/projects",
+      "Tasks": "/tasks",
+      "Teams": "/teams",
+      "Workspaces": "/workspaces",
+      "Workflows": "/workflows",
+      "Templates": "/templates",
+      "Logs": "/logs",
+      "AuditLogs": "/audit-logs",
+      "Integrations": "/integrations",
+      "ApiDocs": "/api-docs",
+      "Support": "/support",
+      "Help": "/help",
+      "Billing": "/billing",
+      "Plans": "/plans",
+      "Usage": "/usage",
+      "Permissions": "/permissions",
+      "Notifications": "/notifications"
+    };
+    if (friendlyToRoute[name]) {
+      return friendlyToRoute[name];
+    }
+    const lowerName = name.toLowerCase();
+    for (const [key, value] of Object.entries(friendlyToRoute)) {
+      if (key.toLowerCase() === lowerName) {
+        return value;
+      }
+    }
+    if (name.startsWith("/")) {
+      if (name === "/") {
+        return "/";
+      }
+      return name.toLowerCase();
+    }
+    return "/" + lowerName;
+  }
+  /**
+   * Normalize route paths
+   * Converts dynamic segments to parameters and friendly names to route paths
+   */
+  normalizeRoute(path2) {
+    const buildArtifacts = [
+      /\.(js|css|jpg|jpeg|png|gif|svg|webp|woff|woff2|ttf|eot|map)(\?|#|$)/i,
+      /\[hash\]/i,
+      /\/chunks\//i,
+      /\/vendor\//i,
+      /\/assets\//i,
+      /\.vite\//i
+    ];
+    if (buildArtifacts.some((pattern) => pattern.test(path2))) {
+      return "";
+    }
+    let normalized = this.friendlyNameToRoute(path2);
+    normalized = normalized.split("?")[0].split("#")[0];
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    if (normalized !== "/") {
+      normalized = normalized.toLowerCase().replace(/ +/g, "-");
+    }
+    normalized = normalized.replace(/\/[0-9a-f]{24}(?=\/|$)/gi, "/:id").replace(/\/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}(?=\/|$)/gi, "/:id").replace(/\/\d+(?=\/|$)/g, "/:id").replace(/\/[\w.-]+@[\w.-]+\.[\w]+(?=\/|$)/gi, "/:email").replace(/\/\d{4}-\d{2}-\d{2}(?=\/|$)/g, "/:date");
+    return normalized;
+  }
+  /**
+   * Save raw and processed data for inspection
+   * Helps identify issues in data transformation pipeline
+   */
+  saveDataForInspection(rawData, processedData) {
+    try {
+      const outputDir = ".bigquery-raw-data";
+      const outputPath = (0, import_path.join)(process.cwd(), outputDir);
+      (0, import_fs.mkdirSync)(outputPath, { recursive: true });
+      const rawFile = (0, import_path.join)(outputPath, "raw-bigquery-response.json");
+      (0, import_fs.writeFileSync)(rawFile, JSON.stringify(rawData, null, 2));
+      const processedFile = (0, import_path.join)(outputPath, "processed-navigation-data.json");
+      (0, import_fs.writeFileSync)(processedFile, JSON.stringify(processedData, null, 2));
+      const summary = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        rawRowCount: rawData.length,
+        processedRowCount: processedData.length,
+        dataLoss: rawData.length - processedData.length,
+        dataLossPercentage: ((rawData.length - processedData.length) / rawData.length * 100).toFixed(2) + "%",
+        totalTransitions: processedData.reduce((sum, d) => sum + d.count, 0),
+        uniqueFromRoutes: new Set(processedData.map((d) => d.from)).size,
+        uniqueToRoutes: new Set(processedData.map((d) => d.to)).size,
+        topTransitions: processedData.slice(0, 10)
+      };
+      const summaryFile = (0, import_path.join)(outputPath, "data-transformation-summary.json");
+      (0, import_fs.writeFileSync)(summaryFile, JSON.stringify(summary, null, 2));
+      if (this.debug) {
+        console.log(`
+\u{1F4CA} Data Inspection Summary:`);
+        console.log(`   Raw rows from BigQuery: ${summary.rawRowCount}`);
+        console.log(`   Processed rows (after filtering): ${summary.processedRowCount}`);
+        console.log(`   Data loss: ${summary.dataLoss} rows (${summary.dataLossPercentage})`);
+        console.log(`   Total transitions count: ${summary.totalTransitions}`);
+        console.log(`   Unique source routes: ${summary.uniqueFromRoutes}`);
+        console.log(`   Unique destination routes: ${summary.uniqueToRoutes}`);
+        console.log(`
+   Files saved:`);
+        console.log(`   \u2022 ${rawFile}`);
+        console.log(`   \u2022 ${processedFile}`);
+        console.log(`   \u2022 ${summaryFile}`);
+      }
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Could not save inspection data:`, error instanceof Error ? error.message : error);
+    }
+  }
+  /**
+   * Fetch navigation data WITH segment information
+   * Includes segment/role field so plugin can group by any role dynamically
+   * @param config - Data range configuration
+   * @returns Navigation data with segment field included
+   */
+  async fetchNavigationWithSegments(config = {}) {
+    const { days = 30 } = config;
+    console.log(`\u{1F4CA} Fetching navigation data with segments from BigQuery...`);
+    console.log(`   Dataset: ${this.datasetId}`);
+    console.log(`   Date range: Last ${days} days`);
+    try {
+      const query = `
+        WITH page_sessions AS (
+          SELECT
+            user_id,
+            (SELECT value.int_value FROM UNNEST(event_params) WHERE KEY = 'ga_session_id' LIMIT 1) as session_id,
+            (SELECT value.string_value FROM UNNEST(event_params) WHERE KEY = 'page_path' LIMIT 1) as page_path,
+            (SELECT value.string_value FROM UNNEST(event_params) WHERE KEY = 'user_role' LIMIT 1) as user_role,
+            (SELECT value.string_value FROM UNNEST(event_params) WHERE KEY = 'user_segment' LIMIT 1) as user_segment,
+            event_timestamp,
+            ROW_NUMBER() OVER (
+              PARTITION BY user_id, (SELECT value.int_value FROM UNNEST(event_params) WHERE KEY = 'ga_session_id' LIMIT 1)
+              ORDER BY event_timestamp
+            ) as page_sequence
+          FROM \`${this.projectId}.${this.datasetId}.events_*\`
+          WHERE
+            event_name = 'page_view'
+            AND _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL ${days} DAY))
+              AND FORMAT_DATE('%Y%m%d', CURRENT_DATE())
+            AND (SELECT value.string_value FROM UNNEST(event_params) WHERE KEY = 'page_path' LIMIT 1) IS NOT NULL
+        ),
+        transitions AS (
+          SELECT
+            COALESCE(curr.page_path, '(direct)') as from_page,
+            LEAD(curr.page_path) OVER (
+              PARTITION BY curr.user_id, curr.session_id
+              ORDER BY curr.page_sequence
+            ) as to_page,
+            COALESCE(curr.user_role, curr.user_segment, 'unknown') as segment
+          FROM page_sessions curr
+          WHERE curr.page_sequence > 0
+        )
+        SELECT
+          from_page as previous_page_path,
+          to_page as page_path,
+          segment,
+          COUNT(*) as transition_count
+        FROM transitions
+        WHERE to_page IS NOT NULL
+        GROUP BY from_page, to_page, segment
+        ORDER BY segment, transition_count DESC
+        LIMIT 50000
+      `;
+      if (this.debug) {
+        console.log(`\u{1F4E4} Query with segments:`);
+        console.log(query);
+      }
+      const [rows] = await this.bigquery.query({
+        query,
+        location: "US"
+      });
+      if (this.debug) {
+        console.log(`\u2705 Query executed successfully`);
+        console.log(`   Rows returned: ${rows.length}`);
+      }
+      const navigationData = [];
+      rows.forEach((row) => {
+        const previousPage = row.previous_page_path || "(direct)";
+        const currentPage = row.page_path || "";
+        const transitionCount = parseInt(row.transition_count || "0");
+        const segment = row.segment || "unknown";
+        const normalizedPrevious = previousPage === "(direct)" || previousPage === "(not set)" ? "(direct)" : this.normalizeRoute(previousPage);
+        const normalizedCurrent = this.normalizeRoute(currentPage);
+        if (normalizedCurrent && transitionCount >= 1) {
+          navigationData.push({
+            from: normalizedPrevious,
+            to: normalizedCurrent,
+            count: transitionCount,
+            segment
+            // Include segment/role field
+          });
+        }
+      });
+      if (this.debug && navigationData.length > 0) {
+        console.log(`\u2705 Processed ${navigationData.length} transitions with segment data`);
+        const uniqueSegments = new Set(navigationData.map((d) => d.segment));
+        console.log(`
+   Detected segments: ${Array.from(uniqueSegments).sort().join(", ")}`);
+        const bySegment = /* @__PURE__ */ new Map();
+        navigationData.forEach((d) => {
+          if (!bySegment.has(d.segment)) {
+            bySegment.set(d.segment, []);
+          }
+          bySegment.get(d.segment).push(d);
+        });
+        bySegment.forEach((transitions, segment) => {
+          console.log(`
+   Top 3 transitions for ${segment}:`);
+          transitions.sort((a, b) => b.count - a.count).slice(0, 3).forEach((nav, i) => {
+            console.log(`   ${i + 1}. ${nav.from} \u2192 ${nav.to} (${nav.count} transitions)`);
+          });
+        });
+      }
+      return navigationData;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      console.warn(`\u26A0\uFE0F  Failed to fetch navigation data with segments: ${errorMessage}`);
+      return [];
+    }
+  }
+  /**
+   * Test connection to BigQuery
+   * Note: May fail if service account lacks bigquery.jobs.create permission
+   * but actual queries may still work. This is expected for viewer-only accounts.
+   */
+  async testConnection() {
+    try {
+      const query = `SELECT 1 as test_value`;
+      await this.bigquery.query({
+        query,
+        location: "US"
+      });
+      if (this.debug) {
+        console.log("\u2705 BigQuery connection test successful");
+      }
+      return true;
+    } catch (error) {
+      if (this.debug) {
+        console.warn("\u26A0\uFE0F  BigQuery connection test failed (may be expected for read-only accounts)");
+      }
+      return false;
+    }
+  }
+};
+
+// src/plugin/model/guessjs-ml-trainer.ts
+var MarkovChainTrainer = class {
+  constructor(config, debug = false) {
+    this.config = config;
+    this.debug = debug;
+  }
+  /**
+   * Train Markov chain model from navigation data
+   * Calculates transition probabilities: P(dest | src) = transitions(src→dest) / total_from_src
+   */
+  trainMLModel(navigationData, environment) {
+    if (this.debug) {
+      console.log(`
+\u{1F916} Training Markov Chain Model...`);
+      console.log(`   Model type: ${this.config.type}`);
+      console.log(`   Threshold: ${this.config.threshold * 100}%`);
+      console.log(`   Max prefetch per route: ${this.config.maxPrefetch}`);
+      console.log(`   Input transitions: ${navigationData.length}`);
+    }
+    const navigationGraph = this.buildNavigationGraph(navigationData);
+    const routes = this.extractRoutes(navigationData);
+    if (this.debug) {
+      console.log(`
+   \u{1F4CA} Analysis:`);
+      console.log(`   Unique routes: ${routes.size}`);
+      console.log(`   Routes: ${Array.from(routes).sort().join(", ")}`);
+      console.log(`   Source routes: ${navigationGraph.size}`);
+    }
+    const predictions = this.calculateMarkovProbabilities(navigationGraph);
+    if (this.debug) {
+      console.log(`
+   Predictions generated:`);
+      console.log(`   Routes with predictions: ${predictions.size}`);
+      const totalTargets = Array.from(predictions.values()).reduce(
+        (sum, targets) => sum + targets.length,
+        0
+      );
+      console.log(`   Total prefetch targets: ${totalTargets}`);
+    }
+    const model = {
+      version: "1.0.0",
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      environment,
+      config: this.config,
+      dataSource: {
+        provider: "markov-chain",
+        dateRange: this.getDateRange(30),
+        totalSessions: navigationData.reduce((sum, d) => sum + d.count, 0),
+        totalRoutes: routes.size
+      },
+      routes: {}
+    };
+    predictions.forEach((targets, source) => {
+      model.routes[source] = {
+        prefetch: targets,
+        metadata: this.calculateMetadata(navigationGraph, source)
+      };
+    });
+    if (this.debug) {
+      console.log(`
+   \u2705 Model trained successfully`);
+      const sampleRoutes = Array.from(predictions.entries()).slice(0, 3);
+      if (sampleRoutes.length > 0) {
+        console.log(`
+   Sample predictions:`);
+        sampleRoutes.forEach(([source, targets]) => {
+          console.log(`   ${source}:`);
+          targets.forEach((target) => {
+            console.log(
+              `     \u2192 ${target.route} (${(target.probability * 100).toFixed(1)}%, ${target.priority})`
+            );
+          });
+        });
+      }
+    }
+    return model;
+  }
+  /**
+   * Extract all unique routes from navigation data
+   */
+  extractRoutes(data) {
+    const routes = /* @__PURE__ */ new Set();
+    data.forEach((d) => {
+      routes.add(d.from);
+      routes.add(d.to);
+    });
+    return routes;
+  }
+  /**
+   * Build navigation graph from user navigation patterns
+   * Graph represents: sourceRoute -> { targetRoute: transitionCount }
+   */
+  buildNavigationGraph(data) {
+    const graph = /* @__PURE__ */ new Map();
+    data.forEach(({ from, to, count }) => {
+      if (!graph.has(from)) {
+        graph.set(from, /* @__PURE__ */ new Map());
+      }
+      const targets = graph.get(from);
+      targets.set(to, (targets.get(to) || 0) + count);
+    });
+    return graph;
+  }
+  /**
+   * Calculate Markov probabilities with normalization
+   * P(dest | src) = count(src→dest) / total_transitions_from_src
+   * Then normalizes scores to 0-1 range
+   */
+  calculateMarkovProbabilities(navigationGraph) {
+    const predictions = /* @__PURE__ */ new Map();
+    navigationGraph.forEach((targets, source) => {
+      const targetArray = [];
+      const totalFromSource = Array.from(targets.values()).reduce(
+        (sum, count) => sum + count,
+        0
+      );
+      if (totalFromSource === 0) return;
+      const probabilities = /* @__PURE__ */ new Map();
+      targets.forEach((count, destination) => {
+        probabilities.set(destination, count / totalFromSource);
+      });
+      const maxProb = Math.max(...Array.from(probabilities.values()));
+      if (maxProb > 0) {
+        probabilities.forEach((prob, dest) => {
+          probabilities.set(dest, prob / maxProb);
+        });
+      }
+      const sorted = Array.from(probabilities.entries()).sort((a, b) => b[1] - a[1]).slice(0, this.config.maxPrefetch);
+      sorted.forEach(([route, probability]) => {
+        if (probability >= this.config.threshold) {
+          targetArray.push({
+            route,
+            probability,
+            count: targets.get(route) || 0,
+            priority: this.getPriority(probability)
+          });
+        }
+      });
+      if (targetArray.length > 0) {
+        predictions.set(source, targetArray);
+      }
+    });
+    return predictions;
+  }
+  /**
+   * Determine priority based on ML confidence score
+   */
+  getPriority(score) {
+    if (score >= 0.7) return "high";
+    if (score >= 0.4) return "medium";
+    return "low";
+  }
+  /**
+   * Calculate metadata for a route
+   */
+  calculateMetadata(navigationGraph, route) {
+    const targets = navigationGraph.get(route);
+    if (!targets || targets.size === 0) {
+      return {
+        totalTransitions: 0,
+        topDestination: ""
+      };
+    }
+    const totalTransitions = Array.from(targets.values()).reduce(
+      (sum, count) => sum + count,
+      0
+    );
+    let topDestination = "";
+    let maxCount = 0;
+    targets.forEach((count, targetRoute) => {
+      if (count > maxCount) {
+        maxCount = count;
+        topDestination = targetRoute;
+      }
+    });
+    return {
+      totalTransitions,
+      topDestination
+    };
+  }
+  /**
+   * Train segment-specific Markov models from navigation data with segment field
+   * Creates separate models for each user segment/role
+   */
+  trainSegmentedModels(navigationDataWithSegments, environment) {
+    if (this.debug) {
+      console.log(`
+\u{1F916} Training Segment-Specific Markov Models...`);
+    }
+    const dataBySegment = /* @__PURE__ */ new Map();
+    navigationDataWithSegments.forEach((data) => {
+      const segment = data.segment || "default";
+      if (!dataBySegment.has(segment)) {
+        dataBySegment.set(segment, []);
+      }
+      dataBySegment.get(segment).push({
+        from: data.from,
+        to: data.to,
+        count: data.count
+      });
+    });
+    if (this.debug) {
+      console.log(`
+   \u{1F4CA} Detected segments:`);
+      dataBySegment.forEach((data, segment) => {
+        console.log(`   \u2022 ${segment}: ${data.length} transitions`);
+      });
+    }
+    const segmentModels = /* @__PURE__ */ new Map();
+    dataBySegment.forEach((navigationData, segment) => {
+      if (this.debug) {
+        console.log(`
+   \u{1F504} Training model for segment: "${segment}"`);
+      }
+      const model = this.trainMLModel(navigationData, environment);
+      model.dataSource.provider = `markov-chain[${segment}]`;
+      segmentModels.set(segment, model);
+      if (this.debug) {
+        const totalTargets = Object.values(model.routes).reduce(
+          (sum, route) => sum + (route.prefetch?.length || 0),
+          0
+        );
+        console.log(`   \u2705 Model for "${segment}" trained with ${totalTargets} prefetch targets`);
+      }
+    });
+    if (this.debug) {
+      console.log(`
+   \u2705 All ${segmentModels.size} segment models trained successfully`);
+    }
+    return segmentModels;
+  }
+  /**
+   * Get date range string
+   */
+  getDateRange(days) {
+    const end = /* @__PURE__ */ new Date();
+    const start = /* @__PURE__ */ new Date();
+    start.setDate(start.getDate() - days);
+    return `${start.toISOString().split("T")[0]} to ${end.toISOString().split("T")[0]}`;
+  }
+};
+
+// src/plugin/config-generator.ts
+var _ConfigGenerator = class _ConfigGenerator {
+  constructor(manifest, manualRules = {}, debug = false) {
+    this.manifest = manifest;
+    this.manualRules = manualRules;
+    this.debug = debug;
+  }
+  /**
+   * Generate final prefetch configuration with chunk mappings
+   * Includes common prefetch rules and segment-specific rules if available
+   */
+  generate(model) {
+    if (this.debug) {
+      console.log(`
+\u{1F4E6} Generating prefetch configuration...`);
+      console.log(`   Manifest entries: ${Object.keys(this.manifest).length}`);
+      console.log(`   Model routes: ${Object.keys(model.routes).length}`);
+      console.log(`   Manual rules: ${Object.keys(this.manualRules).length}`);
+      if (Object.values(model.routes).some((r) => r.segments)) {
+        console.log(`   \u2139\uFE0F  Segment-based rules detected`);
+      }
+    }
+    const mergedModel = this.mergeManualRules(model);
+    const config = {
+      version: model.version,
+      generatedAt: model.generatedAt,
+      environment: model.environment,
+      dataSource: model.dataSource,
+      model: {
+        type: model.config.type,
+        threshold: model.config.threshold,
+        maxPrefetch: model.config.maxPrefetch
+      },
+      routes: {},
+      chunks: {}
+    };
+    let mappedRoutes = 0;
+    let unmappedRoutes = 0;
+    let totalSegmentRules = 0;
+    Object.entries(mergedModel.routes).forEach(([sourceRoute, prediction]) => {
+      const prefetchTargets = [];
+      const segmentConfigs = {};
+      const sourceChunk = this.routeToChunk(sourceRoute);
+      if (sourceChunk && !config.chunks[sourceRoute]) {
+        config.chunks[sourceRoute] = sourceChunk;
+      }
+      prediction.prefetch.forEach((target) => {
+        const chunkFile = this.routeToChunk(target.route);
+        if (chunkFile) {
+          const manifestEntry = this.getManifestEntryByFile(chunkFile);
+          const importChunkIds = manifestEntry?.imports || [];
+          const imports = importChunkIds.map((chunkId) => {
+            const entry = this.manifest[chunkId];
+            return entry?.file;
+          }).filter((file) => !!file);
+          prefetchTargets.push({
+            ...target,
+            chunk: chunkFile,
+            imports
+            // Include dependency chunks (resolved to file paths)
+          });
+          config.chunks[target.route] = chunkFile;
+          mappedRoutes++;
+          if (this.debug) {
+            console.log(`   \u2705 ${sourceRoute} \u2192 ${target.route}`);
+            console.log(`      Chunk: ${chunkFile}`);
+            if (imports.length > 0) {
+              console.log(`      Dependencies: ${imports.join(", ")}`);
+            }
+          }
+        } else {
+          if (this.debug) {
+            console.log(`   \u26A0\uFE0F  No chunk found for route: ${target.route}`);
+            console.log(`      Attempted to map using routeToChunk()`);
+          }
+          unmappedRoutes++;
+        }
+      });
+      if (prediction.segments) {
+        Object.entries(prediction.segments).forEach(([segment, segmentTargets]) => {
+          const segmentPrefetchTargets = [];
+          segmentTargets.forEach((target) => {
+            const chunkFile = this.routeToChunk(target.route);
+            if (chunkFile) {
+              const manifestEntry = this.getManifestEntryByFile(chunkFile);
+              const importChunkIds = manifestEntry?.imports || [];
+              const imports = importChunkIds.map((chunkId) => {
+                const entry = this.manifest[chunkId];
+                return entry?.file;
+              }).filter((file) => !!file);
+              segmentPrefetchTargets.push({
+                ...target,
+                chunk: chunkFile,
+                imports
+              });
+              config.chunks[target.route] = chunkFile;
+              totalSegmentRules++;
+            }
+          });
+          if (segmentPrefetchTargets.length > 0) {
+            segmentConfigs[segment] = segmentPrefetchTargets;
+          }
+        });
+        if (this.debug && Object.keys(segmentConfigs).length > 0) {
+          console.log(`   \u{1F465} Segment configs for ${sourceRoute}: ${Object.keys(segmentConfigs).join(", ")}`);
+        }
+      }
+      if (prefetchTargets.length > 0 || Object.keys(segmentConfigs).length > 0) {
+        config.routes[sourceRoute] = {
+          prefetch: prefetchTargets,
+          ...Object.keys(segmentConfigs).length > 0 && {
+            segments: segmentConfigs
+          },
+          metadata: prediction.metadata
+        };
+      }
+    });
+    if (this.debug) {
+      console.log(`\u2705 Configuration generated`);
+      console.log(`   Routes with prefetch: ${Object.keys(config.routes).length}`);
+      console.log(`   Mapped chunks: ${mappedRoutes}`);
+      console.log(`   Segment-specific rules: ${totalSegmentRules}`);
+      console.log(`   Unmapped routes: ${unmappedRoutes}`);
+    }
+    const allSegments = /* @__PURE__ */ new Set();
+    Object.values(config.routes).forEach((route) => {
+      if (route.segments) {
+        Object.keys(route.segments).forEach((seg) => allSegments.add(seg));
+      }
+    });
+    if (allSegments.size > 0) {
+      config.segmentInfo = {
+        available: Array.from(allSegments),
+        description: "Load segment-specific config based on user role/segment"
+      };
+    }
+    return config;
+  }
+  /**
+   * Merge manual rules into model
+   * Manual rules take precedence over ML predictions
+   */
+  mergeManualRules(model) {
+    const merged = { ...model, routes: { ...model.routes } };
+    Object.entries(this.manualRules).forEach(([sourceRoute, targetRoutes]) => {
+      if (!merged.routes[sourceRoute]) {
+        merged.routes[sourceRoute] = {
+          prefetch: []
+        };
+      }
+      targetRoutes.forEach((targetRoute) => {
+        const existing = merged.routes[sourceRoute].prefetch.find(
+          (t) => t.route === targetRoute
+        );
+        if (existing) {
+          existing.manual = true;
+          existing.priority = "high";
+          existing.probability = 1;
+        } else {
+          merged.routes[sourceRoute].prefetch.unshift({
+            route: targetRoute,
+            probability: 1,
+            count: 0,
+            // Not from analytics
+            priority: "high",
+            manual: true
+          });
+        }
+      });
+      if (this.debug) {
+        console.log(`   \u2705 Added manual rule: ${sourceRoute} \u2192 [${targetRoutes.join(", ")}]`);
+      }
+    });
+    return merged;
+  }
+  /**
+   * NEW STRATEGY 0: Route to Chunk Name Mapping
+   * Maps route → component name → chunk name → manifest file
+   * This is the most reliable method as it uses the actual vite.config.ts chunking strategy
+   */
+  routeToChunkViaName(route) {
+    const normalizedRoute = route.toLowerCase();
+    const componentName = _ConfigGenerator.ROUTE_TO_COMPONENT_NAME[normalizedRoute];
+    if (!componentName) {
+      if (this.debug) {
+        console.log(`      \u274C Route ${route} not in ROUTE_TO_COMPONENT_NAME mapping`);
+      }
+      return null;
+    }
+    const chunkName = _ConfigGenerator.COMPONENT_TO_CHUNK_NAME[componentName];
+    if (!chunkName) {
+      if (this.debug) {
+        console.log(`      \u274C Component ${componentName} not in COMPONENT_TO_CHUNK_NAME mapping`);
+      }
+      return null;
+    }
+    const chunkEntry = Object.entries(this.manifest).find(
+      ([key, entry]) => entry.name === chunkName || key.includes(chunkName)
+    );
+    if (!chunkEntry) {
+      if (this.debug) {
+        console.log(`      \u274C Chunk name ${chunkName} not found in manifest`);
+      }
+      return null;
+    }
+    const chunkFile = chunkEntry[1].file;
+    if (this.debug) {
+      console.log(
+        `      \u2705 Via-Name Strategy: ${route} \u2192 ${componentName} \u2192 ${chunkName} \u2192 ${chunkFile}`
+      );
+    }
+    return chunkFile;
+  }
+  /**
+   * Map route to chunk file using Vite manifest
+   * Tries multiple strategies to find the correct chunk
+   */
+  routeToChunk(route) {
+    const viaName = this.routeToChunkViaName(route);
+    if (viaName) {
+      return viaName;
+    }
+    const directMatch = this.findDirectMatch(route);
+    if (directMatch) {
+      return directMatch;
+    }
+    const patternMatch = this.findPatternMatch(route);
+    if (patternMatch) {
+      return patternMatch;
+    }
+    const fuzzyMatch = this.findFuzzyMatch(route);
+    if (fuzzyMatch) {
+      return fuzzyMatch;
+    }
+    return null;
+  }
+  /**
+   * Strategy 1: Direct path match
+   */
+  findDirectMatch(route) {
+    const normalizedRoute = route.replace(/\/[:$]\w+/g, "");
+    const cleanRoutePath = normalizedRoute.replace(/^\//, "");
+    const routeSegments = normalizedRoute.split("/").filter(Boolean);
+    const pascalCaseComponent = routeSegments.map((segment) => {
+      const words = segment.split("-");
+      return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+    }).join("/");
+    let singleSegmentPascal = null;
+    if (routeSegments.length === 1) {
+      const segment = routeSegments[0];
+      const words = segment.split("-");
+      singleSegmentPascal = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+    }
+    const patterns = [
+      // HIGHEST PRIORITY: Exact page component name matches
+      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.tsx` : null,
+      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.ts` : null,
+      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.jsx` : null,
+      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.js` : null,
+      // For multi-segment routes with hyphens
+      `src/pages/${pascalCaseComponent}.tsx`,
+      `src/pages/${pascalCaseComponent}.ts`,
+      `src/pages/${pascalCaseComponent}.jsx`,
+      `src/pages/${pascalCaseComponent}.js`,
+      // Features folder
+      `src/features${normalizedRoute}/index.ts`,
+      `src/features${normalizedRoute}/index.tsx`,
+      `src/features${normalizedRoute}/index.js`,
+      `src/features${normalizedRoute}/index.jsx`,
+      // Pages folder - try both directory and file formats
+      `src/pages${normalizedRoute}/index.tsx`,
+      `src/pages${normalizedRoute}/index.ts`,
+      `src/pages${normalizedRoute}/index.jsx`,
+      `src/pages${normalizedRoute}/index.js`,
+      `src/pages${normalizedRoute}.tsx`,
+      `src/pages${normalizedRoute}.ts`,
+      `src/pages${normalizedRoute}.jsx`,
+      `src/pages${normalizedRoute}.js`,
+      // Fallback to old capitalize method (single capital letter)
+      `src/pages/${this.capitalize(cleanRoutePath)}.tsx`,
+      `src/pages/${this.capitalize(cleanRoutePath)}.ts`,
+      // Full paths with app prefix
+      `apps/farmart-pro/src/features${normalizedRoute}/index.ts`,
+      `apps/farmart-pro/src/features${normalizedRoute}/index.tsx`,
+      `apps/farmart-pro/src/pages${normalizedRoute}/index.tsx`
+    ].filter(Boolean);
+    for (let i = 0; i < patterns.length; i++) {
+      const pattern = patterns[i];
+      const entry = this.manifest[pattern];
+      if (entry) {
+        return entry.file;
+      }
+    }
+    return null;
+  }
+  /**
+   * Capitalize first letter of string
+   */
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  /**
+   * Strategy 2: Pattern matching with wildcards
+   */
+  findPatternMatch(route) {
+    const routeSegments = route.split("/").filter(Boolean);
+    if (routeSegments.length === 0) return null;
+    const candidates = Object.entries(this.manifest).filter(([path2]) => {
+      const pathSegments = path2.split("/").filter(Boolean);
+      return routeSegments.every(
+        (segment) => pathSegments.some(
+          (ps) => ps.toLowerCase().includes(segment.replace(/[:$]\w+/, "").toLowerCase())
+        )
+      );
+    }).sort(([pathA], [pathB]) => {
+      if (pathA.includes("/pages/") && !pathB.includes("/pages/")) return -1;
+      if (!pathA.includes("/pages/") && pathB.includes("/pages/")) return 1;
+      const aIsEntry = pathA.includes("index.tsx") || pathA.includes("index.ts");
+      const bIsEntry = pathB.includes("index.tsx") || pathB.includes("index.ts");
+      if (aIsEntry && !bIsEntry) return -1;
+      if (!aIsEntry && bIsEntry) return 1;
+      if (pathA.includes(".tsx") && !pathB.includes(".tsx")) return -1;
+      if (!pathA.includes(".tsx") && pathB.includes(".tsx")) return 1;
+      return 0;
+    });
+    if (candidates.length > 0) {
+      if (this.debug) {
+        console.log(`      \u2705 Pattern match found: ${candidates[0][0]} \u2192 ${candidates[0][1].file}`);
+      }
+      return candidates[0][1].file;
+    }
+    if (this.debug) {
+      console.log(`      No pattern match found`);
+    }
+    return null;
+  }
+  /**
+   * Strategy 3: Fuzzy matching
+   * Converts route to camelCase/PascalCase and searches
+   */
+  findFuzzyMatch(route) {
+    const cleanRoute = route.replace(/\/[:$]\w+/g, "");
+    const routeSegments = cleanRoute.split("/").filter(Boolean);
+    const pascalCase = routeSegments.map((segment) => {
+      const words = segment.split("-");
+      return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+    }).join("");
+    const camelCase = pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+    if (this.debug) {
+      console.log(`      Fuzzy match - Route: ${route}`);
+      console.log(`      Trying PascalCase: ${pascalCase}, camelCase: ${camelCase}`);
+    }
+    const candidates = Object.entries(this.manifest).filter(([path2, entry]) => {
+      if (path2.startsWith("_") || path2.startsWith("node_modules")) {
+        return false;
+      }
+      const fileName = path2.split("/").pop() || "";
+      const fileNameWithoutExt = fileName.replace(/\.[^.]+$/, "");
+      if (fileNameWithoutExt === pascalCase || fileNameWithoutExt === camelCase) {
+        return true;
+      }
+      if (fileName.includes(pascalCase) || fileName.includes(camelCase)) {
+        return true;
+      }
+      const pathSegments = path2.toLowerCase().split("/");
+      const lowerPascal = pascalCase.toLowerCase();
+      const lowerCamel = camelCase.toLowerCase();
+      return pathSegments.some(
+        (seg) => seg.includes(lowerPascal) || seg.includes(lowerCamel)
+      );
+    }).sort(([pathA, entryA], [pathB, entryB]) => {
+      const aHasSrc = entryA.src ? 1 : 0;
+      const bHasSrc = entryB.src ? 1 : 0;
+      if (aHasSrc !== bHasSrc) return bHasSrc - aHasSrc;
+      const fileA = pathA.split("/").pop()?.replace(/\.[^.]+$/, "") || "";
+      const fileB = pathB.split("/").pop()?.replace(/\.[^.]+$/, "") || "";
+      if (fileA === pascalCase) return -1;
+      if (fileB === pascalCase) return 1;
+      if (fileA === camelCase) return -1;
+      if (fileB === camelCase) return 1;
+      if (pathA.includes("/pages/") && !pathB.includes("/pages/")) return -1;
+      if (!pathA.includes("/pages/") && pathB.includes("/pages/")) return 1;
+      return 0;
+    });
+    if (candidates.length > 0) {
+      const result = candidates[0][1].file;
+      if (this.debug) {
+        console.log(`      \u2705 Fuzzy match found: ${candidates[0][0]} \u2192 ${result}`);
+      }
+      return result;
+    }
+    if (this.debug) {
+      console.log(`      No fuzzy match found`);
+    }
+    return null;
+  }
+  /**
+   * Get manifest entry by file name
+   */
+  getManifestEntryByFile(fileName) {
+    return Object.values(this.manifest).find((entry) => entry.file === fileName);
+  }
+  /**
+   * Get all chunks referenced in config
+   */
+  getReferencedChunks(config) {
+    return Object.values(config.chunks);
+  }
+  /**
+   * Validate that all chunks exist in manifest
+   */
+  validateChunks(config) {
+    const missing = [];
+    const manifestFiles = new Set(Object.values(this.manifest).map((e) => e.file));
+    Object.entries(config.chunks).forEach(([route, chunk]) => {
+      if (!manifestFiles.has(chunk)) {
+        missing.push(`${route} -> ${chunk}`);
+      }
+    });
+    return {
+      valid: missing.length === 0,
+      missing
+    };
+  }
+  /**
+   * Generate segment-specific prefetch configurations
+   * Creates one config per user segment/role
+   */
+  generateSegmentConfigs(segmentModels) {
+    const segmentConfigs = /* @__PURE__ */ new Map();
+    segmentModels.forEach((model, segment) => {
+      if (this.debug) {
+        console.log(`
+\u{1F4E6} Generating config for segment: "${segment}"`);
+      }
+      const config = this.generate(model);
+      config.segment = segment;
+      segmentConfigs.set(segment, config);
+      if (this.debug) {
+        console.log(`   \u2705 Config generated for "${segment}"`);
+        console.log(`      Routes: ${Object.keys(config.routes).length}`);
+        console.log(`      Chunks: ${Object.keys(config.chunks).length}`);
+      }
+    });
+    if (this.debug) {
+      console.log(`
+\u2705 Generated ${segmentConfigs.size} segment-specific configurations`);
+    }
+    return segmentConfigs;
+  }
+};
+/**
+ * Maps routes to their component names based on vite.config.ts chunk strategy
+ * This is derived from the route configuration in src/routes/index.ts
+ * Note: These are the core routes from vite.config.ts chunking strategy
+ * Routes not listed here will fall through to fuzzy matching
+ */
+_ConfigGenerator.ROUTE_TO_COMPONENT_NAME = {
+  "/": "Home",
+  "/home": "Home",
+  "/dashboard": "Dashboard",
+  "/profile": "Profile",
+  "/settings": "Settings",
+  "/preferences": "Preferences",
+  "/privacy": "Privacy",
+  "/security": "Security",
+  "/analytics": "Analytics",
+  "/reports": "Reports",
+  "/metrics": "Metrics",
+  "/projects": "Projects",
+  "/tasks": "Tasks",
+  "/teams": "Teams",
+  "/workspaces": "Workspaces",
+  "/workflows": "Workflows",
+  "/templates": "Templates",
+  "/logs": "Logs",
+  "/audit-logs": "AuditLogs",
+  "/integrations": "Integrations",
+  "/api-docs": "ApiDocs",
+  "/api-documentation": "ApiDocs",
+  // Alias for space-separated variant
+  "/support": "Support",
+  "/help": "Help",
+  "/billing": "Billing",
+  "/plans": "Plans",
+  "/usage": "Usage",
+  "/permissions": "Permissions",
+  "/notifications": "Notifications"
+};
+/**
+ * Maps component names to chunk names based on vite.config.ts manualChunks strategy
+ * Each component is assigned to a specific chunk group for code splitting
+ *
+ * Note: Core components (Home, Dashboard) are not in manual chunks - they're part of main bundle
+ * For these, we return the main bundle file path 'js/index-*.js' which will be resolved from manifest
+ */
+_ConfigGenerator.COMPONENT_TO_CHUNK_NAME = {
+  // Core components - loaded with main bundle (not code-split)
+  Home: "index",
+  // Special marker for main entry point
+  Dashboard: "index",
+  // User Profile & Settings chunk
+  Profile: "chunk-user-profile",
+  Settings: "chunk-user-profile",
+  Preferences: "chunk-user-profile",
+  Privacy: "chunk-user-profile",
+  Security: "chunk-user-profile",
+  // Analytics & Reporting chunk
+  Analytics: "chunk-analytics",
+  Reports: "chunk-analytics",
+  Metrics: "chunk-analytics",
+  // Project Management chunk
+  Projects: "chunk-projects",
+  Tasks: "chunk-projects",
+  Teams: "chunk-projects",
+  Workspaces: "chunk-projects",
+  // Workflows & Operations chunk
+  Workflows: "chunk-operations",
+  Templates: "chunk-operations",
+  Logs: "chunk-operations",
+  AuditLogs: "chunk-operations",
+  // Integration chunk
+  Integrations: "chunk-integrations",
+  ApiDocs: "chunk-integrations",
+  Support: "chunk-integrations",
+  Help: "chunk-integrations",
+  // Billing & Plans chunk
+  Billing: "chunk-billing",
+  Plans: "chunk-billing",
+  Usage: "chunk-billing",
+  // Admin & Notifications chunk
+  Permissions: "chunk-admin",
+  Notifications: "chunk-admin"
+};
+var ConfigGenerator = _ConfigGenerator;
+
+// src/plugin/cache-manager.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var CacheManager = class {
+  constructor(config = {}, debug = false) {
+    this.enabled = config.enabled ?? true;
+    this.ttl = config.ttl ?? 24 * 60 * 60 * 1e3;
+    this.cacheDir = config.path ?? path.join(process.cwd(), ".prefetch-cache");
+    this.debug = debug;
+    if (this.enabled && !fs.existsSync(this.cacheDir)) {
+      fs.mkdirSync(this.cacheDir, { recursive: true });
+      if (this.debug) {
+        console.log(`\u{1F4C1} Created cache directory: ${this.cacheDir}`);
+      }
+    }
+  }
+  /**
+   * Get cached model for environment
+   * Returns null if cache doesn't exist or is expired
+   */
+  async get(environment) {
+    if (!this.enabled) {
+      if (this.debug) console.log("\u23ED\uFE0F  Cache disabled, skipping cache lookup");
+      return null;
+    }
+    try {
+      const cacheFile = path.join(this.cacheDir, `${environment}.json`);
+      if (!fs.existsSync(cacheFile)) {
+        if (this.debug) console.log(`\u{1F4E6} Cache miss for environment: ${environment}`);
+        return null;
+      }
+      const stats = fs.statSync(cacheFile);
+      const cacheAge = Date.now() - stats.mtimeMs;
+      if (cacheAge > this.ttl) {
+        if (this.debug) console.log(`\u23F0 Cache expired for ${environment} (${Math.round(cacheAge / 1e3 / 60)} minutes old)`);
+        fs.unlinkSync(cacheFile);
+        return null;
+      }
+      const cachedData = fs.readFileSync(cacheFile, "utf-8");
+      const model = JSON.parse(cachedData);
+      if (this.debug) {
+        console.log(`\u2705 Cache hit for environment: ${environment} (${Math.round(cacheAge / 1e3)} seconds old)`);
+        console.log(`   Cached model has ${Object.keys(model.routes).length} routes`);
+      }
+      return model;
+    } catch (error) {
+      console.error(`\u274C Error reading cache for ${environment}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Save model to cache
+   */
+  async set(environment, model) {
+    if (!this.enabled) {
+      if (this.debug) console.log("\u23ED\uFE0F  Cache disabled, skipping cache write");
+      return;
+    }
+    try {
+      const cacheFile = path.join(this.cacheDir, `${environment}.json`);
+      fs.writeFileSync(cacheFile, JSON.stringify(model, null, 2), "utf-8");
+      if (this.debug) {
+        console.log(`\u{1F4BE} Cached model for ${environment}`);
+        console.log(`   Location: ${cacheFile}`);
+        console.log(`   Routes: ${Object.keys(model.routes).length}`);
+      }
+    } catch (error) {
+      console.error(`\u274C Error writing cache for ${environment}:`, error);
+    }
+  }
+  /**
+   * Invalidate cache for specific environment or all environments
+   */
+  async invalidate(environment) {
+    if (!this.enabled) return;
+    try {
+      if (environment) {
+        const cacheFile = path.join(this.cacheDir, `${environment}.json`);
+        if (fs.existsSync(cacheFile)) {
+          fs.unlinkSync(cacheFile);
+          if (this.debug) {
+            console.log(`\u{1F5D1}\uFE0F  Invalidated cache for ${environment}`);
+          }
+        }
+      } else {
+        const files = fs.readdirSync(this.cacheDir);
+        files.forEach((file) => {
+          if (file.endsWith(".json")) {
+            fs.unlinkSync(path.join(this.cacheDir, file));
+          }
+        });
+        if (this.debug) {
+          console.log(`\u{1F5D1}\uFE0F  Cleared all cache files`);
+        }
+      }
+    } catch (error) {
+      console.error(`\u274C Error invalidating cache:`, error);
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const cachedEnvironments = [];
+    let totalSize = 0;
+    if (this.enabled && fs.existsSync(this.cacheDir)) {
+      const files = fs.readdirSync(this.cacheDir);
+      files.forEach((file) => {
+        if (file.endsWith(".json")) {
+          const filePath = path.join(this.cacheDir, file);
+          const stats = fs.statSync(filePath);
+          cachedEnvironments.push(file.replace(".json", ""));
+          totalSize += stats.size;
+        }
+      });
+    }
+    return {
+      enabled: this.enabled,
+      cacheDir: this.cacheDir,
+      ttl: this.ttl,
+      cachedEnvironments,
+      totalSize
+    };
+  }
+  /**
+   * Check if cache exists and is valid for environment
+   */
+  async isValid(environment) {
+    if (!this.enabled) return false;
+    try {
+      const cacheFile = path.join(this.cacheDir, `${environment}.json`);
+      if (!fs.existsSync(cacheFile)) {
+        return false;
+      }
+      const stats = fs.statSync(cacheFile);
+      const cacheAge = Date.now() - stats.mtimeMs;
+      return cacheAge <= this.ttl;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get cache age in milliseconds
+   */
+  async getCacheAge(environment) {
+    if (!this.enabled) return null;
+    try {
+      const cacheFile = path.join(this.cacheDir, `${environment}.json`);
+      if (!fs.existsSync(cacheFile)) {
+        return null;
+      }
+      const stats = fs.statSync(cacheFile);
+      return Date.now() - stats.mtimeMs;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/plugin/index.ts
+function smartPrefetch(options = {}) {
+  const {
+    framework = "react",
+    strategy = "hybrid",
+    analytics,
+    manualRules = {},
+    cache = {},
+    advanced = {}
+  } = options;
+  const debug = advanced.debug ?? false;
+  let config;
+  let cacheManager;
+  let prefetchModel = null;
+  let segmentModels = null;
+  return {
+    name: "@farmart/vite-plugin-smart-prefetch",
+    enforce: "post",
+    async configResolved(resolvedConfig) {
+      config = resolvedConfig;
+      if (!config.build.manifest) {
+        config.build.manifest = true;
+        if (debug) {
+          console.log("\u2705 Enabled Vite manifest generation");
+        }
+      }
+      cacheManager = new CacheManager(cache, debug);
+      if (debug) {
+        console.log("\n\u{1F680} Smart Prefetch Plugin Initialized");
+        console.log(`   Framework: ${framework}`);
+        console.log(`   Strategy: ${strategy}`);
+        console.log(`   Analytics: ${analytics ? "enabled" : "disabled"}`);
+        console.log(`   Manual rules: ${Object.keys(manualRules).length}`);
+        console.log(`   Cache: ${cache.enabled !== false ? "enabled" : "disabled"}`);
+      }
+      if (config.command === "serve" && debug) {
+        const devManifest = {};
+        Object.keys(manualRules).forEach((route) => {
+          const routeKey = `src/features${route}/index.tsx`;
+          devManifest[routeKey] = {
+            file: `features${route.replace(/\//g, "-")}.js`,
+            imports: []
+          };
+        });
+        const fs2 = await import("fs");
+        const path2 = await import("path");
+        const pagesDir = path2.join(config.root, "src/pages");
+        if (fs2.existsSync(pagesDir)) {
+          const files = fs2.readdirSync(pagesDir);
+          files.forEach((file) => {
+            if (file.endsWith(".tsx") || file.endsWith(".ts")) {
+              const pageName = file.replace(/\.(tsx|ts)$/, "");
+              const routeKey = `src/pages/${file}`;
+              devManifest[routeKey] = {
+                file: `chunks/${pageName}-[hash].js`,
+                imports: []
+              };
+            }
+          });
+        }
+        config.__smartPrefetchDevManifest = devManifest;
+      }
+    },
+    configureServer(server) {
+      return () => {
+        server.middlewares.use("/prefetch-config.json", async (req, res, next) => {
+          if (req.method !== "GET") {
+            next();
+            return;
+          }
+          try {
+            if (!prefetchModel) {
+              if (debug) {
+                console.warn("\u26A0\uFE0F  No prefetch model available yet");
+              }
+              res.statusCode = 503;
+              res.end(JSON.stringify({ error: "Prefetch model not ready, still loading analytics data..." }));
+              return;
+            }
+            const devManifest = {};
+            Object.keys(prefetchModel.routes).forEach((route) => {
+              const routeKey = `src/pages${route}/index.tsx`;
+              const routeName = route.split("/").filter(Boolean).pop() || "index";
+              const devHash = "dev-" + routeName.slice(0, 6).padEnd(8, "0");
+              devManifest[routeKey] = {
+                file: `chunks/${routeName}-${devHash}.js`,
+                imports: []
+              };
+            });
+            const generator = new ConfigGenerator(devManifest, manualRules, debug);
+            const finalConfig = generator.generate(prefetchModel);
+            res.setHeader("Content-Type", "application/json");
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+            res.end(JSON.stringify(finalConfig, null, 2));
+            if (debug) {
+              console.log("\u{1F4E4} Serving fresh prefetch-config.json from development server");
+            }
+            return;
+          } catch (error) {
+            if (debug) {
+              console.error("Error serving prefetch-config.json:", error);
+            }
+            res.statusCode = 500;
+            res.end(JSON.stringify({ error: "Internal server error", details: String(error) }));
+          }
+        });
+      };
+    },
+    async buildStart() {
+      if (!analytics) {
+        if (debug) {
+          console.log("\n\u23ED\uFE0F  Analytics disabled, using manual rules only");
+        }
+        prefetchModel = createManualModel(manualRules, config.command === "serve" ? "development" : "production");
+        return;
+      }
+      const environment = analytics.environment || (config.command === "serve" ? "development" : "production");
+      const cached = await cacheManager.get(environment);
+      if (cached) {
+        prefetchModel = cached;
+        return;
+      }
+      try {
+        if (debug) {
+          console.log(`
+\u{1F4CA} Fetching ${analytics.provider} data and training model...`);
+        }
+        const bqConnector = new BigQueryAnalyticsConnector(
+          analytics.credentials.projectId,
+          analytics.credentials.datasetId,
+          debug
+        );
+        console.log("\n\u{1F3AF} Using real navigation data from BigQuery GA4 export...");
+        const navigationData = await bqConnector.fetchNavigationSequences(analytics.dataRange);
+        if (navigationData.length === 0) {
+          console.warn("\u26A0\uFE0F  No navigation data found, using manual rules only");
+          prefetchModel = createManualModel(manualRules, environment);
+          return;
+        }
+        console.log(`
+\u{1F916} Training model using Markov Chain ML...`);
+        const mlTrainer = new MarkovChainTrainer(analytics.model, debug);
+        const prefetchModelResult = mlTrainer.trainMLModel(navigationData, environment);
+        prefetchModel = prefetchModelResult;
+        await cacheManager.set(environment, prefetchModel);
+        try {
+          const navigationWithSegments = await bqConnector.fetchNavigationWithSegments(analytics.dataRange);
+          if (navigationWithSegments.length > 0) {
+            console.log(`
+\u{1F465} Training segment-specific models...`);
+            segmentModels = mlTrainer.trainSegmentedModels(navigationWithSegments, environment);
+            if (debug && segmentModels.size > 0) {
+              console.log(`   \u2705 Trained ${segmentModels.size} segment-specific models`);
+            }
+          }
+        } catch (error) {
+          if (debug) {
+            console.warn(`\u26A0\uFE0F  Could not train segment models:`, error instanceof Error ? error.message : "Unknown error");
+          }
+        }
+      } catch (error) {
+        console.error("\u274C Failed to fetch analytics data:", error);
+        console.log("\u26A0\uFE0F  Falling back to manual rules only");
+        prefetchModel = createManualModel(manualRules, environment);
+        if (debug) {
+          console.error("Error details:", error);
+        }
+      }
+    },
+    async writeBundle(outputOptions) {
+      if (!prefetchModel) {
+        console.warn("\u26A0\uFE0F  No prefetch model available, skipping config generation");
+        return;
+      }
+      const fs2 = await import("fs");
+      const path2 = await import("path");
+      const outDir = outputOptions.dir || "dist";
+      const manifestPath = path2.join(outDir, ".vite", "manifest.json");
+      if (!fs2.existsSync(manifestPath)) {
+        console.warn("\u26A0\uFE0F  Vite manifest not found at:", manifestPath);
+        return;
+      }
+      const manifestContent = fs2.readFileSync(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestContent);
+      if (debug) {
+        console.log(`
+\u{1F4E6} Vite manifest loaded: ${Object.keys(manifest).length} entries`);
+      }
+      const generator = new ConfigGenerator(manifest, manualRules, debug);
+      const finalConfig = generator.generate(prefetchModel);
+      const validation = generator.validateChunks(finalConfig);
+      if (!validation.valid) {
+        console.warn("\u26A0\uFE0F  Some chunks could not be mapped:");
+        validation.missing.forEach((m) => console.warn(`   ${m}`));
+      } else {
+        console.log(`\u2705 All ${Object.keys(finalConfig.chunks).length} chunks successfully mapped with real build hashes`);
+      }
+      const configPath = path2.join(outDir, "prefetch-config.json");
+      fs2.writeFileSync(configPath, JSON.stringify(finalConfig, null, 2));
+      const modelRoutesPath = path2.join(outDir, "model-routes.json");
+      fs2.writeFileSync(modelRoutesPath, JSON.stringify(prefetchModel.routes, null, 2));
+      if (debug) {
+        console.log("\u2705 Emitted prefetch-config.json with real chunk hashes");
+        console.log("\u2705 Emitted model-routes.json");
+        console.log(`\u{1F4CA} Total routes configured: ${Object.keys(finalConfig.routes).length}`);
+        console.log(`\u{1F4E6} Total chunks: ${Object.keys(finalConfig.chunks).length}`);
+      }
+      if (segmentModels && segmentModels.size > 0) {
+        console.log(`
+\u{1F4C1} Generating segment-specific prefetch configurations...`);
+        const segmentGenerator = new ConfigGenerator(manifest, manualRules, debug);
+        const segmentConfigs = segmentGenerator.generateSegmentConfigs(segmentModels);
+        const segmentDir = path2.join(outDir, "prefetch-configs");
+        if (!fs2.existsSync(segmentDir)) {
+          fs2.mkdirSync(segmentDir, { recursive: true });
+        }
+        segmentConfigs.forEach((segConfig, segment) => {
+          const segmentPath = path2.join(segmentDir, `${segment}.json`);
+          fs2.writeFileSync(segmentPath, JSON.stringify(segConfig, null, 2));
+          if (debug) {
+            console.log(`   \u2705 Emitted ${segment}.json (${Object.keys(segConfig.routes).length} routes)`);
+          }
+        });
+        const segmentIndex = {
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          environment: analytics?.environment || (config.command === "serve" ? "development" : "production"),
+          segments: Array.from(segmentConfigs.keys()),
+          description: "Segment-specific prefetch configurations. Use based on user role/segment."
+        };
+        const segmentIndexPath = path2.join(segmentDir, "index.json");
+        fs2.writeFileSync(segmentIndexPath, JSON.stringify(segmentIndex, null, 2));
+        if (debug) {
+          console.log(`
+\u2705 Emitted ${segmentConfigs.size} segment-specific configurations`);
+          console.log(`   Location: ${segmentDir}`);
+          console.log(`   Segments: ${Array.from(segmentConfigs.keys()).join(", ")}`);
+        }
+      }
+      if (analytics?.dashboard) {
+        const dashboardHtml = generateDashboard(finalConfig);
+        const dashboardPath = path2.join(outDir, "prefetch-report.html");
+        fs2.writeFileSync(dashboardPath, dashboardHtml);
+        if (debug) {
+          console.log("\u2705 Emitted prefetch-report.html");
+        }
+      }
+    },
+    transformIndexHtml() {
+      return [
+        {
+          tag: "script",
+          attrs: { type: "module" },
+          children: `
+            // Smart Prefetch Plugin Runtime Config
+            window.__SMART_PREFETCH__ = {
+              strategy: '${strategy}',
+              framework: '${framework}',
+              debug: ${debug},
+            };
+          `,
+          injectTo: "head"
+        }
+      ];
+    }
+  };
+}
+function createManualModel(manualRules, environment) {
+  const model = {
+    version: "1.0.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    environment,
+    routes: {},
+    dataSource: {
+      provider: "manual",
+      dateRange: "N/A",
+      totalSessions: 0,
+      totalRoutes: Object.keys(manualRules).length
+    },
+    config: {
+      type: "probability",
+      threshold: 1,
+      maxPrefetch: 10
+    }
+  };
+  Object.entries(manualRules).forEach(([source, targets]) => {
+    model.routes[source] = {
+      prefetch: targets.map((target) => ({
+        route: target,
+        probability: 1,
+        count: 0,
+        priority: "high",
+        manual: true
+      }))
+    };
+  });
+  return model;
+}
+function generateDashboard(config) {
+  const totalRoutes = Object.keys(config.routes).length;
+  const totalPrefetches = Object.values(config.routes).reduce(
+    (sum, route) => sum + route.prefetch.length,
+    0
+  );
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Smart Prefetch Report</title>
+  <style>
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 2rem;
+      background: #f5f5f5;
+    }
+    h1 { color: #333; }
+    .stats {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+      gap: 1rem;
+      margin: 2rem 0;
+    }
+    .stat-card {
+      background: white;
+      padding: 1.5rem;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .stat-value { font-size: 2rem; font-weight: bold; color: #4CAF50; }
+    .stat-label { color: #666; margin-top: 0.5rem; }
+    .route-list {
+      background: white;
+      padding: 1.5rem;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .route-item {
+      padding: 1rem;
+      border-bottom: 1px solid #eee;
+    }
+    .route-item:last-child { border-bottom: none; }
+    .route-source { font-weight: bold; color: #333; }
+    .prefetch-target {
+      margin-left: 2rem;
+      padding: 0.5rem;
+      color: #666;
+    }
+    .priority-high { color: #4CAF50; }
+    .priority-medium { color: #FF9800; }
+    .priority-low { color: #9E9E9E; }
+  </style>
+</head>
+<body>
+  <h1>\u{1F680} Smart Prefetch Report</h1>
+  <p>Generated: ${config.generatedAt}</p>
+  <p>Environment: ${config.environment}</p>
+
+  <div class="stats">
+    <div class="stat-card">
+      <div class="stat-value">${totalRoutes}</div>
+      <div class="stat-label">Routes with Prefetch</div>
+    </div>
+    <div class="stat-card">
+      <div class="stat-value">${totalPrefetches}</div>
+      <div class="stat-label">Total Prefetch Targets</div>
+    </div>
+    <div class="stat-card">
+      <div class="stat-value">${config.dataSource?.totalSessions?.toLocaleString() || "N/A"}</div>
+      <div class="stat-label">Sessions Analyzed</div>
+    </div>
+    <div class="stat-card">
+      <div class="stat-value">${(config.model.threshold * 100).toFixed(0)}%</div>
+      <div class="stat-label">Probability Threshold</div>
+    </div>
+  </div>
+
+  <div class="route-list">
+    <h2>Prefetch Configuration</h2>
+    ${Object.entries(config.routes).map(
+    ([source, data]) => `
+      <div class="route-item">
+        <div class="route-source">${source}</div>
+        ${data.prefetch.map(
+      (target) => `
+          <div class="prefetch-target">
+            \u2192 ${target.route}
+            <span class="priority-${target.priority}">
+              (${(target.probability * 100).toFixed(1)}%, ${target.priority})
+            </span>
+          </div>
+        `
+    ).join("")}
+      </div>
+    `
+  ).join("")}
+  </div>
+</body>
+</html>`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  smartPrefetch
+});
+//# sourceMappingURL=index.cjs.map