@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/server/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    debounce: null,
+    isBlockedPage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    debounce: function() {
+        return debounce;
+    },
+    isBlockedPage: function() {
+        return isBlockedPage;
+    }
+});
+const _constants = require("../shared/lib/constants");
+function isBlockedPage(page) {
+    return _constants.BLOCKED_PAGES.includes(page);
+}
+function debounce(fn, ms, maxWait = Infinity) {
+    let timeoutId;
+    // The time the debouncing function was first called during this debounce queue.
+    let startTime = 0;
+    // The time the debouncing function was last called.
+    let lastCall = 0;
+    // The arguments and this context of the last call to the debouncing function.
+    let args, context;
+    // A helper used to that either invokes the debounced function, or
+    // reschedules the timer if a more recent call was made.
+    function run() {
+        const now = Date.now();
+        const diff = lastCall + ms - now;
+        // If the diff is non-positive, then we've waited at least `ms`
+        // milliseconds since the last call. Or if we've waited for longer than the
+        // max wait time, we must call the debounced function.
+        if (diff <= 0 || startTime + maxWait >= now) {
+            // It's important to clear the timeout id before invoking the debounced
+            // function, in case the function calls the debouncing function again.
+            timeoutId = undefined;
+            fn.apply(context, args);
+        } else {
+            // Else, a new call was made after the original timer was scheduled. We
+            // didn't clear the timeout (doing so is very slow), so now we need to
+            // reschedule the timer for the time difference.
+            timeoutId = setTimeout(run, diff);
+        }
+    }
+    return function(...passedArgs) {
+        // The arguments and this context of the most recent call are saved so the
+        // debounced function can be invoked with them later.
+        args = passedArgs;
+        context = this;
+        // Instead of constantly clearing and scheduling a timer, we record the
+        // time of the last call. If a second call comes in before the timer fires,
+        // then we'll reschedule in the run function. Doing this is considerably
+        // faster.
+        lastCall = Date.now();
+        // Only schedule a new timer if we're not currently waiting.
+        if (timeoutId === undefined) {
+            startTime = lastCall;
+            timeoutId = setTimeout(run, ms);
+        }
+    };
+}
+
+//# sourceMappingURL=utils.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/web/adapter.js

