@wular/coder 0.3.17 → 0.4.0

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/pipeline-UW47K537.js

@@ -0,0 +1,961 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+import {
+  handleRouteModule,
+  routeParamsFromPath
+} from "./chunk-C2LIV2MM.js";
+import {
+  isPprShellUpgradeEligible,
+  metadataRouteHandlerModule,
+  renderGlobalNotFoundResponse,
+  renderPageResponse,
+  renderPageWithStatus,
+  runWithCacheScope
+} from "./chunk-PZ5AXOLW.js";
+import {
+  setRequestRuntime
+} from "./chunk-VC5O2SDP.js";
+import {
+  abortUpstreamFetchOnDisconnect,
+  bootstrapCompat
+} from "./chunk-COXJAPTU.js";
+import {
+  markErrorLogged
+} from "./chunk-62KEQM43.js";
+import {
+  normalizePathname,
+  parseNavState,
+  publishEmittedAssets,
+  selectRouteForRequest
+} from "./chunk-SNVPTULL.js";
+import {
+  applyProxyResponse,
+  createProxyRunner
+} from "./chunk-7DCNCW6O.js";
+import {
+  canonicalTrailingSlashPath,
+  importModuleOnce,
+  malformedUrlResponse,
+  registerServerRuntime,
+  serverBundleTargetForRuntime,
+  trailingSlashRedirect
+} from "./chunk-E6IXL2NJ.js";
+import "./chunk-L2IWDUXG.js";
+import {
+  flushWorkUnit,
+  flushWorkUnitOnClose,
+  getWorkUnit,
+  loadConfig,
+  pathToFileHref,
+  runWithWorkUnit,
+  setPhase,
+  setWorkUnitRoute
+} from "./chunk-JESFYECC.js";
+import "./chunk-5RDEILQB.js";
+import "./chunk-JRPJM2XY.js";
+import {
+  getRenderSpanExtensions
+} from "./chunk-CCATPVTW.js";
+import "./chunk-HT6KKX6A.js";
+import "./chunk-NQE46AZN.js";
+import {
+  resolveManifest
+} from "./chunk-2HFY3DQT.js";
+import {
+  finalizeResponse,
+  getAssetExtensions,
+  getProxyExtensions,
+  getRenderExtensions,
+  getRequestExtensions,
+  reportRequestError,
+  runInitHooks,
+  setRequestExtensions,
+  withRouteRuntime
+} from "./chunk-4P5CMIYT.js";
+import {
+  stopEsbuildService
+} from "./chunk-FTJVHFWD.js";
+import "./chunk-3UPROT2C.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/cli/serve/pipeline.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { stat } from "node:fs/promises";
+import path2 from "node:path";
+import { constants as zlibConstants, createGzip, gzipSync } from "node:zlib";
+import { Readable } from "node:stream";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/routing/forwarded.ts
+var FORWARDED_HOST = "x-forwarded-host";
+var FORWARDED_PORT = "x-forwarded-port";
+var FORWARDED_PROTO = "x-forwarded-proto";
+var FORWARDED_FOR = "x-forwarded-for";
+function withForwardedHeaders(request, peer) {
+  const headers = request.headers;
+  const hasHost = headers.has(FORWARDED_HOST);
+  const hasPort = headers.has(FORWARDED_PORT);
+  const hasProto = headers.has(FORWARDED_PROTO);
+  const hasFor = headers.has(FORWARDED_FOR);
+  if (hasHost && hasPort && hasProto && (hasFor || !peer)) return request;
+  let url;
+  try {
+    url = new URL(request.url);
+  } catch {
+    return request;
+  }
+  const host = headers.get("host") ?? url.host;
+  const proto = url.protocol.replace(":", "");
+  const port = url.port;
+  const next = new Headers(headers);
+  if (!hasHost) next.set(FORWARDED_HOST, host);
+  if (!hasPort) next.set(FORWARDED_PORT, port);
+  if (!hasProto) next.set(FORWARDED_PROTO, proto);
+  if (!hasFor && peer) {
+    const address = peer.requestIP(request)?.address;
+    if (address) next.set(FORWARDED_FOR, address);
+  }
+  return new Request(request, { headers: next });
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/utils/content-type.ts
+import path from "node:path";
+var contentTypes = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".css": "text/css; charset=utf-8",
+  ".eot": "application/vnd.ms-fontobject",
+  ".gif": "image/gif",
+  ".htm": "text/html; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".otf": "font/otf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function contentType(file) {
+  return contentTypes[path.extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/cli/serve/pipeline.ts
+async function moduleHrefForRoute(config, route) {
+  const { devServerModuleHref } = await import("./modules-UVOCE4C2.js");
+  return devServerModuleHref(config, route.file, "build", {
+    conditionTarget: serverBundleTargetForRuntime(route.segmentConfig?.runtime)
+  });
+}
+async function createRequestHandler(options = {}) {
+  const config = options.config ?? await loadConfig(options.root, { serve: true });
+  await bootstrapCompat(config);
+  const manifestPath = path2.join(config.outPath, "manifest.json");
+  const manifest = resolveManifest(
+    options.manifest ?? JSON.parse(await readFile(manifestPath, "utf8")),
+    config.outPath,
+    config.root
+  );
+  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);
+  setRequestRuntime({ config, routes: manifest.routes, dev: false });
+  const proxyRunner = createProxyRunner(config, {
+    compiledModuleHref: manifest.proxyModule ? pathToFileHref(path2.resolve(config.outPath, manifest.proxyModule)) : void 0
+  });
+  const routesById = new Map(manifest.routes.map((route) => [route.id, route]));
+  const nextCompat = Boolean(config.compat?.next);
+  const regenerating = /* @__PURE__ */ 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 () => {
+      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");
+          registerServerRuntime(config, route.sourceFiles);
+          const href = compatModuleMode(config) ? await moduleHrefForRoute(config, route) : pathToFileHref(route.file);
+          const module = await importModuleOnce(href);
+          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) {
+    void runRegeneration(pathname, file, relative, metadata, "stale");
+  }
+  setRequestExtensions({
+    onDemandRevalidatePath: async (pathname) => {
+      const built = await builtFileInfo(config.outPath, pathname, manifest.staticFiles);
+      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
+    );
+    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
+    );
+  }
+  stopEsbuildService();
+  return function handleRequest(request, server) {
+    return runWithWorkUnit("render", async () => {
+      const unit = getWorkUnit();
+      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 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 canonicalUrl = new URL(request.url);
+    const canonicalHeaders = request.headers;
+    let proxyResponse;
+    const proxyResult = revalidateBypass ? void 0 : 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 canonicalRedirect = trailingSlashRedirect(config, requestedUrl, method);
+    if (canonicalRedirect) return applyProxyResponse(canonicalRedirect, proxyResponse);
+    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) : null;
+    const hardStaticStale = built !== null && // Content-hashed build assets are immutable and are never route outputs, so a
+    // revalidatePath/revalidateTag must not mark them stale. Without this,
+    // revalidatePath('/', 'layout') - whose pattern matches EVERY path - would flag the client entry
+    // script as stale, drop it from static serving, and leave the browser without the router
+    // runtime, silently downgrading every soft navigation to a hard one.
+    !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" : void 0;
+    const softStale = staleReason === "soft";
+    const staleOnDemand = hardStaticStale && !softStale;
+    const hardExpired = built?.metadata?.expireSeconds !== void 0 && isHtmlPageFile(built.file) && Date.now() - built.mtimeMs >= built.metadata.expireSeconds * 1e3;
+    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) : void 0;
+      if (route?.segmentConfig?.runtime === "edge" || route?.segmentConfig?.runtime === "experimental-edge") {
+        withRouteRuntime(route.segmentConfig.runtime, () => void 0);
+      }
+      const staticFile = await maybeBuiltFile(
+        config.outPath,
+        url.pathname,
+        manifest.staticFiles,
+        request.method,
+        request.headers,
+        nextCompat
+      );
+      if (staticFile && !(draftBypass && isHtmlResponse(staticFile))) {
+        const staticMode = servedBuilt.metadata?.revalidateSeconds !== void 0 ? "isr" : "static";
+        setWorkUnitRoute(
+          isHtmlResponse(staticFile) ? "html" : "static-asset",
+          staticMode,
+          servedBuilt.metadata?.revalidateSeconds !== void 0 ? { revalidateSeconds: servedBuilt.metadata.revalidateSeconds } : void 0
+        );
+        if (isHtmlResponse(staticFile) && !hasBuildCapturedCacheControl(servedBuilt.metadata)) {
+          staticFile.headers.delete("cache-control");
+        }
+        if (servedBuilt.metadata) {
+          const servedTtl = servedBuilt.metadata.revalidateSeconds;
+          const expired = softStale || servedTtl !== void 0 && Date.now() - servedBuilt.mtimeMs >= servedTtl * 1e3;
+          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, 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 && // force-dynamic / revalidate 0 opt the handler out of static output:
+      // every request must re-run it (generateSitemaps + force-dynamic must
+      // produce a fresh sitemap per request — dynamic-in-generate-params).
+      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(path2.dirname(file), { recursive: true });
+          await writeFile(file, new Uint8Array(await handlerResponse.clone().arrayBuffer()));
+          const relative = path2.relative(path2.join(config.outPath, "public"), file).split(path2.sep).join("/");
+          const routeRevalidate = matched.route.segmentConfig?.revalidate;
+          const revalidateSeconds = typeof routeRevalidate === "number" && routeRevalidate > 0 ? renderedHandler.revalidateSeconds === void 0 ? 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 !== void 0 ? { 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" : void 0;
+    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 : void 0);
+    const renderWasDynamic = matched.route.mode === "dynamic" || matched.route.usesRequest || renderedPage.noStore === true;
+    if (renderRevalidateSeconds !== void 0 && 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" && // A request that can promote a fallback shell into a more specific route
+    // shell must keep re-entering the renderer: caching its first (still
+    // un-upgraded) render on disk would serve every later request as a HIT
+    // and the upgraded shell would never reach the client.
+    !isPprShellUpgradeEligible(config, matched.route, url) && (forceStaticRoute || !matched.route.usesRequest && // Next never statically caches `runtime = 'edge'` pages (they are
+    // excluded from build prerendering too — see build.ts); their data
+    // stability comes from the fetch cache alone.
+    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(path2.dirname(file), { recursive: true });
+        await writeFile(file, await pageResponse.clone().text());
+        const relative = path2.relative(path2.join(config.outPath, "public"), file).split(path2.sep).join("/");
+        manifest.staticFiles ??= {};
+        manifest.staticFiles[relative] = {
+          status: 200,
+          // Persist the cacheLife SWR headers (and the route's prerendered
+          // Link header) so later static HITs (served by maybeBuiltFile
+          // straight off disk) re-emit them without a render.
+          headers: [
+            ...matched.route.linkHeader ? [["link", matched.route.linkHeader]] : [],
+            ...cacheLifeHeaders
+          ],
+          routeId: matched.route.id,
+          kind: "page",
+          ...renderedPage.revalidateSeconds !== void 0 ? { revalidateSeconds: renderedPage.revalidateSeconds } : {},
+          ...matched.route.cacheLife?.expireSeconds !== void 0 ? { expireSeconds: matched.route.cacheLife.expireSeconds } : {},
+          ...matched.route.cacheLife?.staleSeconds !== void 0 ? { 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 void 0;
+}
+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;
+}
+function compatModuleMode(config) {
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+}
+async function handleRoute(config, route, request, params) {
+  return withRouteRuntime(route.segmentConfig?.runtime, async () => {
+    registerServerRuntime(config, route.sourceFiles);
+    const spans = getRenderSpanExtensions();
+    const module = await spans.withFindPageComponentsSpan(route.route, async () => {
+      const href = compatModuleMode(config) ? await moduleHrefForRoute(config, route) : new URL(`file://${route.file}`).href;
+      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 void 0;
+  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) {
+  const file = await firstFile(
+    path2.join(outPath, "public"),
+    builtFileCandidates(outPath, pathname, nextStaticFallback)
+  );
+  if (!file) return null;
+  const publicPath = path2.join(outPath, "public");
+  const fileStat = await stat(file);
+  const relative = path2.relative(publicPath, file).split(path2.sep).join("/");
+  return { file, relative, mtimeMs: fileStat.mtimeMs, metadata: staticFiles[relative] };
+}
+function builtFileCandidates(outPath, pathname, nextStaticFallback = false) {
+  const publicPath = path2.join(outPath, "public");
+  const trimmed = pathname.replace(/^\/+/, "");
+  if (pathname === "/") return [path2.join(publicPath, "index.html")];
+  const candidates = [
+    path2.join(publicPath, trimmed, "index.html"),
+    path2.join(publicPath, trimmed),
+    path2.join(publicPath, `${trimmed.replace(/\/+$/, "")}.html`)
+  ];
+  try {
+    const decoded = decodeURIComponent(trimmed);
+    if (decoded !== trimmed && !decoded.split("/").some((seg) => seg === ".." || seg === "")) {
+      candidates.push(
+        path2.join(publicPath, decoded, "index.html"),
+        path2.join(publicPath, `${decoded.replace(/\/+$/, "")}.html`)
+      );
+    }
+  } catch {
+  }
+  if (nextStaticFallback && trimmed.startsWith("_next/static/")) {
+    const asset = trimmed.slice("_next/static/".length);
+    candidates.push(path2.join(publicPath, "assets", asset));
+  }
+  return candidates;
+}
+function lazyStaticHtmlPath(outPath, pathname) {
+  const publicPath = path2.join(outPath, "public");
+  const file = pathname === "/" ? path2.join(publicPath, "index.html") : path2.join(publicPath, pathname.replace(/^\/+|\/+$/g, ""), "index.html");
+  const relative = path2.relative(publicPath, file);
+  if (relative.startsWith("..") || path2.isAbsolute(relative)) return null;
+  return file;
+}
+function lazyStaticHandlerPath(outPath, pathname) {
+  if (pathname === "/") return null;
+  const publicPath = path2.join(outPath, "public");
+  const file = path2.join(publicPath, pathname.replace(/^\/+|\/+$/g, ""));
+  const relative = path2.relative(publicPath, file);
+  if (relative.startsWith("..") || path2.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 !== void 0 && expireSeconds !== void 0) {
+    const swr = Math.max(0, expireSeconds - revalidateSeconds);
+    headers.push(["cache-control", `s-maxage=${revalidateSeconds}, stale-while-revalidate=${swr}`]);
+  }
+  if (staleSeconds !== void 0) 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 === void 0 || b === void 0) 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) {
+  const normalizedMethod = method.toUpperCase();
+  if (normalizedMethod !== "GET" && normalizedMethod !== "HEAD") return null;
+  const publicPath = path2.join(outPath, "public");
+  const file = await firstFile(
+    publicPath,
+    builtFileCandidates(outPath, pathname, nextStaticFallback)
+  );
+  if (!file) return null;
+  const relative = path2.relative(publicPath, file).split(path2.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")) {
+    headers.set("cache-control", immutableAssetPath(relative) ? 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();
+  void (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(() => void 0);
+    }
+  })();
+  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 = /* @__PURE__ */ 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 !== void 0) gzipCache.delete(oldest);
+  }
+  gzipCache.set(key, zipped);
+  return zipped;
+}
+var immutableCacheControl = "public, max-age=31536000, immutable";
+function immutableAssetPath(relativePath) {
+  return immutableAssetPrefixes().some((prefix) => relativePath.startsWith(prefix));
+}
+function immutableAssetPrefixes() {
+  return [
+    "assets/",
+    "_next/static/",
+    ...getAssetExtensions().staticAssetPublicPrefixes().map((prefix) => prefix.replace(/^\/+/, ""))
+  ];
+}
+async function firstFile(root, files) {
+  for (const file of files) {
+    if (!isInside(root, file)) continue;
+    if (!existsSync(file)) continue;
+    if ((await stat(file)).isFile()) return file;
+  }
+  return null;
+}
+function isInside(root, file) {
+  const relative = path2.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+export {
+  compressResponse,
+  createRequestHandler,
+  immutableAssetPath,
+  immutableAssetPrefixes,
+  immutableCacheControl,
+  maybeBuiltFile
+};