@flight-framework/core 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,19 +1,865 @@
-export { createFileRouter, loadRoutes, scanRoutes } from './chunk-I5RHYGX6.js';
-export { RedirectError, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './chunk-TKXN7KGE.js';
-export { createRouteContext, error, json, parseBody, redirect } from './chunk-AJ3IBYXT.js';
-export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from './chunk-QEFGUHYD.js';
-export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError as isRscRedirectError, notFound, revalidatePath, revalidateTag, redirect as rscRedirect, serializeProps, serverFetch, withErrorBoundary } from './chunk-AFSKXC6V.js';
+export { createFileRouter, loadRoutes, scanRoutes } from './chunk-WOMWIW7D.js';
+export { RedirectError, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './chunk-JIW55ZVD.js';
+export { createRouteContext, error, json, parseBody, redirect } from './chunk-W6D62JCI.js';
+export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from './chunk-ABNCAPQB.js';
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError as isRscRedirectError, notFound, redirect as rscRedirect, revalidatePath as rscRevalidatePath, revalidateTag as rscRevalidateTag, serializeProps, serverFetch, withErrorBoundary } from './chunk-5KF3QQWZ.js';
 import './chunk-ZVC3ZWLM.js';
 export { createCache } from './chunk-3AIQVGTM.js';
-import './chunk-Q4C5CCHK.js';
-export { createServer } from './chunk-Y22KEW2F.js';
+import './chunk-SUILH4ID.js';
+export { createServer } from './chunk-6LYV4VQX.js';
 export { createRouter } from './chunk-GCQZ4FHI.js';
 export { createMiddlewareChain } from './chunk-KWFX6WHG.js';