@@ -0,0 +1,466 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NextRequestHint: null,
+    adapter: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NextRequestHint: function() {
+        return NextRequestHint;
+    },
+    adapter: function() {
+        return adapter;
+    }
+});
+const _error = require("./error");
+const _utils = require("./utils");
+const _fetchevent = require("./spec-extension/fetch-event");
+const _request = require("./spec-extension/request");
+const _response = require("./spec-extension/response");
+const _relativizeurl = require("../../shared/lib/router/utils/relativize-url");
+const _nexturl = require("./next-url");
+const _internalutils = require("../internal-utils");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _globals = require("./globals");
+const _requeststore = require("../async-storage/request-store");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _workstore = require("../async-storage/work-store");
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _tracer = require("../lib/trace/tracer");
+const _constants = require("../lib/trace/constants");
+const _webonclose = require("./web-on-close");
+const _forwardtracecontext = require("./forward-trace-context");
+const _getedgepreviewprops = require("./get-edge-preview-props");
+const _builtinrequestcontext = require("../after/builtin-request-context");
+const _implicittags = require("../lib/implicit-tags");
+const _isrscrequest = require("../lib/is-rsc-request");
+const _requestmeta = require("../request-meta");
+// The proxy (middleware) does not support `'use cache'`, so this work store
+// never reaches the code that reads `cacheLife` (and `'use cache'` is
+// disallowed on the edge runtime anyway). This sentinel satisfies the
+// non-optional type while throwing if `default` is ever read, matching the
+// "never read" sentinels used for the proxy's other unused renderOpts fields
+// (`staticPageGenerationTimeout: 0`, `useCacheTimeout: 0`). It surfaces loudly
+// rather than silently serving a misleading profile.
+const proxyCacheLifeProfiles = {
+    get default () {
+        throw new _invarianterror.InvariantError('Proxy does not support `use cache`, so reading its `default` cacheLife profile is unexpected.');
+    }
+};
+class NextRequestHint extends _request.NextRequest {
+    constructor(params){
+        super(params.input, params.init);
+        this.sourcePage = params.page;
+    }
+    get request() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+    respondWith() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+    waitUntil() {
+        throw new _error.PageSignatureError({
+            page: this.sourcePage
+        });
+    }
+}
+const headersGetter = {
+    keys: (headers)=>Array.from(headers.keys()),
+    get: (headers, key)=>headers.get(key) ?? undefined
+};
+function isMiddlewarePage(page) {
+    return page === '/middleware' || page === '/src/middleware' || page === '/proxy' || page === '/src/proxy';
+}
+let propagator = (request, fn)=>{
+    // An active (host) span wins over a `traceparent` the request carries: the
+    // header can't be trusted to override, e.g., an APM's or the platform's
+    // server span. The middleware forwards the context it continues to the
+    // downstream request (the render), so both stay in one trace.
+    return (0, _tracer.getTracer)().withPropagatedContext(request.headers, fn, headersGetter);
+};
+let testApisIntercepted = false;
+function ensureTestApisIntercepted() {
+    if (!testApisIntercepted) {
+        testApisIntercepted = true;
+        if (process.env.NEXT_PRIVATE_TEST_PROXY === 'true') {
+            const { interceptTestApis, wrapRequestHandler } = // eslint-disable-next-line @next/internal/typechecked-require -- experimental/testmode is not built ins next/dist/esm
+            require('next/dist/experimental/testmode/server-edge');
+            interceptTestApis();
+            propagator = wrapRequestHandler(propagator);
+        }
+    }
+}
+async function adapter(params) {
+    var _getBuiltinRequestContext;
+    ensureTestApisIntercepted();
+    await (0, _globals.ensureInstrumentationRegistered)();
+    // TODO-APP: use explicit marker for this
+    const isEdgeRendering = typeof globalThis.__BUILD_MANIFEST !== 'undefined';
+    params.request.url = (0, _apppaths.normalizeRscURL)(params.request.url);
+    const requestURL = params.bypassNextUrl ? new URL(params.request.url) : new _nexturl.NextURL(params.request.url, {
+        headers: params.request.headers,
+        nextConfig: params.request.nextConfig
+    });
+    // Iterator uses an index to keep track of the current iteration. Because of deleting and appending below we can't just use the iterator.
+    // Instead we use the keys before iteration.
+    const keys = [
+        ...requestURL.searchParams.keys()
+    ];
+    for (const key of keys){
+        const value = requestURL.searchParams.getAll(key);
+        const normalizedKey = (0, _utils.normalizeNextQueryParam)(key);
+        if (normalizedKey) {
+            requestURL.searchParams.delete(normalizedKey);
+            for (const val of value){
+                requestURL.searchParams.append(normalizedKey, val);
+            }
+            requestURL.searchParams.delete(key);
+        }
+    }
+    // Ensure users only see page requests, never data requests.
+    let buildId = process.env.__NEXT_BUILD_ID || '';
+    if ('buildId' in requestURL) {
+        buildId = requestURL.buildId || '';
+        requestURL.buildId = '';
+    }
+    let deploymentId = process.env.NEXT_DEPLOYMENT_ID;
+    const requestHeaders = (0, _utils.fromNodeOutgoingHttpHeaders)(params.request.headers);
+    const isNextDataRequest = requestHeaders.has('x-nextjs-data');
+    const isRSCRequest = (0, _isrscrequest.isRSCRequestHeader)(requestHeaders.get(_approuterheaders.RSC_HEADER));
+    if (isNextDataRequest && requestURL.pathname === '/index') {
+        requestURL.pathname = '/';
+    }
+    const flightHeaders = new Map();
+    // Headers should only be stripped for middleware
+    if (!isEdgeRendering && !process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE) {
+        for (const header of _approuterheaders.FLIGHT_HEADERS){
+            const value = requestHeaders.get(header);
+            if (value !== null) {
+                flightHeaders.set(header, value);
+                requestHeaders.delete(header);
+            }
+        }
+    }
+    const normalizeURL = process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE ? new URL(params.request.url) : requestURL;
+    const rscHash = normalizeURL.searchParams.get(_approuterheaders.NEXT_RSC_UNION_QUERY);
+    const request = new NextRequestHint({
+        page: params.page,
+        // Strip internal query parameters off the request.
+        input: process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE ? normalizeURL.toString() : (0, _internalutils.stripInternalSearchParams)(normalizeURL).toString(),
+        init: {
+            body: params.request.body,
+            headers: requestHeaders,
+            method: params.request.method,
+            nextConfig: params.request.nextConfig,
+            signal: params.request.signal
+        }
+    });
+    if (params.request.requestMeta) {
+        (0, _requestmeta.setRequestMeta)(request, params.request.requestMeta);
+    }
+    /**
+   * This allows to identify the request as a data request. The user doesn't
+   * need to know about this property neither use it. We add it for testing
+   * purposes.
+   */ if (isNextDataRequest) {
+        Object.defineProperty(request, '__isData', {
+            enumerable: false,
+            value: true
+        });
+    }
+    if (// If we are inside of the next start sandbox
+    // leverage the shared instance if not we need
+    // to create a fresh cache instance each time
+    !globalThis.__incrementalCacheShared && params.IncrementalCache) {
+        ;
+        globalThis.__incrementalCache = new params.IncrementalCache({
+            CurCacheHandler: params.incrementalCacheHandler,
+            minimalMode: process.env.NODE_ENV !== 'development',
+            fetchCacheKeyPrefix: process.env.__NEXT_FETCH_CACHE_KEY_PREFIX,
+            dev: process.env.NODE_ENV === 'development',
+            requestHeaders: params.request.headers,
+            previewProps: (0, _getedgepreviewprops.getEdgePreviewProps)(),
+            prerenderManifest: {
+                version: -1,
+                routes: {},
+                dynamicRoutes: {},
+                notFoundRoutes: [],
+                preview: (0, _getedgepreviewprops.getEdgePreviewProps)()
+            }
+        });
+    }
+    // if we're in an edge runtime sandbox, we should use the waitUntil
+    // that we receive from the enclosing NextServer
+    const outerWaitUntil = params.request.waitUntil ?? ((_getBuiltinRequestContext = (0, _builtinrequestcontext.getBuiltinRequestContext)()) == null ? void 0 : _getBuiltinRequestContext.waitUntil);
+    const event = new _fetchevent.NextFetchEvent({
+        request,
+        page: params.page,
+        context: outerWaitUntil ? {
+            waitUntil: outerWaitUntil
+        } : undefined
+    });
+    let response;
+    let cookiesFromResponse;
+    // The trace context of the span the middleware span and the downstream
+    // request share as their parent, to forward to the downstream request (see
+    // `forwardTraceContextToRequest`), and the request headers as the
+    // middleware received them.
+    let forwardedTraceContext;
+    let forwardedRequestHeaders;
+    response = await propagator(request, ()=>{
+        // we only care to make async storage available for middleware
+        const isMiddleware = isMiddlewarePage(params.page);
+        if (isMiddleware) {
+            // if we're in an edge function, we only get a subset of `nextConfig` (no `experimental`),
+            // so we have to inject it via DefinePlugin.
+            // in `next start` this will be passed normally (see `NextNodeServer.runMiddleware`).
+            const waitUntil = event.waitUntil.bind(event);
+            const closeController = new _webonclose.CloseController();
+            const tracer = (0, _tracer.getTracer)();
+            const executeMiddleware = ()=>{
+                // The middleware span and the downstream request (the render) are
+                // siblings: they share the currently active context as their parent.
+                // That is an active host span, otherwise the request's `traceparent`
+                // (incoming, or written by next-server's middleware-invoke pass), or
+                // the root span inserted below. When this request registered
+                // `instrumentation.ts`, its lifecycle spans are children of the
+                // middleware span, which is backdated to cover registration.
+                const receivedHeaders = new Headers(request.headers);
+                forwardedTraceContext = (0, _forwardtracecontext.getSharedParentTraceContext)(receivedHeaders, tracer.getTraceContextHeaders());
+                if (forwardedTraceContext) {
+                    // Snapshot before the handler can mutate `request.headers`.
+                    forwardedRequestHeaders = receivedHeaders;
+                }
+                return tracer.trace(_constants.MiddlewareSpan.execute, {
+                    spanName: `middleware ${request.method}`,
+                    startTime: params.emitInstrumentationSpans ? params.requestStartTime : undefined,
+                    attributes: {
+                        'http.target': request.nextUrl.pathname,
+                        'http.method': request.method
+                    }
+                }, async ()=>{
+                    params.emitInstrumentationSpans == null ? void 0 : params.emitInstrumentationSpans.call(params);
+                    try {
+                        var _params_request_nextConfig_experimental, _params_request_nextConfig;
+                        const onUpdateCookies = (cookies)=>{
+                            cookiesFromResponse = cookies;
+                        };
+                        const previewProps = (0, _getedgepreviewprops.getEdgePreviewProps)();
+                        const page = '/' // Fake Work
+                        ;
+                        const fallbackRouteParams = null;
+                        const implicitTags = await (0, _implicittags.getImplicitTags)(page, request.nextUrl.pathname, fallbackRouteParams);
+                        const requestStore = (0, _requeststore.createRequestStoreForAPI)(request, request.nextUrl, implicitTags, onUpdateCookies, previewProps, // Edge route handlers can't use `"use cache"`, so there's no HMR
+                        // refresh hash to thread through here.
+                        undefined);
+                        const workStore = (0, _workstore.createWorkStore)({
+                            page,
+                            renderOpts: {
+                                cacheLifeProfiles: proxyCacheLifeProfiles,
+                                // Proxy doesn't do static generation, so this value does not
+                                // apply here. 0 is a sentinel: if something ever reads it,
+                                // it'll surface loudly instead of silently using a misleading
+                                // default.
+                                staticPageGenerationTimeout: 0,
+                                cacheComponents: false,
+                                // Proxy doesn't run instant validation; the level value is
+                                // irrelevant here.
+                                // TODO: remove validationLevel and other global config from renderOpts
+                                validationLevel: 'warning',
+                                experimental: {
+                                    isRoutePPREnabled: false,
+                                    authInterrupts: !!((_params_request_nextConfig = params.request.nextConfig) == null ? void 0 : (_params_request_nextConfig_experimental = _params_request_nextConfig.experimental) == null ? void 0 : _params_request_nextConfig_experimental.authInterrupts),
+                                    // Proxy doesn't fill Cache Components entries, so this value
+                                    // is never read. 0 is a sentinel: if something ever reads it,
+                                    // the cache fill will time out immediately and surface the
+                                    // bug.
+                                    useCacheTimeout: 0,
+                                    durableUseCacheEntries: false
+                                },
+                                waitUntil,
+                                onClose: closeController.onClose.bind(closeController),
+                                onAfterTaskError: undefined
+                            },
+                            isPrefetchRequest: request.headers.get(_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER) === '1',
+                            buildId: buildId ?? '',
+                            deploymentId: deploymentId ?? '',
+                            previouslyRevalidatedTags: []
+                        });
+                        return await _workasyncstorageexternal.workAsyncStorage.run(workStore, ()=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, params.handler, request, event));
+                    } finally{
+                        // middleware cannot stream, so we can consider the response closed
+                        // as soon as the handler returns.
+                        // we can delay running it until a bit later --
+                        // if it's needed, we'll have a `waitUntil` lock anyway.
+                        setTimeout(()=>{
+                            closeController.dispatchClose();
+                        }, 0);
+                    }
+                });
+            };
+            if (tracer.isOpenTelemetryEnabled() && !tracer.hasActiveSpanContext()) {
+                // Middleware invoked separately from the render without any trace
+                // context (no incoming `traceparent`, no host span): insert a root
+                // span for the request. Its context is forwarded to the render, so the
+                // middleware and the render are siblings in one trace instead of two
+                // independent root spans. It's named after the method only (like
+                // next-server's request span before its route is known): the path
+                // would make the span name high-cardinality. It is backdated to when
+                // the request was received, to cover registering `instrumentation.ts`.
+                return tracer.trace(_constants.NextSpan.request, {
+                    spanName: request.method,
+                    kind: _tracer.SpanKind.SERVER,
+                    startTime: params.requestStartTime,
+                    attributes: {
+                        'http.target': request.nextUrl.pathname,
+                        'http.method': request.method
+                    }
+                }, executeMiddleware);
+            }
+            return executeMiddleware();
+        }
+        return params.handler(request, event);
+    });
+    // check if response is a Response object
+    if (response && !(response instanceof Response)) {
+        throw new TypeError('Expected an instance of Response to be returned');
+    }
+    if (response && cookiesFromResponse) {
+        response.headers.set('set-cookie', cookiesFromResponse);
+    }
+    /**
+   * For rewrites we must always include the locale in the final pathname
+   * so we re-create the NextURL forcing it to include it when the it is
+   * an internal rewrite. Also we make sure the outgoing rewrite URL is
+   * a data URL if the request was a data request.
+   */ const rewrite = response == null ? void 0 : response.headers.get('x-middleware-rewrite');
+    if (response && rewrite && (isRSCRequest || !isEdgeRendering)) {
+        var _params_request_nextConfig_experimental_clientParamParsingOrigins, _params_request_nextConfig_experimental, _params_request_nextConfig;
+        const destination = new _nexturl.NextURL(rewrite, {
+            forceLocale: true,
+            headers: params.request.headers,
+            nextConfig: params.request.nextConfig
+        });
+        if (!process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE && !isEdgeRendering) {
+            if (destination.host === request.nextUrl.host) {
+                destination.buildId = buildId || destination.buildId;
+                response.headers.set('x-middleware-rewrite', String(destination));
+            }
+        }
+        /**
+     * When the request is a data request we must show if there was a rewrite
+     * with an internal header so the client knows which component to load
+     * from the data request.
+     */ const { url: relativeDestination, isRelative } = (0, _relativizeurl.parseRelativeURL)(destination.toString(), requestURL.toString());
+        if (!isEdgeRendering && isNextDataRequest && // if the rewrite is external and external rewrite
+        // resolving config is enabled don't add this header
+        // so the upstream app can set it instead
+        !(process.env.__NEXT_EXTERNAL_MIDDLEWARE_REWRITE_RESOLVE && relativeDestination.match(/http(s)?:\/\//))) {
+            response.headers.set('x-nextjs-rewrite', relativeDestination);
+        }
+        // Check to see if this is a non-relative rewrite. If it is, we need
+        // to check to see if it's an allowed origin to receive the rewritten
+        // headers.
+        const isAllowedOrigin = !isRelative ? (_params_request_nextConfig = params.request.nextConfig) == null ? void 0 : (_params_request_nextConfig_experimental = _params_request_nextConfig.experimental) == null ? void 0 : (_params_request_nextConfig_experimental_clientParamParsingOrigins = _params_request_nextConfig_experimental.clientParamParsingOrigins) == null ? void 0 : _params_request_nextConfig_experimental_clientParamParsingOrigins.some((origin)=>new RegExp(origin).test(destination.origin)) : false;
+        // If this is an RSC request, and the pathname or search has changed, and
+        // this isn't an external rewrite, we need to set the rewritten pathname and
+        // query headers.
+        if (isRSCRequest && (isRelative || isAllowedOrigin)) {
+            if (requestURL.pathname !== destination.pathname) {
+                response.headers.set(_approuterheaders.NEXT_REWRITTEN_PATH_HEADER, destination.pathname);
+            }
+            if (requestURL.search !== destination.search) {
+                response.headers.set(_approuterheaders.NEXT_REWRITTEN_QUERY_HEADER, // remove the leading ? from the search string
+                destination.search.slice(1));
+            }
+        }
+    }
+    /**
+   * Always forward the `_rsc` search parameter to the rewritten URL for RSC requests,
+   * unless it's already present. This is necessary to ensure that RSC hash validation
+   * works correctly after a rewrite. For internal rewrites, the server can validate the
+   * RSC hash using the original URL, so forwarding the `_rsc` parameter is less critical.
+   * However, for external rewrites (where the request is proxied to another Next.js server),
+   * the external server does not have access to the original URL or its search parameters.
+   * In these cases, forwarding the `_rsc` parameter is essential so that the external server
+   * can perform the correct RSC hash validation.
+   */ if (response && rewrite && isRSCRequest && rscHash) {
+        const rewriteURL = new URL(rewrite);
+        if (!rewriteURL.searchParams.has(_approuterheaders.NEXT_RSC_UNION_QUERY)) {
+            rewriteURL.searchParams.set(_approuterheaders.NEXT_RSC_UNION_QUERY, rscHash);
+            response.headers.set('x-middleware-rewrite', rewriteURL.toString());
+        }
+    }
+    /**
+   * For redirects we will not include the locale in case when it is the
+   * default and we must also make sure the outgoing URL is a data one if
+   * the incoming request was a data request.
+   */ const redirect = response == null ? void 0 : response.headers.get('Location');
+    if (response && redirect && !isEdgeRendering) {
+        const redirectURL = new _nexturl.NextURL(redirect, {
+            forceLocale: false,
+            headers: params.request.headers,
+            nextConfig: params.request.nextConfig
+        });
+        /**
+     * Responses created from redirects have immutable headers so we have
+     * to clone the response to be able to modify it.
+     */ response = new Response(response.body, response);
+        if (!process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE) {
+            if (redirectURL.host === requestURL.host) {
+                redirectURL.buildId = buildId || redirectURL.buildId;
+                response.headers.set('Location', (0, _relativizeurl.getRelativeURL)(redirectURL, requestURL));
+            }
+        }
+        /**
+     * When the request is a data request we can't use the location header as
+     * it may end up with CORS error. Instead we map to an internal header so
+     * the client knows the destination.
+     */ if (isNextDataRequest) {
+            response.headers.delete('Location');
+            response.headers.set('x-nextjs-redirect', (0, _relativizeurl.getRelativeURL)(redirectURL.toString(), requestURL.toString()));
+        }
+    }
+    const finalResponse = response ? response : _response.NextResponse.next();
+    if (forwardedRequestHeaders) {
+        // Make the downstream request (render) a sibling of the middleware span
+        // in the same trace. Every host applies these request-header overrides to
+        // the render, including next-server's router server, so this works
+        // whether or not the host invokes the middleware separately from the
+        // render.
+        (0, _forwardtracecontext.forwardTraceContextToRequest)(finalResponse.headers, forwardedRequestHeaders, forwardedTraceContext);
+    }
+    // Flight headers are not overridable / removable so they are applied at the end.
+    const middlewareOverrideHeaders = finalResponse.headers.get('x-middleware-override-headers');
+    const overwrittenHeaders = [];
+    if (middlewareOverrideHeaders) {
+        for (const [key, value] of flightHeaders){
+            finalResponse.headers.set(`x-middleware-request-${key}`, value);
+            overwrittenHeaders.push(key);
+        }
+        if (overwrittenHeaders.length > 0) {
+            finalResponse.headers.set('x-middleware-override-headers', middlewareOverrideHeaders + ',' + overwrittenHeaders.join(','));
+        }
+    }
+    return {
+        response: finalResponse,
+        waitUntil: (0, _fetchevent.getWaitUntilPromiseFromEvent)(event) ?? Promise.resolve(),
+        fetchMetrics: request.fetchMetrics
+    };
+}
+
+//# sourceMappingURL=adapter.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/web/edge-route-module-wrapper.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EdgeRouteModuleWrapper", {
+    enumerable: true,
+    get: function() {
+        return EdgeRouteModuleWrapper;
+    }
+});
+require("./globals");
+const _adapter = require("./adapter");
+const _incrementalcache = require("../lib/incremental-cache");
+const _handlers = require("../use-cache/handlers");
+const _internaledgewaituntil = require("./internal-edge-wait-until");
+const _serverutils = require("../server-utils");
+const _querystring = require("../../shared/lib/router/utils/querystring");
+const _webonclose = require("./web-on-close");
+const _getedgepreviewprops = require("./get-edge-preview-props");
+const _web = require("../../server/base-http/web");
+const _utils = require("../../shared/lib/router/utils");
+class EdgeRouteModuleWrapper {
+    /**
+   * The constructor is wrapped with private to ensure that it can only be
+   * constructed by the static wrap method.
+   *
+   * @param routeModule the route module to wrap
+   */ constructor(routeModule, cacheHandlers){
+        this.routeModule = routeModule;
+        this.cacheHandlers = cacheHandlers;
+        this.pageIsDynamic = (0, _utils.isDynamicRoute)(routeModule.definition.pathname);
+    }
+    /**
+   * This will wrap a module with the EdgeModuleWrapper and return a function
+   * that can be used as a handler for the edge runtime.
+   *
+   * @param module the module to wrap
+   * @param options any options that should be passed to the adapter and
+   *                override the ones passed from the runtime
+   * @returns a function that can be used as a handler for the edge runtime
+   */ static wrap(routeModule, options) {
+        // Create the module wrapper.
+        const wrapper = new EdgeRouteModuleWrapper(routeModule, options.cacheHandlers ?? {});
+        // Return the wrapping function.
+        return (opts)=>{
+            return (0, _adapter.adapter)({
+                ...opts,
+                IncrementalCache: _incrementalcache.IncrementalCache,
+                incrementalCacheHandler: options.incrementalCacheHandler,
+                // Bind the handler method to the wrapper so it still has context.
+                handler: wrapper.handler.bind(wrapper),
+                page: options.page
+            });
+        };
+    }
+    async handler(request, evt) {
+        const utils = (0, _serverutils.getServerUtils)({
+            pageIsDynamic: this.pageIsDynamic,
+            page: this.routeModule.definition.pathname,
+            basePath: request.nextUrl.basePath,
+            // We don't need the `handleRewrite` util, so can just pass an empty object
+            rewrites: {},
+            // only used for rewrites, so setting an arbitrary default value here
+            caseSensitive: false
+        });
+        const { nextConfig } = this.routeModule.getNextConfigEdge(new _web.WebNextRequest(request));
+        (0, _handlers.initializeCacheHandlers)(nextConfig.cacheMaxMemorySize);
+        for (const [kind, cacheHandler] of Object.entries(this.cacheHandlers)){
+            (0, _handlers.setCacheHandler)(kind, cacheHandler);
+        }
+        const { params } = utils.normalizeDynamicRouteParams((0, _querystring.searchParamsToUrlQuery)(request.nextUrl.searchParams), false);
+        const waitUntil = evt.waitUntil.bind(evt);
+        const closeController = new _webonclose.CloseController();
+        const previewProps = (0, _getedgepreviewprops.getEdgePreviewProps)();
+        // Create the context for the handler. This contains the params from the
+        // match (if any).
+        const context = {
+            params,
+            previewProps,
+            renderOpts: {
+                waitUntil,
+                onClose: closeController.onClose.bind(closeController),
+                onAfterTaskError: undefined,
+                cacheComponents: !!process.env.__NEXT_CACHE_COMPONENTS,
+                // Edge runtime doesn't run instant validation; the level value is
+                // irrelevant here.
+                // TODO: Remove validationLevel and other global config from renderOpts
+                validationLevel: 'warning',
+                experimental: {
+                    authInterrupts: !!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS,
+                    // Edge runtime doesn't support Cache Components, so this value is
+                    // never read. 0 is a sentinel: if something ever reads it, the cache
+                    // fill will time out immediately and surface the bug.
+                    useCacheTimeout: 0,
+                    durableUseCacheEntries: false
+                },
+                cacheLifeProfiles: nextConfig.cacheLife,
+                // Edge runtime doesn't do static generation, so this value does not
+                // apply here. 0 is a sentinel: if something ever reads it, it'll
+                // surface loudly instead of silently using a misleading default.
+                staticPageGenerationTimeout: 0
+            },
+            sharedContext: {
+                buildId: '',
+                deploymentId: ''
+            }
+        };
+        // Get the response from the handler.
+        let res = await this.routeModule.handle(request, context);
+        const waitUntilPromises = [
+            (0, _internaledgewaituntil.internal_getCurrentFunctionWaitUntil)()
+        ];
+        if (context.renderOpts.pendingWaitUntil) {
+            waitUntilPromises.push(context.renderOpts.pendingWaitUntil);
+        }
+        evt.waitUntil(Promise.all(waitUntilPromises));
+        if (!res.body) {
+            // we can delay running it until a bit later --
+            // if it's needed, we'll have a `waitUntil` lock anyway.
+            setTimeout(()=>closeController.dispatchClose(), 0);
+        } else {
+            // NOTE: if this is a streaming response, onClose may be called later,
+            // so we can't rely on `closeController.listeners` -- it might be 0 at this point.
+            const trackedBody = (0, _webonclose.trackStreamConsumed)(res.body, ()=>closeController.dispatchClose());
+            res = new Response(trackedBody, {
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers
+            });
+        }
+        return res;
+    }
+}
+
+//# sourceMappingURL=edge-route-module-wrapper.js.map