@wular/coder 0.4.0 → 0.4.2

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

@@ -1,961 +0,0 @@
-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
-};