@ereo/bundler 0.1.6

package/dist/index.js

@@ -0,0 +1,2965 @@
+// @bun
+var __require = import.meta.require;
+
+// src/dev/hmr.ts
+var HMR_CLIENT_CODE = `
+(function() {
+  const ws = new WebSocket('ws://' + location.host + '/__hmr');
+
+  // Module registry for hot updates
+  window.__EREO_HMR__ = window.__EREO_HMR__ || {
+    modules: new Map(),
+    islands: new Map(),
+    acceptedModules: new Set(),
+  };
+
+  ws.onmessage = function(event) {
+    const update = JSON.parse(event.data);
+    const startTime = performance.now();
+
+    // Log with timing info
+    const logUpdate = (msg) => {
+      const duration = (performance.now() - startTime).toFixed(1);
+      console.log('[HMR] ' + msg + ' (' + duration + 'ms)');
+    };
+
+    switch (update.type) {
+      case 'full-reload':
+        logHMRReason(update);
+        location.reload();
+        break;
+
+      case 'css-update':
+        updateCSS(update.path);
+        logUpdate('CSS updated: ' + update.path);
+        break;
+
+      case 'island-update':
+        if (handleIslandUpdate(update)) {
+          logUpdate('Island hot-updated: ' + (update.module?.id || update.path));
+        } else {
+          logHMRReason(update);
+          location.reload();
+        }
+        break;
+
+      case 'component-update':
+        if (handleComponentUpdate(update)) {
+          logUpdate('Component hot-updated: ' + (update.module?.id || update.path));
+        } else {
+          logHMRReason(update);
+          location.reload();
+        }
+        break;
+
+      case 'loader-update':
+        // Loaders require data refetch, do soft reload
+        logUpdate('Loader changed, refreshing data...');
+        refreshLoaderData(update.path);
+        break;
+
+      case 'js-update':
+        // Check if we can do granular update
+        if (update.module?.isIsland && handleIslandUpdate(update)) {
+          logUpdate('Island hot-updated: ' + (update.module?.id || update.path));
+        } else if (update.module?.isComponent && handleComponentUpdate(update)) {
+          logUpdate('Component hot-updated: ' + (update.module?.id || update.path));
+        } else {
+          logHMRReason(update);
+          location.reload();
+        }
+        break;
+
+      case 'error':
+        showErrorOverlay(update.error);
+        break;
+    }
+  };
+
+  ws.onclose = function() {
+    console.log('[HMR] Connection lost, attempting reconnect...');
+    setTimeout(function() {
+      location.reload();
+    }, 1000);
+  };
+
+  function updateCSS(path) {
+    const links = document.querySelectorAll('link[rel="stylesheet"]');
+    for (const link of links) {
+      if (link.href.includes(path)) {
+        const newHref = link.href.split('?')[0] + '?t=' + Date.now();
+        link.href = newHref;
+      }
+    }
+  }
+
+  function handleIslandUpdate(update) {
+    const moduleId = update.module?.id || update.path;
+    if (!moduleId) return false;
+
+    // Find all island elements for this component
+    const componentName = moduleId.split('/').pop()?.replace(/\\.[jt]sx?$/, '');
+    if (!componentName) return false;
+
+    const islands = document.querySelectorAll('[data-component="' + componentName + '"]');
+    if (islands.length === 0) return false;
+
+    // Fetch the updated module and re-hydrate islands
+    return fetchAndRehydrate(moduleId, islands);
+  }
+
+  function handleComponentUpdate(update) {
+    // For now, component updates trigger a soft reload
+    // Future: implement React Fast Refresh integration
+    return false;
+  }
+
+  function fetchAndRehydrate(moduleId, islands) {
+    // Dynamic import with cache busting
+    const importUrl = '/' + moduleId + '?t=' + Date.now();
+
+    import(importUrl)
+      .then(function(module) {
+        const Component = module.default;
+        if (!Component) return;
+
+        // Re-render each island
+        islands.forEach(function(element) {
+          const propsJson = element.getAttribute('data-props');
+          const props = propsJson ? JSON.parse(propsJson) : {};
+
+          // Use React to re-render
+          if (window.__EREO_REACT__) {
+            const { createRoot } = window.__EREO_REACT_DOM__;
+            const { createElement } = window.__EREO_REACT__;
+
+            // Unmount existing
+            const existingRoot = window.__EREO_HMR__.islands.get(element);
+            if (existingRoot) {
+              existingRoot.unmount();
+            }
+
+            // Create new root and render
+            const root = createRoot(element);
+            root.render(createElement(Component, props));
+            window.__EREO_HMR__.islands.set(element, root);
+          }
+        });
+      })
+      .catch(function(err) {
+        console.error('[HMR] Failed to hot-update island:', err);
+        location.reload();
+      });
+
+    return true;
+  }
+
+  function refreshLoaderData(path) {
+    // Fetch fresh loader data and update the page
+    const routePath = path.replace(/\\/routes\\//, '/').replace(/\\.[jt]sx?$/, '');
+    fetch('/__ereo/loader-data' + routePath + '?t=' + Date.now())
+      .then(function(res) { return res.json(); })
+      .then(function(data) {
+        // Emit event for components to update
+        window.dispatchEvent(new CustomEvent('ereo:loader-update', {
+          detail: { path: routePath, data: data }
+        }));
+      })
+      .catch(function() {
+        location.reload();
+      });
+  }
+
+  function logHMRReason(update) {
+    if (update.reason) {
+      console.log('[HMR] ' + update.reason);
+    }
+  }
+
+  function showErrorOverlay(error) {
+    if (!error) return;
+
+    let overlay = document.getElementById('ereo-error-overlay');
+    if (!overlay) {
+      overlay = document.createElement('div');
+      overlay.id = 'ereo-error-overlay';
+      overlay.style.cssText = 'position:fixed;inset:0;background:rgba(0,0,0,0.9);color:#ff5555;padding:2rem;font-family:monospace;white-space:pre-wrap;overflow:auto;z-index:99999';
+      document.body.appendChild(overlay);
+    }
+
+    overlay.innerHTML = '<h2 style="color:#ff5555;margin:0 0 1rem">Error</h2>' +
+      '<p style="color:#fff">' + escapeHtml(error.message) + '</p>' +
+      (error.stack ? '<pre style="color:#888;margin-top:1rem">' + escapeHtml(error.stack) + '</pre>' : '') +
+      '<button onclick="this.parentElement.remove()" style="position:absolute;top:1rem;right:1rem;background:none;border:1px solid #666;color:#fff;padding:0.5rem 1rem;cursor:pointer">Close</button>';
+  }
+
+  function escapeHtml(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  }
+
+  // Clear error overlay on successful update
+  ws.addEventListener('message', function(event) {
+    const update = JSON.parse(event.data);
+    if (update.type !== 'error') {
+      const overlay = document.getElementById('ereo-error-overlay');
+      if (overlay) overlay.remove();
+    }
+  });
+})();
+`;
+
+class HMRServer {
+  clients = new Set;
+  lastUpdate = null;
+  depGraph;
+  moduleAnalyzer;
+  constructor() {
+    this.depGraph = {
+      dependents: new Map,
+      dependencies: new Map,
+      exports: new Map,
+      islands: new Set,
+      routes: new Set
+    };
+    this.moduleAnalyzer = new ModuleAnalyzer;
+  }
+  handleConnection(ws) {
+    this.clients.add(ws);
+    if (this.lastUpdate?.type === "error") {
+      ws.send(JSON.stringify(this.lastUpdate));
+    }
+  }
+  handleClose(ws) {
+    this.clients.delete(ws);
+  }
+  send(update) {
+    this.lastUpdate = update;
+    const message = JSON.stringify(update);
+    for (const client of this.clients) {
+      try {
+        client.send(message);
+      } catch {
+        this.clients.delete(client);
+      }
+    }
+  }
+  reload(reason) {
+    this.send({
+      type: "full-reload",
+      timestamp: Date.now(),
+      reason: reason || "Full reload triggered"
+    });
+  }
+  cssUpdate(path) {
+    this.send({
+      type: "css-update",
+      path,
+      timestamp: Date.now()
+    });
+  }
+  async jsUpdate(path) {
+    const analysis = await this.moduleAnalyzer.analyze(path);
+    if (analysis.isIsland) {
+      this.send({
+        type: "island-update",
+        path,
+        timestamp: Date.now(),
+        module: {
+          id: path,
+          exports: analysis.exports,
+          isIsland: true
+        },
+        reason: `Island component changed: ${path}`
+      });
+      return;
+    }
+    if (analysis.isLoader && !analysis.isComponent) {
+      this.send({
+        type: "loader-update",
+        path,
+        timestamp: Date.now(),
+        module: {
+          id: path,
+          exports: analysis.exports,
+          isLoader: true
+        },
+        reason: `Loader changed: ${path}`
+      });
+      return;
+    }
+    if (analysis.isComponent && !analysis.hasNonComponentExports) {
+      this.send({
+        type: "component-update",
+        path,
+        timestamp: Date.now(),
+        module: {
+          id: path,
+          exports: analysis.exports,
+          isComponent: true
+        },
+        reason: `Component changed: ${path}`
+      });
+      return;
+    }
+    this.send({
+      type: "js-update",
+      path,
+      timestamp: Date.now(),
+      module: {
+        id: path,
+        exports: analysis.exports,
+        isIsland: analysis.isIsland,
+        isLoader: analysis.isLoader,
+        isAction: analysis.isAction,
+        isComponent: analysis.isComponent
+      },
+      reason: this.getReloadReason(path, analysis)
+    });
+  }
+  getReloadReason(path, analysis) {
+    const reasons = [];
+    if (analysis.hasNonComponentExports) {
+      reasons.push(`exports changed (${analysis.exports.join(", ")})`);
+    }
+    if (analysis.isLoader && analysis.isComponent) {
+      reasons.push("mixed loader and component in same file");
+    }
+    if (path.includes("_layout") || path.includes("_error")) {
+      reasons.push("layout/error boundary changed");
+    }
+    if (reasons.length === 0) {
+      reasons.push("module structure changed");
+    }
+    return `Full reload: ${path} - ${reasons.join(", ")}`;
+  }
+  registerModule(moduleId, info) {
+    if (info.dependencies) {
+      this.depGraph.dependencies.set(moduleId, new Set(info.dependencies));
+      for (const dep of info.dependencies) {
+        if (!this.depGraph.dependents.has(dep)) {
+          this.depGraph.dependents.set(dep, new Set);
+        }
+        this.depGraph.dependents.get(dep).add(moduleId);
+      }
+    }
+    if (info.exports) {
+      this.depGraph.exports.set(moduleId, new Set(info.exports));
+    }
+    if (info.isIsland) {
+      this.depGraph.islands.add(moduleId);
+    }
+    if (info.isRoute) {
+      this.depGraph.routes.add(moduleId);
+    }
+  }
+  canHotUpdate(moduleId) {
+    if (this.depGraph.islands.has(moduleId)) {
+      return true;
+    }
+    const dependents = this.depGraph.dependents.get(moduleId);
+    if (dependents) {
+      for (const dep of dependents) {
+        if (this.depGraph.routes.has(dep)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  error(message, stack) {
+    this.send({
+      type: "error",
+      timestamp: Date.now(),
+      error: { message, stack }
+    });
+  }
+  clearError() {
+    if (this.lastUpdate?.type === "error") {
+      this.lastUpdate = null;
+    }
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  getDependencyGraph() {
+    return this.depGraph;
+  }
+}
+
+class ModuleAnalyzer {
+  cache = new Map;
+  async analyze(filePath) {
+    try {
+      const file = Bun.file(filePath);
+      const stat = await file.stat();
+      const mtime = stat?.mtime?.getTime() || 0;
+      const cached = this.cache.get(filePath);
+      if (cached && cached.mtime === mtime) {
+        return cached.analysis;
+      }
+      const content = await file.text();
+      const analysis = this.analyzeContent(content, filePath);
+      this.cache.set(filePath, { analysis, mtime });
+      return analysis;
+    } catch {
+      return {
+        exports: [],
+        isIsland: false,
+        isComponent: false,
+        isLoader: false,
+        isAction: false,
+        hasNonComponentExports: true
+      };
+    }
+  }
+  analyzeContent(content, filePath) {
+    const exports = [];
+    let isIsland = false;
+    let isComponent = false;
+    let isLoader = false;
+    let isAction = false;
+    isIsland = content.includes("client:load") || content.includes("client:idle") || content.includes("client:visible") || content.includes("client:media") || content.includes("data-island") || content.includes("createIsland(") || filePath.includes("/islands/");
+    isLoader = content.includes("export const loader") || content.includes("export async function loader") || content.includes("export function loader");
+    isAction = content.includes("export const action") || content.includes("export async function action") || content.includes("export function action");
+    isComponent = content.includes("export default function") || content.includes("export default class") || /export\s+default\s+\w+/.test(content);
+    const exportMatches = content.matchAll(/export\s+(?:const|let|var|function|async\s+function|class)\s+(\w+)/g);
+    for (const match of exportMatches) {
+      exports.push(match[1]);
+    }
+    if (content.includes("export default")) {
+      exports.push("default");
+    }
+    const namedExportMatch = content.match(/export\s*{([^}]+)}/g);
+    if (namedExportMatch) {
+      for (const match of namedExportMatch) {
+        const names = match.replace(/export\s*{/, "").replace("}", "").split(",");
+        for (const name of names) {
+          const cleanName = name.trim().split(" as ")[0].trim();
+          if (cleanName)
+            exports.push(cleanName);
+        }
+      }
+    }
+    const componentExports = new Set(["default", "loader", "action", "meta", "headers", "config", "handle", "ErrorBoundary"]);
+    const hasNonComponentExports = exports.some((e) => !componentExports.has(e));
+    return {
+      exports,
+      isIsland,
+      isComponent,
+      isLoader,
+      isAction,
+      hasNonComponentExports
+    };
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+}
+function createHMRServer() {
+  return new HMRServer;
+}
+function createHMRWebSocket(hmr) {
+  return {
+    open(ws) {
+      hmr.handleConnection(ws);
+    },
+    close(ws) {
+      hmr.handleClose(ws);
+    },
+    message() {}
+  };
+}
+
+class HMRWatcher {
+  hmr;
+  watching = false;
+  debounceTimer = null;
+  pendingChanges = new Set;
+  watchDir = "";
+  constructor(hmr) {
+    this.hmr = hmr;
+  }
+  watch(dir) {
+    if (this.watching)
+      return;
+    this.watching = true;
+    this.watchDir = dir;
+    try {
+      const { watch } = __require("fs");
+      watch(dir, { recursive: true }, (event, filename) => {
+        if (!filename)
+          return;
+        if (filename.startsWith(".") || filename.includes("node_modules"))
+          return;
+        this.pendingChanges.add(filename);
+        if (this.debounceTimer) {
+          clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+          this.processPendingChanges();
+        }, 50);
+      });
+    } catch (error) {
+      console.warn("File watching not available:", error);
+    }
+  }
+  async processPendingChanges() {
+    const changes = Array.from(this.pendingChanges);
+    this.pendingChanges.clear();
+    const cssChanges = [];
+    const jsChanges = [];
+    const configChanges = [];
+    const otherChanges = [];
+    for (const filename of changes) {
+      const ext = filename.split(".").pop()?.toLowerCase();
+      switch (ext) {
+        case "css":
+        case "scss":
+        case "less":
+          cssChanges.push(filename);
+          break;
+        case "ts":
+        case "tsx":
+        case "js":
+        case "jsx":
+          if (filename.includes(".config.") || filename === "ereo.config.ts") {
+            configChanges.push(filename);
+          } else {
+            jsChanges.push(filename);
+          }
+          break;
+        case "json":
+          if (filename === "package.json" || filename === "tsconfig.json") {
+            configChanges.push(filename);
+          } else {
+            otherChanges.push(filename);
+          }
+          break;
+        default:
+          otherChanges.push(filename);
+      }
+    }
+    if (configChanges.length > 0) {
+      this.hmr.reload(`Config changed: ${configChanges.join(", ")}`);
+      return;
+    }
+    for (const css of cssChanges) {
+      this.hmr.cssUpdate(css);
+    }
+    for (const js of jsChanges) {
+      const fullPath = `${this.watchDir}/${js}`;
+      await this.hmr.jsUpdate(fullPath);
+    }
+    if (otherChanges.length > 0 && cssChanges.length === 0 && jsChanges.length === 0) {
+      this.hmr.reload(`Files changed: ${otherChanges.join(", ")}`);
+    }
+  }
+  stop() {
+    this.watching = false;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.pendingChanges.clear();
+  }
+}
+function createHMRWatcher(hmr) {
+  return new HMRWatcher(hmr);
+}
+// src/dev/error-overlay.ts
+function parseError(error) {
+  if (typeof error === "string") {
+    return {
+      message: error,
+      type: "runtime"
+    };
+  }
+  const info = {
+    message: error.message,
+    stack: error.stack,
+    type: "runtime"
+  };
+  if (error.stack) {
+    const match = error.stack.match(/at\s+.+\((.+):(\d+):(\d+)\)/);
+    if (match) {
+      info.source = {
+        file: match[1],
+        line: parseInt(match[2], 10),
+        column: parseInt(match[3], 10)
+      };
+    }
+  }
+  if (error.name === "SyntaxError") {
+    info.type = "syntax";
+  } else if (error.name === "TypeError") {
+    info.type = "type";
+  }
+  return info;
+}
+function generateErrorOverlayHTML(error) {
+  const escapeHtml = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  const typeColors = {
+    runtime: "#ff5555",
+    build: "#ffaa00",
+    syntax: "#ff55ff",
+    type: "#5555ff"
+  };
+  const typeLabels = {
+    runtime: "Runtime Error",
+    build: "Build Error",
+    syntax: "Syntax Error",
+    type: "Type Error"
+  };
+  const sourceSection = error.source ? `
+    <div style="margin-top: 1rem; padding: 1rem; background: #1a1a1a; border-radius: 4px;">
+      <div style="color: #888; margin-bottom: 0.5rem;">
+        ${escapeHtml(error.source.file)}:${error.source.line}:${error.source.column}
+      </div>
+      ${error.source.code ? `<pre style="color: #fff; margin: 0;">${escapeHtml(error.source.code)}</pre>` : ""}
+    </div>
+  ` : "";
+  const stackSection = error.stack ? `
+    <details style="margin-top: 1rem;">
+      <summary style="cursor: pointer; color: #888;">Stack Trace</summary>
+      <pre style="color: #666; margin-top: 0.5rem; white-space: pre-wrap;">${escapeHtml(error.stack)}</pre>
+    </details>
+  ` : "";
+  return `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Error - EreoJS Dev</title>
+  <style>
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      padding: 2rem;
+      background: #111;
+      color: #fff;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      min-height: 100vh;
+    }
+    .container {
+      max-width: 800px;
+      margin: 0 auto;
+    }
+    .badge {
+      display: inline-block;
+      padding: 0.25rem 0.75rem;
+      border-radius: 4px;
+      font-size: 0.75rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+    h1 {
+      margin: 1rem 0;
+      font-size: 1.5rem;
+      font-weight: 500;
+    }
+    pre {
+      overflow-x: auto;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="badge" style="background: ${typeColors[error.type]}20; color: ${typeColors[error.type]};">
+      ${typeLabels[error.type]}
+    </div>
+    <h1>${escapeHtml(error.message)}</h1>
+    ${sourceSection}
+    ${stackSection}
+    <p style="margin-top: 2rem; color: #666; font-size: 0.875rem;">
+      Fix the error and save the file to see changes.
+    </p>
+  </div>
+</body>
+</html>
+  `.trim();
+}
+function createErrorResponse(error) {
+  const info = parseError(error);
+  const html = generateErrorOverlayHTML(info);
+  return new Response(html, {
+    status: 500,
+    headers: {
+      "Content-Type": "text/html; charset=utf-8"
+    }
+  });
+}
+function createErrorJSON(error) {
+  const info = parseError(error);
+  return new Response(JSON.stringify(info), {
+    status: 500,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var ERROR_OVERLAY_SCRIPT = `
+<script>
+(function() {
+  window.addEventListener('error', function(event) {
+    showOverlay({
+      message: event.message,
+      source: {
+        file: event.filename,
+        line: event.lineno,
+        column: event.colno,
+      },
+      type: 'runtime',
+    });
+  });
+
+  window.addEventListener('unhandledrejection', function(event) {
+    const error = event.reason;
+    showOverlay({
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+      type: 'runtime',
+    });
+  });
+
+  function showOverlay(error) {
+    let overlay = document.getElementById('ereo-error-overlay');
+    if (overlay) overlay.remove();
+
+    overlay = document.createElement('div');
+    overlay.id = 'ereo-error-overlay';
+    overlay.innerHTML = \`
+      <style>
+        #ereo-error-overlay {
+          position: fixed;
+          inset: 0;
+          background: rgba(0,0,0,0.95);
+          color: #fff;
+          padding: 2rem;
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+          overflow: auto;
+          z-index: 99999;
+        }
+        #ereo-error-overlay .close {
+          position: absolute;
+          top: 1rem;
+          right: 1rem;
+          background: none;
+          border: 1px solid #666;
+          color: #fff;
+          padding: 0.5rem 1rem;
+          cursor: pointer;
+          border-radius: 4px;
+        }
+        #ereo-error-overlay .close:hover {
+          background: #333;
+        }
+        #ereo-error-overlay h2 {
+          color: #ff5555;
+          margin: 0 0 1rem;
+        }
+        #ereo-error-overlay pre {
+          background: #1a1a1a;
+          padding: 1rem;
+          border-radius: 4px;
+          overflow-x: auto;
+          color: #888;
+        }
+      </style>
+      <button class="close" onclick="this.parentElement.remove()">Close (Esc)</button>
+      <h2>\${escapeHtml(error.message)}</h2>
+      \${error.source ? '<p style="color:#888">' + escapeHtml(error.source.file) + ':' + error.source.line + '</p>' : ''}
+      \${error.stack ? '<pre>' + escapeHtml(error.stack) + '</pre>' : ''}
+    \`;
+
+    document.body.appendChild(overlay);
+
+    document.addEventListener('keydown', function handler(e) {
+      if (e.key === 'Escape') {
+        overlay.remove();
+        document.removeEventListener('keydown', handler);
+      }
+    });
+  }
+
+  function escapeHtml(str) {
+    if (!str) return '';
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  }
+})();
+</script>
+`;
+// src/prod/build.ts
+import { join as join2, relative, dirname as dirname2, basename as basename2, extname } from "path";
+import { mkdir, rm, readdir, stat, copyFile } from "fs/promises";
+import { initFileRouter } from "@ereo/router";
+
+// src/plugins/islands.ts
+import { basename } from "path";
+var ISLAND_DIRECTIVE_PATTERN = /client:(load|idle|visible|media)(?:="([^"]+)")?/g;
+var COMPONENT_EXPORT_PATTERN = /export\s+(?:default\s+)?(?:function|const|class)\s+(\w+)/g;
+var USE_CLIENT_PATTERN = /^['"]use client['"]/m;
+function extractIslands(content, filePath) {
+  const islands = [];
+  const isClientComponent = USE_CLIENT_PATTERN.test(content);
+  if (!isClientComponent) {
+    const hasDirectives = ISLAND_DIRECTIVE_PATTERN.test(content);
+    if (!hasDirectives) {
+      return islands;
+    }
+  }
+  const componentNames = [];
+  let match;
+  COMPONENT_EXPORT_PATTERN.lastIndex = 0;
+  while ((match = COMPONENT_EXPORT_PATTERN.exec(content)) !== null) {
+    componentNames.push(match[1]);
+  }
+  const fileName = basename(filePath, ".tsx").replace(".ts", "");
+  if (isClientComponent && componentNames.length > 0) {
+    islands.push({
+      id: generateIslandId(filePath),
+      name: componentNames[0],
+      file: filePath,
+      strategy: "load",
+      exports: componentNames
+    });
+  }
+  return islands;
+}
+function generateIslandId(filePath) {
+  return filePath.replace(/[\/\\]/g, "_").replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_]/g, "");
+}
+function transformIslandJSX(code) {
+  let transformed = code;
+  transformed = transformed.replace(/<(\w+)\s+([^>]*client:(load|idle|visible|media)[^>]*)>/g, (match, tag, props, strategy) => {
+    const id = `island-${Math.random().toString(36).slice(2, 8)}`;
+    return `<${tag} data-island="${id}" data-strategy="${strategy}" ${props}>`;
+  });
+  return transformed;
+}
+function generateIslandManifest(islands) {
+  const manifest = {};
+  for (const island of islands) {
+    manifest[island.id] = {
+      name: island.name,
+      file: island.file,
+      strategy: island.strategy,
+      media: island.media,
+      exports: island.exports
+    };
+  }
+  return JSON.stringify(manifest, null, 2);
+}
+function generateIslandEntry(islands) {
+  const imports = [];
+  const registrations = [];
+  for (const island of islands) {
+    const importName = `Island_${island.id}`;
+    imports.push(`import ${importName} from '${island.file}';`);
+    registrations.push(`  registerIslandComponent('${island.name}', ${importName});`);
+  }
+  return `
+import { registerIslandComponent, initializeIslands } from '@ereo/client';
+
+// Import all islands
+${imports.join(`
+`)}
+
+// Register islands
+${registrations.join(`
+`)}
+
+// Initialize
+initializeIslands();
+  `.trim();
+}
+function createIslandsPlugin() {
+  const islands = [];
+  return {
+    name: "ereo:islands",
+    transform(code, id) {
+      if (!id.endsWith(".tsx") && !id.endsWith(".jsx")) {
+        return null;
+      }
+      const fileIslands = extractIslands(code, id);
+      islands.push(...fileIslands);
+      if (fileIslands.length > 0) {
+        return transformIslandJSX(code);
+      }
+      return null;
+    },
+    async buildEnd() {
+      if (islands.length === 0) {
+        return;
+      }
+      console.log(`Found ${islands.length} island(s)`);
+      const manifest = generateIslandManifest(islands);
+      await Bun.write(".ereo/islands.json", manifest);
+      const entry = generateIslandEntry(islands);
+      await Bun.write(".ereo/islands.entry.ts", entry);
+    }
+  };
+}
+function findIslandByName(islands, name) {
+  return islands.find((i) => i.name === name);
+}
+function hasIslands(content) {
+  return USE_CLIENT_PATTERN.test(content) || ISLAND_DIRECTIVE_PATTERN.test(content);
+}
+
+// src/prod/build.ts
+var DEFAULT_ASSET_EXTENSIONS = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".avif",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp3",
+  ".mp4",
+  ".webm",
+  ".ogg",
+  ".wav",
+  ".json",
+  ".xml",
+  ".txt",
+  ".pdf"
+];
+async function build(options = {}) {
+  const startTime = performance.now();
+  const root = options.root || process.cwd();
+  const outDir = options.outDir || join2(root, ".ereo");
+  const minify = options.minify ?? true;
+  const sourcemap = options.sourcemap ?? true;
+  const splitting = options.splitting ?? true;
+  const publicPath = options.publicPath || "/_ereo/";
+  const assetExtensions = options.assetExtensions || DEFAULT_ASSET_EXTENSIONS;
+  const buildId = generateBuildId();
+  const allOutputs = [];
+  const errors = [];
+  console.log(`\x1B[36m\u26A1\x1B[0m Building for production...
+`);
+  try {
+    await cleanAndCreateDirs(outDir);
+    if (options.plugins) {
+      for (const plugin of options.plugins) {
+        await plugin.buildStart?.();
+      }
+    }
+    const router = await initFileRouter({
+      routesDir: join2(root, "app/routes")
+    });
+    const routes = router.getRoutes();
+    const routeCount = countRoutes(routes);
+    console.log(`  \x1B[32m\u2713\x1B[0m Found ${routeCount} route(s)`);
+    const islands = await extractAllIslands(root, routes);
+    if (islands.length > 0) {
+      console.log(`  \x1B[32m\u2713\x1B[0m Found ${islands.length} island(s)`);
+    }
+    const cssFiles = await collectCSSFiles(root);
+    if (cssFiles.length > 0) {
+      console.log(`  \x1B[32m\u2713\x1B[0m Found ${cssFiles.length} CSS file(s)`);
+    }
+    console.log(`
+  Building server bundle...`);
+    const serverResult = await buildServer({
+      root,
+      outDir: join2(outDir, "server"),
+      routes,
+      minify,
+      sourcemap,
+      splitting,
+      external: options.external,
+      plugins: options.plugins
+    });
+    if (serverResult.errors.length > 0) {
+      errors.push(...serverResult.errors);
+    }
+    allOutputs.push(...serverResult.outputs);
+    console.log(`  \x1B[32m\u2713\x1B[0m Server bundle built (${serverResult.outputs.length} files)`);
+    console.log(`
+  Building client bundle...`);
+    const clientResult = await buildClient({
+      root,
+      outDir: join2(outDir, "client"),
+      routes,
+      minify,
+      sourcemap,
+      splitting,
+      plugins: options.plugins
+    });
+    if (clientResult.errors.length > 0) {
+      errors.push(...clientResult.errors);
+    }
+    allOutputs.push(...clientResult.outputs);
+    console.log(`  \x1B[32m\u2713\x1B[0m Client bundle built (${clientResult.outputs.length} files)`);
+    if (islands.length > 0) {
+      console.log(`
+  Building island bundles...`);
+      const islandResult = await buildIslands({
+        root,
+        outDir: join2(outDir, "client/islands"),
+        islands,
+        minify,
+        sourcemap,
+        splitting
+      });
+      if (islandResult.errors.length > 0) {
+        errors.push(...islandResult.errors);
+      }
+      allOutputs.push(...islandResult.outputs);
+      console.log(`  \x1B[32m\u2713\x1B[0m Island bundles built (${islandResult.outputs.length} files)`);
+    }
+    if (cssFiles.length > 0) {
+      console.log(`
+  Building CSS bundle...`);
+      const cssResult = await buildCSS({
+        root,
+        outDir: join2(outDir, "assets"),
+        cssFiles,
+        minify,
+        sourcemap,
+        plugins: options.plugins
+      });
+      if (cssResult.errors.length > 0) {
+        errors.push(...cssResult.errors);
+      }
+      allOutputs.push(...cssResult.outputs);
+      console.log(`  \x1B[32m\u2713\x1B[0m CSS bundle built (${cssResult.outputs.length} files)`);
+    }
+    console.log(`
+  Copying static assets...`);
+    const assetResult = await copyAssets({
+      root,
+      outDir: join2(outDir, "assets"),
+      extensions: assetExtensions
+    });
+    allOutputs.push(...assetResult.outputs);
+    if (assetResult.outputs.length > 0) {
+      console.log(`  \x1B[32m\u2713\x1B[0m Copied ${assetResult.outputs.length} static assets`);
+    }
+    console.log(`
+  Generating manifest...`);
+    await generateManifest({
+      outDir,
+      buildId,
+      routes,
+      islands,
+      serverResult,
+      clientResult,
+      cssFiles: allOutputs.filter((o) => o.type === "css").map((o) => o.path)
+    });
+    console.log(`  \x1B[32m\u2713\x1B[0m Manifest generated`);
+    if (options.plugins) {
+      for (const plugin of options.plugins) {
+        await plugin.buildEnd?.();
+      }
+    }
+    const duration = performance.now() - startTime;
+    const success = errors.length === 0;
+    console.log(`
+\x1B[32m\u2713\x1B[0m Build ${success ? "completed" : "completed with warnings"} in ${duration.toFixed(0)}ms`);
+    return {
+      success,
+      outputs: allOutputs,
+      duration,
+      errors: errors.length > 0 ? errors : undefined
+    };
+  } catch (error) {
+    const duration = performance.now() - startTime;
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`
+\x1B[31m\u2717\x1B[0m Build failed:`, errorMessage);
+    return {
+      success: false,
+      outputs: allOutputs,
+      duration,
+      errors: [errorMessage]
+    };
+  }
+}
+function generateBuildId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+async function cleanAndCreateDirs(outDir) {
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { recursive: true });
+  await mkdir(join2(outDir, "server"), { recursive: true });
+  await mkdir(join2(outDir, "server/routes"), { recursive: true });
+  await mkdir(join2(outDir, "client"), { recursive: true });
+  await mkdir(join2(outDir, "client/islands"), { recursive: true });
+  await mkdir(join2(outDir, "client/chunks"), { recursive: true });
+  await mkdir(join2(outDir, "assets"), { recursive: true });
+}
+function countRoutes(routes) {
+  let count = 0;
+  for (const route of routes) {
+    count++;
+    if (route.children) {
+      count += countRoutes(route.children);
+    }
+  }
+  return count;
+}
+async function extractAllIslands(root, routes) {
+  const islands = [];
+  const processedFiles = new Set;
+  const processRoute = async (route) => {
+    if (processedFiles.has(route.file))
+      return;
+    processedFiles.add(route.file);
+    try {
+      const content = await Bun.file(route.file).text();
+      if (hasIslands(content)) {
+        const fileIslands = extractIslands(content, route.file);
+        islands.push(...fileIslands);
+      }
+    } catch (error) {}
+    if (route.children) {
+      for (const child of route.children) {
+        await processRoute(child);
+      }
+    }
+  };
+  const componentsDir = join2(root, "app/components");
+  try {
+    const componentFiles = await scanForFiles(componentsDir, [".tsx", ".jsx"]);
+    for (const file of componentFiles) {
+      if (processedFiles.has(file))
+        continue;
+      processedFiles.add(file);
+      try {
+        const content = await Bun.file(file).text();
+        if (hasIslands(content)) {
+          const fileIslands = extractIslands(content, file);
+          islands.push(...fileIslands);
+        }
+      } catch (error) {}
+    }
+  } catch (error) {}
+  for (const route of routes) {
+    await processRoute(route);
+  }
+  return islands;
+}
+async function scanForFiles(dir, extensions) {
+  const files = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        const subFiles = await scanForFiles(fullPath, extensions);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        const ext = extname(entry.name);
+        if (extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (error) {}
+  return files;
+}
+async function collectCSSFiles(root) {
+  const cssFiles = [];
+  const dirsToScan = [
+    join2(root, "app"),
+    join2(root, "styles"),
+    join2(root, "src")
+  ];
+  for (const dir of dirsToScan) {
+    try {
+      const files = await scanForFiles(dir, [".css"]);
+      cssFiles.push(...files);
+    } catch (error) {}
+  }
+  return cssFiles;
+}
+async function buildServer(options) {
+  const {
+    root,
+    outDir,
+    routes,
+    minify = true,
+    sourcemap = true,
+    splitting = true,
+    external = [],
+    plugins
+  } = options;
+  const outputs = [];
+  const errors = [];
+  const routeModules = {};
+  const entrypoints = [];
+  const routesDir = join2(outDir, "routes");
+  const collectEntrypoints = (routeList) => {
+    for (const route of routeList) {
+      entrypoints.push(route.file);
+      if (route.children) {
+        collectEntrypoints(route.children);
+      }
+    }
+  };
+  collectEntrypoints(routes);
+  if (entrypoints.length === 0) {
+    return {
+      outputs: [],
+      errors: [],
+      entryFile: "",
+      routeModules: {}
+    };
+  }
+  const serverEntry = generateServerEntry(routes, root);
+  const serverEntryPath = join2(outDir, "_entry.server.ts");
+  await Bun.write(serverEntryPath, serverEntry);
+  try {
+    const result = await Bun.build({
+      entrypoints,
+      outdir: routesDir,
+      target: "bun",
+      minify,
+      sourcemap: sourcemap ? "external" : "none",
+      splitting,
+      external: ["react", "react-dom", "@ereo/core", "@ereo/router", "@ereo/render", ...external],
+      naming: {
+        entry: "[dir]/[name].[ext]",
+        chunk: "../chunks/[name]-[hash].[ext]",
+        asset: "../assets/[name]-[hash].[ext]"
+      }
+    });
+    if (!result.success) {
+      for (const log of result.logs) {
+        errors.push(log.message);
+      }
+    }
+    for (const output of result.outputs) {
+      const fileStat = await Bun.file(output.path).stat();
+      const relativePath = relative(options.root, output.path);
+      outputs.push({
+        path: relativePath,
+        size: fileStat?.size || 0,
+        type: output.path.endsWith(".css") ? "css" : output.path.endsWith(".map") ? "map" : "js",
+        isEntry: output.kind === "entry-point"
+      });
+      if (output.kind === "entry-point") {
+        const sourcePath = entrypoints.find((e) => output.path.includes(basename2(e, extname(e))));
+        if (sourcePath) {
+          const routeId = relative(join2(root, "app/routes"), sourcePath).replace(/\.[^.]+$/, "").replace(/\\/g, "/");
+          routeModules[routeId] = relativePath;
+        }
+      }
+    }
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+  }
+  try {
+    const entryResult = await Bun.build({
+      entrypoints: [serverEntryPath],
+      outdir: outDir,
+      target: "bun",
+      minify,
+      sourcemap: sourcemap ? "external" : "none",
+      splitting: false,
+      external: ["react", "react-dom", "@ereo/core", "@ereo/router", "@ereo/render", ...external],
+      naming: {
+        entry: "index.[ext]"
+      }
+    });
+    if (!entryResult.success) {
+      for (const log of entryResult.logs) {
+        errors.push(log.message);
+      }
+    }
+    for (const output of entryResult.outputs) {
+      const fileStat = await Bun.file(output.path).stat();
+      outputs.push({
+        path: relative(options.root, output.path),
+        size: fileStat?.size || 0,
+        type: output.path.endsWith(".map") ? "map" : "js",
+        isEntry: true
+      });
+    }
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+  }
+  try {
+    await rm(serverEntryPath);
+  } catch (error) {}
+  return {
+    outputs,
+    errors,
+    entryFile: ".ereo/server/index.js",
+    routeModules
+  };
+}
+function generateServerEntry(routes, root) {
+  const imports = [];
+  const routeRegistrations = [];
+  const processRoute = (route, index) => {
+    const varName = `route_${index}`;
+    const relativePath = relative(root, route.file).replace(/\\/g, "/");
+    imports.push(`import * as ${varName} from './routes/${relative(join2(root, "app/routes"), route.file).replace(/\\/g, "/").replace(/\.[^.]+$/, ".js")}';`);
+    routeRegistrations.push(`  {
+    id: '${route.id}',
+    path: '${route.path}',
+    module: ${varName},
+    index: ${route.index || false},
+    layout: ${route.layout || false},
+  }`);
+    if (route.children) {
+      route.children.forEach((child, childIndex) => {
+        processRoute(child, index * 100 + childIndex);
+      });
+    }
+  };
+  routes.forEach((route, index) => processRoute(route, index));
+  return `/**
+ * Server Entry - Auto-generated by @ereo/bundler
+ * Do not edit this file directly.
+ */
+
+${imports.join(`
+`)}
+
+// Route registry
+export const routes = [
+${routeRegistrations.join(`,
+`)}
+];
+
+// Route lookup map for fast access
+export const routeMap = new Map(routes.map(r => [r.path, r]));
+
+// Find route by path
+export function findRoute(path) {
+  return routeMap.get(path);
+}
+
+// Get all route paths
+export function getRoutePaths() {
+  return routes.map(r => r.path);
+}
+
+// Default export for Bun.serve compatibility
+export default {
+  routes,
+  routeMap,
+  findRoute,
+  getRoutePaths,
+};
+`;
+}
+async function buildClient(options) {
+  const { root, outDir, routes, minify = true, sourcemap = true, splitting = true } = options;
+  const outputs = [];
+  const errors = [];
+  const chunks = {};
+  const clientEntry = join2(root, "app/entry.client.tsx");
+  const clientEntryAlt = join2(root, "app/entry.client.ts");
+  const hasClientEntry = await Bun.file(clientEntry).exists();
+  const hasClientEntryAlt = await Bun.file(clientEntryAlt).exists();
+  let entrypoint;
+  if (hasClientEntry) {
+    entrypoint = clientEntry;
+  } else if (hasClientEntryAlt) {
+    entrypoint = clientEntryAlt;
+  } else {
+    const defaultEntry = join2(outDir, "_entry.client.tsx");
+    await Bun.write(defaultEntry, generateDefaultClientEntry(routes));
+    entrypoint = defaultEntry;
+  }
+  try {
+    const result = await Bun.build({
+      entrypoints: [entrypoint],
+      outdir: outDir,
+      target: "browser",
+      minify,
+      sourcemap: sourcemap ? "external" : "none",
+      splitting,
+      naming: {
+        entry: "index.[ext]",
+        chunk: "chunks/[name]-[hash].[ext]",
+        asset: "../assets/[name]-[hash].[ext]"
+      }
+    });
+    if (!result.success) {
+      for (const log of result.logs) {
+        errors.push(log.message);
+      }
+    }
+    for (const output of result.outputs) {
+      const fileStat = await Bun.file(output.path).stat();
+      const relativePath = relative(options.root, output.path);
+      outputs.push({
+        path: relativePath,
+        size: fileStat?.size || 0,
+        type: output.path.endsWith(".css") ? "css" : output.path.endsWith(".map") ? "map" : "js",
+        isEntry: output.kind === "entry-point"
+      });
+      if (output.kind === "chunk") {
+        const chunkName = basename2(output.path, extname(output.path));
+        chunks[chunkName] = relativePath;
+      }
+    }
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+  }
+  if (!hasClientEntry && !hasClientEntryAlt) {
+    try {
+      await rm(join2(outDir, "_entry.client.tsx"));
+    } catch (error) {}
+  }
+  return {
+    outputs,
+    errors,
+    entryFile: ".ereo/client/index.js",
+    chunks
+  };
+}
+function generateDefaultClientEntry(routes) {
+  return `/**
+ * Client Entry - Auto-generated by @ereo/bundler
+ * Do not edit this file directly.
+ */
+
+// Initialize client-side hydration
+import { hydrateRoot } from 'react-dom/client';
+
+// Client-side router and hydration
+async function initClient() {
+  // Wait for DOM to be ready
+  if (document.readyState === 'loading') {
+    await new Promise(resolve => document.addEventListener('DOMContentLoaded', resolve));
+  }
+
+  // Get hydration data from server-rendered script
+  const dataScript = document.getElementById('__EREO_DATA__');
+  const serverData = dataScript ? JSON.parse(dataScript.textContent || '{}') : {};
+
+  console.log('[EreoJS] Client hydration initialized');
+
+  // Initialize islands
+  const islands = document.querySelectorAll('[data-island]');
+  if (islands.length > 0) {
+    console.log(\`[EreoJS] Found \${islands.length} island(s) to hydrate\`);
+  }
+}
+
+// Auto-initialize
+initClient().catch(console.error);
+
+export { initClient };
+`;
+}
+async function buildIslands(options) {
+  const { root, outDir, islands, minify = true, sourcemap = true, splitting = true } = options;
+  const outputs = [];
+  const errors = [];
+  const islandMap = {};
+  if (islands.length === 0) {
+    return { outputs, errors, islands: islandMap };
+  }
+  const islandEntry = generateIslandEntry(islands);
+  const islandEntryPath = join2(outDir, "_islands.entry.ts");
+  await Bun.write(islandEntryPath, islandEntry);
+  const islandManifest = generateIslandManifest(islands);
+  await Bun.write(join2(outDir, "manifest.json"), islandManifest);
+  const islandEntrypoints = islands.map((island) => island.file);
+  try {
+    const result = await Bun.build({
+      entrypoints: islandEntrypoints,
+      outdir: outDir,
+      target: "browser",
+      minify,
+      sourcemap: sourcemap ? "external" : "none",
+      splitting,
+      external: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"],
+      naming: {
+        entry: "[name]-[hash].[ext]",
+        chunk: "shared/[name]-[hash].[ext]",
+        asset: "../assets/[name]-[hash].[ext]"
+      }
+    });
+    if (!result.success) {
+      for (const log of result.logs) {
+        errors.push(log.message);
+      }
+    }
+    for (const output of result.outputs) {
+      const fileStat = await Bun.file(output.path).stat();
+      const relativePath = relative(options.root, output.path);
+      outputs.push({
+        path: relativePath,
+        size: fileStat?.size || 0,
+        type: output.path.endsWith(".css") ? "css" : output.path.endsWith(".map") ? "map" : "js",
+        isEntry: output.kind === "entry-point"
+      });
+      if (output.kind === "entry-point") {
+        const sourceIsland = islands.find((i) => output.path.includes(basename2(i.file, extname(i.file))));
+        if (sourceIsland) {
+          islandMap[sourceIsland.id] = relativePath;
+        }
+      }
+    }
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+  }
+  try {
+    await rm(islandEntryPath);
+  } catch (error) {}
+  return {
+    outputs,
+    errors,
+    islands: islandMap
+  };
+}
+async function buildCSS(options) {
+  const { root, outDir, cssFiles, minify = true, sourcemap = true, plugins } = options;
+  const outputs = [];
+  const errors = [];
+  if (cssFiles.length === 0) {
+    return { outputs, errors };
+  }
+  let combinedCSS = "";
+  for (const cssFile of cssFiles) {
+    try {
+      let content = await Bun.file(cssFile).text();
+      if (plugins) {
+        for (const plugin of plugins) {
+          if (plugin.transform) {
+            const transformed = await plugin.transform(content, cssFile);
+            if (transformed) {
+              content = transformed;
+            }
+          }
+        }
+      }
+      combinedCSS += `/* Source: ${relative(root, cssFile)} */
+${content}
+
+`;
+    } catch (error) {
+      errors.push(`Failed to read CSS file ${cssFile}: ${error}`);
+    }
+  }
+  const outputPath = join2(outDir, "styles.css");
+  if (minify) {
+    combinedCSS = minifyCSS(combinedCSS);
+  }
+  await Bun.write(outputPath, combinedCSS);
+  const fileStat = await Bun.file(outputPath).stat();
+  outputs.push({
+    path: relative(root, outputPath),
+    size: fileStat?.size || 0,
+    type: "css",
+    isEntry: true
+  });
+  if (sourcemap) {
+    const mapContent = JSON.stringify({
+      version: 3,
+      sources: cssFiles.map((f) => relative(root, f)),
+      names: [],
+      mappings: ""
+    });
+    const mapPath = outputPath + ".map";
+    await Bun.write(mapPath, mapContent);
+    const mapStat = await Bun.file(mapPath).stat();
+    outputs.push({
+      path: relative(root, mapPath),
+      size: mapStat?.size || 0,
+      type: "map"
+    });
+  }
+  return { outputs, errors };
+}
+function minifyCSS(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{}:;,>+~])\s*/g, "$1").replace(/;}/g, "}").trim();
+}
+async function copyAssets(options) {
+  const { root, outDir, extensions } = options;
+  const outputs = [];
+  const assetDirs = [
+    join2(root, "public"),
+    join2(root, "app/assets"),
+    join2(root, "assets")
+  ];
+  for (const dir of assetDirs) {
+    try {
+      const files = await scanForFiles(dir, extensions);
+      for (const file of files) {
+        const relativePath = relative(dir, file);
+        const destPath = join2(outDir, relativePath);
+        await mkdir(dirname2(destPath), { recursive: true });
+        await copyFile(file, destPath);
+        const fileStat = await stat(destPath);
+        outputs.push({
+          path: relative(options.root, destPath),
+          size: fileStat.size,
+          type: "asset"
+        });
+      }
+    } catch (error) {}
+  }
+  return { outputs };
+}
+async function generateManifest(options) {
+  const { outDir, buildId, routes, islands, serverResult, clientResult, cssFiles } = options;
+  const routeEntries = [];
+  const processRoute = (route, parentId) => {
+    routeEntries.push({
+      id: route.id,
+      path: route.path,
+      file: route.file,
+      index: route.index,
+      layout: route.layout,
+      hasLoader: !!route.module?.loader,
+      hasAction: !!route.module?.action,
+      hasMeta: !!route.module?.meta,
+      hasErrorBoundary: !!route.module?.ErrorBoundary,
+      parentId
+    });
+    if (route.children) {
+      route.children.forEach((child) => processRoute(child, route.id));
+    }
+  };
+  routes.forEach((route) => processRoute(route));
+  const islandEntries = {};
+  for (const island of islands) {
+    islandEntries[island.id] = {
+      id: island.id,
+      name: island.name,
+      file: island.file,
+      strategy: island.strategy,
+      exports: island.exports
+    };
+  }
+  const assets = {};
+  const allOutputs = [...serverResult.outputs, ...clientResult.outputs];
+  for (const output of allOutputs) {
+    if (output.isEntry) {
+      assets[output.path] = {
+        file: output.path,
+        isEntry: true
+      };
+    }
+  }
+  const manifest = {
+    version: 1,
+    buildTime: new Date().toISOString(),
+    buildId,
+    routes: routeEntries,
+    server: {
+      entry: serverResult.entryFile,
+      modules: serverResult.routeModules
+    },
+    client: {
+      entry: clientResult.entryFile,
+      islands: islandEntries,
+      chunks: clientResult.chunks
+    },
+    assets,
+    css: cssFiles
+  };
+  await Bun.write(join2(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+}
+function formatSize(bytes) {
+  if (bytes < 1024)
+    return bytes + " B";
+  if (bytes < 1024 * 1024)
+    return (bytes / 1024).toFixed(2) + " KB";
+  return (bytes / (1024 * 1024)).toFixed(2) + " MB";
+}
+function printBuildReport(result) {
+  console.log(`
+Build Report:`);
+  console.log("\u2500".repeat(60));
+  const byType = {
+    js: result.outputs.filter((o) => o.type === "js"),
+    css: result.outputs.filter((o) => o.type === "css"),
+    asset: result.outputs.filter((o) => o.type === "asset")
+  };
+  for (const [type, files] of Object.entries(byType)) {
+    if (files.length === 0)
+      continue;
+    const totalSize2 = files.reduce((sum, f) => sum + f.size, 0);
+    console.log(`
+${type.toUpperCase()} (${files.length} files, ${formatSize(totalSize2)}):`);
+    for (const file of files.slice(0, 10)) {
+      const entryMark = file.isEntry ? " (entry)" : "";
+      console.log(`  ${file.path} (${formatSize(file.size)})${entryMark}`);
+    }
+    if (files.length > 10) {
+      console.log(`  ... and ${files.length - 10} more`);
+    }
+  }
+  console.log(`
+` + "\u2500".repeat(60));
+  const totalSize = result.outputs.reduce((sum, o) => sum + o.size, 0);
+  console.log(`Total: ${result.outputs.length} files (${formatSize(totalSize)})`);
+  console.log(`Duration: ${result.duration.toFixed(0)}ms`);
+  if (result.errors && result.errors.length > 0) {
+    console.log(`
+\x1B[33mWarnings/Errors:\x1B[0m`);
+    for (const error of result.errors.slice(0, 5)) {
+      console.log(`  - ${error}`);
+    }
+    if (result.errors.length > 5) {
+      console.log(`  ... and ${result.errors.length - 5} more`);
+    }
+  }
+}
+function analyzeBuild(result) {
+  const jsFiles = result.outputs.filter((o) => o.type === "js");
+  const cssFiles = result.outputs.filter((o) => o.type === "css");
+  const assetFiles = result.outputs.filter((o) => o.type === "asset");
+  const totalSize = result.outputs.reduce((sum, o) => sum + o.size, 0);
+  const jsSize = jsFiles.reduce((sum, o) => sum + o.size, 0);
+  const cssSize = cssFiles.reduce((sum, o) => sum + o.size, 0);
+  const assetSize = assetFiles.reduce((sum, o) => sum + o.size, 0);
+  const largestFiles = [...result.outputs].filter((o) => o.type !== "map").sort((a, b) => b.size - a.size).slice(0, 5);
+  const recommendations = [];
+  if (jsSize > 500 * 1024) {
+    recommendations.push("Consider code splitting to reduce initial bundle size");
+  }
+  const largeJsFiles = jsFiles.filter((f) => f.size > 100 * 1024);
+  if (largeJsFiles.length > 0) {
+    recommendations.push(`${largeJsFiles.length} JS file(s) exceed 100KB - consider splitting`);
+  }
+  if (jsFiles.length > 50) {
+    recommendations.push("Many small chunks detected - consider adjusting splitting strategy");
+  }
+  return {
+    totalSize,
+    jsSize,
+    cssSize,
+    assetSize,
+    largestFiles,
+    recommendations
+  };
+}
+// src/plugins/types.ts
+import { join as join3 } from "path";
+function extractParams(path) {
+  const params = {};
+  const segments = path.split("/").filter(Boolean);
+  for (const segment of segments) {
+    const catchAllMatch = segment.match(/^\[\.\.\.(\w+)\]$/);
+    if (catchAllMatch) {
+      params[catchAllMatch[1]] = { type: "string[]" };
+      continue;
+    }
+    const optionalMatch = segment.match(/^\[\[(\w+)\]\]$/);
+    if (optionalMatch) {
+      params[optionalMatch[1]] = { type: "string", optional: true };
+      continue;
+    }
+    const dynamicMatch = segment.match(/^\[(\w+)\]$/);
+    if (dynamicMatch) {
+      params[dynamicMatch[1]] = { type: "string" };
+      continue;
+    }
+  }
+  return params;
+}
+function generateImportPath(file, routesDir) {
+  let importPath = file.replace(routesDir, "@routes").replace(/\.(tsx?|jsx?)$/, "");
+  return importPath;
+}
+function safeIdentifier(path) {
+  return path.replace(/[^a-zA-Z0-9]/g, "_");
+}
+function collectRouteInfos(routes, routesDir, inferTypes, parentPath) {
+  const routeInfos = [];
+  for (const route of routes) {
+    if (!route.layout) {
+      const importPath = generateImportPath(route.file, routesDir);
+      const info = {
+        path: route.path,
+        file: route.file,
+        params: extractParams(route.path),
+        hasLoader: !!route.module?.loader,
+        hasAction: !!route.module?.action,
+        hasMeta: !!route.module?.meta,
+        hasHandle: !!route.module?.handle,
+        hasSearchParams: !!route.module?.searchParams,
+        hasHashParams: false,
+        parentPath,
+        config: {
+          renderMode: route.config?.render?.mode,
+          auth: route.config?.auth?.required
+        }
+      };
+      if (inferTypes) {
+        if (info.hasLoader) {
+          info.loaderTypeRef = `typeof import('${importPath}')['loader']`;
+        }
+        if (info.hasAction) {
+          info.actionTypeRef = `typeof import('${importPath}')['action']`;
+        }
+        if (info.hasSearchParams) {
+          info.searchParamsTypeRef = `typeof import('${importPath}')['searchParams']`;
+        }
+        if (route.module?.hashParams) {
+          info.hasHashParams = true;
+          info.hashParamsTypeRef = `typeof import('${importPath}')['hashParams']`;
+        }
+      }
+      routeInfos.push(info);
+    }
+    if (route.children) {
+      const childInfos = collectRouteInfos(route.children, routesDir, inferTypes, route.path);
+      routeInfos.push(...childInfos);
+    }
+  }
+  return routeInfos;
+}
+function generateParamsType(params) {
+  const entries = Object.entries(params);
+  if (entries.length === 0) {
+    return "Record<string, never>";
+  }
+  const parts = entries.map(([key, { type, optional }]) => {
+    const optionalMark = optional ? "?" : "";
+    return `${key}${optionalMark}: ${type}`;
+  });
+  return `{ ${parts.join("; ")} }`;
+}
+function generateRouteTypes(routes, options = {}) {
+  const {
+    routesDir = "app/routes",
+    inferTypes = true,
+    generateSearchParams = true,
+    generateHashParams = true,
+    generateContext = true,
+    lazyEvaluation = true
+  } = options;
+  const routeInfos = collectRouteInfos(routes, routesDir, inferTypes);
+  const lines = [
+    "// Auto-generated by @ereo/bundler",
+    "// Do not edit this file manually",
+    "// Generated at: " + new Date().toISOString(),
+    "",
+    "// Performance: Uses object maps and lazy evaluation for large route trees",
+    ""
+  ];
+  if (lazyEvaluation) {
+    lines.push("// Lazy evaluation wrapper for better TypeScript performance");
+    lines.push("type LazyEval<T> = T extends infer U ? U : never;");
+    lines.push("");
+  }
+  if (inferTypes) {
+    lines.push("// Route module imports for type inference");
+    const uniqueImports = new Set;
+    for (const info of routeInfos) {
+      const importPath = generateImportPath(info.file, routesDir);
+      if (!uniqueImports.has(importPath)) {
+        uniqueImports.add(importPath);
+        const safeName = safeIdentifier(importPath);
+        lines.push(`import type * as ${safeName} from '${importPath}';`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("declare module '@ereo/core' {");
+  lines.push("  export interface RouteTypes {");
+  for (const info of routeInfos) {
+    const paramsType = generateParamsType(info.params);
+    const importPath = generateImportPath(info.file, routesDir);
+    const safeName = safeIdentifier(importPath);
+    const wrapType = lazyEvaluation ? (t) => `LazyEval<${t}>` : (t) => t;
+    lines.push(`    '${info.path}': {`);
+    lines.push(`      params: ${paramsType};`);
+    if (generateSearchParams && info.hasSearchParams && inferTypes) {
+      lines.push(`      search: ${wrapType(`${safeName} extends { searchParams: infer S } ? (S extends { parse: (data: any) => infer R } ? R : Record<string, string | string[] | undefined>) : Record<string, string | string[] | undefined>`)};`);
+    } else {
+      lines.push(`      search: Record<string, string | string[] | undefined>;`);
+    }
+    if (generateHashParams && info.hasHashParams && inferTypes) {
+      lines.push(`      hash: ${wrapType(`${safeName} extends { hashParams: infer H } ? (H extends { parse: (data: any) => infer R } ? R : Record<string, string | undefined>) : Record<string, string | undefined>`)};`);
+    } else {
+      lines.push(`      hash: Record<string, string | undefined>;`);
+    }
+    if (info.hasLoader && inferTypes) {
+      lines.push(`      loader: ${wrapType(`${safeName} extends { loader: infer L } ? (L extends (...args: any[]) => infer R ? Awaited<R> : never) : never`)};`);
+    } else {
+      lines.push(`      loader: unknown;`);
+    }
+    if (info.hasAction && inferTypes) {
+      lines.push(`      action: ${wrapType(`${safeName} extends { action: infer A } ? (A extends (...args: any[]) => infer R ? Awaited<R> : never) : never`)};`);
+    } else {
+      lines.push(`      action: unknown;`);
+    }
+    if (generateContext && info.parentPath) {
+      lines.push(`      context: RouteTypes['${info.parentPath}'] extends { context: infer C } ? C : Record<string, unknown>;`);
+    } else {
+      lines.push(`      context: Record<string, unknown>;`);
+    }
+    lines.push(`      meta: ${info.hasMeta};`);
+    lines.push(`      handle: ${info.hasHandle ? `${safeName}['handle']` : "undefined"};`);
+    lines.push("    };");
+  }
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  lines.push("// All available route paths (using object map for performance)");
+  lines.push("type RoutePathMap = {");
+  for (const info of routeInfos) {
+    lines.push(`  '${info.path}': true;`);
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push("export type RoutePath = keyof RoutePathMap;");
+  lines.push("");
+  lines.push("// Helper types for route-safe navigation");
+  lines.push(generateHelperTypes(lazyEvaluation));
+  lines.push("");
+  lines.push("// Runtime path builder");
+  lines.push(generateBuildPathFunction());
+  lines.push("");
+  lines.push("export {};");
+  return lines.join(`
+`);
+}
+function generateHelperTypes(lazyEvaluation) {
+  const lazy = lazyEvaluation ? "LazyEval" : "";
+  const wrap = (t) => lazyEvaluation ? `LazyEval<${t}>` : t;
+  return `
+/**
+ * Extract params type for a route path.
+ */
+export type ParamsFor<T extends RoutePath> =
+  T extends keyof import('@ereo/core').RouteTypes
+    ? ${wrap("import('@ereo/core').RouteTypes[T]['params']")}
+    : Record<string, string>;
+
+/**
+ * Extract search params type for a route path.
+ * This is typed per-route (TanStack limitation solved).
+ */
+export type SearchParamsFor<T extends RoutePath> =
+  T extends keyof import('@ereo/core').RouteTypes
+    ? ${wrap("import('@ereo/core').RouteTypes[T]['search']")}
+    : Record<string, string | string[] | undefined>;
+
+/**
+ * Extract hash params type for a route path.
+ * UNIQUE to Ereo - TanStack has no hash param support.
+ */
+export type HashParamsFor<T extends RoutePath> =
+  T extends keyof import('@ereo/core').RouteTypes
+    ? ${wrap("import('@ereo/core').RouteTypes[T]['hash']")}
+    : Record<string, string | undefined>;
+
+/**
+ * Extract loader data type for a route path.
+ */
+export type LoaderDataFor<T extends RoutePath> =
+  T extends keyof import('@ereo/core').RouteTypes
+    ? ${wrap("import('@ereo/core').RouteTypes[T]['loader']")}
+    : unknown;
+
+/**
+ * Extract action data type for a route path.
+ */
+export type ActionDataFor<T extends RoutePath> =
+  T extends keyof import('@ereo/core').RouteTypes
+    ? ${wrap("import('@ereo/core').RouteTypes[T]['action']")}
+    : unknown;
+
+/**
+ * Extract context type for a route path.
+ * Context is accumulated from parent layouts.
+ */
+export type ContextFor<T extends RoutePath> =
+  T extends keyof import('@ereo/core').RouteTypes
+    ? ${wrap("import('@ereo/core').RouteTypes[T]['context']")}
+    : Record<string, unknown>;
+
+/**
+ * Extract handle type for a route path.
+ */
+export type HandleFor<T extends RoutePath> =
+  T extends keyof import('@ereo/core').RouteTypes
+    ? ${wrap("import('@ereo/core').RouteTypes[T]['handle']")}
+    : undefined;
+
+/**
+ * Type-safe route with all params.
+ */
+export type TypedRoute<T extends RoutePath> = {
+  path: T;
+  params: ParamsFor<T>;
+  search?: SearchParamsFor<T>;
+  hash?: HashParamsFor<T>;
+};
+
+/**
+ * Full route data type.
+ */
+export type RouteData<T extends RoutePath> = {
+  params: ParamsFor<T>;
+  search: SearchParamsFor<T>;
+  hash: HashParamsFor<T>;
+  loaderData: LoaderDataFor<T>;
+  actionData: ActionDataFor<T> | undefined;
+  context: ContextFor<T>;
+  handle: HandleFor<T>;
+};
+
+/**
+ * Check if params object is empty (no required params).
+ */
+export type HasRequiredParams<T extends RoutePath> =
+  keyof ParamsFor<T> extends never ? false : true;
+
+/**
+ * Conditionally require params based on route.
+ */
+export type ParamsRequired<T extends RoutePath> =
+  Record<string, never> extends ParamsFor<T>
+    ? { params?: ParamsFor<T> }
+    : { params: ParamsFor<T> };
+`.trim();
+}
+function generateBuildPathFunction() {
+  return `
+/**
+ * Build a URL path with params, search, and hash.
+ */
+export function buildPath<T extends RoutePath>(
+  path: T,
+  options: {
+    params?: ParamsFor<T>;
+    search?: SearchParamsFor<T>;
+    hash?: HashParamsFor<T>;
+  } = {}
+): string {
+  const { params, search, hash } = options;
+
+  // Build path with params
+  let result: string = path;
+  if (params) {
+    for (const [key, value] of Object.entries(params as Record<string, string | string[]>)) {
+      if (value === undefined) continue;
+      result = result.replace(\`[...\${key}]\`, Array.isArray(value) ? value.join('/') : value);
+      result = result.replace(\`[[\${key}]]\`, Array.isArray(value) ? value[0] : value || '');
+      result = result.replace(\`[\${key}]\`, Array.isArray(value) ? value[0] : value);
+    }
+  }
+
+  // Remove unfilled optional params
+  result = result.replace(/\\/\\?\\[\\[[^\\]]+\\]\\]/g, '');
+
+  // Add search params
+  if (search && Object.keys(search).length > 0) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(search as Record<string, unknown>)) {
+      if (value === undefined || value === null) continue;
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          searchParams.append(key, String(v));
+        }
+      } else {
+        searchParams.set(key, String(value));
+      }
+    }
+    const queryString = searchParams.toString();
+    if (queryString) {
+      result += '?' + queryString;
+    }
+  }
+
+  // Add hash params
+  if (hash && Object.keys(hash).length > 0) {
+    const hashParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(hash as Record<string, unknown>)) {
+      if (value === undefined || value === null) continue;
+      hashParams.set(key, String(value));
+    }
+    const hashString = hashParams.toString();
+    if (hashString) {
+      result += '#' + hashString;
+    }
+  }
+
+  return result;
+}
+`.trim();
+}
+function groupRoutesByPrefix(routeInfos, maxPerFile) {
+  const groups = new Map;
+  for (const info of routeInfos) {
+    const prefix = info.path.split("/").filter(Boolean)[0] || "_root";
+    const key = `routes_${prefix}`;
+    if (!groups.has(key)) {
+      groups.set(key, []);
+    }
+    groups.get(key).push(info);
+  }
+  const result = new Map;
+  for (const [key, infos] of groups) {
+    if (infos.length <= maxPerFile) {
+      result.set(key, infos);
+    } else {
+      let chunkIndex = 0;
+      for (let i = 0;i < infos.length; i += maxPerFile) {
+        result.set(`${key}_${chunkIndex}`, infos.slice(i, i + maxPerFile));
+        chunkIndex++;
+      }
+    }
+  }
+  return result;
+}
+function generateSplitRouteTypes(routes, options = {}) {
+  const {
+    routesDir = "app/routes",
+    inferTypes = true,
+    maxRoutesPerFile = 50
+  } = options;
+  const routeInfos = collectRouteInfos(routes, routesDir, inferTypes);
+  const groups = groupRoutesByPrefix(routeInfos, maxRoutesPerFile);
+  const files = new Map;
+  for (const [fileName, infos] of groups) {
+    const content = generatePartialRouteTypes(infos, routesDir, inferTypes);
+    files.set(`${fileName}.d.ts`, content);
+  }
+  const indexContent = generateIndexFile(Array.from(groups.keys()));
+  files.set("index.d.ts", indexContent);
+  return files;
+}
+function generatePartialRouteTypes(routeInfos, routesDir, inferTypes) {
+  const lines = [
+    "// Auto-generated partial route types",
+    ""
+  ];
+  if (inferTypes) {
+    const uniqueImports = new Set;
+    for (const info of routeInfos) {
+      const importPath = generateImportPath(info.file, routesDir);
+      if (!uniqueImports.has(importPath)) {
+        uniqueImports.add(importPath);
+        lines.push(`import type * as ${safeIdentifier(importPath)} from '${importPath}';`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("export const routeTypes = {");
+  for (const info of routeInfos) {
+    const paramsType = generateParamsType(info.params);
+    lines.push(`  '${info.path}': {} as {`);
+    lines.push(`    params: ${paramsType};`);
+    lines.push(`    search: Record<string, string | string[] | undefined>;`);
+    lines.push(`    hash: Record<string, string | undefined>;`);
+    lines.push(`    loader: unknown;`);
+    lines.push(`    action: unknown;`);
+    lines.push(`    context: Record<string, unknown>;`);
+    lines.push(`    meta: boolean;`);
+    lines.push(`    handle: unknown;`);
+    lines.push(`  },`);
+  }
+  lines.push("};");
+  return lines.join(`
+`);
+}
+function generateIndexFile(fileNames) {
+  const lines = [
+    "// Auto-generated index file",
+    "// Combines split route type files",
+    ""
+  ];
+  for (const name of fileNames) {
+    lines.push(`export * from './${name}';`);
+  }
+  return lines.join(`
+`);
+}
+async function writeRouteTypes(outDir, routes, options = {}) {
+  const types = generateRouteTypes(routes, options);
+  const outPath = join3(outDir, "routes.d.ts");
+  await Bun.write(outPath, types);
+  console.log(`\x1B[32m\u2713\x1B[0m Route types written to ${outPath}`);
+}
+async function writeSplitRouteTypes(outDir, routes, options = {}) {
+  const files = generateSplitRouteTypes(routes, options);
+  for (const [fileName, content] of files) {
+    const outPath = join3(outDir, fileName);
+    await Bun.write(outPath, content);
+  }
+  console.log(`\x1B[32m\u2713\x1B[0m Split route types written to ${outDir} (${files.size} files)`);
+}
+function createTypesPlugin(options = {}) {
+  const {
+    outDir = ".ereo",
+    routesDir = "app/routes",
+    inferTypes = true,
+    watch = false,
+    splitFiles = false,
+    maxRoutesPerFile = 50
+  } = options;
+  let routes = [];
+  return {
+    name: "ereo:types",
+    transformRoutes(routeList) {
+      routes = routeList;
+      return routeList;
+    },
+    async buildEnd() {
+      if (routes.length === 0)
+        return;
+      const genOptions = {
+        routesDir,
+        inferTypes,
+        generateSearchParams: true,
+        generateHashParams: true,
+        generateContext: true,
+        lazyEvaluation: true,
+        maxRoutesPerFile
+      };
+      if (splitFiles && routes.length > maxRoutesPerFile) {
+        await writeSplitRouteTypes(outDir, routes, genOptions);
+      } else {
+        await writeRouteTypes(outDir, routes, genOptions);
+      }
+    },
+    async configureServer(_server) {
+      if (watch) {}
+    }
+  };
+}
+function generateLinkTypes(routes) {
+  const routeInfos = routes.filter((r) => !r.layout).map((r) => ({
+    path: r.path,
+    params: extractParams(r.path)
+  }));
+  const pathTypes = routeInfos.map((r) => `'${r.path}'`);
+  return `
+// Auto-generated Link types
+import type { ComponentProps, ReactNode } from 'react';
+import type { RoutePath, ParamsFor, SearchParamsFor, HashParamsFor, ParamsRequired } from './routes';
+
+/**
+ * Type-safe Link component props.
+ * Validates route existence and params at compile time.
+ */
+export type LinkProps<T extends RoutePath = RoutePath> =
+  Omit<ComponentProps<'a'>, 'href'> &
+  { to: T } &
+  ParamsRequired<T> &
+  {
+    /** Search params (type-safe per route) */
+    search?: SearchParamsFor<T>;
+    /** Hash params (type-safe per route, Ereo exclusive) */
+    hash?: HashParamsFor<T>;
+    /** Prefetch strategy */
+    prefetch?: 'hover' | 'viewport' | 'none' | 'intent' | 'render';
+    /** Replace current history entry */
+    replace?: boolean;
+    /** Scroll to top on navigation */
+    scroll?: boolean;
+    /** State to pass */
+    state?: unknown;
+    /** Children */
+    children?: ReactNode;
+  };
+
+/**
+ * Type-safe NavLink component props.
+ */
+export type NavLinkProps<T extends RoutePath = RoutePath> =
+  Omit<LinkProps<T>, 'className' | 'style'> & {
+    className?: string | ((props: { isActive: boolean; isPending: boolean }) => string);
+    style?: React.CSSProperties | ((props: { isActive: boolean; isPending: boolean }) => React.CSSProperties);
+    end?: boolean;
+  };
+
+/**
+ * All available routes.
+ */
+export type AppRoutes = ${pathTypes.join(" | ") || "string"};
+  `.trim();
+}
+function generateHookTypes() {
+  return `
+// Auto-generated hook types
+import type {
+  RoutePath,
+  LoaderDataFor,
+  ActionDataFor,
+  ParamsFor,
+  SearchParamsFor,
+  HashParamsFor,
+  ContextFor,
+  HandleFor,
+} from './routes';
+
+/**
+ * Get loader data for the current route (type-safe).
+ *
+ * @example
+ * // In /blog/[slug].tsx
+ * const { post, comments } = useLoaderData<'/blog/[slug]'>();
+ * //      ^? { post: Post, comments: Comment[] }
+ */
+export declare function useLoaderData<T extends RoutePath>(): LoaderDataFor<T>;
+
+/**
+ * Get route params for the current route (type-safe).
+ *
+ * @example
+ * // In /blog/[slug].tsx
+ * const { slug } = useParams<'/blog/[slug]'>();
+ * //      ^? string
+ */
+export declare function useParams<T extends RoutePath>(): ParamsFor<T>;
+
+/**
+ * Get search params for the current route (type-safe).
+ *
+ * @example
+ * // In /posts.tsx with searchParams schema
+ * const { page, sort } = useSearchParams<'/posts'>();
+ */
+export declare function useSearchParams<T extends RoutePath>(): SearchParamsFor<T>;
+
+/**
+ * Get hash params for the current route (type-safe).
+ * UNIQUE to Ereo - TanStack has no hash param support.
+ *
+ * @example
+ * // In /docs/[topic].tsx with hashParams schema
+ * const { section } = useHashParams<'/docs/[topic]'>();
+ */
+export declare function useHashParams<T extends RoutePath>(): HashParamsFor<T>;
+
+/**
+ * Get action data for the current route (type-safe).
+ *
+ * @example
+ * // In /blog/[slug].tsx
+ * const actionData = useActionData<'/blog/[slug]'>();
+ */
+export declare function useActionData<T extends RoutePath>(): ActionDataFor<T> | undefined;
+
+/**
+ * Get accumulated context from parent layouts.
+ *
+ * @example
+ * const { user } = useRouteContext<'/dashboard/settings'>();
+ */
+export declare function useRouteContext<T extends RoutePath>(): ContextFor<T>;
+
+/**
+ * Get route matches with typed data.
+ */
+export declare function useMatches<T extends RoutePath>(): Array<{
+  id: string;
+  pathname: string;
+  params: ParamsFor<T>;
+  data: LoaderDataFor<T>;
+  handle: HandleFor<T>;
+}>;
+
+/**
+ * Navigation hook with type-safe paths.
+ */
+export declare function useNavigate(): {
+  <T extends RoutePath>(to: T, options?: {
+    params?: ParamsFor<T>;
+    search?: SearchParamsFor<T>;
+    hash?: HashParamsFor<T>;
+    replace?: boolean;
+    state?: unknown;
+  }): void;
+  (delta: number): void;
+};
+  `.trim();
+}
+// src/plugins/tailwind.ts
+import { join as join4, resolve } from "path";
+import { readFileSync, existsSync, statSync } from "fs";
+import postcss from "postcss";
+import tailwindcss from "tailwindcss";
+import autoprefixer from "autoprefixer";
+var DEFAULT_CONTENT_PATHS = [
+  "./app/**/*.{js,ts,jsx,tsx,mdx}",
+  "./components/**/*.{js,ts,jsx,tsx,mdx}",
+  "./pages/**/*.{js,ts,jsx,tsx,mdx}",
+  "./src/**/*.{js,ts,jsx,tsx,mdx}"
+];
+function createTailwindPlugin(options = {}) {
+  const {
+    content = DEFAULT_CONTENT_PATHS,
+    config,
+    darkMode = "class",
+    minify = false,
+    sourcemap = true,
+    postcssPlugins = [],
+    watch = true
+  } = options;
+  let tailwindConfig = null;
+  let root = process.cwd();
+  let mode = "development";
+  let cssCache = new Map;
+  let processor = null;
+  let contentFilesCache = new Map;
+  let scannedClasses = new Set;
+  async function loadTailwindConfig() {
+    const configPaths = [
+      config ? resolve(root, config) : null,
+      join4(root, "tailwind.config.js"),
+      join4(root, "tailwind.config.ts"),
+      join4(root, "tailwind.config.mjs"),
+      join4(root, "tailwind.config.cjs")
+    ].filter(Boolean);
+    for (const configPath of configPaths) {
+      try {
+        if (existsSync(configPath)) {
+          delete __require.cache?.[configPath];
+          const imported = await import(configPath);
+          const loadedConfig = imported.default || imported;
+          console.log(`  [Tailwind] Using config: ${configPath}`);
+          return loadedConfig;
+        }
+      } catch (error) {
+        console.warn(`  [Tailwind] Failed to load config from ${configPath}:`, error);
+      }
+    }
+    console.log("  [Tailwind] Using default configuration");
+    return createDefaultConfig();
+  }
+  function createDefaultConfig() {
+    return {
+      content: content.map((p) => resolve(root, p)),
+      darkMode,
+      theme: {
+        extend: {}
+      },
+      plugins: []
+    };
+  }
+  function mergeConfig(userConfig) {
+    const resolvedContent = userConfig.content || content.map((p) => resolve(root, p));
+    return {
+      ...userConfig,
+      content: Array.isArray(resolvedContent) ? resolvedContent.map((p) => typeof p === "string" && !p.startsWith("/") && !p.startsWith(".") ? resolve(root, p) : p) : resolvedContent,
+      darkMode: userConfig.darkMode ?? darkMode
+    };
+  }
+  function createProcessor(tailwindCfg) {
+    const plugins = [
+      tailwindcss(tailwindCfg),
+      autoprefixer(),
+      ...postcssPlugins
+    ];
+    if (minify) {
+      try {
+        const cssnano = __require("cssnano");
+        plugins.push(cssnano({
+          preset: ["default", {
+            discardComments: { removeAll: true },
+            normalizeWhitespace: true
+          }]
+        }));
+      } catch {
+        console.warn("  [Tailwind] cssnano not available, skipping minification");
+      }
+    }
+    return postcss(plugins);
+  }
+  async function processTailwindCSS(css, filename, force = false) {
+    const cached = cssCache.get(filename);
+    if (cached && !force) {
+      const fileStats = existsSync(filename) ? statSync(filename).mtimeMs : 0;
+      if (cached.timestamp >= fileStats) {
+        let contentChanged = false;
+        for (const dep of cached.dependencies) {
+          if (existsSync(dep)) {
+            const depStats = statSync(dep).mtimeMs;
+            if (depStats > cached.timestamp) {
+              contentChanged = true;
+              break;
+            }
+          }
+        }
+        if (!contentChanged) {
+          return { css: cached.css, map: cached.map };
+        }
+      }
+    }
+    if (!processor) {
+      processor = createProcessor(tailwindConfig);
+    }
+    try {
+      const result = await processor.process(css, {
+        from: filename,
+        to: filename.replace(/\.css$/, ".out.css"),
+        map: sourcemap ? { inline: false, annotation: false } : false
+      });
+      const dependencies = [];
+      for (const message of result.messages) {
+        if (message.type === "dependency") {
+          dependencies.push(message.file);
+        }
+      }
+      cssCache.set(filename, {
+        css: result.css,
+        map: result.map?.toString(),
+        timestamp: Date.now(),
+        dependencies
+      });
+      return {
+        css: result.css,
+        map: result.map?.toString()
+      };
+    } catch (error) {
+      console.error(`  [Tailwind] Processing error in ${filename}:`);
+      console.error(`    ${error.message}`);
+      if (error.line && error.column) {
+        console.error(`    at line ${error.line}, column ${error.column}`);
+      }
+      throw error;
+    }
+  }
+  async function scanContentFiles() {
+    const classes = new Set;
+    const files = [];
+    try {
+      const { glob } = await import("glob");
+      for (const pattern of tailwindConfig.content) {
+        if (typeof pattern === "string") {
+          const matches = await glob(pattern, {
+            cwd: root,
+            absolute: true,
+            ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+          });
+          for (const file of matches) {
+            files.push(file);
+            const content2 = readFileSync(file, "utf-8");
+            extractClasses(content2, classes);
+          }
+        } else if (pattern.raw) {
+          extractClasses(pattern.raw, classes);
+        }
+      }
+    } catch (error) {
+      console.warn("  [Tailwind] Failed to scan content files:", error);
+    }
+    return { classes, files };
+  }
+  function extractClasses(content2, classes) {
+    const patterns = [
+      /class(?:Name)?=["'`]([^"'`]+)["'`]/g,
+      /class(?:Name)?={[`"]([^`"]+)[`"]}/g,
+      /clsx\(([^)]+)\)/g,
+      /cn\(([^)]+)\)/g,
+      /tw`([^`]+)`/g,
+      /cva\(([^)]+)\)/g
+    ];
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(content2)) !== null) {
+        const classString = match[1];
+        const individualClasses = classString.split(/\s+/).filter(Boolean);
+        for (const cls of individualClasses) {
+          const cleanClass = cls.replace(/['"`,]/g, "").trim();
+          if (cleanClass && !cleanClass.includes("{") && !cleanClass.includes("$")) {
+            classes.add(cleanClass);
+          }
+        }
+      }
+    }
+  }
+  async function haveContentFilesChanged() {
+    const { glob } = await import("glob");
+    for (const pattern of tailwindConfig.content) {
+      if (typeof pattern !== "string")
+        continue;
+      const matches = await glob(pattern, {
+        cwd: root,
+        absolute: true,
+        ignore: ["**/node_modules/**"]
+      });
+      for (const file of matches) {
+        try {
+          const stats = statSync(file);
+          const cachedTime = contentFilesCache.get(file);
+          if (!cachedTime || stats.mtimeMs > cachedTime) {
+            contentFilesCache.set(file, stats.mtimeMs);
+            return true;
+          }
+        } catch {}
+      }
+    }
+    return false;
+  }
+  function invalidateCache() {
+    cssCache.clear();
+    processor = null;
+  }
+  return {
+    name: "ereo:tailwind",
+    async setup(context) {
+      root = context.root;
+      mode = context.mode;
+      const userConfig = await loadTailwindConfig();
+      tailwindConfig = mergeConfig(userConfig);
+      processor = createProcessor(tailwindConfig);
+      console.log(`  [Tailwind] Initialized in ${mode} mode`);
+      console.log(`  [Tailwind] Scanning ${tailwindConfig.content.length} content patterns`);
+    },
+    async transform(code, id) {
+      if (!id.endsWith(".css")) {
+        return null;
+      }
+      const hasTailwindDirectives = code.includes("@tailwind") || code.includes("@apply") || code.includes("@layer") || code.includes("@config");
+      if (!hasTailwindDirectives) {
+        return null;
+      }
+      try {
+        if (mode === "development" && watch) {
+          const changed = await haveContentFilesChanged();
+          if (changed) {
+            invalidateCache();
+          }
+        }
+        const result = await processTailwindCSS(code, id);
+        return result.css;
+      } catch (error) {
+        if (mode === "development") {
+          return `/* Tailwind CSS Error: ${error.message.replace(/\*\//g, "*\\/")} */
+${code}`;
+        }
+        throw error;
+      }
+    },
+    resolveId(id) {
+      if (id === "virtual:tailwind.css" || id === "@ereo/tailwind") {
+        return "\x00virtual:tailwind.css";
+      }
+      return null;
+    },
+    async load(id) {
+      if (id === "\x00virtual:tailwind.css") {
+        const css = `
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+        `.trim();
+        try {
+          const result = await processTailwindCSS(css, "virtual:tailwind.css");
+          return result.css;
+        } catch (error) {
+          console.error("  [Tailwind] Failed to generate virtual CSS:", error.message);
+          return css;
+        }
+      }
+      return null;
+    },
+    async configureServer(server) {
+      const configPaths = [
+        "tailwind.config.js",
+        "tailwind.config.ts",
+        "tailwind.config.mjs",
+        "tailwind.config.cjs"
+      ];
+      if (server.watcher) {
+        for (const configFile of configPaths) {
+          const fullPath = join4(root, configFile);
+          if (existsSync(fullPath)) {
+            server.watcher.add(fullPath);
+          }
+        }
+        server.watcher.on("change", async (file) => {
+          if (configPaths.some((cfg) => file.endsWith(cfg))) {
+            console.log("  [Tailwind] Config changed, reloading...");
+            const userConfig = await loadTailwindConfig();
+            tailwindConfig = mergeConfig(userConfig);
+            processor = createProcessor(tailwindConfig);
+            invalidateCache();
+            if (server.ws) {
+              server.ws.send({
+                type: "full-reload",
+                path: "*"
+              });
+            }
+          }
+        });
+      }
+      if (server.middlewares) {
+        server.middlewares.push(async (request, context, next) => {
+          const url = new URL(request.url);
+          if (url.pathname === "/__tailwind.css") {
+            try {
+              const css = `
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+              `.trim();
+              const result = await processTailwindCSS(css, "__tailwind.css");
+              return new Response(result.css, {
+                headers: {
+                  "Content-Type": "text/css",
+                  "Cache-Control": "no-cache, no-store, must-revalidate",
+                  "X-Tailwind-Version": "3.4"
+                }
+              });
+            } catch (error) {
+              return new Response(`/* Tailwind CSS Error: ${error.message} */`, {
+                status: 500,
+                headers: { "Content-Type": "text/css" }
+              });
+            }
+          }
+          return next();
+        });
+      }
+    },
+    async buildStart() {
+      if (mode === "production") {
+        console.log("  [Tailwind] Scanning content files...");
+        const { classes, files } = await scanContentFiles();
+        scannedClasses = classes;
+        console.log(`  [Tailwind] Found ${classes.size} unique classes in ${files.length} files`);
+      }
+    },
+    async buildEnd() {
+      if (mode === "production") {
+        console.log("  [Tailwind] Build complete");
+      }
+    }
+  };
+}
+function generateTailwindConfig(options = {}) {
+  const { content = DEFAULT_CONTENT_PATHS, darkMode = "class" } = options;
+  return `
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ${JSON.stringify(content, null, 4)},
+  darkMode: '${darkMode}',
+  theme: {
+    extend: {
+      // Add your custom theme extensions here
+      colors: {
+        // primary: '#3b82f6',
+      },
+      fontFamily: {
+        // sans: ['Inter', 'sans-serif'],
+      },
+    },
+  },
+  plugins: [
+    // Add plugins here
+    // require('@tailwindcss/forms'),
+    // require('@tailwindcss/typography'),
+  ],
+};
+  `.trim();
+}
+function generateCSSEntry() {
+  return `
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/*
+ * Custom base styles
+ * Use @layer base { ... } for base styles
+ */
+
+/*
+ * Custom components
+ * Use @layer components { ... } for component styles
+ */
+
+/*
+ * Custom utilities
+ * Use @layer utilities { ... } for utility styles
+ */
+  `.trim();
+}
+async function hasTailwindConfig(root) {
+  const configFiles = [
+    "tailwind.config.js",
+    "tailwind.config.ts",
+    "tailwind.config.cjs",
+    "tailwind.config.mjs"
+  ];
+  for (const file of configFiles) {
+    if (existsSync(join4(root, file))) {
+      return true;
+    }
+  }
+  try {
+    const pkgPath = join4(root, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      return "tailwindcss" in deps;
+    }
+  } catch {}
+  return false;
+}
+function tailwindMiddleware(options = {}) {
+  let processor = null;
+  let tailwindConfig = null;
+  let cssCache = null;
+  let cacheTimestamp = 0;
+  async function getProcessor(root) {
+    if (!processor) {
+      const configPaths = [
+        options.config ? resolve(root, options.config) : null,
+        join4(root, "tailwind.config.js"),
+        join4(root, "tailwind.config.ts")
+      ].filter(Boolean);
+      for (const configPath of configPaths) {
+        if (existsSync(configPath)) {
+          try {
+            const imported = await import(configPath);
+            tailwindConfig = imported.default || imported;
+            break;
+          } catch {}
+        }
+      }
+      if (!tailwindConfig) {
+        tailwindConfig = {
+          content: (options.content || DEFAULT_CONTENT_PATHS).map((p) => resolve(root, p)),
+          darkMode: options.darkMode || "class",
+          theme: { extend: {} },
+          plugins: []
+        };
+      }
+      processor = postcss([
+        tailwindcss(tailwindConfig),
+        autoprefixer()
+      ]);
+    }
+    return processor;
+  }
+  return async (request, context, next) => {
+    const url = new URL(request.url);
+    if (url.pathname === "/__tailwind.css") {
+      const root = context.root || process.cwd();
+      try {
+        const now = Date.now();
+        if (cssCache && now - cacheTimestamp < 1000) {
+          return new Response(cssCache, {
+            headers: {
+              "Content-Type": "text/css",
+              "Cache-Control": "no-cache"
+            }
+          });
+        }
+        const proc = await getProcessor(root);
+        const css = `
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+        `.trim();
+        const result = await proc.process(css, {
+          from: "__tailwind.css"
+        });
+        cssCache = result.css;
+        cacheTimestamp = now;
+        return new Response(result.css, {
+          headers: {
+            "Content-Type": "text/css",
+            "Cache-Control": "no-cache"
+          }
+        });
+      } catch (error) {
+        return new Response(`/* Tailwind CSS Error: ${error.message} */`, {
+          status: 500,
+          headers: { "Content-Type": "text/css" }
+        });
+      }
+    }
+    return next();
+  };
+}
+function extractTailwindClasses(content) {
+  const classes = new Set;
+  const patterns = [
+    /class(?:Name)?=["']([^"']+)["']/g,
+    /class(?:Name)?={`([^`]+)`}/g,
+    /class(?:Name)?={\s*["']([^"']+)["']\s*}/g,
+    /tw`([^`]+)`/g,
+    /clsx\(\s*["']([^"']+)["']/g,
+    /cn\(\s*["']([^"']+)["']/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const classString = match[1];
+      classString.split(/\s+/).filter(Boolean).forEach((cls) => {
+        const cleanClass = cls.replace(/['"`,]/g, "").trim();
+        if (cleanClass && !cleanClass.includes("{") && !cleanClass.includes("$")) {
+          classes.add(cleanClass);
+        }
+      });
+    }
+  }
+  return Array.from(classes);
+}
+async function generateSafelist(root, patterns) {
+  const classes = new Set;
+  try {
+    const { glob } = await import("glob");
+    for (const pattern of patterns) {
+      const files = await glob(pattern, {
+        cwd: root,
+        absolute: true,
+        ignore: ["**/node_modules/**"]
+      });
+      for (const file of files) {
+        const content = readFileSync(file, "utf-8");
+        extractTailwindClasses(content).forEach((cls) => classes.add(cls));
+      }
+    }
+  } catch (error) {
+    console.warn("Failed to generate safelist:", error);
+  }
+  return Array.from(classes);
+}
+export {
+  writeRouteTypes,
+  transformIslandJSX,
+  tailwindMiddleware,
+  printBuildReport,
+  parseError,
+  hasTailwindConfig,
+  hasIslands,
+  generateTailwindConfig,
+  generateSafelist,
+  generateRouteTypes,
+  generateLinkTypes,
+  generateIslandManifest,
+  generateIslandEntry,
+  generateHookTypes,
+  generateErrorOverlayHTML,
+  generateCSSEntry,
+  formatSize,
+  findIslandByName,
+  extractTailwindClasses,
+  extractParams,
+  extractIslands,
+  createTypesPlugin,
+  createTailwindPlugin,
+  createIslandsPlugin,
+  createHMRWebSocket,
+  createHMRWatcher,
+  createHMRServer,
+  createErrorResponse,
+  createErrorJSON,
+  build,
+  analyzeBuild,
+  HMR_CLIENT_CODE,
+  HMRWatcher,
+  HMRServer,
+  ERROR_OVERLAY_SCRIPT
+};