-export { defineConfig } from './chunk-WAGCTWGY.js';
+export { defineConfig } from './chunk-3TPAA52K.js';
+import { promises } from 'fs';
+import { dirname, join } from 'path';
+
+// src/config/route-rules.ts
+function matchRouteRule(path, rules) {
+  if (rules[path]) {
+    return rules[path];
+  }
+  const patterns = Object.keys(rules).sort((a, b) => {
+    if (!a.includes("*") && b.includes("*")) return -1;
+    if (a.includes("*") && !b.includes("*")) return 1;
+    return b.length - a.length;
+  });
+  for (const pattern of patterns) {
+    if (matchPattern(path, pattern)) {
+      return rules[pattern];
+    }
+  }
+  return void 0;
+}
+function matchPattern(path, pattern) {
+  if (pattern === path) {
+    return true;
+  }
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\[([^\]]+)\]/g, "[^/]+");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+function mergeRouteRules(...rules) {
+  const result = {};
+  for (const rule of rules) {
+    if (!rule) continue;
+    Object.assign(result, rule);
+    if (rule.headers) {
+      result.headers = { ...result.headers, ...rule.headers };
+    }
+    if (rule.cache) {
+      result.cache = { ...result.cache, ...rule.cache };
+    }
+    if (rule.tags) {
+      result.tags = [...result.tags || [], ...rule.tags];
+    }
+  }
+  return result;
+}
+function getRenderModeFromRule(rule) {
+  if (rule.ssr === false) {
+    return "csr";
+  }
+  if (rule.prerender) {
+    return "ssg";
+  }
+  if (rule.isr !== void 0) {
+    return "isr";
+  }
+  return "ssr";
+}
+function getRevalidateTime(rule) {
+  if (rule.isr !== void 0) {
+    if (rule.isr === true) {
+      return false;
+    }
+    return typeof rule.isr === "number" ? rule.isr : 60;
+  }
+  if (rule.swr !== void 0) {
+    if (rule.swr === true) {
+      return 60;
+    }
+    return typeof rule.swr === "number" ? rule.swr : 60;
+  }
+  return false;
+}
+function getCacheOptionsFromRule(rule) {
+  const revalidate = getRevalidateTime(rule);
+  if (revalidate === false && !rule.cache) {
+    return void 0;
+  }
+  return {
+    ttl: revalidate || rule.cache?.ttl,
+    swr: rule.swr !== void 0 ? typeof rule.swr === "number" ? rule.swr : 60 : void 0,
+    tags: rule.tags || rule.cache?.tags
+  };
+}
+function buildCacheControlHeader(rule) {
+  const revalidate = getRevalidateTime(rule);
+  if (rule.ssr === false) {
+    return "no-store";
+  }
+  if (rule.prerender && revalidate === false) {
+    return "public, max-age=31536000, immutable";
+  }
+  if (revalidate !== false) {
+    const maxAge = revalidate;
+    const swr = rule.swr !== void 0 ? typeof rule.swr === "number" ? rule.swr : 60 : 0;
+    if (swr > 0) {
+      return `public, max-age=${maxAge}, stale-while-revalidate=${swr}`;
+    }
+    return `public, max-age=${maxAge}`;
+  }
+  return void 0;
+}
+function createDefaultRouteRules() {
+  return {
+    // API routes: no cache by default
+    "/api/**": { ssr: true, cache: { ttl: 0 } },
+    // Static assets: cache forever
+    "/_static/**": { headers: { "Cache-Control": "public, max-age=31536000, immutable" } }
+  };
+}
+
+// src/render/revalidate.ts
+var globalISRCache = null;
+function setISRCache(cache) {
+  globalISRCache = cache;
+}
+function getISRCache() {
+  return globalISRCache;
+}
+function createMemoryISRCache() {
+  const store = /* @__PURE__ */ new Map();
+  const tagIndex = /* @__PURE__ */ new Map();
+  return {
+    async get(path) {
+      const entry = store.get(path);
+      if (!entry) return void 0;
+      if (entry.revalidateAfter && Date.now() > entry.revalidateAfter) {
+        return entry;
+      }
+      return entry;
+    },
+    async set(path, entry, options) {
+      store.set(path, entry);
+      const tags = entry.tags || options?.tags || [];
+      for (const tag of tags) {
+        if (!tagIndex.has(tag)) {
+          tagIndex.set(tag, /* @__PURE__ */ new Set());
+        }
+        tagIndex.get(tag).add(path);
+      }
+    },
+    async delete(path) {
+      return store.delete(path);
+    },
+    async invalidateTag(tag) {
+      const paths = tagIndex.get(tag);
+      if (!paths) return;
+      for (const path of paths) {
+        store.delete(path);
+      }
+      tagIndex.delete(tag);
+    },
+    async keys() {
+      return Array.from(store.keys());
+    }
+  };
+}
+async function revalidatePath2(path) {
+  const cache = getISRCache();
+  if (!cache) {
+    return {
+      success: false,
+      error: "ISR cache not configured",
+      timestamp: Date.now()
+    };
+  }
+  try {
+    const deleted = await cache.delete(path);
+    return {
+      success: deleted,
+      paths: deleted ? [path] : [],
+      timestamp: Date.now()
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      error: error2 instanceof Error ? error2.message : "Unknown error",
+      timestamp: Date.now()
+    };
+  }
+}
+async function revalidateTag2(tag) {
+  const cache = getISRCache();
+  if (!cache) {
+    return {
+      success: false,
+      error: "ISR cache not configured",
+      timestamp: Date.now()
+    };
+  }
+  try {
+    await cache.invalidateTag(tag);
+    return {
+      success: true,
+      timestamp: Date.now()
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      error: error2 instanceof Error ? error2.message : "Unknown error",
+      timestamp: Date.now()
+    };
+  }
+}
+async function revalidatePaths(paths) {
+  const cache = getISRCache();
+  if (!cache) {
+    return {
+      success: false,
+      error: "ISR cache not configured",
+      timestamp: Date.now()
+    };
+  }
+  const revalidated = [];
+  try {
+    for (const path of paths) {
+      const deleted = await cache.delete(path);
+      if (deleted) {
+        revalidated.push(path);
+      }
+    }
+    return {
+      success: true,
+      paths: revalidated,
+      timestamp: Date.now()
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      paths: revalidated,
+      error: error2 instanceof Error ? error2.message : "Unknown error",
+      timestamp: Date.now()
+    };
+  }
+}
+function createRevalidateHandler(options = {}) {
+  const { secret, headerName = "x-revalidate-token" } = options;
+  return async (request) => {
+    if (secret) {
+      const token = request.headers.get(headerName);
+      if (token !== secret) {
+        return new Response(
+          JSON.stringify({ error: "Invalid revalidation token" }),
+          { status: 401, headers: { "Content-Type": "application/json" } }
+        );
+      }
+    }
+    try {
+      const body = await request.json();
+      const results = [];
+      if (body.path) {
+        results.push(await revalidatePath2(body.path));
+      }
+      if (body.paths && body.paths.length > 0) {
+        results.push(await revalidatePaths(body.paths));
+      }
+      if (body.tag) {
+        results.push(await revalidateTag2(body.tag));
+      }
+      if (body.tags && body.tags.length > 0) {
+        for (const tag of body.tags) {
+          results.push(await revalidateTag2(tag));
+        }
+      }
+      const success = results.every((r) => r.success);
+      return new Response(
+        JSON.stringify({
+          revalidated: success,
+          results,
+          timestamp: Date.now()
+        }),
+        {
+          status: success ? 200 : 500,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    } catch (error2) {
+      return new Response(
+        JSON.stringify({
+          error: "Invalid request body",
+          message: error2 instanceof Error ? error2.message : "Unknown error"
+        }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+  };
+}
+function createISRCacheFromFlightCache(cache) {
+  const ISR_PREFIX = "isr:";
+  return {
+    async get(path) {
+      return cache.get(`${ISR_PREFIX}${path}`);
+    },
+    async set(path, entry, options) {
+      const ttl = entry.revalidateAfter ? Math.floor((entry.revalidateAfter - Date.now()) / 1e3) : options?.ttl;
+      await cache.set(`${ISR_PREFIX}${path}`, entry, {
+        ...options,
+        ttl: ttl && ttl > 0 ? ttl : void 0,
+        tags: entry.tags || options?.tags
+      });
+    },
+    async delete(path) {
+      return cache.delete(`${ISR_PREFIX}${path}`);
+    },
+    async invalidateTag(tag) {
+      await cache.invalidateTag(tag);
+    }
+  };
+}
+async function prerenderRoutes(options) {
+  const {
+    routes,
+    outDir,
+    renderFn,
+    concurrency = 10,
+    onProgress,
+    onError,
+    crawlLinks = false
+  } = options;
+  const startTime = Date.now();
+  const errors = [];
+  const files = [];
+  const processedRoutes = /* @__PURE__ */ new Set();
+  const routeQueue = typeof routes === "function" ? await routes() : [...routes];
+  let discoveredCount = 0;
+  await promises.mkdir(outDir, { recursive: true });
+  let completed = 0;
+  const total = routeQueue.length;
+  while (routeQueue.length > 0) {
+    const batch = routeQueue.splice(0, concurrency);
+    const results = await Promise.allSettled(
+      batch.map(async (route) => {
+        if (processedRoutes.has(route)) {
+          return null;
+        }
+        processedRoutes.add(route);
+        if (onProgress) {
+          onProgress({
+            currentRoute: route,
+            completed,
+            total: total + discoveredCount,
+            percentage: Math.round(completed / (total + discoveredCount) * 100)
+          });
+        }
+        const result = await renderFn(route);
+        const filePath = getOutputPath(route, outDir);
+        await ensureDir(dirname(filePath));
+        await promises.writeFile(filePath, result.html, "utf-8");
+        files.push(filePath);
+        completed++;
+        return result.links || [];
+      })
+    );
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const route = batch[i];
+      if (result.status === "rejected") {
+        const error2 = { route, error: result.reason };
+        errors.push(error2);
+        if (onError) {
+          onError(error2);
+        }
+      } else if (crawlLinks && result.value) {
+        for (const link of result.value) {
+          if (!processedRoutes.has(link) && !routeQueue.includes(link)) {
+            routeQueue.push(link);
+            discoveredCount++;
+          }
+        }
+      }
+    }
+  }
+  return {
+    total: processedRoutes.size,
+    success: files.length,
+    failed: errors.length,
+    discovered: discoveredCount,
+    duration: Date.now() - startTime,
+    files,
+    errors
+  };
+}
+function getOutputPath(route, outDir) {
+  let normalizedRoute = route;
+  if (!normalizedRoute.startsWith("/")) {
+    normalizedRoute = "/" + normalizedRoute;
+  }
+  if (normalizedRoute === "/") {
+    return join(outDir, "index.html");
+  }
+  if (normalizedRoute.endsWith("/")) {
+    return join(outDir, normalizedRoute, "index.html");
+  }
+  if (!normalizedRoute.includes(".")) {
+    return join(outDir, normalizedRoute + ".html");
+  }
+  return join(outDir, normalizedRoute);
+}
+async function ensureDir(dir) {
+  try {
+    await promises.mkdir(dir, { recursive: true });
+  } catch (error2) {
+    if (error2.code !== "EEXIST") {
+      throw error2;
+    }
+  }
+}
+function extractLinks(html, baseUrl) {
+  const links = [];
+  const linkRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>/gi;
+  let match;
+  while ((match = linkRegex.exec(html)) !== null) {
+    const href = match[1];
+    if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("javascript:")) {
+      continue;
+    }
+    let normalizedLink = href;
+    if (href.startsWith("/")) {
+      normalizedLink = href;
+    } else if (baseUrl) {
+      const base = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
+      normalizedLink = new URL(href, base).pathname;
+    }
+    normalizedLink = normalizedLink.split("?")[0].split("#")[0];
+    if (normalizedLink && !links.includes(normalizedLink)) {
+      links.push(normalizedLink);
+    }
+  }
+  return links;
+}
+async function expandDynamicRoutes(routePattern, generateParams) {
+  const params = await generateParams();
+  return params.map((paramSet) => {
+    let route = routePattern;
+    for (const [key, value] of Object.entries(paramSet)) {
+      const paramValue = Array.isArray(value) ? value.join("/") : value;
+      route = route.replace(`[${key}]`, paramValue);
+      route = route.replace(`[...${key}]`, paramValue);
+    }
+    return route;
+  });
+}
+
+// src/render/static.ts
+async function generateAllStaticPaths(pageModules) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [path, module] of pageModules) {
+    if (module.generateStaticParams) {
+      try {
+        const params = await module.generateStaticParams();
+        result.set(path, params);
+      } catch (error2) {
+        console.error(`[Flight] Failed to generate static params for ${path}:`, error2);
+        result.set(path, []);
+      }
+    }
+  }
+  return result;
+}
+var pageCache = /* @__PURE__ */ new Map();
+async function getOrGeneratePage(path, generateFn, revalidate) {
+  const cached = pageCache.get(path);
+  const now = Date.now();
+  if (cached) {
+    if (revalidate === false) {
+      return { html: cached.html, fromCache: true };
+    }
+    if (now < cached.revalidateAfter) {
+      return { html: cached.html, fromCache: true };
+    }
+    regeneratePageInBackground(path, generateFn, revalidate || 60);
+    return { html: cached.html, fromCache: true };
+  }
+  const html = await generateFn();
+  if (revalidate !== false) {
+    const revalidateMs = (revalidate || 60) * 1e3;
+    pageCache.set(path, {
+      html,
+      generatedAt: now,
+      revalidateAfter: now + revalidateMs
+    });
+  }
+  return { html, fromCache: false };
+}
+async function regeneratePageInBackground(path, generateFn, revalidate) {
+  try {
+    const html = await generateFn();
+    const now = Date.now();
+    pageCache.set(path, {
+      html,
+      generatedAt: now,
+      revalidateAfter: now + revalidate * 1e3
+    });
+  } catch (error2) {
+    console.error(`[Flight] Background regeneration failed for ${path}:`, error2);
+  }
+}
+function purgePage(path) {
+  return pageCache.delete(path);
+}
+function purgeAllPages() {
+  pageCache.clear();
+}
+function shouldDynamicallyRender(module, hasParams) {
+  if (module.dynamic === "force-dynamic") {
+    return true;
+  }
+  if (module.dynamic === "force-static") {
+    return false;
+  }
+  if (module.dynamic === "error") {
+    return false;
+  }
+  if (hasParams && !module.generateStaticParams) {
+    return true;
+  }
+  return false;
+}
+function createStreamingResponse2(stream) {
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      "Transfer-Encoding": "chunked"
+    }
+  });
+}
+function createHtmlStream() {
+  const encoder = new TextEncoder();
+  let controller;
+  const readable = new ReadableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  return {
+    readable,
+    write(html) {
+      controller.enqueue(encoder.encode(html));
+    },
+    close() {
+      controller.close();
+    }
+  };
+}
+
+// src/render/metadata.ts
+function renderMetadataToHead(meta) {
+  const tags = [];
+  if (meta.title) {
+    const title = typeof meta.title === "string" ? meta.title : meta.title.default;
+    tags.push(`<title>${escapeHtml(title)}</title>`);
+  }
+  if (meta.description) {
+    tags.push(`<meta name="description" content="${escapeAttr(meta.description)}">`);
+  }
+  if (meta.keywords) {
+    const keywords = Array.isArray(meta.keywords) ? meta.keywords.join(", ") : meta.keywords;
+    tags.push(`<meta name="keywords" content="${escapeAttr(keywords)}">`);
+  }
+  if (meta.canonical) {
+    tags.push(`<link rel="canonical" href="${escapeAttr(meta.canonical)}">`);
+  }
+  if (meta.robots) {
+    const robotsContent = typeof meta.robots === "string" ? meta.robots : buildRobotsContent(meta.robots);
+    tags.push(`<meta name="robots" content="${escapeAttr(robotsContent)}">`);
+  }
+  if (meta.openGraph) {
+    const og = meta.openGraph;
+    if (og.title) tags.push(`<meta property="og:title" content="${escapeAttr(og.title)}">`);
+    if (og.description) tags.push(`<meta property="og:description" content="${escapeAttr(og.description)}">`);
+    if (og.url) tags.push(`<meta property="og:url" content="${escapeAttr(og.url)}">`);
+    if (og.siteName) tags.push(`<meta property="og:site_name" content="${escapeAttr(og.siteName)}">`);
+    if (og.type) tags.push(`<meta property="og:type" content="${escapeAttr(og.type)}">`);
+    if (og.locale) tags.push(`<meta property="og:locale" content="${escapeAttr(og.locale)}">`);
+    if (og.images) {
+      for (const image of og.images) {
+        if (typeof image === "string") {
+          tags.push(`<meta property="og:image" content="${escapeAttr(image)}">`);
+        } else {
+          tags.push(`<meta property="og:image" content="${escapeAttr(image.url)}">`);
+          if (image.width) tags.push(`<meta property="og:image:width" content="${image.width}">`);
+          if (image.height) tags.push(`<meta property="og:image:height" content="${image.height}">`);
+          if (image.alt) tags.push(`<meta property="og:image:alt" content="${escapeAttr(image.alt)}">`);
+        }
+      }
+    }
+  }
+  if (meta.twitter) {
+    const tw = meta.twitter;
+    if (tw.card) tags.push(`<meta name="twitter:card" content="${escapeAttr(tw.card)}">`);
+    if (tw.site) tags.push(`<meta name="twitter:site" content="${escapeAttr(tw.site)}">`);
+    if (tw.creator) tags.push(`<meta name="twitter:creator" content="${escapeAttr(tw.creator)}">`);
+    if (tw.title) tags.push(`<meta name="twitter:title" content="${escapeAttr(tw.title)}">`);
+    if (tw.description) tags.push(`<meta name="twitter:description" content="${escapeAttr(tw.description)}">`);
+    if (tw.images) {
+      for (const image of tw.images) {
+        tags.push(`<meta name="twitter:image" content="${escapeAttr(image)}">`);
+      }
+    }
+  }
+  if (meta.icons) {
+    const icons = meta.icons;
+    if (icons.icon) {
+      const iconList = Array.isArray(icons.icon) ? icons.icon : [icons.icon];
+      for (const icon of iconList) {
+        tags.push(`<link rel="icon" href="${escapeAttr(icon)}">`);
+      }
+    }
+    if (icons.apple) {
+      const appleList = Array.isArray(icons.apple) ? icons.apple : [icons.apple];
+      for (const icon of appleList) {
+        tags.push(`<link rel="apple-touch-icon" href="${escapeAttr(icon)}">`);
+      }
+    }
+    if (icons.shortcut) {
+      tags.push(`<link rel="shortcut icon" href="${escapeAttr(icons.shortcut)}">`);
+    }
+  }
+  if (meta.alternates) {
+    if (meta.alternates.canonical) {
+      tags.push(`<link rel="canonical" href="${escapeAttr(meta.alternates.canonical)}">`);
+    }
+    if (meta.alternates.languages) {
+      for (const [lang, url] of Object.entries(meta.alternates.languages)) {
+        tags.push(`<link rel="alternate" hreflang="${escapeAttr(lang)}" href="${escapeAttr(url)}">`);
+      }
+    }
+  }
+  if (meta.verification) {
+    if (meta.verification.google) {
+      tags.push(`<meta name="google-site-verification" content="${escapeAttr(meta.verification.google)}">`);
+    }
+    if (meta.verification.bing) {
+      tags.push(`<meta name="msvalidate.01" content="${escapeAttr(meta.verification.bing)}">`);
+    }
+    if (meta.verification.yandex) {
+      tags.push(`<meta name="yandex-verification" content="${escapeAttr(meta.verification.yandex)}">`);
+    }
+  }
+  if (meta.other) {
+    for (const [name, content] of Object.entries(meta.other)) {
+      tags.push(`<meta name="${escapeAttr(name)}" content="${escapeAttr(content)}">`);
+    }
+  }
+  return tags.join("\n    ");
+}
+function buildRobotsContent(robots) {
+  const directives = [];
+  if (robots.index === false) directives.push("noindex");
+  else if (robots.index === true) directives.push("index");
+  if (robots.follow === false) directives.push("nofollow");
+  else if (robots.follow === true) directives.push("follow");
+  if (robots.nocache) directives.push("nocache");
+  return directives.join(", ") || "index, follow";
+}
+function mergeMetadata(...metadataList) {
+  const result = {};
+  for (const meta of metadataList) {
+    if (!meta) continue;
+    if (meta.title !== void 0) result.title = meta.title;
+    if (meta.description !== void 0) result.description = meta.description;
+    if (meta.keywords !== void 0) result.keywords = meta.keywords;
+    if (meta.canonical !== void 0) result.canonical = meta.canonical;
+    if (meta.robots !== void 0) result.robots = meta.robots;
+    if (meta.openGraph) {
+      result.openGraph = { ...result.openGraph, ...meta.openGraph };
+    }
+    if (meta.twitter) {
+      result.twitter = { ...result.twitter, ...meta.twitter };
+    }
+    if (meta.icons) {
+      result.icons = { ...result.icons, ...meta.icons };
+    }
+    if (meta.alternates) {
+      result.alternates = { ...result.alternates, ...meta.alternates };
+    }
+    if (meta.verification) {
+      result.verification = { ...result.verification, ...meta.verification };
+    }
+    if (meta.other) {
+      result.other = { ...result.other, ...meta.other };
+    }
+  }
+  return result;
+}
+async function resolveMetadata(pageModule, props) {
+  if (pageModule.metadata) {
+    return pageModule.metadata;
+  }
+  if (pageModule.generateMetadata) {
+    return await pageModule.generateMetadata(props);
+  }
+  return {};
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/render/devtools.ts
+function injectDevTools(options = {}) {
+  if (process.env.NODE_ENV !== "development") {
+    return "";
+  }
+  const data = JSON.stringify(options, null, 2);
+  return `
+<!-- Flight DevTools - Development Only - NO TELEMETRY -->
+<div id="flight-devtools" style="display:none;">
+    <div id="flight-devtools-toggle" style="
+        position: fixed;
+        bottom: 16px;
+        right: 16px;
+        width: 40px;
+        height: 40px;
+        background: #1a1a2e;
+        border-radius: 8px;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        z-index: 99999;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+        font-size: 20px;
+    ">\u2708</div>
+    <div id="flight-devtools-panel" style="
+        position: fixed;
+        bottom: 70px;
+        right: 16px;
+        width: 320px;
+        max-height: 400px;
+        background: #1a1a2e;
+        color: #e0e0e0;
+        border-radius: 8px;
+        padding: 16px;
+        font-family: ui-monospace, monospace;
+        font-size: 12px;
+        z-index: 99998;
+        overflow-y: auto;
+        display: none;
+        box-shadow: 0 8px 24px rgba(0,0,0,0.4);
+    ">
+        <div style="display:flex;justify-content:space-between;margin-bottom:12px;">
+            <strong style="color:#60a5fa;">Flight DevTools</strong>
+            <span style="color:#6b7280;font-size:10px;">LOCAL ONLY</span>
+        </div>
+        <div id="flight-devtools-content"></div>
+    </div>
+</div>
+<script>
+(function() {
+    // DevTools data
+    var data = ${data};
+    
+    // Wait for DOM
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+    
+    function init() {
+        var container = document.getElementById('flight-devtools');
+        var toggle = document.getElementById('flight-devtools-toggle');
+        var panel = document.getElementById('flight-devtools-panel');
+        var content = document.getElementById('flight-devtools-content');
+        
+        if (!container || !toggle || !panel || !content) return;
+        
+        container.style.display = 'block';
+        
+        // Render content
+        var html = '';
+        
+        if (data.route) {
+            html += '<div style="margin-bottom:8px;"><span style="color:#6b7280;">Route:</span> <span style="color:#34d399;">' + escapeHtml(data.route) + '</span></div>';
+        }
+        
+        if (data.renderMode) {
+            var modeColor = {ssr:'#f59e0b',ssg:'#10b981',isr:'#8b5cf6',csr:'#3b82f6'}[data.renderMode] || '#6b7280';
+            html += '<div style="margin-bottom:8px;"><span style="color:#6b7280;">Mode:</span> <span style="color:' + modeColor + ';text-transform:uppercase;">' + data.renderMode + '</span></div>';
+        }
+        
+        if (data.renderTime !== undefined) {
+            var timeColor = data.renderTime < 50 ? '#10b981' : data.renderTime < 200 ? '#f59e0b' : '#ef4444';
+            html += '<div style="margin-bottom:8px;"><span style="color:#6b7280;">Render:</span> <span style="color:' + timeColor + ';">' + data.renderTime + 'ms</span></div>';
+        }
+        
+        if (data.cacheStatus) {
+            var cacheColor = {hit:'#10b981',miss:'#ef4444',stale:'#f59e0b'}[data.cacheStatus] || '#6b7280';
+            html += '<div style="margin-bottom:8px;"><span style="color:#6b7280;">Cache:</span> <span style="color:' + cacheColor + ';">' + data.cacheStatus.toUpperCase() + '</span></div>';
+        }
+        
+        if (data.params && Object.keys(data.params).length > 0) {
+            html += '<div style="margin-bottom:8px;"><span style="color:#6b7280;">Params:</span></div>';
+            html += '<pre style="background:#0f0f1a;padding:8px;border-radius:4px;margin:0;overflow-x:auto;">' + escapeHtml(JSON.stringify(data.params, null, 2)) + '</pre>';
+        }
+        
+        if (data.hydrated !== undefined) {
+            html += '<div style="margin-bottom:8px;"><span style="color:#6b7280;">Hydrated:</span> <span style="color:' + (data.hydrated ? '#10b981' : '#f59e0b') + ';">' + (data.hydrated ? 'Yes' : 'Pending') + '</span></div>';
+        }
+        
+        if (data.customData) {
+            html += '<details style="margin-top:12px;"><summary style="cursor:pointer;color:#6b7280;">Custom Data</summary>';
+            html += '<pre style="background:#0f0f1a;padding:8px;border-radius:4px;margin-top:8px;overflow-x:auto;">' + escapeHtml(JSON.stringify(data.customData, null, 2)) + '</pre></details>';
+        }
+        
+        content.innerHTML = html || '<span style="color:#6b7280;">No data available</span>';
+        
+        // Toggle panel
+        toggle.addEventListener('click', function() {
+            panel.style.display = panel.style.display === 'none' ? 'block' : 'none';
+        });
+        
+        // Update hydration status
+        window.addEventListener('load', function() {
+            setTimeout(function() {
+                var hydrationEl = content.querySelector('[data-hydration]');
+                if (hydrationEl) {
+                    hydrationEl.textContent = 'Yes';
+                    hydrationEl.style.color = '#10b981';
+                }
+            }, 100);
+        });
+    }
+    
+    function escapeHtml(str) {
+        return String(str).replace(/[&<>"']/g, function(m) {
+            return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[m];
+        });
+    }
+})();
+</script>
+`;
+}
+function isDevToolsEnabled() {
+  return process.env.NODE_ENV === "development";
+}
+function createDevToolsData(startTime, options = {}) {
+  return {
+    renderTime: Date.now() - startTime,
+    hydrated: false,
+    ...options
+  };
+}
 
 // src/index.ts
 var VERSION = "0.0.1";
 
-export { VERSION };
+export { VERSION, buildCacheControlHeader, createDefaultRouteRules, createDevToolsData, createHtmlStream, createISRCacheFromFlightCache, createMemoryISRCache, createRevalidateHandler, createStreamingResponse2 as createStaticStreamingResponse, expandDynamicRoutes, extractLinks, generateAllStaticPaths, getCacheOptionsFromRule, getISRCache, getOrGeneratePage, getRenderModeFromRule, getRevalidateTime, injectDevTools, isDevToolsEnabled, matchRouteRule, mergeMetadata, mergeRouteRules, prerenderRoutes, purgeAllPages, purgePage, renderMetadataToHead, resolveMetadata, revalidatePath2 as revalidatePath, revalidatePaths, revalidateTag2 as revalidateTag, setISRCache, shouldDynamicallyRender };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map