@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-4q2gbfwk.js

@@ -0,0 +1,2530 @@
+// @bun
+import {
+  coerceString,
+  settledPromise,
+  staticMetadataForPathFromFiles
+} from "./index-3tf1xjsp.js";
+import {
+  RSC_CONTENT_TYPE_HEADER
+} from "./index-stbk3jhn.js";
+import {
+  createVaryingParams,
+  createVaryingSearchParams,
+  getMetadataVaryParamsAccumulator,
+  varyNamesFor,
+  varyTrackingInfo
+} from "./index-x0y005nh.js";
+import {
+  readSourceSync,
+  readSourceText
+} from "./index-fp8r0sqs.js";
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+import {
+  getWorkUnit,
+  legacyRequestAPIs,
+  queueAfterTask
+} from "./index-grta8ap3.js";
+import {
+  extraPageExtensions
+} from "./index-zqpqyg8p.js";
+import {
+  stripComments
+} from "./index-qjj6gddn.js";
+
+// src/compat/otel/api.ts
+import { createRequire } from "module";
+import path from "path";
+var resolved;
+function getOtelApi(appRoot) {
+  if (resolved !== undefined)
+    return resolved;
+  resolved = null;
+  try {
+    const req = createRequire(path.join(appRoot, "package.json"));
+    const api = req("@opentelemetry/api");
+    if (api?.trace && api.context)
+      resolved = api;
+  } catch {
+    resolved = null;
+  }
+  return resolved;
+}
+
+// src/compat/otel/tracer.ts
+var SPAN_TYPE = {
+  handleRequest: "BaseServer.handleRequest",
+  getBodyResult: "AppRender.getBodyResult",
+  fetch: "AppRender.fetch",
+  runHandler: "AppRouteRouteHandlers.runHandler",
+  generateMetadata: "ResolveMetadata.generateMetadata",
+  createComponentTree: "NextNodeServer.createComponentTree",
+  getLayoutOrPageModule: "NextNodeServer.getLayoutOrPageModule",
+  findPageComponents: "NextNodeServer.findPageComponents",
+  startResponse: "NextNodeServer.startResponse",
+  clientComponentLoading: "NextNodeServer.clientComponentLoading",
+  middleware: "Middleware.execute",
+  getRequestHandler: "NextServer.getRequestHandler",
+  nodeRunHandler: "Node.runHandler",
+  renderDocument: "Render.renderDocument",
+  getServerSideProps: "Render.getServerSideProps",
+  getStaticProps: "Render.getStaticProps"
+};
+var EDGE_SANDBOX_SPAN_TYPES = new Set([
+  SPAN_TYPE.getBodyResult,
+  SPAN_TYPE.createComponentTree,
+  SPAN_TYPE.getLayoutOrPageModule,
+  SPAN_TYPE.generateMetadata,
+  SPAN_TYPE.fetch,
+  SPAN_TYPE.renderDocument,
+  SPAN_TYPE.getServerSideProps,
+  SPAN_TYPE.getStaticProps
+]);
+var OTEL_STATE = Symbol.for("pnext.compat.otel.state");
+function childRuntime(state, spanType) {
+  return state.edgeMode === "page" && EDGE_SANDBOX_SPAN_TYPES.has(spanType) ? "edge" : "nodejs";
+}
+var cachedAppRoot;
+var spanEndDepth = 0;
+function setOtelAppRoot(root) {
+  cachedAppRoot = root;
+}
+function api() {
+  return cachedAppRoot ? getOtelApi(cachedAppRoot) : null;
+}
+function stateOf(unit) {
+  return unit?.compat?.[OTEL_STATE];
+}
+function startRootSpan(input) {
+  const a = api();
+  if (!a)
+    return;
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  unit.compat ??= {};
+  if (unit.compat[OTEL_STATE])
+    return;
+  const carrier = {};
+  input.headers.forEach((value, key) => {
+    carrier[key] = value;
+  });
+  const incomingContext = a.propagation.extract(a.context.active(), carrier, headerGetter);
+  const spanName = `${input.rsc ? "RSC " : ""}${input.method} ${input.target}`;
+  const tracer = a.trace.getTracer("next.js", "0.0.1");
+  let verboseSpan;
+  let rootParentCtx = incomingContext;
+  if (process.env.NEXT_OTEL_VERBOSE === "1") {
+    verboseSpan = tracer.startSpan(SPAN_TYPE.getRequestHandler, {
+      kind: a.SpanKind.INTERNAL,
+      attributes: {
+        "next.span_name": SPAN_TYPE.getRequestHandler,
+        "next.span_type": SPAN_TYPE.getRequestHandler
+      }
+    }, incomingContext);
+    rootParentCtx = a.trace.setSpan(incomingContext, verboseSpan);
+  }
+  const rootSpan = tracer.startSpan(spanName, {
+    kind: a.SpanKind.SERVER,
+    attributes: {
+      "http.method": input.method,
+      "http.target": input.target,
+      "next.rsc": input.rsc,
+      "next.span_name": spanName,
+      "next.span_type": SPAN_TYPE.handleRequest
+    }
+  }, rootParentCtx);
+  const rootContext = a.trace.setSpan(rootParentCtx, rootSpan);
+  const state = {
+    api: a,
+    rootContext,
+    rootSpan,
+    rootEnded: false,
+    method: input.method,
+    rsc: input.rsc,
+    target: input.target,
+    incomingContext,
+    ...verboseSpan ? { verboseSpan } : {},
+    currentContext: rootContext
+  };
+  unit.compat[OTEL_STATE] = state;
+}
+function setRootSpanRoute(route, options = {}) {
+  const state = stateOf(getWorkUnit());
+  if (!state)
+    return;
+  state.route = route;
+  const { rootSpan } = state;
+  const name = `${state.rsc ? "RSC " : ""}${state.method} ${route}`;
+  rootSpan.setAttribute("next.route", route);
+  rootSpan.setAttribute("http.route", route);
+  rootSpan.setAttribute("next.span_name", name);
+  rootSpan.updateName(name);
+  if (!options.edge)
+    return;
+  state.edgeMode = options.kind === "handler" ? "handler" : "page";
+  if (state.edgeMode !== "page")
+    return;
+  const [pathname = "", search = ""] = splitTarget(state.target);
+  const query = new URLSearchParams(search);
+  for (const [key, value] of Object.entries(options.params ?? {})) {
+    if (Array.isArray(value))
+      query.set(key, value.join("/"));
+    else
+      query.set(key, value);
+  }
+  const queryText = query.toString();
+  if (queryText) {
+    rootSpan.setAttribute("http.target", `${pathname}?${queryText}`);
+  }
+}
+function splitTarget(target) {
+  const index = target.indexOf("?");
+  return index === -1 ? [target, ""] : [target.slice(0, index), target.slice(index + 1)];
+}
+function endRootSpan(status) {
+  const state = stateOf(getWorkUnit());
+  if (!state || state.rootEnded)
+    return;
+  state.rootEnded = true;
+  const { api: a, rootSpan } = state;
+  rootSpan.setAttribute("http.status_code", status);
+  if (status >= 500) {
+    rootSpan.setAttribute("error.type", String(status));
+    rootSpan.setStatus({ code: a.SpanStatusCode.ERROR });
+  } else {
+    rootSpan.setStatus({ code: a.SpanStatusCode.UNSET });
+  }
+  endSpan(rootSpan, state.edgeMode === "page" ? "edge" : "nodejs");
+  if (state.verboseSpan) {
+    state.verboseSpan.setStatus({ code: a.SpanStatusCode.UNSET });
+    endSpan(state.verboseSpan, "nodejs");
+  }
+}
+function endRootSpanIfUnclosed(fallbackStatus) {
+  const state = stateOf(getWorkUnit());
+  if (!state || state.rootEnded)
+    return;
+  endRootSpan(fallbackStatus);
+}
+function rootOtelContext() {
+  const state = stateOf(getWorkUnit());
+  if (!state)
+    return;
+  return { api: state.api, context: state.rootContext };
+}
+function activeOtelContext() {
+  const state = stateOf(getWorkUnit());
+  if (!state)
+    return;
+  return { api: state.api, context: state.api.context.active() };
+}
+function withChildSpan(name, spanType, attributes, fn, options = {}) {
+  const state = stateOf(getWorkUnit());
+  if (!state)
+    return fn();
+  const { api: a } = state;
+  const parentContext = state.currentContext;
+  const tracer = a.trace.getTracer("next.js", "0.0.1");
+  const span = tracer.startSpan(name, {
+    kind: options.kind ?? a.SpanKind.INTERNAL,
+    attributes: {
+      ...attributes,
+      "next.span_name": name,
+      "next.span_type": spanType
+    }
+  }, parentContext);
+  const childContext = a.trace.setSpan(parentContext, span);
+  state.currentContext = childContext;
+  const settle = (error) => {
+    state.currentContext = parentContext;
+    if (error !== undefined) {
+      if (options.onError)
+        options.onError(span, error);
+      else {
+        span.recordException(error);
+        span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) });
+      }
+    } else {
+      span.setStatus({ code: a.SpanStatusCode.UNSET });
+    }
+    endSpan(span, childRuntime(state, spanType));
+  };
+  try {
+    const result = a.context.with(childContext, fn);
+    if (isThenable(result)) {
+      return result.then((value) => {
+        settle();
+        return value;
+      }, (error) => {
+        settle(error);
+        throw error;
+      });
+    }
+    settle();
+    return result;
+  } catch (error) {
+    settle(error);
+    throw error;
+  }
+}
+function withRenderBodySpan(name, route, fn, spanType = SPAN_TYPE.getBodyResult) {
+  const state = stateOf(getWorkUnit());
+  if (!state)
+    return fn();
+  const { api: a } = state;
+  const parentContext = state.currentContext;
+  const tracer = a.trace.getTracer("next.js", "0.0.1");
+  const span = tracer.startSpan(name, {
+    kind: a.SpanKind.INTERNAL,
+    attributes: {
+      "next.route": route,
+      "next.span_name": name,
+      "next.span_type": spanType
+    }
+  }, parentContext);
+  const spanContext = a.trace.setSpan(parentContext, span);
+  const previousRenderSpan = state.renderSpan;
+  state.renderSpan = { span, parentContext, spanContext, ended: false, spanType };
+  state.currentContext = spanContext;
+  const finish = (error) => {
+    const current = state.renderSpan;
+    if (current?.span !== span || current.ended)
+      return;
+    current.ended = true;
+    endComponentTreeSpan(state);
+    if (current.discarded) {
+      state.renderSpan = previousRenderSpan;
+      if (state.currentContext === spanContext)
+        state.currentContext = parentContext;
+      return;
+    }
+    if (error !== undefined)
+      markSpanError(a, span, error);
+    else if (!current.errored && span.isRecording()) {
+      span.setStatus({ code: a.SpanStatusCode.UNSET });
+    }
+    endSpan(span, childRuntime(state, spanType));
+    state.renderSpan = previousRenderSpan;
+    if (state.currentContext === spanContext)
+      state.currentContext = parentContext;
+  };
+  const queued = queueAfterTask(() => finish());
+  try {
+    const result = a.context.with(spanContext, fn);
+    if (isThenable(result)) {
+      return result.then((value) => {
+        if (!queued)
+          finish();
+        return value;
+      }, (error) => {
+        finish(error);
+        throw error;
+      });
+    }
+    if (!queued)
+      finish();
+    return result;
+  } catch (error) {
+    finish(error);
+    throw error;
+  }
+}
+function markRenderSpanError(error) {
+  const state = stateOf(getWorkUnit());
+  const render = state?.renderSpan;
+  if (!state || !render || render.ended)
+    return;
+  render.errored = true;
+  markSpanError(state.api, render.span, error);
+}
+function withRouteHandlerSpan(route, fn) {
+  return runHandlerSpan(`executing api route (app) ${route}`, SPAN_TYPE.runHandler, { "next.route": route }, fn);
+}
+function runHandlerSpan(name, spanType, attributes, fn) {
+  const state = stateOf(getWorkUnit());
+  if (!state)
+    return fn();
+  const { api: a } = state;
+  const edge = state.edgeMode === "handler";
+  const parentContext = edge ? state.incomingContext : state.currentContext;
+  const tracer = a.trace.getTracer("next.js", "0.0.1");
+  const span = tracer.startSpan(name, {
+    kind: a.SpanKind.INTERNAL,
+    attributes: {
+      ...attributes,
+      "next.span_name": name,
+      "next.span_type": spanType
+    }
+  }, parentContext);
+  const spanContext = a.trace.setSpan(parentContext, span);
+  const previousContext = state.currentContext;
+  state.currentContext = spanContext;
+  const settle = (error) => {
+    state.currentContext = previousContext;
+    if (error !== undefined) {
+      span.recordException(error);
+      span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) });
+    } else {
+      span.setStatus({ code: a.SpanStatusCode.UNSET });
+    }
+    endSpan(span, edge ? "edge" : "nodejs");
+  };
+  try {
+    const result = a.context.with(spanContext, fn);
+    if (isThenable(result)) {
+      return result.then((value) => {
+        settle();
+        return value;
+      }, (error) => {
+        settle(error);
+        throw error;
+      });
+    }
+    settle();
+    return result;
+  } catch (error) {
+    settle(error);
+    throw error;
+  }
+}
+function withPagesApiHandlerSpan(route, fn) {
+  const state = stateOf(getWorkUnit());
+  if (state)
+    state.pagesApi = true;
+  const name = `executing api route (pages) ${route}`;
+  return runHandlerSpan(name, SPAN_TYPE.nodeRunHandler, {}, fn);
+}
+function withPagesDataSpan(kind, fn) {
+  const state = stateOf(getWorkUnit());
+  const route = state?.route;
+  if (!state || !route)
+    return fn();
+  const { api: a } = state;
+  const spanType = kind === "getServerSideProps" ? SPAN_TYPE.getServerSideProps : SPAN_TYPE.getStaticProps;
+  const name = `${kind} ${route}`;
+  const span = a.trace.getTracer("next.js", "0.0.1").startSpan(name, {
+    kind: a.SpanKind.INTERNAL,
+    attributes: {
+      "next.route": route,
+      "next.span_name": name,
+      "next.span_type": spanType
+    }
+  }, state.rootContext);
+  const settle = (error, result) => {
+    if (error !== undefined) {
+      markSpanError(a, span, error);
+      emitPagesErrorFallbackSpans(state, route);
+    } else {
+      span.setStatus({ code: a.SpanStatusCode.UNSET });
+      if (result?.notFound) {
+        emitPagesNotFoundFallbackSpans(state, route);
+      }
+    }
+    endSpan(span, childRuntime(state, spanType));
+  };
+  try {
+    const result = fn();
+    if (isThenable(result)) {
+      return result.then((value) => {
+        settle(undefined, value);
+        return value;
+      }, (error) => {
+        settle(error ?? new Error("getServerSideProps error"), undefined);
+        throw error;
+      });
+    }
+    settle(undefined, result);
+    return result;
+  } catch (error) {
+    settle(error ?? new Error("getServerSideProps error"), undefined);
+    throw error;
+  }
+}
+function emitRootLeafSpan(state, name, spanType, attributes) {
+  const { api: a } = state;
+  const span = a.trace.getTracer("next.js", "0.0.1").startSpan(name, {
+    kind: a.SpanKind.INTERNAL,
+    attributes: {
+      ...attributes,
+      "next.span_name": name,
+      "next.span_type": spanType
+    }
+  }, state.rootContext);
+  span.setStatus({ code: a.SpanStatusCode.UNSET });
+  endSpan(span, "nodejs");
+}
+function discardRenderSpan(state) {
+  state.pagesFallback = true;
+  if (state.renderSpan && !state.renderSpan.ended)
+    state.renderSpan.discarded = true;
+}
+function emitPagesErrorFallbackSpans(state, _route) {
+  discardRenderSpan(state);
+  emitRootLeafSpan(state, "render route (pages) /_error", SPAN_TYPE.renderDocument, {
+    "next.route": "/_error"
+  });
+  emitRootLeafSpan(state, "resolve page components", SPAN_TYPE.findPageComponents, {
+    "next.route": "/_error"
+  });
+  for (let i = 0;i < 2; i += 1) {
+    emitRootLeafSpan(state, "resolve page components", SPAN_TYPE.findPageComponents, {
+      "next.route": "/500"
+    });
+  }
+}
+function emitPagesNotFoundFallbackSpans(state, _route) {
+  discardRenderSpan(state);
+  emitRootLeafSpan(state, "resolve page components", SPAN_TYPE.findPageComponents, {
+    "next.route": "/_not-found"
+  });
+}
+function emitStartResponseSpan() {
+  const state = stateOf(getWorkUnit());
+  if (state?.pagesFallback || state?.pagesApi)
+    return;
+  emitNodeLeafSpan("start response", SPAN_TYPE.startResponse, {});
+}
+function emitClientComponentLoadingSpan(count) {
+  const state = stateOf(getWorkUnit());
+  if (!state?.renderSpan || state.renderSpan.ended)
+    return;
+  emitNodeLeafSpan(SPAN_TYPE.clientComponentLoading, SPAN_TYPE.clientComponentLoading, {
+    "next.clientComponentLoadCount": count
+  });
+}
+function emitNodeLeafSpan(name, spanType, attributes) {
+  const state = stateOf(getWorkUnit());
+  if (!state)
+    return;
+  const { api: a } = state;
+  const render = state.renderSpan;
+  const parentContext = render && !render.ended ? render.spanContext : state.rootContext;
+  const span = a.trace.getTracer("next.js", "0.0.1").startSpan(name, {
+    kind: a.SpanKind.INTERNAL,
+    attributes: {
+      ...attributes,
+      "next.span_name": name,
+      "next.span_type": spanType
+    }
+  }, parentContext);
+  span.setStatus({ code: a.SpanStatusCode.UNSET });
+  endSpan(span, "nodejs");
+}
+function withMiddlewareSpan(request, fn) {
+  const a = api();
+  if (!a)
+    return fn();
+  const method = request.method.toUpperCase();
+  let target = "";
+  try {
+    const url = new URL(request.url);
+    target = url.pathname + url.search;
+  } catch {
+    target = request.url;
+  }
+  const carrier = {};
+  request.headers.forEach((value, key) => {
+    carrier[key] = value;
+  });
+  const parentCtx = a.propagation.extract(a.context.active(), carrier, headerGetter);
+  const name = `middleware ${method}`;
+  const tracer = a.trace.getTracer("next.js", "0.0.1");
+  const span = tracer.startSpan(name, {
+    attributes: {
+      "http.method": method,
+      "http.target": target,
+      "next.span_name": name,
+      "next.span_type": SPAN_TYPE.middleware
+    }
+  }, parentCtx);
+  const spanCtx = a.trace.setSpan(parentCtx, span);
+  const settle = (error) => {
+    if (error !== undefined) {
+      span.recordException(error);
+      span.setStatus({ code: a.SpanStatusCode.ERROR, message: errorMessage(error) });
+    } else {
+      span.setStatus({ code: a.SpanStatusCode.UNSET });
+    }
+    endSpan(span, "edge");
+  };
+  try {
+    const result = a.context.with(spanCtx, fn);
+    if (isThenable(result)) {
+      return result.then((value) => {
+        settle();
+        return value;
+      }, (error) => {
+        settle(error);
+        throw error;
+      });
+    }
+    settle();
+    return result;
+  } catch (error) {
+    settle(error);
+    throw error;
+  }
+}
+function emitLeafSpan(name, spanType, attributes, kind) {
+  if (spanType === SPAN_TYPE.getLayoutOrPageModule) {
+    emitSegmentSpan(name, spanType, attributes, kind);
+    return;
+  }
+  withChildSpan(name, spanType, attributes, () => {
+    return;
+  }, kind !== undefined ? { kind } : {});
+}
+function emitSegmentSpan(name, spanType, attributes, kind) {
+  const state = stateOf(getWorkUnit());
+  if (state?.pagesFallback)
+    return;
+  if (!state?.renderSpan || state.renderSpan.ended) {
+    withChildSpan(name, spanType, attributes, () => {
+      return;
+    }, kind !== undefined ? { kind } : {});
+    return;
+  }
+  const tree = ensureComponentTreeSpan(state);
+  const previous = state.currentContext;
+  state.currentContext = tree.spanContext;
+  try {
+    withChildSpan(name, spanType, attributes, () => {
+      return;
+    }, kind !== undefined ? { kind } : {});
+  } finally {
+    state.currentContext = previous;
+  }
+}
+function ensureComponentTreeSpan(state) {
+  const current = state.componentTreeSpan;
+  if (current && !current.ended)
+    return current;
+  const { api: a } = state;
+  const parentContext = state.renderSpan?.spanContext ?? state.currentContext;
+  const name = "build component tree";
+  const span = a.trace.getTracer("next.js", "0.0.1").startSpan(name, {
+    kind: a.SpanKind.INTERNAL,
+    attributes: {
+      "next.span_name": name,
+      "next.span_type": SPAN_TYPE.createComponentTree
+    }
+  }, parentContext);
+  const spanContext = a.trace.setSpan(parentContext, span);
+  const next = { span, parentContext, spanContext, ended: false };
+  state.componentTreeSpan = next;
+  return next;
+}
+function endComponentTreeSpan(state) {
+  const tree = state.componentTreeSpan;
+  if (!tree || tree.ended)
+    return;
+  tree.ended = true;
+  tree.span.setStatus({ code: state.api.SpanStatusCode.UNSET });
+  endSpan(tree.span, childRuntime(state, SPAN_TYPE.createComponentTree));
+  if (state.currentContext === tree.spanContext)
+    state.currentContext = tree.parentContext;
+}
+var headerGetter = {
+  keys(carrier) {
+    return Object.keys(carrier);
+  },
+  get(carrier, key) {
+    return carrier[key.toLowerCase()] ?? carrier[key];
+  }
+};
+var carrierSetter = {
+  set(carrier, key, value) {
+    carrier[key] = value;
+  }
+};
+function errorMessage(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function markSpanError(api2, span, error) {
+  span.setAttribute("error.type", error instanceof Error ? error.name : typeof error);
+  span.recordException(error);
+  span.setStatus({ code: api2.SpanStatusCode.ERROR, message: errorMessage(error) });
+}
+function otelExportInProgress() {
+  return spanEndDepth > 0;
+}
+function endSpan(span, runtime) {
+  spanEndDepth++;
+  const previousRuntime = process.env.NEXT_RUNTIME;
+  if (runtime)
+    process.env.NEXT_RUNTIME = runtime;
+  try {
+    span.end();
+  } finally {
+    if (runtime) {
+      if (previousRuntime === undefined)
+        delete process.env.NEXT_RUNTIME;
+      else
+        process.env.NEXT_RUNTIME = previousRuntime;
+    }
+    spanEndDepth--;
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+
+// src/compat/metadata.ts
+async function readNextModuleMetadata(module, props, parent, modulePath) {
+  if (typeof module.generateMetadata === "function") {
+    const generate = module.generateMetadata;
+    const headProps = headVaryTrackedProps(props);
+    const run = () => generate({ params: headProps.params, searchParams: headProps.searchParams }, Promise.resolve(resolvedParentMetadata(parent)));
+    const name = metadataSpanName(modulePath);
+    return await (name ? withChildSpan(name, SPAN_TYPE.generateMetadata, { "next.page": name.slice("generateMetadata ".length) }, run) : run());
+  }
+  return module.metadata;
+}
+function metadataSpanName(modulePath) {
+  if (!modulePath)
+    return;
+  const normalized = modulePath.replace(/\\/g, "/").replace(/\.[cm]?[jt]sx?$/, "");
+  const idx = normalized.lastIndexOf("/app/");
+  const rel = idx >= 0 ? normalized.slice(idx) : `/${normalized.replace(/^\/+/, "")}`;
+  return `generateMetadata ${rel}`;
+}
+async function readNextModuleViewport(module, props) {
+  if (typeof module.generateViewport === "function") {
+    const headProps = headVaryTrackedProps(props);
+    return module.generateViewport({
+      params: headProps.params,
+      searchParams: headProps.searchParams
+    });
+  }
+  return module.viewport;
+}
+function headVaryTrackedProps(props) {
+  const head = getMetadataVaryParamsAccumulator();
+  if (!head)
+    return { params: props.params, searchParams: props.searchParams };
+  return {
+    params: retrackSettled(props.params, (raw, info) => createVaryingParams(head, raw, info.optionalCatchAllParam)),
+    searchParams: retrackSettled(props.searchParams, (raw) => createVaryingSearchParams(head, raw))
+  };
+}
+function retrackSettled(promise, wrap) {
+  const settled = promise;
+  if (settled.status !== "fulfilled" || settled.value === undefined)
+    return promise;
+  const info = varyTrackingInfo(settled.value);
+  if (!info)
+    return promise;
+  return settledPromise(wrap(info.raw, info));
+}
+function hasRuntimeMetadata(module) {
+  return typeof module.generateMetadata === "function";
+}
+function shouldRenderMetadataInBody({
+  config,
+  request
+}) {
+  const userAgent = request?.headers.get("user-agent") ?? "";
+  const limitedBot = config.htmlLimitedBots ?? /Twitterbot|Slackbot|Bingbot|Discordbot|LinkedInBot|Google-PageRenderer|Chrome-Lighthouse|Lighthouse/i;
+  return !limitedBot.test(userAgent);
+}
+function resolvedParentMetadata(parent) {
+  return {
+    ...parent,
+    metadataBase: parent.metadataBase === undefined ? undefined : coerceString(parent.metadataBase),
+    keywords: normalizeKeywordList(parent.keywords),
+    openGraph: resolvedParentOpenGraph(parent.openGraph),
+    twitter: parent.twitter ?? {},
+    robots: parent.robots ?? {},
+    alternates: parent.alternates ?? {},
+    icons: parent.icons ?? {}
+  };
+}
+function resolvedParentOpenGraph(openGraph) {
+  if (!openGraph)
+    return {};
+  return {
+    ...openGraph,
+    title: openGraph.title === undefined || typeof openGraph.title === "object" && openGraph.title !== null ? openGraph.title : { absolute: coerceString(openGraph.title) },
+    images: openGraph.images === undefined ? [] : Array.isArray(openGraph.images) ? openGraph.images : [openGraph.images]
+  };
+}
+function normalizeKeywordList(value) {
+  if (value === undefined || value === null)
+    return;
+  return Array.isArray(value) ? value : [value];
+}
+async function warnNextMetadataBuildIssues(appPath, routes, staticMetadataFiles) {
+  const warned = new Set;
+  const facts = new Map;
+  const factsFor = async (file) => {
+    let cached = facts.get(file);
+    if (!cached) {
+      cached = metadataSourceFacts(await readSourceTextOrEmpty(file));
+      facts.set(file, cached);
+    }
+    return cached;
+  };
+  for (const route of routes) {
+    if (route.kind !== "page")
+      continue;
+    const routeFacts = await Promise.all(routeSourceFiles(appPath, route).map(factsFor));
+    const some = (pick) => routeFacts.some(pick);
+    if (!legacyRequestAPIs() && some((fact) => fact.themeColor)) {
+      warnOnce(warned, `themeColor:${route.route}`, `Unsupported metadata themeColor is configured in metadata export in ${route.route || "/"}. Please move it to viewport
+Read more: https://nextjs.org/docs/app/api-reference/functions/generate-viewport`);
+    }
+    if (some((fact) => fact.appleTouchFullscreen)) {
+      warnOnce(warned, "apple-touch-fullscreen", "Unsupported metadata other.apple-touch-fullscreen is configured in metadata export. Use appleWebApp instead.");
+    }
+    if (some((fact) => fact.appleTouchIconPrecomposed)) {
+      warnOnce(warned, "apple-touch-icon-precomposed", "Unsupported metadata other.apple-touch-icon-precomposed is configured in metadata export. Use icons.apple instead.");
+    }
+    if (!some((fact) => fact.metadataBase) && routeUsesRelativeSocialImage(route, routeFacts, staticMetadataFiles)) {
+      warnOnce(warned, "metadataBase", 'metadataBase property in metadata export is not set for resolving social open graph or twitter images, using "http://localhost:3000". See https://nextjs.org/docs/app/api-reference/functions/generate-metadata#metadatabase');
+    }
+  }
+}
+function routeSourceFiles(appPath, route) {
+  const root = `${appPath}/`;
+  return route.sourceFiles.filter((file) => file === appPath || file.startsWith(root));
+}
+async function readSourceTextOrEmpty(file) {
+  try {
+    return await readSourceText(file);
+  } catch {
+    return "";
+  }
+}
+function metadataSourceFacts(source) {
+  return {
+    themeColor: themeColorInMetadataExport(source),
+    appleTouchFullscreen: source.includes("apple-touch-fullscreen") && /['"]apple-touch-fullscreen['"]/.test(source),
+    appleTouchIconPrecomposed: source.includes("apple-touch-icon-precomposed") && /['"]apple-touch-icon-precomposed['"]/.test(source),
+    metadataBase: source.includes("metadataBase") && /\bmetadataBase\s*:/.test(source),
+    relativeSocialImage: hasRelativeSocialImage(source)
+  };
+}
+function themeColorInMetadataExport(source) {
+  if (!source.includes("themeColor") || !/\bthemeColor\s*:/.test(source))
+    return false;
+  return /\bthemeColor\s*:/.test(stripViewportExports(source));
+}
+function stripViewportExports(source) {
+  const starts = /export\s+(?:const|let|var)\s+viewport\b|export\s+(?:async\s+)?function\s+generateViewport\b/g;
+  let out = "";
+  let last = 0;
+  for (let match = starts.exec(source);match; match = starts.exec(source)) {
+    const open = source.indexOf("{", match.index);
+    if (open === -1)
+      break;
+    let depth = 0;
+    let end = open;
+    for (;end < source.length; end++) {
+      const char = source[end];
+      if (char === "{")
+        depth++;
+      else if (char === "}" && --depth === 0)
+        break;
+    }
+    out += source.slice(last, match.index);
+    last = end + 1;
+    starts.lastIndex = last;
+  }
+  return out + source.slice(last);
+}
+function routeUsesRelativeSocialImage(route, facts, staticMetadataFiles) {
+  if (facts.some((fact) => fact.relativeSocialImage))
+    return true;
+  if (route.params.length > 0)
+    return false;
+  const staticMetadata = staticMetadataForPathFromFiles(staticMetadataFiles, route.route);
+  return Boolean(staticMetadata.openGraphImage || staticMetadata.twitterImage);
+}
+function hasRelativeSocialImage(source) {
+  if (!source.includes("images"))
+    return false;
+  return /(?:openGraph|twitter)\s*:\s*\{[\s\S]*?\bimages\s*:\s*['"`](?:\/|\.\.?\/)/m.test(source);
+}
+function warnOnce(warned, key, message) {
+  if (warned.has(key))
+    return;
+  warned.add(key);
+  console.warn(message);
+}
+
+// src/compat/validation/validate.ts
+import { existsSync, readdirSync } from "fs";
+import path2 from "path";
+
+// src/compat/validation/errors.ts
+function missingRootLayoutMessage(pageFile) {
+  return `${pageFile} doesn't have a root layout. To fix this error, make sure every page has a root layout.`;
+}
+function conflictingAppAndPageMessage(conflicts) {
+  const numConflicting = conflicts.length;
+  const list = conflicts.map((item) => `  "${item.page}" - "${item.app}"`).join(`
+`);
+  return `Conflicting app and page file${numConflicting === 1 ? " was" : "s were"} found, ` + `please remove the conflicting files to continue:
+${list}
+`;
+}
+function conflictingParallelPagesMessage(existingPath, appPath) {
+  return `You cannot have two parallel pages that resolve to the same path. ` + `Please check ${existingPath} and ${appPath}. ` + `Refer to the route group docs for more information: ` + `https://nextjs.org/docs/app/building-your-application/routing/route-groups`;
+}
+function missingDefaultParallelRouteMessage(segmentPath, slotName) {
+  return `Missing required default.js file for parallel route at ${segmentPath}
+` + `The parallel route slot "${slotName}" is missing a default.js file. ` + `When using parallel routes, each slot must have a default.js file to serve as a fallback.
+
+` + `Create a default.js file at: ${segmentPath}/default.js`;
+}
+function missingSuspenseWithCsrBailoutMessage(page) {
+  return `useSearchParams() should be wrapped in a suspense boundary at page "${page}". ` + `Read more: https://nextjs.org/docs/messages/missing-suspense-with-csr-bailout
+` + `    at Page (.next/server/app${page === "/" ? "" : page}/page.js)`;
+}
+function incompatibleCacheComponentsSegmentConfigMessage(key) {
+  return `Route segment config "${key}" is not compatible with \`nextConfig.cacheComponents\`. Please remove it.`;
+}
+function undefinedDefaultExportMessage(componentPath) {
+  return `Error occurred prerendering page "${componentPath.replace(/\/(?:page|layout|not-found)$/, "") || "/"}". Read more: https://nextjs.org/docs/messages/prerender-error
+Error: The default export is not a React Component in "${componentPath}"`;
+}
+function missingGenerateStaticParamsForExportMessage(page) {
+  return `Page "${page}" is missing "generateStaticParams()" so it cannot be used with "output: export" config.`;
+}
+function dynamicForceDynamicWithExportMessage(page) {
+  return `export const dynamic = "force-dynamic" on page "${page}" cannot be used with "output: export". ` + `See more info here: https://nextjs.org/docs/advanced-features/static-html-export`;
+}
+function forceDynamicPageWithExportMessage() {
+  return `Page with \`dynamic = "force-dynamic"\` couldn't be exported. ` + `\`output: "export"\` requires all pages be renderable statically ` + `because there is no runtime server to dynamically render routes in this output format. ` + `Learn more: https://nextjs.org/docs/app/building-your-application/deploying/static-exports`;
+}
+function routeHandlerNotStaticWithExportMessage(route) {
+  return `export const dynamic = "force-static"/export const revalidate not configured on route "${route}" ` + `with "output: export".`;
+}
+function exportPathMapWithAppDirMessage() {
+  return `The "exportPathMap" configuration cannot be used with the "app" directory. ` + `Please use generateStaticParams() instead. ` + `See more info here: https://nextjs.org/docs/app/building-your-application/deploying/static-exports`;
+}
+function unresolvedCodemodCommentMessage(note) {
+  return `You have an unresolved @next/codemod comment "${note}" that needs review.
+` + `After review, either remove the comment if you made the necessary changes or replace ` + `"@next-codemod-error" with "@next-codemod-ignore" to bypass the build error if no action at this line can be taken.`;
+}
+
+// src/compat/validation/validate.ts
+var BASE_PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js", "mjs"];
+
+class PnextBuildValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PnextBuildValidationError";
+  }
+}
+function validateBuild(config, routes) {
+  sourceCache.clear();
+  const pageRoutes = routes.filter((route) => route.kind === "page" && !route.interception);
+  warnBuildDiagnostics(config, routes);
+  validateRootLayout(config, pageRoutes);
+  validateAppPagesConflict(config);
+  validateParallelPageConflicts(config, pageRoutes);
+  validateMissingSlotDefaults(config, routes);
+  validateCodemodComments(routes);
+  validateDefaultExports(config, routes);
+  validateSearchParamsSuspense(config, pageRoutes);
+  validateUseCacheDirectives(config, routes);
+  validateUseCacheSearchParams(routes);
+  validateUseCacheHangingInputs(routes);
+  validateCacheComponentsSegmentConfigs(config, routes);
+  validateInstantStaticShells(config, routes);
+  validateClientSegmentConfigs(config, routes);
+  validateImageLoaderFile(config);
+  validateStaticImageImports(config, routes);
+  validateExportMode(config, routes);
+}
+function validateInstantStaticShells(config, routes) {
+  if (!cacheComponentsIsEnabled())
+    return;
+  for (const route of routes) {
+    if (route.kind !== "page")
+      continue;
+    const pageSource = readSource(route.file);
+    if (!pageSource || !/\bexport\s+const\s+unstable_instant\s*=\s*false\b/.test(pageSource))
+      continue;
+    if (!/\bconnection\s*\(/.test(pageSource))
+      continue;
+    const staticParent = layoutChain(config.appPath, route.file).some((file) => {
+      const source = readSource(file);
+      return Boolean(source && /\bexport\s+const\s+unstable_instant\s*=\s*true\b/.test(source));
+    });
+    if (!staticParent)
+      continue;
+    throw new PnextBuildValidationError(`Error occurred during prerendering page "${route.route || "/"}": Next.js encountered uncached data during prerendering.`);
+  }
+}
+function validateUseCacheHangingInputs(routes) {
+  if (!cacheComponentsIsEnabled())
+    return;
+  const failures = [];
+  const timeout = 'Filling a cache during prerender timed out, likely because request-specific arguments such as params, searchParams, cookies() or dynamic data were used inside "use cache".';
+  for (const route of routes) {
+    if (route.kind !== "page")
+      continue;
+    const source = readSource(route.file);
+    if (!source || useCacheDirectives(source).length === 0)
+      continue;
+    const routePath = nextPagePath(route);
+    const thrown = /\bthrow\s+new\s+Error\(\s*['"]([^'"]+)['"]\s*\)/.exec(source);
+    if (thrown?.[1] && !readsRequestDataOutsideCache(source)) {
+      failures.push(`Error occurred prerendering page "${routePath}". Read more: https://nextjs.org/docs/messages/prerender-error
+Error: ${thrown[1]}`);
+      continue;
+    }
+    const scoped = useCacheScopedSource(source).filter((scope) => scope.kind !== "private");
+    const isHangingInput = (ident) => ident === "promise" || /^[A-Za-z_$][\w$]*Promise$/.test(ident) || !route.hasStaticParams && ident === "params";
+    const hangs = scoped.some((scope) => {
+      const params = new Set(scope.params);
+      return awaitedIdentifiers(scope.body).some((ident) => isHangingInput(ident) && !params.has(ident));
+    });
+    const cachedNames = new Set(scoped.map((scope) => scope.name).filter((name) => name !== ""));
+    const exemptNames = new Set([...cachedNames, ...requestApiNames(source)]);
+    const receivesUncachedPromise = scoped.some((scope) => scope.name !== "" && scope.params.length > 0 && passesUncachedPromiseInto(source, scope.name, exemptNames));
+    if (!hangs && !receivesUncachedPromise)
+      continue;
+    failures.push(`${timeout}
+Error occurred prerendering page "${routePath}". Read more: https://nextjs.org/docs/messages/prerender-error`);
+  }
+  if (failures.length > 0)
+    throw new PnextBuildValidationError(failures.join(`
+
+`));
+}
+function validateUseCacheSearchParams(routes) {
+  if (!cacheComponentsIsEnabled())
+    return;
+  const failures = [];
+  for (const route of routes) {
+    if (route.kind !== "page")
+      continue;
+    const source = readSource(route.file);
+    if (!source || useCacheDirectives(source).length === 0)
+      continue;
+    const scoped = useCacheScopedSource(source).filter((scope) => scope.kind !== "private");
+    const violates = scoped.some((scope) => {
+      const params = new Set(scope.params);
+      return awaitedIdentifiers(scope.body).some((ident) => ident === "searchParams" && !params.has(ident));
+    });
+    if (!violates)
+      continue;
+    const routePath = route.route || "/";
+    failures.push(`Route ${routePath} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. ` + "If you need some search params inside a cached function await `searchParams` outside of the cached function and pass only the required search params as arguments to the cached function. " + `See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache
+` + `Error occurred prerendering page "${routePath}"`);
+  }
+  if (failures.length > 0)
+    throw new PnextBuildValidationError(failures.join(`
+
+`));
+}
+function validateClientSegmentConfigs(config, routes) {
+  for (const route of routes) {
+    if (route.kind !== "page")
+      continue;
+    const source = readSource(route.file);
+    if (!source || !hasDirective(source, "use client"))
+      continue;
+    if (/\bexport\s+const\s+unstable_instant\b/.test(source)) {
+      throw new PnextBuildValidationError(`"unstable_instant" is a route segment config and can only be used when the segment is a Server Component module. Remove the "use client" directive`);
+    }
+    if (getNextConfig().output === "export" && /\bexport\s+(?:async\s+)?function\s+generateStaticParams\b/.test(source)) {
+      throw new PnextBuildValidationError(`Page "/${appDirRelativeFile(config, route.file).replace(/\.[^.]+$/, "")}" cannot use both "use client" and export function "generateStaticParams()".`);
+    }
+  }
+}
+function validateImageLoaderFile(config) {
+  const images = getNextConfig().images;
+  if (!images || typeof images !== "object" || Array.isArray(images))
+    return;
+  const loaderFile = images.loaderFile;
+  if (typeof loaderFile !== "string" || loaderFile.length === 0)
+    return;
+  const file = path2.resolve(config.root, loaderFile);
+  const source = readSource(file);
+  if (source && /\bexport\s+default\b|\bmodule\.exports\s*=/.test(source))
+    return;
+  throw new PnextBuildValidationError(`images.loaderFile detected but the file is missing default export.
+` + "Read more: https://nextjs.org/docs/messages/invalid-images-config");
+}
+function validateStaticImageImports(config, routes) {
+  const seen = new Set;
+  for (const route of routes) {
+    for (const file of routeFiles(route)) {
+      if (seen.has(file))
+        continue;
+      seen.add(file);
+      if (!isAppSourceFile(config, file))
+        continue;
+      const source = readSource(file);
+      if (!source)
+        continue;
+      const imports = stripComments(source).matchAll(/\bimport\s+(?:[^'";]+?\s+from\s+)?['"]([^'"]+\.(?:png|jpe?g|gif|webp|avif|ico|bmp|svg))['"]/gi);
+      for (const match of imports) {
+        const specifier = match[1];
+        if (!specifier.startsWith("."))
+          continue;
+        if (existsSync(path2.resolve(path2.dirname(file), specifier)))
+          continue;
+        throw new PnextBuildValidationError(`Module not found: Can't resolve '${specifier}'
+./app/${appDirRelativeFile(config, file)}`);
+      }
+    }
+  }
+}
+function warnBuildDiagnostics(config, routes) {
+  const nextConfig = getNextConfig();
+  const experimental = nextConfig.experimental;
+  if (hasBabelConfig(config.root) && experimental?.forceSwcTransforms !== true) {
+    console.warn("Disabled SWC as replacement for Babel because of custom Babel configuration");
+  }
+  if (!legacyRequestAPIs() && typeof nextConfig.outputFileTracingRoot !== "string" && !(nextConfig.turbopack && typeof nextConfig.turbopack === "object" && typeof nextConfig.turbopack.root === "string")) {
+    warnMultipleLockfiles(config.root);
+  }
+  let warnedEdgeRuntime = false;
+  for (const file of new Set(routes.flatMap((route) => routeFiles(route)))) {
+    if (!isAppSourceFile(config, file))
+      continue;
+    const source = readSource(file);
+    if (!source)
+      continue;
+    if (!warnedEdgeRuntime && /\bruntime\s*=\s*['"](?:edge|experimental-edge)['"]/.test(source)) {
+      console.warn('The Edge Runtime is deprecated. You can use the "nodejs" runtime instead.');
+      warnedEdgeRuntime = true;
+    }
+    for (const key of ["runtime", "preferredRegion"]) {
+      if (new RegExp(`\\bexport\\s*\\{[^}]*\\b${key}\\b[^}]*\\}\\s*from\\s*['"]`).test(source)) {
+        console.warn(`Next.js can't recognize the exported \`${key}\` field in ${toPosix(path2.relative(config.root, file))}`);
+      }
+    }
+  }
+}
+function hasBabelConfig(root) {
+  return [
+    ".babelrc",
+    ".babelrc.json",
+    ".babelrc.js",
+    ".babelrc.cjs",
+    "babel.config.js",
+    "babel.config.cjs"
+  ].some((name) => existsSync(path2.join(root, name)));
+}
+function warnMultipleLockfiles(root) {
+  if (typeof getNextConfig().outputFileTracingRoot === "string")
+    return;
+  const lockfiles = [];
+  let current = root;
+  while (true) {
+    for (const name of [
+      "package-lock.json",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      "bun.lock",
+      "bun.lockb"
+    ]) {
+      const file = path2.join(current, name);
+      if (existsSync(file))
+        lockfiles.push(file);
+    }
+    if (existsSync(path2.join(current, "pnpm-workspace.yaml")))
+      break;
+    const parent = path2.dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  const dirs = [...new Set(lockfiles.map((file) => path2.dirname(file)))];
+  if (dirs.length < 2)
+    return;
+  const selected = dirs[0];
+  const additional = lockfiles.filter((file) => path2.dirname(file) !== selected);
+  console.warn(`\u26A0 Warning: Next.js inferred your workspace root, but it may not be correct.
+` + ` We detected multiple lockfiles and selected the directory of ${selected} as the root directory.
+` + " To silence this warning, set `outputFileTracingRoot` in your Next.js config, or consider removing one of the lockfiles if it's not needed.\n" + `   See https://nextjs.org/docs/app/api-reference/config/next-config-js/output#caveats for more information.
+` + ` Detected additional lockfiles: 
+` + additional.map((file) => `   * ${file}`).join(`
+`));
+}
+var sourceCache = new Map;
+function readSource(file) {
+  if (sourceCache.has(file))
+    return sourceCache.get(file);
+  let source;
+  try {
+    source = readSourceSync(file);
+  } catch {
+    source = undefined;
+  }
+  sourceCache.set(file, source);
+  return source;
+}
+function routeFiles(route) {
+  return [...new Set([route.file, ...route.sourceFiles])];
+}
+function isAppSourceFile(config, file) {
+  const materialized = file.includes(`${path2.sep}source-app${path2.sep}`) || file.includes(`${path2.sep}source-pages${path2.sep}`);
+  if (isInside(config.outPath, file))
+    return materialized && file.includes(`${path2.sep}pnext-pages-compat${path2.sep}`);
+  const relative = path2.relative(config.root, file);
+  if (relative !== "" && !relative.startsWith("..") && !path2.isAbsolute(relative)) {
+    return !relative.split(path2.sep).includes("node_modules");
+  }
+  return materialized;
+}
+function isInside(parent, file) {
+  const relative = path2.relative(parent, file);
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+function hasDirective(source, directive) {
+  return directivePrologue(source, 0).includes(directive);
+}
+function cacheComponentsIsEnabled() {
+  const nextConfig = getNextConfig();
+  const experimental = nextConfig.experimental;
+  return nextConfig.cacheComponents === true || experimental?.cacheComponents === true || experimental?.useCache === true || experimental?.dynamicIO === true || process.env.__NEXT_CACHE_COMPONENTS === "true";
+}
+var CACHE_COMPONENTS_FORBIDDEN_SEGMENT_CONFIGS = [
+  "dynamic",
+  "dynamicParams",
+  "revalidate",
+  "fetchCache"
+];
+var SEGMENT_CONFIG_FILE = /(?:^|\/)(?:page|layout|route|default)\.(?:tsx|ts|jsx|js|mjs)$/;
+function validateCacheComponentsSegmentConfigs(config, routes) {
+  if (!cacheComponentsIsEnabled())
+    return;
+  const projectRoot = path2.resolve(config.appPath, "..");
+  const seen = new Set;
+  const failures = [];
+  for (const route of routes) {
+    for (const file of route.sourceFiles) {
+      if (seen.has(file))
+        continue;
+      if (!SEGMENT_CONFIG_FILE.test(toPosix(file)))
+        continue;
+      seen.add(file);
+      if (!isProjectSourceFile(projectRoot, file))
+        continue;
+      const source = readSource(file);
+      if (source === undefined)
+        continue;
+      if (isMaterializedPagesWrapper(source))
+        continue;
+      let earliest;
+      for (const key of CACHE_COMPONENTS_FORBIDDEN_SEGMENT_CONFIGS) {
+        const match = new RegExp(`(?:^|[;\\n])\\s*export\\s+const\\s+${key}\\b`).exec(source);
+        if (match && (earliest === undefined || match.index < earliest.index)) {
+          earliest = { key, index: match.index };
+        }
+      }
+      const runtimeMatch = /(?:^|[;\n])\s*export\s+const\s+runtime\s*=\s*['"]([^'"]+)['"]/.exec(source);
+      if (runtimeMatch && (runtimeMatch[1] !== "edge" || useCacheOnlyIsEnabled()) && (earliest === undefined || runtimeMatch.index < earliest.index)) {
+        earliest = { key: "runtime", index: runtimeMatch.index };
+      }
+      if (!earliest)
+        continue;
+      if (useCacheOnlyIsEnabled()) {
+        throw new PnextBuildValidationError(useCacheSegmentConfigBuildError(source, earliest.key));
+      }
+      let trace = "";
+      if (/(?:^|\/)layout\.(?:tsx|ts|jsx|js|mjs)$/.test(toPosix(file))) {
+        const importers = new Set;
+        for (const other of routes) {
+          if (other.kind !== "page")
+            continue;
+          if (!other.sourceFiles.includes(file))
+            continue;
+          importers.add(`./app/${appDirRelativeFile(config, other.file)}`);
+        }
+        const layoutRel = `./app/${appDirRelativeFile(config, file)}`;
+        for (const importer of [...importers].sort()) {
+          trace += `
+
+Import trace for requested module:
+${importer}
+${layoutRel}`;
+        }
+      }
+      failures.push(`./app/${appDirRelativeFile(config, file)}
+` + incompatibleCacheComponentsSegmentConfigMessage(earliest.key) + trace);
+    }
+  }
+  if (failures.length > 0)
+    throw new PnextBuildValidationError(failures.join(`
+
+`));
+}
+function useCacheOnlyIsEnabled() {
+  const nextConfig = getNextConfig();
+  const experimental = nextConfig.experimental;
+  return experimental?.useCache === true && nextConfig.cacheComponents !== true && experimental?.cacheComponents !== true && experimental?.dynamicIO !== true && process.env.__NEXT_CACHE_COMPONENTS !== "true";
+}
+function useCacheSegmentConfigBuildError(source, key) {
+  const lines = source.split(`
+`);
+  const exportRe = new RegExp(`\\bexport\\s+const\\s+${key}\\b`);
+  let line = 1;
+  let column = 1;
+  for (let i = 0;i < lines.length; i += 1) {
+    const match = new RegExp(`\\b${key}\\b`).exec(lines[i] ?? "");
+    if (exportRe.test(lines[i] ?? "") && match) {
+      line = i + 1;
+      column = match.index + 1;
+      break;
+    }
+  }
+  const last = Math.min(lines.length, line + 3);
+  const width = String(last).length;
+  const gutter = " ".repeat(width + 2);
+  const frame = [`${gutter},-[${line}:1]`];
+  for (let n = line;n <= last; n += 1) {
+    frame.push(` ${String(n).padStart(width)} | ${lines[n - 1] ?? ""}`);
+    if (n === line) {
+      frame.push(`${gutter}: ${" ".repeat(column - 1)}${"^".repeat(key.length)}`);
+    }
+  }
+  frame.push(`${gutter}\`----`);
+  return `Failed to compile.
+` + `
+` + `__next_edge_ssr_entry__
+` + `Error:   x Route segment config "${key}" is not compatible with \`nextConfig.experimental.useCache\`. Please remove it.
+` + `${frame.join(`
+`)}
+` + `
+` + `Import trace for requested module:
+` + `__next_edge_ssr_entry__
+` + `
+` + `
+` + "> Build failed because of webpack errors";
+}
+function isMaterializedPagesWrapper(source) {
+  return /\bfrom\s+['"][^'"]*source-pages[/\\]/.test(source);
+}
+function validateUseCacheDirectives(config, routes) {
+  const nextConfig = getNextConfig();
+  const experimental = nextConfig.experimental;
+  const enabled = nextConfig.cacheComponents === true || experimental?.cacheComponents === true || experimental?.useCache === true || experimental?.dynamicIO === true || process.env.__NEXT_CACHE_COMPONENTS === "true";
+  const kinds = new Set(["default", "private", "remote"]);
+  const configured = nextConfig.cacheHandlers;
+  if (configured && typeof configured === "object" && !Array.isArray(configured)) {
+    for (const kind of Object.keys(configured))
+      kinds.add(kind);
+  }
+  const projectRoot = path2.resolve(config.appPath, "..");
+  const seen = new Set;
+  for (const route of routes) {
+    for (const file of route.sourceFiles) {
+      if (seen.has(file))
+        continue;
+      seen.add(file);
+      if (!isProjectSourceFile(projectRoot, file))
+        continue;
+      const source = readSource(file);
+      if (source === undefined)
+        continue;
+      for (const directive of useCacheDirectives(source)) {
+        if (!enabled) {
+          throw new PnextBuildValidationError(useCacheNotEnabledBuildError(`./app/${appDirRelativeFile(config, file)}`, source));
+        }
+        const kind = directive.kind;
+        if (!kinds.has(kind)) {
+          throw new PnextBuildValidationError(unknownCacheKindBuildError(`./app/${appDirRelativeFile(config, file)}`, source, kind));
+        }
+      }
+    }
+  }
+}
+function isProjectSourceFile(projectRoot, file) {
+  const relative = path2.relative(projectRoot, file);
+  return relative !== "" && !relative.startsWith("..") && !path2.isAbsolute(relative) && !relative.split(path2.sep).includes("node_modules");
+}
+function useCacheDirectives(source) {
+  const directives = [
+    ...directivePrologue(source, 0),
+    ...functionBodies(source).flatMap((offset) => directivePrologue(source, offset))
+  ];
+  return directives.flatMap((value) => {
+    const match = /^use cache(?:\s*:\s*([\w-]+))?$/.exec(value);
+    return match ? [{ kind: match[1] ?? "default" }] : [];
+  });
+}
+function useCacheScopedSource(source) {
+  const kindOf = (value) => /^use cache(?:\s*:\s*([\w-]+))?$/.exec(value);
+  for (const directive of directivePrologue(source, 0)) {
+    const match = kindOf(directive);
+    if (match)
+      return [{ kind: match[1] ?? "default", body: source, params: [], name: "" }];
+  }
+  const scopes = [];
+  for (const scope of functionScopes(source)) {
+    for (const directive of directivePrologue(source, scope.offset)) {
+      const match = kindOf(directive);
+      if (!match)
+        continue;
+      scopes.push({
+        kind: match[1] ?? "default",
+        body: source.slice(scope.offset, functionBodyEnd(source, scope.offset)),
+        params: scope.params,
+        name: scope.name
+      });
+      break;
+    }
+  }
+  return scopes;
+}
+function passesUncachedPromiseInto(source, name, resolvableNames) {
+  const isUncached = (expression) => isUncachedPromiseExpression(expression, resolvableNames);
+  const pattern = new RegExp(`(<)?\\b${escapeRegExp(name)}\\b`, "g");
+  for (const match of source.matchAll(pattern)) {
+    const index = match.index;
+    if (index === undefined || !isCodeOffset(source, index))
+      continue;
+    const after = index + match[0].length;
+    if (match[1] === "<") {
+      if (jsxPropsPassUncachedPromise(source, after, isUncached))
+        return true;
+      continue;
+    }
+    const open = source.slice(after).search(/\S/);
+    if (open === -1 || source[after + open] !== "(")
+      continue;
+    const args = balancedFrom(source, after + open, "(", ")");
+    if (args !== undefined && splitTopLevelCommas(args).some(isUncached))
+      return true;
+  }
+  return false;
+}
+function jsxPropsPassUncachedPromise(source, offset, isUncached) {
+  for (let cursor = offset;cursor < source.length; cursor++) {
+    const current = source[cursor];
+    if (current === ">")
+      return false;
+    if (current !== "{")
+      continue;
+    const expression = balancedFrom(source, cursor, "{", "}");
+    if (expression === undefined)
+      return false;
+    if (isUncached(expression))
+      return true;
+    cursor += expression.length + 1;
+  }
+  return false;
+}
+function balancedFrom(source, index, open, close) {
+  let depth = 0;
+  let quote;
+  for (let cursor = index;cursor < source.length; cursor++) {
+    const current = source[cursor];
+    if (quote) {
+      if (current === "\\")
+        cursor++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`") {
+      quote = current;
+      continue;
+    }
+    if (current === open)
+      depth++;
+    else if (current === close && --depth === 0)
+      return source.slice(index + 1, cursor);
+  }
+  return;
+}
+function isUncachedPromiseExpression(expression, resolvableNames) {
+  const trimmed = expression.trim();
+  if (trimmed === "" || /^await\b/.test(trimmed))
+    return false;
+  const call = /^([A-Za-z_$][\w$.]*)\s*\(/.exec(trimmed);
+  return call !== null && !resolvableNames.has(call[1]);
+}
+function requestApiNames(source) {
+  const names = new Set;
+  const imports = source.matchAll(/\bimport\s*\{([^}]*)\}\s*from\s*['"]next\/(?:headers|root-params)['"]/g);
+  for (const match of imports) {
+    for (const clause of match[1].split(",")) {
+      const local = /([A-Za-z_$][\w$]*)\s*$/.exec(clause.trim());
+      if (local)
+        names.add(local[1]);
+    }
+  }
+  return names;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readsRequestDataOutsideCache(source) {
+  const outside = useCacheScopedSource(source).reduce((rest, scope) => rest.replace(scope.body, ""), source);
+  return /\b(?:connection|cookies|headers|draftMode)\s*\(\s*\)/.test(outside);
+}
+function functionBodyEnd(source, offset) {
+  let depth = 1;
+  let quote;
+  for (let cursor = offset;cursor < source.length; cursor++) {
+    const current = source[cursor];
+    if (quote) {
+      if (current === "\\")
+        cursor++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === "/" && source[cursor + 1] === "/") {
+      const newline = source.indexOf(`
+`, cursor + 2);
+      if (newline === -1)
+        return source.length;
+      cursor = newline;
+      continue;
+    }
+    if (current === "/" && source[cursor + 1] === "*") {
+      const end = source.indexOf("*/", cursor + 2);
+      if (end === -1)
+        return source.length;
+      cursor = end + 1;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`") {
+      quote = current;
+      continue;
+    }
+    if (current === "{")
+      depth++;
+    else if (current === "}" && --depth === 0)
+      return cursor;
+  }
+  return source.length;
+}
+function useCacheNotEnabledBuildError(displayPath, source) {
+  return useCacheDirectiveBuildError(displayPath, source, 'To use "use cache", please enable the feature flag `cacheComponents` in your Next.js config.\n' + `  |
+` + "  | Read more: https://nextjs.org/docs/app/api-reference/directives/use-cache#usage");
+}
+function unknownCacheKindBuildError(displayPath, source, kind) {
+  return useCacheDirectiveBuildError(displayPath, source, `Unknown cache kind "${kind}". Please configure a cache handler for this kind in the \`cacheHandlers\` object in your Next.js config.`);
+}
+function useCacheDirectiveBuildError(displayPath, source, message) {
+  const match = /(['"])use cache(?:\s*:\s*[\w-]+)?\1/.exec(source);
+  const index = match?.index ?? 0;
+  const span = match?.[0].length ?? 11;
+  const before = source.slice(0, index);
+  const line = before.split(`
+`).length;
+  const column = index - before.lastIndexOf(`
+`);
+  const frame = swcCodeFrame(source, line, column, span);
+  return `Failed to compile.
+` + `
+` + `${displayPath}
+` + `Error:   x ${message}
+` + `
+` + `${frame}
+` + `
+` + `Import trace for requested module:
+` + `${displayPath}
+` + `
+` + `
+` + "> Build failed because of webpack errors";
+}
+function swcCodeFrame(source, line, column, span) {
+  const lines = source.split(`
+`);
+  const last = Math.min(lines.length, line + 3);
+  const width = String(last).length;
+  const gutter = " ".repeat(width + 2);
+  const out = [`${gutter},-[${line}:${column}]`];
+  for (let n = line;n <= last; n += 1) {
+    out.push(` ${String(n).padStart(width)} | ${lines[n - 1] ?? ""}`);
+    if (n === line) {
+      out.push(`${gutter}: ${" ".repeat(column - 1)}${"^".repeat(span)}`);
+    }
+  }
+  out.push(`${gutter}\`----`);
+  return out.join(`
+`);
+}
+function directivePrologue(source, offset) {
+  const directives = [];
+  let cursor = offset;
+  while (true) {
+    cursor = skipTrivia(source, cursor);
+    const quote = source[cursor];
+    if (quote !== '"' && quote !== "'")
+      return directives;
+    const end = stringEnd(source, cursor, quote);
+    if (end === -1)
+      return directives;
+    const value = source.slice(cursor + 1, end);
+    const afterString = end + 1;
+    cursor = skipTrivia(source, afterString);
+    if (source[cursor] === ";")
+      cursor++;
+    else if (cursor < source.length && source[cursor] !== "}" && !/[\r\n]/.test(source.slice(afterString, cursor))) {
+      return directives;
+    }
+    directives.push(value);
+  }
+}
+function functionBodies(source) {
+  return functionScopes(source).map((scope) => scope.offset);
+}
+function functionScopes(source) {
+  const scopes = [];
+  const pattern = /\b(?:async\s+)?function(?:\s*\*)?(?:\s+[A-Za-z_$][\w$]*)?\s*(?:<[^>{}]*>)?\s*\([^)]*\)\s*(?::\s*[^={]+)?\{|\b(?:async\s+)?(?:[A-Za-z_$][\w$]*|\([^)]*\))\s*=>\s*\{/g;
+  for (const match of source.matchAll(pattern)) {
+    if (match.index !== undefined && isCodeOffset(source, match.index)) {
+      scopes.push({
+        offset: match.index + match[0].length,
+        params: signatureParams(match[0]),
+        name: signatureName(source, match.index, match[0])
+      });
+    }
+  }
+  return scopes;
+}
+function signatureName(source, index, signature) {
+  const declared = /\bfunction(?:\s*\*)?\s+([A-Za-z_$][\w$]*)/.exec(signature);
+  if (declared)
+    return declared[1];
+  const before = source.slice(Math.max(0, index - 200), index);
+  const assigned = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=;]*)?=\s*$/.exec(before);
+  return assigned?.[1] ?? "";
+}
+function signatureParams(signature) {
+  const bareArrow = /(?:^|[^\w$.])([A-Za-z_$][\w$]*)\s*=>\s*\{\s*$/.exec(signature);
+  if (bareArrow && !signature.includes("("))
+    return [bareArrow[1]];
+  const open = signature.indexOf("(");
+  if (open === -1)
+    return [];
+  const close = signature.indexOf(")", open);
+  if (close === -1)
+    return [];
+  return paramBindingNames(signature.slice(open + 1, close));
+}
+function paramBindingNames(paramList) {
+  const names = [];
+  for (const raw of splitTopLevelCommas(paramList)) {
+    const part = stripDefaultValue(raw).trim().replace(/^\.\.\.\s*/, "");
+    if (!part)
+      continue;
+    if (part.startsWith("{") || part.startsWith("[")) {
+      destructureBindings(firstBalancedGroup(part), names);
+    } else {
+      const ident = /^([A-Za-z_$][\w$]*)/.exec(part);
+      if (ident)
+        names.push(ident[1]);
+    }
+  }
+  return names;
+}
+function destructureBindings(pattern, names) {
+  const inner = pattern.slice(1, -1);
+  for (const raw of splitTopLevelCommas(inner)) {
+    const entry = stripDefaultValue(raw).trim().replace(/^\.\.\.\s*/, "");
+    if (!entry)
+      continue;
+    const colon = topLevelColonIndex(entry);
+    const binding = (colon === -1 ? entry : entry.slice(colon + 1)).trim();
+    if (binding.startsWith("{") || binding.startsWith("[")) {
+      destructureBindings(firstBalancedGroup(binding), names);
+    } else {
+      const ident = /^([A-Za-z_$][\w$]*)/.exec(binding);
+      if (ident)
+        names.push(ident[1]);
+    }
+  }
+}
+function splitTopLevelCommas(text) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  let quote;
+  for (let i = 0;i < text.length; i++) {
+    const current = text[i];
+    if (quote) {
+      if (current === "\\")
+        i++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`")
+      quote = current;
+    else if (current === "{" || current === "[" || current === "(" || current === "<")
+      depth++;
+    else if (current === "}" || current === "]" || current === ")" || current === ">")
+      depth--;
+    else if (current === "," && depth === 0) {
+      parts.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts;
+}
+function firstBalancedGroup(text) {
+  const open = text[0];
+  const close = open === "{" ? "}" : "]";
+  let depth = 0;
+  let quote;
+  for (let i = 0;i < text.length; i++) {
+    const current = text[i];
+    if (quote) {
+      if (current === "\\")
+        i++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`")
+      quote = current;
+    else if (current === open)
+      depth++;
+    else if (current === close && --depth === 0)
+      return text.slice(0, i + 1);
+  }
+  return text;
+}
+function topLevelColonIndex(text) {
+  let depth = 0;
+  let quote;
+  for (let i = 0;i < text.length; i++) {
+    const current = text[i];
+    if (quote) {
+      if (current === "\\")
+        i++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`")
+      quote = current;
+    else if (current === "{" || current === "[" || current === "(" || current === "<")
+      depth++;
+    else if (current === "}" || current === "]" || current === ")" || current === ">")
+      depth--;
+    else if (current === ":" && depth === 0)
+      return i;
+  }
+  return -1;
+}
+function stripDefaultValue(entry) {
+  let depth = 0;
+  let quote;
+  for (let i = 0;i < entry.length; i++) {
+    const current = entry[i];
+    if (quote) {
+      if (current === "\\")
+        i++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`")
+      quote = current;
+    else if (current === "{" || current === "[" || current === "(" || current === "<")
+      depth++;
+    else if (current === "}" || current === "]" || current === ")" || current === ">")
+      depth--;
+    else if (current === "=" && depth === 0 && entry[i + 1] !== "=" && entry[i + 1] !== ">" && entry[i - 1] !== "=" && entry[i - 1] !== "!" && entry[i - 1] !== "<" && entry[i - 1] !== ">") {
+      return entry.slice(0, i);
+    }
+  }
+  return entry;
+}
+function awaitedIdentifiers(body) {
+  return [...body.matchAll(/\bawait\s+([A-Za-z_$][\w$]*)\b/g)].map((match) => match[1]);
+}
+function isCodeOffset(source, target) {
+  let quote;
+  for (let cursor = 0;cursor < target; cursor++) {
+    const current = source[cursor];
+    if (quote) {
+      if (current === "\\")
+        cursor++;
+      else if (current === quote)
+        quote = undefined;
+      continue;
+    }
+    if (current === "/" && source[cursor + 1] === "/") {
+      const newline = source.indexOf(`
+`, cursor + 2);
+      if (newline === -1 || newline >= target)
+        return false;
+      cursor = newline;
+      continue;
+    }
+    if (current === "/" && source[cursor + 1] === "*") {
+      const end = source.indexOf("*/", cursor + 2);
+      if (end === -1 || end >= target)
+        return false;
+      cursor = end + 1;
+      continue;
+    }
+    if (current === '"' || current === "'" || current === "`")
+      quote = current;
+  }
+  return quote === undefined;
+}
+function skipTrivia(source, start) {
+  let cursor = start;
+  while (cursor < source.length) {
+    if (/\s/.test(source[cursor])) {
+      cursor++;
+      continue;
+    }
+    if (source[cursor] === "/" && source[cursor + 1] === "/") {
+      const newline = source.indexOf(`
+`, cursor + 2);
+      cursor = newline === -1 ? source.length : newline + 1;
+      continue;
+    }
+    if (source[cursor] === "/" && source[cursor + 1] === "*") {
+      const end = source.indexOf("*/", cursor + 2);
+      if (end === -1)
+        return source.length;
+      cursor = end + 2;
+      continue;
+    }
+    return cursor;
+  }
+  return cursor;
+}
+function stringEnd(source, start, quote) {
+  for (let cursor = start + 1;cursor < source.length; cursor++) {
+    if (source[cursor] === "\\") {
+      cursor++;
+      continue;
+    }
+    if (source[cursor] === quote)
+      return cursor;
+  }
+  return -1;
+}
+function validateCodemodComments(routes) {
+  for (const file of new Set(routes.map((route) => route.file))) {
+    const source = readSource(file);
+    if (source === undefined)
+      continue;
+    const match = /@next-codemod-error\s+([^\n*]+)/.exec(source);
+    if (match?.[1]) {
+      throw new PnextBuildValidationError(unresolvedCodemodCommentMessage(match[1].trim()));
+    }
+  }
+}
+function validateRootLayout(config, pageRoutes) {
+  if (pageRoutes.length === 0)
+    return;
+  const hasRootLayout = pageExtensions().some((ext) => existsSync(path2.join(config.appPath, `layout.${ext}`)));
+  if (hasRootLayout)
+    return;
+  const orphan = pageRoutes.find((route) => !hasAncestorLayout(config.appPath, route.file));
+  if (!orphan)
+    return;
+  throw new PnextBuildValidationError(missingRootLayoutMessage(appDirRelativeFile(config, orphan.file)));
+}
+function hasAncestorLayout(appPath, routeFile) {
+  let dir = path2.dirname(routeFile);
+  while (dir.startsWith(appPath)) {
+    if (pageExtensions().some((ext) => existsSync(path2.join(dir, `layout.${ext}`))))
+      return true;
+    if (dir === appPath)
+      break;
+    dir = path2.dirname(dir);
+  }
+  return false;
+}
+function pageExtensions() {
+  return [...new Set([...BASE_PAGE_EXTENSIONS, ...extraPageExtensions()])];
+}
+function validateAppPagesConflict(config) {
+  const pagesDir = pagesDirFor(config);
+  if (!pagesDir || !existsSync(pagesDir))
+    return;
+  const pagePaths = collectPagesRouterPaths(pagesDir);
+  if (pagePaths.size === 0)
+    return;
+  const appPaths = collectAppRouterPaths(path2.join(config.root, "app"));
+  const conflicts = [];
+  for (const [route, app] of appPaths) {
+    const page = pagePaths.get(route);
+    if (page)
+      conflicts.push({ page, app });
+  }
+  if (conflicts.length === 0)
+    return;
+  throw new PnextBuildValidationError(conflictingAppAndPageMessage(dedupeConflicts(conflicts).sort(conflictSort)));
+}
+function pagesDirFor(config) {
+  return path2.join(config.root, "pages");
+}
+function collectAppRouterPaths(appDir) {
+  const paths = new Map;
+  if (!existsSync(appDir))
+    return paths;
+  const walk = (dir, segments) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith("@") || entry.name.startsWith("(") && entry.name.includes("."))
+          continue;
+        walk(full, entry.name.startsWith("(") && entry.name.endsWith(")") ? segments : [...segments, entry.name]);
+        continue;
+      }
+      if (!/^page\.(?:tsx|ts|jsx|js|mjs)$/.test(entry.name))
+        continue;
+      const route = segments.length === 0 ? "/" : `/${segments.join("/")}`;
+      paths.set(route, toPosix(path2.relative(path2.dirname(appDir), full)));
+    }
+  };
+  walk(appDir, []);
+  return paths;
+}
+function collectPagesRouterPaths(pagesDir) {
+  const paths = new Map;
+  const walk = (dir, prefix) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith("_"))
+        continue;
+      const full = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "api")
+          continue;
+        walk(full, `${prefix}/${entry.name}`);
+        continue;
+      }
+      const match = /^(.*)\.(tsx|ts|jsx|js|mjs)$/.exec(entry.name);
+      if (!match)
+        continue;
+      const base = match[1];
+      const rel = toPosix(path2.relative(path2.dirname(pagesDir), full));
+      if (base === "index") {
+        paths.set(prefix || "/", rel);
+      } else {
+        paths.set(`${prefix}/${base}`, rel);
+      }
+    }
+  };
+  walk(pagesDir, "");
+  return paths;
+}
+function dedupeConflicts(conflicts) {
+  const seen = new Set;
+  return conflicts.filter((conflict) => {
+    const key = `${conflict.page}\x00${conflict.app}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function conflictSort(a, b) {
+  return a.page.localeCompare(b.page) || a.app.localeCompare(b.app);
+}
+function validateParallelPageConflicts(config, pageRoutes) {
+  const byPattern = new Map;
+  for (const route of pageRoutes) {
+    if (route.synthetic)
+      continue;
+    const existing = byPattern.get(route.pattern);
+    if (existing) {
+      const labels = [routeGroupLabel(config, existing), routeGroupLabel(config, route)].sort();
+      throw new PnextBuildValidationError(conflictingParallelPagesMessage(labels[0], labels[1]));
+    }
+    byPattern.set(route.pattern, route);
+  }
+}
+function routeGroupLabel(config, route) {
+  const dir = path2.dirname(appDirRelativeFile(config, route.file));
+  return dir === "." ? "/" : `/${dir}`;
+}
+function validateMissingSlotDefaults(config, routes) {
+  const failures = [];
+  const interceptedTargets = interceptedTargetDirs(routes);
+  const visit = (dir) => {
+    for (const entry of readDirEntries(dir)) {
+      if (!entry.isDirectory())
+        continue;
+      const child = path2.join(dir, entry.name);
+      if (isSlotDir(entry.name))
+        continue;
+      visit(child);
+    }
+    if (!hasNormalChildRoute(dir))
+      return;
+    if (interceptedTargets.has(dir))
+      return;
+    for (const slot of readDirEntries(dir)) {
+      if (!slot.isDirectory() || !isNamedSlotDir(slot.name))
+        continue;
+      const slotDir = path2.join(dir, slot.name);
+      if (hasConventionFile(slotDir, "default"))
+        continue;
+      if (slotHasCatchAllPage(slotDir))
+        continue;
+      failures.push(missingDefaultParallelRouteMessage(appPath(config, slotDir), slot.name));
+    }
+  };
+  visit(config.appPath);
+  if (failures.length > 0)
+    throw new PnextBuildValidationError(failures.join(`
+
+`));
+}
+function interceptedTargetDirs(routes) {
+  const patterns = new Set(routes.filter((route) => route.kind === "page" && route.interception).map((route) => route.pattern));
+  return new Set(routes.filter((route) => route.kind === "page" && !route.interception && patterns.has(route.pattern)).map((route) => path2.dirname(route.file)));
+}
+function hasNormalChildRoute(dir, depth = 0) {
+  for (const entry of readDirEntries(dir)) {
+    if (!entry.isDirectory() || isSlotDir(entry.name))
+      continue;
+    const child = path2.join(dir, entry.name);
+    const nextDepth = isGroupDir(entry.name) ? depth : depth + 1;
+    if (nextDepth > 0 && (hasConventionFile(child, "page") || hasConventionFile(child, "default"))) {
+      return true;
+    }
+    if (hasNormalChildRoute(child, nextDepth))
+      return true;
+  }
+  return false;
+}
+function slotHasCatchAllPage(dir) {
+  for (const entry of readDirEntries(dir)) {
+    if (!entry.isDirectory())
+      continue;
+    const child = path2.join(dir, entry.name);
+    if (/^\[\[?\.\.\..+\]\]?$/.test(entry.name) && hasConventionFile(child, "page"))
+      return true;
+    if (slotHasCatchAllPage(child))
+      return true;
+  }
+  return false;
+}
+function hasConventionFile(dir, name) {
+  return pageExtensions().some((ext) => existsSync(path2.join(dir, `${name}.${ext}`)));
+}
+function readDirEntries(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+function isSlotDir(name) {
+  return name.startsWith("@");
+}
+function isNamedSlotDir(name) {
+  return isSlotDir(name) && name !== "@children";
+}
+function isGroupDir(name) {
+  return name.startsWith("(") && name.endsWith(")");
+}
+function appPath(config, file) {
+  return `app/${appDirRelativeFile(config, file)}`;
+}
+function validateDefaultExports(config, routes) {
+  const failures = [];
+  const appPath2 = path2.resolve(config.appPath);
+  for (const route of routes) {
+    if (route.kind !== "page" || route.interception || route.synthetic)
+      continue;
+    for (const file of defaultExportFiles(route)) {
+      if (/\.mdx?$/.test(file))
+        continue;
+      if (isRootLayoutFile(appPath2, file))
+        continue;
+      const source = readSource(file);
+      if (source === undefined)
+        continue;
+      if (!hasDefaultExport(stripCommentsAndStrings(source))) {
+        failures.push(undefinedDefaultExportMessage(componentRoutePath(route, file)));
+      }
+    }
+  }
+  if (failures.length > 0)
+    throw new PnextBuildValidationError([...new Set(failures)].join(`
+`));
+}
+function defaultExportFiles(route) {
+  const files = new Set([route.file]);
+  const dir = path2.dirname(route.file);
+  for (const ext of pageExtensions()) {
+    files.add(path2.join(dir, `layout.${ext}`));
+    files.add(path2.join(dir, `not-found.${ext}`));
+  }
+  return [...files].filter((file) => existsSync(file));
+}
+function isRootLayoutFile(appPath2, file) {
+  return path2.basename(file).replace(/\.[^.]+$/, "") === "layout" && path2.resolve(path2.dirname(file)) === appPath2;
+}
+function componentRoutePath(route, file) {
+  const convention = path2.basename(file).replace(/\.(tsx|ts|jsx|js|mjs)$/, "");
+  const routePath = route.route || "/";
+  if (convention === "page")
+    return routePath === "/" ? "/page" : `${routePath}/page`;
+  return `${routePath === "/" ? "" : routePath}/${convention}`;
+}
+function hasDefaultExport(searchable) {
+  return /\bexport\s+default\b/.test(searchable) || hasDefaultNamedExport(searchable);
+}
+function hasDefaultNamedExport(searchable) {
+  for (const match of searchable.matchAll(/\bexport\s*\{([^}]*)\}/g)) {
+    const specifiers = match[1]?.split(",") ?? [];
+    if (specifiers.some(exportsDefaultSpecifier))
+      return true;
+  }
+  return false;
+}
+function exportsDefaultSpecifier(specifier) {
+  const parts = specifier.trim().split(/\s+as\s+/);
+  return parts.length === 1 ? parts[0] === "default" : parts.at(-1) === "default";
+}
+function validateSearchParamsSuspense(config, pageRoutes) {
+  for (const route of pageRoutes) {
+    if (!route.client)
+      continue;
+    if (!isStaticallyPrerendered(route))
+      continue;
+    const source = readSource(route.file);
+    if (source === undefined)
+      continue;
+    const stripped = stripCommentsAndStrings(source);
+    if (/\buseSyncExternalStore\s*\(/.test(stripped))
+      continue;
+    if (!usesSearchParamsHook(stripped))
+      continue;
+    if (fileTreeHasSuspense(config, route))
+      continue;
+    throw new PnextBuildValidationError(missingSuspenseWithCsrBailoutMessage(route.route || "/"));
+  }
+}
+function usesSearchParamsHook(searchable) {
+  return /\buseSearchParams\s*\(/.test(searchable);
+}
+function isStaticallyPrerendered(route) {
+  const config = route.segmentConfig;
+  const configForcesDynamic = config?.dynamic === "force-dynamic" || config?.revalidate === 0 || config?.fetchCache === "force-no-store";
+  if (configForcesDynamic)
+    return false;
+  const isDynamicRoute = route.params.length > 0 || Boolean(route.catchAll);
+  if (isDynamicRoute && !route.hasStaticParams)
+    return false;
+  return true;
+}
+function fileTreeHasSuspense(config, route) {
+  const files = [route.file, ...layoutChain(config.appPath, route.file)];
+  for (const file of files) {
+    const source = readSource(file);
+    if (source === undefined)
+      continue;
+    if (/<Suspense[\s/>]/.test(source) || /\bReact\.Suspense\b/.test(source))
+      return true;
+  }
+  return false;
+}
+function layoutChain(appPath2, routeFile) {
+  const files = [];
+  let dir = path2.dirname(routeFile);
+  while (dir.startsWith(appPath2)) {
+    for (const ext of pageExtensions()) {
+      const candidate = path2.join(dir, `layout.${ext}`);
+      if (existsSync(candidate))
+        files.push(candidate);
+    }
+    if (dir === appPath2)
+      break;
+    dir = path2.dirname(dir);
+  }
+  return files;
+}
+function validateExportMode(config, routes) {
+  const nextConfig = getNextConfig();
+  if (nextConfig.output !== "export")
+    return;
+  const hasAppPages = routes.some((route) => route.kind === "page" && !route.interception);
+  if (hasAppPages && typeof nextConfig.exportPathMap === "function") {
+    throw new PnextBuildValidationError(exportPathMapWithAppDirMessage());
+  }
+  if (routesUseServerActions(routes)) {
+    throw new PnextBuildValidationError("Server Actions are not supported with static export.");
+  }
+  if (routes.some((route) => route.interception)) {
+    throw new PnextBuildValidationError("Intercepting routes are not supported with static export.");
+  }
+  for (const route of routes) {
+    if (route.interception || route.synthetic)
+      continue;
+    if (route.segmentConfig?.dynamic === "force-dynamic") {
+      throw new PnextBuildValidationError(route.kind === "page" ? forceDynamicPageWithExportMessage() : dynamicForceDynamicWithExportMessage(nextPagePath(route)));
+    }
+    if (route.kind === "handler" && !routeHandlerStaticExportable(route)) {
+      throw new PnextBuildValidationError(routeHandlerNotStaticWithExportMessage(nextPagePath(route)));
+    }
+    const isDynamicRoute = route.params.length > 0 || Boolean(route.catchAll);
+    if (route.kind === "page" && isDynamicRoute && !route.hasStaticParams) {
+      throw new PnextBuildValidationError(missingGenerateStaticParamsForExportMessage(nextPagePath(route)));
+    }
+  }
+}
+function routesUseServerActions(routes) {
+  const seen = new Set;
+  for (const route of routes) {
+    for (const file of route.sourceFiles ?? []) {
+      if (seen.has(file))
+        continue;
+      seen.add(file);
+      const source = readSource(file);
+      if (source === undefined)
+        continue;
+      if (/(["'])use server\1\s*;?/.test(source))
+        return true;
+    }
+  }
+  return false;
+}
+function routeHandlerStaticExportable(route) {
+  const config = route.segmentConfig;
+  return config?.dynamic === "force-static" || config?.dynamic === "error" || config?.revalidate === false || typeof config?.revalidate === "number" && config.revalidate > 0 || route.hasStaticParams;
+}
+function nextPagePath(route) {
+  let value = route.route || "/";
+  if (route.catchAll) {
+    const token = route.catchAllOptional ? `[[...${route.catchAll}]]` : `[...${route.catchAll}]`;
+    value = value.replace(`:${route.catchAll}*`, token);
+  }
+  for (const param of route.params)
+    value = value.replace(`:${param}`, `[${param}]`);
+  return value;
+}
+function appDirRelativeFile(config, file) {
+  return toPosix(path2.relative(config.appPath, file));
+}
+function toPosix(file) {
+  return file.split(path2.sep).join("/");
+}
+function stripCommentsAndStrings(source) {
+  let out = "";
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const ch = source[i];
+    const next = source[i + 1];
+    if (ch === "/" && next === "*") {
+      const end = source.indexOf("*/", i + 2);
+      out += " ";
+      i = end === -1 ? n : end + 2;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      const end = source.indexOf(`
+`, i + 2);
+      out += " ";
+      i = end === -1 ? n : end;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      out += quote;
+      i += 1;
+      while (i < n) {
+        const c = source[i];
+        if (c === "\\") {
+          i += 2;
+          continue;
+        }
+        if (c === quote) {
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      out += quote;
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+}
+
+// src/compat/segment/tree.ts
+var TREE_SEGMENT_PATH = "/_tree";
+var DEFAULT_DYNAMIC_STALE_TIME_SECONDS = 0;
+var DEFAULT_STATIC_STALE_TIME_SECONDS = 300;
+function buildRootTreePrefetch(options) {
+  const staleTime = options.staleTimeSeconds ?? (options.isStatic ? DEFAULT_STATIC_STALE_TIME_SECONDS : DEFAULT_DYNAMIC_STALE_TIME_SECONDS);
+  return {
+    ...options.buildId ? { buildId: options.buildId } : {},
+    tree: buildTree(options),
+    staleTime,
+    isStatic: options.isStatic,
+    ...options.vary ? { vary: options.vary } : {},
+    ...options.routePattern ? { route: options.routePattern } : {},
+    ...options.params ? { params: options.params } : {},
+    ...options.headOutlined ? { headOutlined: true } : {},
+    ...options.headFirst ? { headFirst: true } : {}
+  };
+}
+function buildTree(options) {
+  const parts = routeParts(options);
+  const bodySize = options.bodySizeBytes ?? 0;
+  const budget = options.inlineBudgetBytes ?? 32 * 1024;
+  const canInlineBody = options.isStatic && !options.postponed && bodySize <= budget;
+  let child = pageNode(parts.length === 0, {
+    isStatic: options.isStatic,
+    canInlineBody,
+    bodySizeBytes: options.bodySizeBytes,
+    ...options.vary ? { varyParams: options.vary.params } : {}
+  });
+  for (let index = parts.length - 1;index >= 0; index--) {
+    child = routeNode(parts[index], child, index === 0, {
+      isStatic: options.isStatic,
+      canInlineBody,
+      runtimePrefetch: options.runtimePrefetch
+    });
+  }
+  return {
+    name: "",
+    param: null,
+    slots: { children: child },
+    prefetchHints: 16 /* IsRootLayout */ | (canInlineBody ? 64 /* InlinedIntoChild */ : 0)
+  };
+}
+function routeParts(options) {
+  const source = options.routeId ?? options.pathname;
+  if (source === "index" || source === "/")
+    return [];
+  return source.split("/").map((part) => part.trim()).filter(Boolean).filter((part) => !part.startsWith("(") && !part.startsWith("@")).map((part) => part === "index" ? "__PAGE__" : part);
+}
+function routeNode(name, child, parentInlined, options) {
+  const dynamic = !options.isStatic || name.includes("instant-false");
+  const runtime = Boolean(options.runtimePrefetch) || name.includes("runtime");
+  const inlinesIntoChild = options.canInlineBody && !dynamic && !runtime;
+  return {
+    name,
+    param: name.startsWith("[") ? { type: "d", key: null, siblings: null } : null,
+    slots: {
+      children: { ...child, prefetchHints: child.prefetchHints | parentHint(inlinesIntoChild) }
+    },
+    prefetchHints: (parentInlined ? 32 /* ParentInlinedIntoSelf */ : 0) | (runtime ? 1 /* HasRuntimePrefetch */ : 0) | (dynamic ? 1024 /* PrefetchDisabled */ : 0) | (inlinesIntoChild ? 64 /* InlinedIntoChild */ : 0)
+  };
+}
+function pageNode(parentInlined, options) {
+  return {
+    name: "__PAGE__",
+    param: null,
+    slots: null,
+    prefetchHints: (parentInlined ? 32 /* ParentInlinedIntoSelf */ : 0) | (options.canInlineBody ? 128 /* HeadInlinedIntoSelf */ : 256 /* HeadOutlined */),
+    ...options.bodySizeBytes !== undefined ? { sizeBytes: options.bodySizeBytes } : {},
+    ...options.canInlineBody ? {} : { segmentPath: ROUTE_SEGMENT_PATH },
+    ...options.varyParams ? { varyParams: options.varyParams } : {}
+  };
+}
+function parentHint(enabled) {
+  return enabled ? 32 /* ParentInlinedIntoSelf */ : 0;
+}
+function rootTreePrefetchText(payload, format = "json") {
+  const json = JSON.stringify(payload);
+  return format === "flight" ? `0:${json}` : json;
+}
+function treePrefetchResponse(payload, options = {}) {
+  return new Response(rootTreePrefetchText(payload, options.format), {
+    status: 200,
+    headers: {
+      "content-type": RSC_CONTENT_TYPE_HEADER,
+      "x-nextjs-postponed": "2",
+      "x-nextjs-stale-time": String(payload.staleTime),
+      ...payload.isStatic ? { "x-nextjs-prerender": "1" } : {},
+      "cache-control": payload.isStatic ? "s-maxage=31536000, stale-while-revalidate" : "private, no-store"
+    }
+  });
+}
+var ROUTE_SEGMENT_PATH = "/";
+function segmentBodyText(segment, html, format = "flight", vary, shell) {
+  const payload = {
+    segment,
+    html,
+    ...vary ? { vary: vary.vary } : {},
+    ...vary?.layoutVary ? { layoutVary: vary.layoutVary } : {},
+    ...vary?.pageVary ? { pageVary: vary.pageVary } : {},
+    ...vary?.route ? { route: vary.route } : {},
+    ...vary?.params ? { params: vary.params } : {},
+    ...shell ? { shell } : {}
+  };
+  const json = JSON.stringify(payload);
+  return format === "flight" ? `0:${json}` : json;
+}
+var SEGMENT_VARY_HEADER = "x-pnext-segment-vary";
+var SEGMENT_ROUTE_HEADER = "x-pnext-segment-route";
+var SEGMENT_LAYOUT_VARY_HEADER = "x-pnext-segment-layout-vary";
+var SEGMENT_PAGE_VARY_HEADER = "x-pnext-segment-page-vary";
+function buildSegmentMeta(options) {
+  const inlined = !options.postponed && options.bodySizeBytes !== undefined && options.bodySizeBytes <= (options.inlineBudgetBytes ?? 32 * 1024);
+  return {
+    status: options.status,
+    staleTime: options.staleTime,
+    postponed: options.postponed,
+    segmentPaths: [TREE_SEGMENT_PATH, ROUTE_SEGMENT_PATH],
+    ...options.bodySizeBytes !== undefined ? { segmentSizes: { [ROUTE_SEGMENT_PATH]: options.bodySizeBytes } } : {},
+    ...inlined ? { inlinedSegmentPaths: [ROUTE_SEGMENT_PATH] } : {},
+    ...options.prefetchHints ? { prefetchHints: options.prefetchHints } : {},
+    ...options.vary ? {
+      vary: varyNamesFor(options.vary, "body"),
+      ...options.vary.params.length > 0 || options.vary.search ? {
+        layoutVary: varyNamesFor(options.vary, "layout"),
+        pageVary: varyNamesFor(options.vary, "page")
+      } : {}
+    } : {}
+  };
+}
+function segmentBodyResponse(body, staleTimeSeconds, postponed = false, prerendered = false, deploymentId, segment = ROUTE_SEGMENT_PATH, vary, shell) {
+  const cacheable = prerendered && !postponed;
+  return new Response(segmentBodyText(segment, body, "flight", vary, shell), {
+    status: 200,
+    headers: {
+      "content-type": RSC_CONTENT_TYPE_HEADER,
+      "x-nextjs-stale-time": String(staleTimeSeconds),
+      "x-nextjs-postponed": "2",
+      ...postponed ? { "x-pnext-segment-postponed": "1" } : {},
+      ...prerendered ? { "x-nextjs-prerender": "1" } : {},
+      ...deploymentId ? { "x-nextjs-deployment-id": deploymentId } : {},
+      ...vary ? { [SEGMENT_VARY_HEADER]: vary.vary.join(",") } : {},
+      ...vary?.layoutVary ? { [SEGMENT_LAYOUT_VARY_HEADER]: vary.layoutVary.join(",") } : {},
+      ...vary?.pageVary ? { [SEGMENT_PAGE_VARY_HEADER]: vary.pageVary.join(",") } : {},
+      ...vary?.route ? { [SEGMENT_ROUTE_HEADER]: vary.route } : {},
+      "cache-control": cacheable ? "s-maxage=31536000, stale-while-revalidate" : "private, no-store"
+    }
+  });
+}
+function segmentDir(outPath, routeId) {
+  return `${outPath}/segments/${routeId}`;
+}
+function treeSegmentFile(outPath, routeId) {
+  return `${segmentDir(outPath, routeId)}/_tree.segment.rsc`;
+}
+function bodySegmentFile(outPath, routeId) {
+  return `${segmentDir(outPath, routeId)}/index.segment.rsc`;
+}
+function segmentMetaFile(outPath, routeId) {
+  return `${segmentDir(outPath, routeId)}/route.segment.meta`;
+}
+
+// src/compat/bundler/wasm.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path3 from "path";
+var WASM_MODULE_FILTER = /\.wasm\?module(?:[?#].*)?$/;
+var manifestWasmBindings = new Map;
+function outPathKey(outPath) {
+  return path3.resolve(outPath);
+}
+function sourcePathFromSpecifier(specifier, resolveDir) {
+  const [sourcePath] = specifier.split(/[?#]/, 1);
+  if (!sourcePath)
+    return;
+  return path3.isAbsolute(sourcePath) ? sourcePath : path3.resolve(resolveDir, sourcePath);
+}
+function assetFileName(bytes) {
+  const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+  return `wasm_${hash}.wasm`;
+}
+function registerManifestBinding(outPath, sourcePath, name) {
+  const key = outPathKey(outPath);
+  const bySource = manifestWasmBindings.get(key) ?? new Map;
+  bySource.set(sourcePath, { name, filePath: `server/edge-chunks/${name}` });
+  manifestWasmBindings.set(key, bySource);
+}
+function readMiddlewareWasmBindingsForOutPath(outPath) {
+  const key = outPathKey(outPath);
+  const bindings = manifestWasmBindings.get(key);
+  if (!bindings || bindings.size === 0)
+    return [];
+  return [...bindings.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+var WASM_FILTER = /\.wasm(?:[?#].*)?$/;
+var WASM_INSTANCE_NAMESPACE = "pnext-wasm-instance";
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function wasmInstanceModuleSource(bytes) {
+  const names = WebAssembly.Module.exports(new WebAssembly.Module(bytes.buffer)).map((entry) => entry.name).filter((name) => IDENTIFIER.test(name));
+  return [
+    `const bytes = Uint8Array.from(atob(${JSON.stringify(Buffer.from(bytes).toString("base64"))}), c => c.charCodeAt(0));`,
+    "const wasmExports = new WebAssembly.Instance(new WebAssembly.Module(bytes), {}).exports;",
+    ...names.map((name) => `export const ${name} = wasmExports[${JSON.stringify(name)}];`),
+    "export default wasmExports;"
+  ].join(`
+`);
+}
+function registerWasmModuleRuntime(config) {
+  const root = path3.resolve(config.root);
+  if (wasmRuntimeRoots.has(root))
+    return;
+  wasmRuntimeRoots.add(root);
+  Bun.plugin({
+    name: `pnext-compat-wasm-runtime-${root}`,
+    setup(plugin) {
+      plugin.onLoad({ filter: /\.wasm$/ }, async ({ path: file }) => ({
+        contents: wasmInstanceModuleSource(new Uint8Array(await readFile(file))),
+        loader: "js"
+      }));
+    }
+  });
+}
+var wasmRuntimeRoots = new Set;
+function wasmModulePlugin(config) {
+  const edgeChunkDir = path3.join(config.outPath, "server", "edge-chunks");
+  return {
+    name: "pnext-compat-wasm-module",
+    setup(build) {
+      build.onResolve({ filter: WASM_MODULE_FILTER }, (args) => {
+        const sourcePath = sourcePathFromSpecifier(args.path, args.resolveDir);
+        if (!sourcePath)
+          return;
+        return { path: sourcePath, namespace: "pnext-wasm-module" };
+      });
+      build.onLoad({ filter: /.*/, namespace: "pnext-wasm-module" }, async (args) => {
+        const sourcePath = path3.resolve(args.path);
+        const bytes = new Uint8Array(await readFile(sourcePath));
+        const name = assetFileName(bytes);
+        const outFile = path3.join(edgeChunkDir, name);
+        if (!existsSync2(outFile)) {
+          await mkdir(path3.dirname(outFile), { recursive: true });
+          await writeFile(outFile, bytes);
+        }
+        registerManifestBinding(config.outPath, sourcePath, name);
+        const moduleBytes = JSON.stringify([...bytes]);
+        return {
+          contents: [
+            `const bytes = new Uint8Array(${moduleBytes});`,
+            "const module = new WebAssembly.Module(bytes.buffer);",
+            "export default module;"
+          ].join(`
+`),
+          loader: "js"
+        };
+      });
+      build.onResolve({ filter: WASM_FILTER }, (args) => {
+        if (WASM_MODULE_FILTER.test(args.path))
+          return;
+        const sourcePath = sourcePathFromSpecifier(args.path, args.resolveDir);
+        return sourcePath ? { path: sourcePath, namespace: WASM_INSTANCE_NAMESPACE } : undefined;
+      });
+      build.onLoad({ filter: /.*/, namespace: WASM_INSTANCE_NAMESPACE }, async (args) => ({
+        contents: wasmInstanceModuleSource(new Uint8Array(await readFile(path3.resolve(args.path)))),
+        loader: "js"
+      }));
+    }
+  };
+}
+
+export { getOtelApi, SPAN_TYPE, setOtelAppRoot, startRootSpan, setRootSpanRoute, endRootSpan, endRootSpanIfUnclosed, rootOtelContext, activeOtelContext, withChildSpan, withRenderBodySpan, markRenderSpanError, withRouteHandlerSpan, withPagesApiHandlerSpan, withPagesDataSpan, emitStartResponseSpan, emitClientComponentLoadingSpan, withMiddlewareSpan, emitLeafSpan, carrierSetter, otelExportInProgress, readNextModuleMetadata, readNextModuleViewport, hasRuntimeMetadata, shouldRenderMetadataInBody, warnNextMetadataBuildIssues, PnextBuildValidationError, validateBuild, TREE_SEGMENT_PATH, DEFAULT_DYNAMIC_STALE_TIME_SECONDS, DEFAULT_STATIC_STALE_TIME_SECONDS, buildRootTreePrefetch, rootTreePrefetchText, treePrefetchResponse, ROUTE_SEGMENT_PATH, buildSegmentMeta, segmentBodyResponse, segmentDir, treeSegmentFile, bodySegmentFile, segmentMetaFile, readMiddlewareWasmBindingsForOutPath, registerWasmModuleRuntime, wasmModulePlugin };