@wular/coder 0.4.6 → 0.4.8

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/pipeline-yjdnwbhm.js

@@ -0,0 +1,836 @@
+// @bun
+import {
+  contentType,
+  withForwardedHeaders
+} from "./index-5hr4062s.js";
+import {
+  immutableAssetPath,
+  immutableCacheControl
+} from "./index-rcs322t1.js";
+import {
+  handleRouteModule,
+  routeParamsFromPath
+} from "./index-qpwsgt3a.js";
+import {
+  isPprShellUpgradeEligible,
+  metadataRouteHandlerModule,
+  renderGlobalNotFoundResponse,
+  renderPageResponse,
+  renderPageWithStatus
+} from "./index-yghskk8w.js";
+import {
+  normalizePathname,
+  parseNavState,
+  selectRouteForRequest
+} from "./index-aarf1brn.js";
+import {
+  applyProxyResponse,
+  createProxyRunner
+} from "./index-vqs3rebe.js";
+import {
+  importModuleOnce,
+  registerServerRuntime,
+  serverBundleTargetForRuntime
+} from "./index-912z4mfx.js";
+import {
+  publishEmittedAssets
+} from "./index-xrsg0041.js";
+import {
+  getRenderSpanExtensions
+} from "./index-web361b8.js";
+import"./index-ye9hmsvf.js";
+import {
+  setRequestRuntime
+} from "./index-z88qv16t.js";
+import"./index-yhxkxghe.js";
+import"./index-jjppzw0s.js";
+import"./index-veycp46e.js";
+import {
+  exactNameIndex,
+  hasExactName,
+  resolveManifest
+} from "./index-4qsce64w.js";
+import"./index-vz0km5qk.js";
+import {
+  abortUpstreamFetchOnDisconnect,
+  bootstrapCompat
+} from "./index-yzcpr3yw.js";
+import {
+  loadConfig,
+  pathToFileHref
+} from "./index-zedjt25v.js";
+import"./index-bzd2ef7t.js";
+import {
+  markErrorLogged
+} from "./index-jcsjq3d1.js";
+import {
+  attachRelease,
+  buildManifestFile,
+  releaseFrameworkRoot,
+  releaseModuleHref
+} from "./index-fpghsgb4.js";
+import"./index-ras0sdab.js";
+import {
+  flushWorkUnit,
+  flushWorkUnitOnClose,
+  getWorkUnit,
+  runWithWorkUnit,
+  setPhase,
+  setWorkUnitRelease,
+  setWorkUnitRoute
+} from "./index-grta8ap3.js";
+import"./index-kresp2n8.js";
+import"./index-e3a6yx84.js";
+import"./index-pym1cezq.js";
+import"./index-jt8e1pje.js";
+import {
+  finalizeResponse,
+  getProxyExtensions,
+  getRenderExtensions,
+  getRequestExtensions,
+  reportRequestError,
+  runInitHooks,
+  setRequestExtensions,
+  withRouteRuntime
+} from "./index-zqpqyg8p.js";
+import"./index-qjj6gddn.js";
+import"./index-4399bvd2.js";
+import"./index-rt9qq1va.js";
+
+// src/cli/serve/pipeline.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { stat } from "fs/promises";
+import path from "path";
+import { constants as zlibConstants, createGzip, gzipSync } from "zlib";
+import { Readable } from "stream";
+import {
+  canonicalTrailingSlashPath,
+  malformedUrlResponse,
+  repeatedSlashRedirect,
+  trailingSlashRedirect
+} from "../../../src/routing/href.ts";
+import { runWithCacheScope } from "../../../src/request/cache.ts";
+async function createRequestHandler(options = {}) {
+  const config = options.config ?? await loadConfig(options.root, { serve: true });
+  await bootstrapCompat(config);
+  const manifestPath = buildManifestFile(config.outPath);
+  const manifest = resolveManifest(options.manifest ?? JSON.parse(await readFile(manifestPath, "utf8")), config.outPath, config.root, releaseFrameworkRoot(config.outPath));
+  const release = attachRelease(config);
+  release.staticMetadataFiles = manifest.staticMetadataFiles;
+  const handlerHrefs = new Map(manifest.routes.filter((route) => route.kind === "handler").map((route) => [
+    route.id,
+    releaseModuleHref(release, "server", serverBundleTargetForRuntime(route.segmentConfig?.runtime), route.file)
+  ]));
+  const persistManifest = async () => {
+    const stored = JSON.parse(await readFile(manifestPath, "utf8"));
+    stored.staticFiles = manifest.staticFiles;
+    await writeFile(manifestPath, `${JSON.stringify(stored, null, 2)}
+`);
+  };
+  runInitHooks(config);
+  publishEmittedAssets(config.outPath, manifest.assetNames);
+  const exactNames = exactNameIndex(config.outPath);
+  setRequestRuntime({ config, routes: manifest.routes, dev: false });
+  const proxyRunner = createProxyRunner(config, {
+    compiledModuleHref: manifest.proxyModule ? pathToFileHref(path.resolve(config.outPath, manifest.proxyModule)) : undefined,
+    released: release.proxy
+  });
+  const routesById = new Map(manifest.routes.map((route) => [route.id, route]));
+  const nextCompat = Boolean(config.compat?.next);
+  const regenerating = new Map;
+  async function regenerateStaticFile(pathname, file, relative, metadata, reason) {
+    if (!metadata.routeId)
+      return;
+    const route = routesById.get(metadata.routeId);
+    if (!route)
+      return;
+    await runWithWorkUnit("render", async () => {
+      setWorkUnitRelease(release);
+      const url = new URL(`http://pnext.local${pathname}`);
+      const params = routeParamsFromPath(route, pathname);
+      const fetchCache = route.segmentConfig?.fetchCache;
+      try {
+        if (route.kind === "handler") {
+          setWorkUnitRoute("route-handler", "isr", { revalidateReason: reason });
+          setPhase("handler");
+          await registerServerRuntime(config, route.sourceFiles);
+          const module = await importModuleOnce(handlerHrefs.get(route.id));
+          const rendered = await getRenderExtensions().collectRenderMeta(() => withRouteRuntime(route.segmentConfig?.runtime, () => runWithCacheScope(() => handleRouteModule(module, new Request(url), params, { routeFile: route.file }))), { fetchCache, blockingStaleFetches: true, route: pathname, handler: true });
+          if (rendered.value.status >= 500)
+            return;
+          await writeFile(file, new Uint8Array(await rendered.value.arrayBuffer()));
+          manifest.staticFiles[relative] = {
+            ...metadata,
+            status: rendered.value.status,
+            headers: [...rendered.value.headers.entries()],
+            ...rendered.tags.length > 0 ? { tags: rendered.tags } : {}
+          };
+        } else {
+          setWorkUnitRoute("html", "isr", { revalidateReason: reason });
+          setPhase("render");
+          const rendered = await getRenderExtensions().collectRenderMeta(() => withRouteRuntime(route.segmentConfig?.runtime, () => renderPageWithStatus({
+            config,
+            route,
+            params,
+            url,
+            ...route.usesRequest ? { request: new Request(url) } : {},
+            staticMetadataFiles: manifest.staticMetadataFiles,
+            staticModuleMetadata: manifest.staticModuleMetadata,
+            staticRouteMetadata: manifest.staticRouteMetadata
+          })), { fetchCache, blockingStaleFetches: true, route: pathname });
+          if (rendered.value.status >= 500)
+            return;
+          await writeFile(file, rendered.value.html);
+          manifest.staticFiles[relative] = {
+            ...metadata,
+            status: rendered.value.status,
+            ...rendered.tags.length > 0 ? { tags: rendered.tags } : {}
+          };
+        }
+      } catch (error) {
+        const unit = getWorkUnit();
+        await reportRequestError(error, { method: "GET", url: url.href, headers: new Headers }, {
+          phase: unit?.phase,
+          routeKind: unit?.routeKind,
+          ...unit?.responseHints ?? {}
+        });
+        throw error;
+      }
+    });
+  }
+  function runRegeneration(pathname, file, relative, metadata, reason) {
+    const existing = regenerating.get(file);
+    if (existing)
+      return existing;
+    const task = regenerateStaticFile(pathname, file, relative, metadata, reason).catch((error) => {
+      console.warn(`pnext start: background revalidate failed for ${pathname}:`, error);
+    }).finally(() => {
+      regenerating.delete(file);
+    });
+    regenerating.set(file, task);
+    return task;
+  }
+  function scheduleRegen(pathname, file, relative, metadata) {
+    runRegeneration(pathname, file, relative, metadata, "stale");
+  }
+  setRequestExtensions({
+    onDemandRevalidatePath: async (pathname) => {
+      const built = await builtFileInfo(config.outPath, pathname, manifest.staticFiles, false, exactNames);
+      if (!built?.metadata)
+        return;
+      await runRegeneration(pathname, built.file, built.relative, built.metadata, "on-demand");
+    }
+  });
+  async function renderNotFound(request) {
+    const built = await maybeBuiltFile(config.outPath, "/404", manifest.staticFiles, request.method, request.headers, nextCompat, manifest.publicAssets, exactNames);
+    if (built) {
+      setWorkUnitRoute("html", "static");
+      const headers = new Headers(built.headers);
+      headers.set("x-nextjs-cache", "HIT");
+      if (!hasBuildCapturedCacheControl(manifest.staticFiles?.["404.html"])) {
+        headers.delete("cache-control");
+      }
+      headers.delete("content-length");
+      return compressResponse(new Response(built.body, { status: 404, headers }), request);
+    }
+    return compressResponse(await renderGlobalNotFoundResponse({
+      config,
+      url: new URL(request.url),
+      request,
+      staticMetadataFiles: manifest.staticMetadataFiles,
+      staticModuleMetadata: manifest.staticModuleMetadata,
+      staticRouteMetadata: manifest.staticRouteMetadata
+    }), request);
+  }
+  return function handleRequest(request, server) {
+    return runWithWorkUnit("render", async () => {
+      const unit = getWorkUnit();
+      setWorkUnitRelease(release);
+      try {
+        const raw = await handle(request, server);
+        const finalized = await finalizeResponse(raw, { method: request.method, url: new URL(request.url), headers: request.headers }, {
+          routeKind: unit?.routeKind ?? "html",
+          routeMode: unit?.routeMode,
+          hints: unit?.responseHints
+        });
+        const response = maybeCloseNodeFetchConnection(finalized, request);
+        abortUpstreamFetchOnDisconnect(response.body, request.signal);
+        return flushWorkUnitOnClose(response, unit, request.signal);
+      } catch (error) {
+        await reportRequestError(error, { method: request.method, url: request.url, headers: request.headers }, { phase: unit?.phase, routeKind: unit?.routeKind });
+        if (markErrorLogged(error)) {
+          console.error(`pnext start: request failed for ${request.url}:`, error);
+        }
+        flushWorkUnit(unit);
+        return new Response("Internal Server Error", { status: 500 });
+      }
+    });
+  };
+  async function handle(request, server) {
+    const badRequest = malformedUrlResponse(request);
+    if (badRequest)
+      return badRequest;
+    request = withForwardedHeaders(request, server);
+    const requestedUrl = new URL(request.url);
+    const slashRedirect = repeatedSlashRedirect(requestedUrl);
+    if (slashRedirect)
+      return slashRedirect;
+    const assetStripped = stripAssetPrefix(request, config.assetPrefix);
+    if (assetStripped)
+      request = assetStripped;
+    if (config.basePath && !assetStripped) {
+      const stripped = stripBasePath(request, config.basePath);
+      if (!stripped) {
+        const answered = await runOutsideBasePathInterceptors(request, config);
+        if (answered instanceof Response)
+          return answered;
+        const rewritten2 = answered && stripBasePath(answered.request, config.basePath);
+        if (!rewritten2)
+          return await renderNotFound(request);
+        request = rewritten2;
+      } else {
+        request = stripped;
+      }
+    }
+    const skipProxyNormalize = getProxyExtensions().skipUrlNormalize();
+    if (nextCompat && !skipProxyNormalize) {
+      request = normalizeDataRequest(request, config) ?? request;
+    }
+    const bypassToken = getRequestExtensions().revalidateBypassToken();
+    const revalidateBypass = Boolean(bypassToken && request.headers.get("x-prerender-revalidate") === bypassToken);
+    const canonicalRedirect = trailingSlashRedirect(config, requestedUrl);
+    if (canonicalRedirect)
+      return canonicalRedirect;
+    const canonicalUrl = new URL(request.url);
+    const canonicalHeaders = request.headers;
+    let proxyResponse;
+    const proxyResult = revalidateBypass ? undefined : await proxyRunner(request);
+    if (proxyResult instanceof Response)
+      return proxyResult;
+    if (proxyResult) {
+      request = proxyResult.request;
+      proxyResponse = proxyResult.response;
+    }
+    if (nextCompat && skipProxyNormalize) {
+      request = normalizeDataRequest(request, config) ?? request;
+    }
+    for (const interceptor of getRequestExtensions().interceptors) {
+      const result = await interceptor(request, { config });
+      if (result instanceof Response)
+        return applyProxyResponse(compressResponse(result, request), proxyResponse);
+      if (result)
+        request = result.request;
+    }
+    let url = new URL(request.url);
+    const rewritten = url.href !== canonicalUrl.href;
+    const canonicalRequestUrl = new URL(canonicalUrl);
+    canonicalRequestUrl.search = url.search;
+    const canonicalRequest = canonicalRequestUrl.href === request.url ? request : new Request(canonicalRequestUrl, { headers: canonicalHeaders });
+    const method = request.method.toUpperCase();
+    const nav = parseNavState(request);
+    const selection = selectRouteForRequest(manifest.routes, url.pathname, nav);
+    const softDynamic = Boolean(nav && selection?.route.kind === "page" && (selection.route.slotDirs?.length || selection.route.synthetic || selection.route.interception || selection.childrenPath !== normalizePathname(url.pathname)));
+    const pprDocumentResume = selection?.route.kind === "page" && selection.route.ppr;
+    const draftBypass = hasDraftBypassCookie(request.headers);
+    const built = method === "GET" || method === "HEAD" ? await builtFileInfo(config.outPath, url.pathname, manifest.staticFiles, nextCompat, exactNames) : null;
+    const hardStaticStale = built !== null && !isImmutableAssetFile(built.relative) && getRequestExtensions().staticStaleness(url.pathname, built.mtimeMs, built.metadata?.tags ?? []);
+    const staleReason = built ? getRequestExtensions().staticStalenessReason(url.pathname, built.mtimeMs, built.metadata?.tags ?? []) ?? "on-demand" : undefined;
+    const softStale = staleReason === "soft";
+    const staleOnDemand = hardStaticStale && !softStale;
+    const hardExpired = built?.metadata?.expireSeconds !== undefined && isHtmlPageFile(built.file) && Date.now() - built.mtimeMs >= built.metadata.expireSeconds * 1000;
+    const builtIsPageHtml = built !== null && isHtmlPageFile(built.file);
+    if (built && !staleOnDemand && !(softDynamic && builtIsPageHtml) && !(pprDocumentResume && builtIsPageHtml) && !hardExpired && !revalidateBypass) {
+      const servedBuilt = built;
+      const metadata = built.metadata;
+      const route = metadata?.routeId ? routesById.get(metadata.routeId) : undefined;
+      if (route?.segmentConfig?.runtime === "edge" || route?.segmentConfig?.runtime === "experimental-edge") {
+        withRouteRuntime(route.segmentConfig.runtime, () => {
+          return;
+        });
+      }
+      const staticFile = await maybeBuiltFile(config.outPath, url.pathname, manifest.staticFiles, request.method, request.headers, nextCompat, manifest.publicAssets, exactNames);
+      if (staticFile && !(draftBypass && isHtmlResponse(staticFile))) {
+        const staticMode = servedBuilt.metadata?.revalidateSeconds !== undefined ? "isr" : "static";
+        setWorkUnitRoute(isHtmlResponse(staticFile) ? "html" : "static-asset", staticMode, servedBuilt.metadata?.revalidateSeconds !== undefined ? { revalidateSeconds: servedBuilt.metadata.revalidateSeconds } : undefined);
+        if (isHtmlResponse(staticFile) && !hasBuildCapturedCacheControl(servedBuilt.metadata)) {
+          staticFile.headers.delete("cache-control");
+        }
+        if (servedBuilt.metadata) {
+          const servedTtl = servedBuilt.metadata.revalidateSeconds;
+          const expired = softStale || servedTtl !== undefined && Date.now() - servedBuilt.mtimeMs >= servedTtl * 1000;
+          if (expired) {
+            scheduleRegen(url.pathname, servedBuilt.file, servedBuilt.relative, servedBuilt.metadata);
+            staticFile.headers.set("x-nextjs-cache", "STALE");
+          } else {
+            staticFile.headers.set("x-nextjs-cache", "HIT");
+          }
+        }
+        return applyProxyResponse(compressResponse(staticFile, request), proxyResponse);
+      }
+    }
+    if (url.pathname.startsWith("/_next/static/") && !built) {
+      setWorkUnitRoute("static-asset");
+      return applyProxyResponse(new Response("Not Found", {
+        status: 404,
+        headers: {
+          "cache-control": "private, no-cache, no-store, max-age=0, must-revalidate",
+          "content-type": "text/plain;charset=utf-8"
+        }
+      }), proxyResponse);
+    }
+    const stalePage = built && (staleOnDemand || hardExpired) && isHtmlPageFile(built.file) ? built.file : null;
+    const matched = selection;
+    if (!matched) {
+      return applyProxyResponse(await renderNotFound(canonicalRequest), proxyResponse);
+    }
+    if (matched.route.kind === "handler") {
+      setWorkUnitRoute("route-handler", staleOnDemand ? "isr" : routeModeOf(matched.route), responseHintsFor(matched.route, staleReason));
+      setPhase("handler");
+      const renderedHandler = await getRenderExtensions().collectRenderMeta(() => handleRoute(config, matched.route, handlerHrefs.get(matched.route.id), canonicalRequest, matched.params), {
+        fetchCache: matched.route.segmentConfig?.fetchCache,
+        refreshFetches: staleOnDemand,
+        route: url.pathname,
+        handler: true
+      });
+      const handlerResponse = renderedHandler.value;
+      if (built && staleOnDemand && !stalePage && method === "GET" && handlerResponse.status === 200) {
+        try {
+          await writeFile(built.file, new Uint8Array(await handlerResponse.clone().arrayBuffer()));
+          handlerResponse.headers.set("x-nextjs-cache", "MISS");
+        } catch {}
+      }
+      if (!built && matched.route.hasStaticParams && matched.route.segmentConfig?.dynamic !== "force-dynamic" && matched.route.segmentConfig?.revalidate !== 0 && method === "GET" && handlerResponse.status < 500) {
+        const file = lazyStaticHandlerPath(config.outPath, url.pathname);
+        try {
+          if (!file)
+            throw new Error("unsafe path");
+          await mkdir(path.dirname(file), { recursive: true });
+          await writeFile(file, new Uint8Array(await handlerResponse.clone().arrayBuffer()));
+          const relative = path.relative(path.join(config.outPath, "static"), file).split(path.sep).join("/");
+          const routeRevalidate = matched.route.segmentConfig?.revalidate;
+          const revalidateSeconds = typeof routeRevalidate === "number" && routeRevalidate > 0 ? renderedHandler.revalidateSeconds === undefined ? routeRevalidate : Math.min(routeRevalidate, renderedHandler.revalidateSeconds) : renderedHandler.revalidateSeconds;
+          manifest.staticFiles ??= {};
+          manifest.staticFiles[relative] = {
+            status: handlerResponse.status,
+            headers: [...handlerResponse.headers.entries()],
+            routeId: matched.route.id,
+            ...revalidateSeconds !== undefined ? { revalidateSeconds } : {},
+            ...renderedHandler.tags.length > 0 ? { tags: renderedHandler.tags } : {}
+          };
+          await persistManifest();
+          handlerResponse.headers.set("x-nextjs-cache", "MISS");
+        } catch {}
+      }
+      return applyProxyResponse(handlerResponse, proxyResponse);
+    }
+    if (matched.route.segmentConfig?.dynamic === "error" && matched.route.usesRequest) {
+      return applyProxyResponse(new Response(`Page with dynamic = "error" encountered dynamic data method on ${url.pathname}`, { status: 500 }), proxyResponse);
+    }
+    if (!dynamicParamsAllowed(matched.route, matched.params)) {
+      return applyProxyResponse(await renderNotFound(canonicalRequest), proxyResponse);
+    }
+    const forceStaticRoute = matched.route.segmentConfig?.dynamic === "force-static";
+    const renderUrl = forceStaticRoute ? new URL(canonicalUrl.pathname, canonicalUrl.origin) : canonicalRequestUrl;
+    const renderRequest = forceStaticRoute ? new Request(renderUrl) : method === "POST" ? new Request(canonicalRequest.url, { headers: canonicalRequest.headers }) : canonicalRequest;
+    const pageRevalidateReason = stalePage ? staleReason : hardExpired ? "on-demand" : undefined;
+    setWorkUnitRoute("html", pageRevalidateReason ? "isr" : routeModeOf(matched.route), responseHintsFor(matched.route, pageRevalidateReason));
+    const renderMatchedPage = () => withRouteRuntime(matched.route.segmentConfig?.runtime, () => renderPageResponse({
+      config,
+      route: matched.route,
+      params: matched.params,
+      url: renderUrl,
+      request: renderRequest,
+      staticMetadataFiles: manifest.staticMetadataFiles,
+      staticModuleMetadata: manifest.staticModuleMetadata,
+      staticRouteMetadata: manifest.staticRouteMetadata,
+      ...nav || rewritten ? {
+        nav: {
+          ...nav ? { soft: true, state: nav } : {},
+          childrenPath: matched.childrenPath,
+          targetPath: matched.targetPath
+        }
+      } : {}
+    }));
+    const renderedPage = await getRenderExtensions().collectRenderMeta(renderMatchedPage, {
+      fetchCache: matched.route.segmentConfig?.fetchCache,
+      refreshFetches: Boolean(stalePage),
+      route: url.pathname
+    });
+    const renderRevalidateSeconds = renderedPage.revalidateSeconds ?? (typeof matched.route.segmentConfig?.revalidate === "number" ? matched.route.segmentConfig.revalidate : undefined);
+    const renderWasDynamic = matched.route.mode === "dynamic" || matched.route.usesRequest || renderedPage.noStore === true;
+    if (renderRevalidateSeconds !== undefined && renderRevalidateSeconds > 0 && !renderWasDynamic) {
+      setWorkUnitRoute("html", "isr", {
+        ...getWorkUnit()?.responseHints ?? {},
+        revalidateSeconds: renderRevalidateSeconds
+      });
+    }
+    const pageResponse = renderedPage.value;
+    if (matched.route.linkHeader && !pageResponse.headers.has("link")) {
+      pageResponse.headers.set("link", matched.route.linkHeader);
+    }
+    const cacheLifeHeaders = cacheLifeResponseHeaders(matched.route.cacheLife);
+    if (cacheLifeHeaders.length > 0 && matched.route.kind === "page") {
+      for (const [key, value] of cacheLifeHeaders) {
+        if (key === "cache-control" && pageResponse.headers.has("cache-control"))
+          continue;
+        pageResponse.headers.set(key, value);
+      }
+    }
+    const lazyStaticCapable = matched.route.kind === "page" && !isPprShellUpgradeEligible(config, matched.route, url) && (forceStaticRoute || !matched.route.usesRequest && matched.route.segmentConfig?.runtime !== "edge" && (matched.route.hasStaticParams || matched.route.mode === "static"));
+    if (!stalePage && !built && !nav && !draftBypass && lazyStaticCapable && !renderedPage.noStore && method === "GET" && url.search === "" && pageResponse.status === 200 && (pageResponse.headers.get("content-type") ?? "").includes("text/html")) {
+      try {
+        const file = lazyStaticHtmlPath(config.outPath, url.pathname);
+        if (!file)
+          throw new Error("unsafe path");
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, await pageResponse.clone().text());
+        const relative = path.relative(path.join(config.outPath, "static"), file).split(path.sep).join("/");
+        manifest.staticFiles ??= {};
+        manifest.staticFiles[relative] = {
+          status: 200,
+          headers: [
+            ...matched.route.linkHeader ? [["link", matched.route.linkHeader]] : [],
+            ...cacheLifeHeaders
+          ],
+          routeId: matched.route.id,
+          kind: "page",
+          ...renderedPage.revalidateSeconds !== undefined ? { revalidateSeconds: renderedPage.revalidateSeconds } : {},
+          ...matched.route.cacheLife?.expireSeconds !== undefined ? { expireSeconds: matched.route.cacheLife.expireSeconds } : {},
+          ...matched.route.cacheLife?.staleSeconds !== undefined ? { staleSeconds: matched.route.cacheLife.staleSeconds } : {},
+          ...renderedPage.tags.length > 0 ? { tags: renderedPage.tags } : {}
+        };
+        pageResponse.headers.set("x-nextjs-cache", "MISS");
+      } catch {}
+    }
+    if (stalePage && !nav && !softDynamic && !draftBypass && method === "GET" && pageResponse.status === 200 && (pageResponse.headers.get("content-type") ?? "").includes("text/html")) {
+      try {
+        await writeFile(stalePage, await pageResponse.clone().text());
+        pageResponse.headers.set("x-nextjs-cache", "MISS");
+      } catch {}
+    }
+    if (revalidateBypass) {
+      if (built && method === "GET" && pageResponse.status === 200 && (pageResponse.headers.get("content-type") ?? "").includes("text/html")) {
+        try {
+          await writeFile(built.file, await pageResponse.clone().text());
+        } catch {}
+      }
+      pageResponse.headers.set("x-nextjs-cache", "REVALIDATED");
+    }
+    return applyProxyResponse(compressResponse(pageResponse, request), proxyResponse);
+  }
+}
+function normalizeDataRequest(request, config) {
+  const method = request.method.toUpperCase();
+  if (method !== "GET" && method !== "HEAD")
+    return null;
+  const url = new URL(request.url);
+  const match = /^\/_next\/data\/[^/]+(\/.+)\.json$/.exec(url.pathname);
+  if (!match)
+    return null;
+  const page = match[1] === "/index" ? "/" : match[1];
+  url.pathname = canonicalTrailingSlashPath(page, Boolean(config.trailingSlash));
+  const headers = new Headers(request.headers);
+  headers.set("x-nextjs-data", "1");
+  return new Request(url, { method, headers });
+}
+async function runOutsideBasePathInterceptors(request, config) {
+  for (const interceptor of getRequestExtensions().outsideBasePathInterceptors) {
+    const result = await interceptor(request, { config, outsideBasePath: true });
+    if (result)
+      return result;
+  }
+  return;
+}
+function stripBasePath(request, basePath) {
+  const url = new URL(request.url);
+  const { pathname } = url;
+  if (pathname !== basePath && !pathname.startsWith(`${basePath}/`))
+    return null;
+  url.pathname = pathname.slice(basePath.length) || "/";
+  return new Request(url, request);
+}
+function stripAssetPrefix(request, assetPrefix) {
+  if (!assetPrefix)
+    return null;
+  let prefixValue = assetPrefix;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(assetPrefix)) {
+    prefixValue = new URL(assetPrefix).pathname;
+  }
+  const prefix = `/${prefixValue.replace(/^\/+|\/+$/g, "")}`;
+  if (prefix === "/")
+    return null;
+  const url = new URL(request.url);
+  const { pathname } = url;
+  if (!pathname.startsWith(`${prefix}/assets/`) && !pathname.startsWith(`${prefix}/_next/static/`)) {
+    return null;
+  }
+  url.pathname = pathname.slice(prefix.length);
+  return new Request(url, request);
+}
+function maybeCloseNodeFetchConnection(response, request) {
+  const userAgent = request.headers.get("user-agent") ?? "";
+  if (!userAgent.includes("node-fetch"))
+    return response;
+  response.headers.set("connection", "close");
+  return response;
+}
+async function handleRoute(config, route, href, request, params) {
+  return withRouteRuntime(route.segmentConfig?.runtime, async () => {
+    await registerServerRuntime(config, route.sourceFiles);
+    const spans = getRenderSpanExtensions();
+    const module = await spans.withFindPageComponentsSpan(route.route, async () => {
+      const imported = await importModuleOnce(href);
+      return metadataRouteHandlerModule(imported, route) ?? imported;
+    });
+    return spans.withRouteHandlerSpan(route.route, () => runWithCacheScope(() => handleRouteModule(module, request, params, { routeFile: route.file })));
+  });
+}
+function hasDraftBypassCookie(headers) {
+  return /(?:^|;\s*)__prerender_bypass=/.test(headers.get("cookie") ?? "");
+}
+function isHtmlResponse(response) {
+  return (response.headers.get("content-type") ?? "").includes("text/html");
+}
+function routeModeOf(route) {
+  if (route.segmentConfig?.dynamic === "force-dynamic")
+    return "dynamic";
+  const revalidate = route.segmentConfig?.revalidate;
+  if (typeof revalidate === "number" && revalidate > 0)
+    return "isr";
+  return route.mode === "static" ? "static" : "dynamic";
+}
+function responseHintsFor(route, revalidateReason) {
+  const runtime = route.segmentConfig?.runtime;
+  const revalidate = route.segmentConfig?.revalidate;
+  if (!revalidateReason && !runtime && typeof revalidate !== "number")
+    return;
+  return {
+    ...revalidateReason ? { revalidateReason } : {},
+    ...runtime ? { runtime } : {},
+    ...typeof revalidate === "number" && revalidate > 0 ? { revalidateSeconds: revalidate } : {}
+  };
+}
+function hasBuildCapturedCacheControl(metadata) {
+  return (metadata?.headers ?? []).some(([key]) => key.toLowerCase() === "cache-control");
+}
+async function builtFileInfo(outPath, pathname, staticFiles = {}, nextStaticFallback = false, exactNames) {
+  const file = await firstFile(path.join(outPath, "static"), builtFileCandidates(outPath, pathname, nextStaticFallback), exactNames);
+  if (!file)
+    return null;
+  const publicPath = path.join(outPath, "static");
+  const fileStat = await stat(file);
+  const relative = path.relative(publicPath, file).split(path.sep).join("/");
+  return { file, relative, mtimeMs: fileStat.mtimeMs, metadata: staticFiles[relative] };
+}
+function builtFileCandidates(outPath, pathname, nextStaticFallback = false) {
+  const publicPath = path.join(outPath, "static");
+  const trimmed = pathname.replace(/^\/+/, "");
+  if (pathname === "/")
+    return [path.join(publicPath, "index.html")];
+  const candidates = [
+    path.join(publicPath, trimmed, "index.html"),
+    path.join(publicPath, trimmed),
+    path.join(publicPath, `${trimmed.replace(/\/+$/, "")}.html`)
+  ];
+  try {
+    const decoded = decodeURIComponent(trimmed);
+    if (decoded !== trimmed && !decoded.split("/").some((seg) => seg === ".." || seg === "")) {
+      candidates.push(path.join(publicPath, decoded, "index.html"), path.join(publicPath, `${decoded.replace(/\/+$/, "")}.html`));
+    }
+  } catch {}
+  if (nextStaticFallback && trimmed.startsWith("_next/static/")) {
+    const asset = trimmed.slice("_next/static/".length);
+    candidates.push(path.join(publicPath, "assets", asset));
+  }
+  return candidates;
+}
+function lazyStaticHtmlPath(outPath, pathname) {
+  const publicPath = path.join(outPath, "static");
+  const file = pathname === "/" ? path.join(publicPath, "index.html") : path.join(publicPath, pathname.replace(/^\/+|\/+$/g, ""), "index.html");
+  const relative = path.relative(publicPath, file);
+  if (relative.startsWith("..") || path.isAbsolute(relative))
+    return null;
+  return file;
+}
+function lazyStaticHandlerPath(outPath, pathname) {
+  if (pathname === "/")
+    return null;
+  const publicPath = path.join(outPath, "static");
+  const file = path.join(publicPath, pathname.replace(/^\/+|\/+$/g, ""));
+  const relative = path.relative(publicPath, file);
+  if (relative.startsWith("..") || path.isAbsolute(relative))
+    return null;
+  return file;
+}
+function isHtmlPageFile(file) {
+  return file.endsWith(".html");
+}
+function cacheLifeResponseHeaders(life) {
+  if (!life)
+    return [];
+  const headers = [];
+  const { revalidateSeconds, expireSeconds, staleSeconds } = life;
+  if (revalidateSeconds !== undefined && expireSeconds !== undefined) {
+    const swr = Math.max(0, expireSeconds - revalidateSeconds);
+    headers.push(["cache-control", `s-maxage=${revalidateSeconds}, stale-while-revalidate=${swr}`]);
+  }
+  if (staleSeconds !== undefined)
+    headers.push(["x-nextjs-stale-time", String(staleSeconds)]);
+  return headers;
+}
+function isImmutableAssetFile(relative) {
+  return relative.startsWith("assets/") || relative.startsWith("_next/static/");
+}
+function dynamicParamsAllowed(route, params) {
+  const governed = route.segmentConfig?.dynamicParamsFalse;
+  if (!governed?.length)
+    return true;
+  const allowed = route.prerenderedParams ?? [];
+  const required = route.segmentConfig?.strictDynamicParams ? [...route.params, ...route.catchAll ? [route.catchAll] : []] : governed;
+  return allowed.some((set) => required.every((param) => paramValueEqual(set[param], params[param])));
+}
+function paramValueEqual(a, b) {
+  if (a === undefined || b === undefined)
+    return false;
+  const join = (value) => Array.isArray(value) ? value.join("/") : value;
+  return join(a) === join(b);
+}
+async function maybeBuiltFile(outPath, pathname, staticFiles = {}, method = "GET", requestHeaders, nextStaticFallback = false, publicAssets = [], exactNames) {
+  const normalizedMethod = method.toUpperCase();
+  if (normalizedMethod !== "GET" && normalizedMethod !== "HEAD")
+    return null;
+  const publicPath = path.join(outPath, "static");
+  const file = await firstFile(publicPath, builtFileCandidates(outPath, pathname, nextStaticFallback), exactNames);
+  if (!file)
+    return null;
+  const relative = path.relative(publicPath, file).split(path.sep).join("/");
+  const metadata = staticFiles[relative];
+  const headers = new Headers(metadata?.headers);
+  if (!headers.has("content-type"))
+    headers.set("content-type", contentType(file));
+  const fileStat = await stat(file);
+  const variant = requestHeaders?.get("rsc") === "1" ? "-rsc" : "";
+  const etag = `W/"${fileStat.size.toString(16)}-${Math.trunc(fileStat.mtimeMs).toString(16)}${variant}"`;
+  if (!headers.has("cache-control")) {
+    const immutable = immutableAssetPath(relative) && !publicAssets.includes(relative);
+    headers.set("cache-control", immutable ? immutableCacheControl : "no-cache");
+    headers.set("etag", etag);
+    if (requestHeaders?.get("if-none-match") === etag) {
+      return new Response(null, { status: 304, headers });
+    }
+  }
+  const raw = await readFile(file);
+  let body = raw;
+  if (compressibleContentType(headers.get("content-type") ?? "") && raw.length > 1024 && acceptsGzip(requestHeaders)) {
+    const zipped = cachedGzip(`${file}:${etag}`, raw);
+    if (zipped.length < raw.length) {
+      body = zipped;
+      headers.set("content-encoding", "gzip");
+      headers.append("vary", "accept-encoding");
+    }
+  }
+  return new Response(normalizedMethod === "HEAD" ? null : body, {
+    status: metadata?.status ?? 200,
+    headers
+  });
+}
+function appendVaryToken(headers, token) {
+  const existing = headers.get("vary");
+  if (!existing) {
+    headers.set("vary", token);
+    return;
+  }
+  const tokens = existing.split(",").map((part) => part.trim().toLowerCase());
+  if (tokens.includes(token.toLowerCase()) || tokens.includes("*"))
+    return;
+  headers.set("vary", `${existing}, ${token}`);
+}
+function compressResponse(response, request) {
+  if (!response.body || response.status === 304 || response.status === 204)
+    return response;
+  if (response.headers.get("content-encoding"))
+    return response;
+  if (!compressibleContentType(response.headers.get("content-type") ?? ""))
+    return response;
+  const headers = new Headers(response.headers);
+  appendVaryToken(headers, "accept-encoding");
+  if (!acceptsGzip(request.headers)) {
+    return new Response(response.body, { status: response.status, headers });
+  }
+  const knownLength = Number(headers.get("content-length"));
+  if (Number.isFinite(knownLength) && knownLength <= 1024) {
+    return new Response(response.body, { status: response.status, headers });
+  }
+  headers.set("content-encoding", "gzip");
+  headers.delete("content-length");
+  return new Response(streamingGzip(response.body), {
+    status: response.status,
+    headers
+  });
+}
+function streamingGzip(body) {
+  const gzip = createGzip();
+  const reader = body.getReader();
+  (async () => {
+    try {
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        gzip.write(value);
+        await new Promise((resolve) => gzip.flush(zlibConstants.Z_SYNC_FLUSH, resolve));
+      }
+      gzip.end();
+    } catch (error) {
+      gzip.destroy(error);
+      reader.cancel(error).catch(() => {
+        return;
+      });
+    }
+  })();
+  return Readable.toWeb(gzip);
+}
+function compressibleContentType(type) {
+  return /^(text\/|application\/(javascript|json|manifest|xml)|image\/svg)/.test(type);
+}
+function acceptsGzip(requestHeaders) {
+  return requestHeaders?.get("accept-encoding")?.includes("gzip") ?? false;
+}
+var gzipCache = new Map;
+var gzipCacheLimit = 512;
+function cachedGzip(key, body) {
+  const cached = gzipCache.get(key);
+  if (cached)
+    return cached;
+  const zipped = gzipSync(body, { level: 6 });
+  if (gzipCache.size >= gzipCacheLimit) {
+    const oldest = gzipCache.keys().next().value;
+    if (oldest !== undefined)
+      gzipCache.delete(oldest);
+  }
+  gzipCache.set(key, zipped);
+  return zipped;
+}
+async function firstFile(root, files, exactNames) {
+  for (const file of files) {
+    if (!isInside(root, file))
+      continue;
+    if (!existsSync(file))
+      continue;
+    if (exactNames && !hasExactName(exactNames, root, path.relative(root, file)))
+      continue;
+    if ((await stat(file)).isFile())
+      return file;
+  }
+  return null;
+}
+function isInside(root, file) {
+  const relative = path.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+export {
+  compressResponse,
+  createRequestHandler,
+  maybeBuiltFile
+};