@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/server/app-render/work-unit-async-storage.external.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getCacheSignal: null,
+    getDraftModeProviderForCacheScope: null,
+    getHmrRefreshHash: null,
+    getResumeDataCache: null,
+    getServerComponentsHmrCache: null,
+    getStagedRenderingController: null,
+    getVaryParamsAccumulator: null,
+    isHmrRefresh: null,
+    throwForMissingRequestStore: null,
+    throwInvariantForMissingStore: null,
+    willConsumerServerCache: null,
+    workUnitAsyncStorage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getCacheSignal: function() {
+        return getCacheSignal;
+    },
+    getDraftModeProviderForCacheScope: function() {
+        return getDraftModeProviderForCacheScope;
+    },
+    getHmrRefreshHash: function() {
+        return getHmrRefreshHash;
+    },
+    getResumeDataCache: function() {
+        return getResumeDataCache;
+    },
+    getServerComponentsHmrCache: function() {
+        return getServerComponentsHmrCache;
+    },
+    getStagedRenderingController: function() {
+        return getStagedRenderingController;
+    },
+    getVaryParamsAccumulator: function() {
+        return getVaryParamsAccumulator;
+    },
+    isHmrRefresh: function() {
+        return isHmrRefresh;
+    },
+    throwForMissingRequestStore: function() {
+        return throwForMissingRequestStore;
+    },
+    throwInvariantForMissingStore: function() {
+        return throwInvariantForMissingStore;
+    },
+    willConsumerServerCache: function() {
+        return willConsumerServerCache;
+    },
+    workUnitAsyncStorage: function() {
+        return _workunitasyncstorageinstance.workUnitAsyncStorageInstance;
+    }
+});
+const _workunitasyncstorageinstance = require("./work-unit-async-storage-instance");
+const _invarianterror = require("../../shared/lib/invariant-error");
+function willConsumerServerCache(workUnitStore) {
+    if (!workUnitStore) {
+        return false;
+    }
+    switch(workUnitStore.type){
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+            return workUnitStore.consumerWillServerCache;
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-legacy':
+            return true;
+        case 'request':
+        case 'prerender-runtime':
+        case 'validation-client':
+        case 'build-time-generator':
+            return false;
+        default:
+            return workUnitStore;
+    }
+}
+function throwForMissingRequestStore(callingExpression) {
+    throw new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`);
+}
+function throwInvariantForMissingStore() {
+    throw new _invarianterror.InvariantError('Expected workUnitAsyncStorage to have a store.');
+}
+function getResumeDataCache(workUnitStore) {
+    switch(workUnitStore.type){
+        case 'request':
+        case 'prerender':
+        case 'prerender-runtime':
+        case 'prerender-client':
+        case 'validation-client':
+            return workUnitStore.resumeDataCache;
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'prerender-legacy':
+        case 'build-time-generator':
+            return null;
+        default:
+            return workUnitStore;
+    }
+}
+function getHmrRefreshHash(workUnitStore) {
+    if (process.env.__NEXT_DEV_SERVER) {
+        switch(workUnitStore.type){
+            case 'cache':
+            case 'private-cache':
+            case 'prerender':
+            case 'prerender-runtime':
+            case 'request':
+                return workUnitStore.hmrRefreshHash;
+            case 'prerender-client':
+            case 'validation-client':
+            case 'prerender-legacy':
+            case 'unstable-cache':
+            case 'build-time-generator':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    return undefined;
+}
+function isHmrRefresh(workUnitStore) {
+    if (process.env.__NEXT_DEV_SERVER) {
+        switch(workUnitStore.type){
+            case 'cache':
+            case 'private-cache':
+            case 'request':
+                return workUnitStore.isHmrRefresh ?? false;
+            case 'prerender':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'prerender-runtime':
+            case 'prerender-legacy':
+            case 'unstable-cache':
+            case 'build-time-generator':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    return false;
+}
+function getServerComponentsHmrCache(workUnitStore) {
+    if (process.env.__NEXT_DEV_SERVER) {
+        switch(workUnitStore.type){
+            case 'cache':
+            case 'private-cache':
+            case 'request':
+                return workUnitStore.serverComponentsHmrCache;
+            case 'prerender':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'prerender-runtime':
+            case 'prerender-legacy':
+            case 'unstable-cache':
+            case 'build-time-generator':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    return undefined;
+}
+function getDraftModeProviderForCacheScope(workStore, workUnitStore) {
+    if (workStore.isDraftMode) {
+        switch(workUnitStore.type){
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+            case 'prerender-runtime':
+            case 'request':
+                return workUnitStore.draftMode;
+            case 'prerender':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'prerender-legacy':
+            case 'build-time-generator':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    return undefined;
+}
+function getStagedRenderingController(workUnitStore) {
+    switch(workUnitStore.type){
+        case 'request':
+        case 'prerender-runtime':
+        case 'prerender':
+            return workUnitStore.stagedRendering ?? null;
+        case 'prerender-client':
+        case 'validation-client':
+        case 'prerender-legacy':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'build-time-generator':
+            return null;
+        default:
+            return workUnitStore;
+    }
+}
+function getCacheSignal(workUnitStore) {
+    switch(workUnitStore.type){
+        case 'prerender':
+        case 'prerender-client':
+        case 'validation-client':
+        case 'prerender-runtime':
+            return workUnitStore.cacheSignal;
+        case 'request':
+            {
+                // In dev, we might fill caches even during a dynamic request.
+                if (workUnitStore.cacheSignal) {
+                    return workUnitStore.cacheSignal;
+                }
+            // fallthrough
+            }
+        case 'prerender-legacy':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'build-time-generator':
+            return null;
+        default:
+            return workUnitStore;
+    }
+}
+function getVaryParamsAccumulator(workUnitStore) {
+    switch(workUnitStore.type){
+        case 'prerender':
+        case 'prerender-runtime':
+        case 'request':
+            {
+                return workUnitStore.varyParamsAccumulator ?? null;
+            }
+        case 'prerender-legacy':
+        case 'cache':
+        case 'private-cache':
+        case 'prerender-client':
+        case 'validation-client':
+        case 'unstable-cache':
+        case 'build-time-generator':
+            return null;
+        default:
+            workUnitStore;
+            return null;
+    }
+}
+
+//# sourceMappingURL=work-unit-async-storage.external.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/async-storage/draft-mode-provider.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DraftModeProvider", {
+    enumerable: true,
+    get: function() {
+        return DraftModeProvider;
+    }
+});
+const _apiutils = require("../api-utils");
+class DraftModeProvider {
+    constructor(previewProps, headers, cookies, mutableCookies){
+        var _cookies_get;
+        // The logic for draftMode() is very similar to tryGetPreviewData()
+        // but Draft Mode does not have any data associated with it.
+        const isOnDemandRevalidate = previewProps && (0, _apiutils.checkIsOnDemandRevalidate)(headers, previewProps).isOnDemandRevalidate;
+        const cookieValue = (_cookies_get = cookies.get(_apiutils.COOKIE_NAME_PRERENDER_BYPASS)) == null ? void 0 : _cookies_get.value;
+        this._isEnabled = Boolean(!isOnDemandRevalidate && cookieValue && previewProps && (cookieValue === previewProps.previewModeId || // In dev mode, the cookie can be actual hash value preview id but the preview props can still be `development-id`.
+        process.env.NODE_ENV !== 'production' && previewProps.previewModeId === 'development-id'));
+        this._previewModeId = previewProps == null ? void 0 : previewProps.previewModeId;
+        this._mutableCookies = mutableCookies;
+    }
+    get isEnabled() {
+        return this._isEnabled;
+    }
+    enable() {
+        if (!this._previewModeId) {
+            throw new Error('Invariant: previewProps missing previewModeId this should never happen');
+        }
+        this._mutableCookies.set({
+            name: _apiutils.COOKIE_NAME_PRERENDER_BYPASS,
+            value: this._previewModeId,
+            httpOnly: true,
+            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
+            secure: process.env.NODE_ENV !== 'development',
+            path: '/'
+        });
+        this._isEnabled = true;
+    }
+    disable() {
+        // To delete a cookie, set `expires` to a date in the past:
+        // https://tools.ietf.org/html/rfc6265#section-4.1.1
+        // `Max-Age: 0` is not valid, thus ignored, and the cookie is persisted.
+        this._mutableCookies.set({
+            name: _apiutils.COOKIE_NAME_PRERENDER_BYPASS,
+            value: '',
+            httpOnly: true,
+            sameSite: process.env.NODE_ENV !== 'development' ? 'none' : 'lax',
+            secure: process.env.NODE_ENV !== 'development',
+            path: '/',
+            expires: new Date(0)
+        });
+        this._isEnabled = false;
+    }
+}
+
+//# sourceMappingURL=draft-mode-provider.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/async-storage/request-store.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createRequestStore: null,
+    createRequestStoreForAPI: null,
+    createRequestStoreForRender: null,
+    synchronizeMutableCookies: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createRequestStore: function() {
+        return createRequestStore;
+    },
+    createRequestStoreForAPI: function() {
+        return createRequestStoreForAPI;
+    },
+    createRequestStoreForRender: function() {
+        return createRequestStoreForRender;
+    },
+    synchronizeMutableCookies: function() {
+        return synchronizeMutableCookies;
+    }
+});
+const _approuterheaders = require("../../client/components/app-router-headers");
+const _headers = require("../web/spec-extension/adapters/headers");
+const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
+const _cookies = require("../web/spec-extension/cookies");
+const _draftmodeprovider = require("./draft-mode-provider");
+const _utils = require("../web/utils");
+/**
+ * Internal request headers that userland `headers()` must not expose. They stay
+ * on the shared request headers for framework plumbing.
+ *
+ * Every internal header that the client can send must be listed here. The
+ * sealed userland view reads through to the shared request headers, so an
+ * omission leaks the header to userland.
+ *
+ * The names are lowercased because `HeadersAdapter.seal` matches them in
+ * lowercase.
+ */ const HIDDEN_REQUEST_HEADERS = new Set([
+    ..._approuterheaders.FLIGHT_HEADERS,
+    // The client sends these dev-only request IDs so the server can route debug
+    // information back to the originating request. Like the flight headers,
+    // they are internal plumbing.
+    _approuterheaders.NEXT_REQUEST_ID_HEADER,
+    _approuterheaders.NEXT_HTML_REQUEST_ID_HEADER
+].map((header)=>header.toLowerCase()));
+function getHeaders(headers) {
+    // The sealed userland view must not copy the request headers.
+    // `HeadersAdapter.from` returns a `Headers` instance unchanged, so the view
+    // reads through to `NextRequest.headers`. A copy detaches `headers()` from
+    // the writes that Proxy makes to `NextRequest.headers` afterwards.
+    //
+    // The view must also not delete the internal headers. Because
+    // `HeadersAdapter.from` does not copy, a delete removes them from the shared
+    // `req.headers`. The dev server reads the request-id headers from the raw
+    // request again, for example when it renders a redirect target after a server
+    // action. Their removal breaks the dev debug channel routing.
+    return _headers.HeadersAdapter.seal(_headers.HeadersAdapter.from(headers), HIDDEN_REQUEST_HEADERS);
+}
+function getMutableCookies(headers, onUpdateCookies) {
+    const cookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(headers));
+    return _requestcookies.MutableRequestCookiesAdapter.wrap(cookies, onUpdateCookies);
+}
+/**
+ * If middleware set cookies in this request (indicated by `x-middleware-set-cookie`),
+ * then merge those into the existing cookie object, so that when `cookies()` is accessed
+ * it's able to read the newly set cookies.
+ */ function mergeMiddlewareCookies(headers, existingCookies) {
+    // TODO: this only fires for `IncomingHttpHeaders`; `Headers` instances
+    // silently fall through (the `in` check and bracket access don't reach header
+    // values stored in internal slots). Confirm whether edge / Web `Headers`
+    // callers need this merge or already handle it elsewhere.
+    if ('x-middleware-set-cookie' in headers && typeof headers['x-middleware-set-cookie'] === 'string') {
+        const setCookieValue = headers['x-middleware-set-cookie'];
+        const responseHeaders = new Headers();
+        for (const cookie of (0, _utils.splitCookiesString)(setCookieValue)){
+            responseHeaders.append('set-cookie', cookie);
+        }
+        const responseCookies = new _cookies.ResponseCookies(responseHeaders);
+        // Transfer cookies from ResponseCookies to RequestCookies
+        for (const cookie of responseCookies.getAll()){
+            existingCookies.set(cookie);
+        }
+    }
+}
+function createRequestStoreForRender(req, res, url, rootParams, implicitTags, onUpdateCookies, previewProps, isHmrRefresh, serverComponentsHmrCache, resumeDataCache, stagedFallbackParams, hmrRefreshHash) {
+    return createRequestStore({
+        // Pages start in render phase by default
+        phase: 'render',
+        headers: req.headers,
+        onUpdateCookies: onUpdateCookies ?? (res ? (cookies)=>{
+            res.setHeader('Set-Cookie', cookies);
+        } : undefined),
+        url,
+        rootParams,
+        implicitTags,
+        resumeDataCache,
+        previewProps,
+        isHmrRefresh,
+        serverComponentsHmrCache,
+        hmrRefreshHash,
+        stagedFallbackParams
+    });
+}
+function createRequestStoreForAPI(req, url, implicitTags, onUpdateCookies, previewProps, hmrRefreshHash) {
+    return createRequestStore({
+        // API routes start in action phase by default
+        phase: 'action',
+        headers: req.headers,
+        onUpdateCookies,
+        url,
+        rootParams: {},
+        implicitTags,
+        resumeDataCache: null,
+        previewProps,
+        isHmrRefresh: false,
+        serverComponentsHmrCache: undefined,
+        hmrRefreshHash,
+        stagedFallbackParams: null
+    });
+}
+function createRequestStore(inputs) {
+    const { phase, headers, onUpdateCookies, url, rootParams, implicitTags, resumeDataCache, previewProps, isHmrRefresh, serverComponentsHmrCache, hmrRefreshHash, stagedFallbackParams } = inputs;
+    const cache = {};
+    return {
+        type: 'request',
+        phase,
+        implicitTags,
+        // Rather than just using the whole `url` here, we pull the parts we want
+        // to ensure we don't use parts of the URL that we shouldn't. This also
+        // lets us avoid requiring an empty string for `search` in the type.
+        url: {
+            pathname: url.pathname,
+            search: url.search ?? ''
+        },
+        rootParams,
+        get headers () {
+            if (!cache.headers) {
+                // Seal the headers object that'll freeze out any methods that could
+                // mutate the underlying data.
+                cache.headers = getHeaders(headers);
+            }
+            return cache.headers;
+        },
+        get cookies () {
+            if (!cache.cookies) {
+                // if middleware is setting cookie(s), then include those in
+                // the initial cached cookies so they can be read in render
+                const requestCookies = new _cookies.RequestCookies(_headers.HeadersAdapter.from(headers));
+                mergeMiddlewareCookies(headers, requestCookies);
+                // Seal the cookies object that'll freeze out any methods that could
+                // mutate the underlying data.
+                cache.cookies = _requestcookies.RequestCookiesAdapter.seal(requestCookies);
+            }
+            return cache.cookies;
+        },
+        set cookies (value){
+            cache.cookies = value;
+        },
+        get mutableCookies () {
+            if (!cache.mutableCookies) {
+                const mutableCookies = getMutableCookies(headers, onUpdateCookies);
+                mergeMiddlewareCookies(headers, mutableCookies);
+                cache.mutableCookies = mutableCookies;
+            }
+            return cache.mutableCookies;
+        },
+        get userspaceMutableCookies () {
+            if (!cache.userspaceMutableCookies) {
+                const userspaceMutableCookies = (0, _requestcookies.createCookiesWithMutableAccessCheck)(this);
+                cache.userspaceMutableCookies = userspaceMutableCookies;
+            }
+            return cache.userspaceMutableCookies;
+        },
+        get draftMode () {
+            if (!cache.draftMode) {
+                cache.draftMode = new _draftmodeprovider.DraftModeProvider(previewProps, headers, this.cookies, this.mutableCookies);
+            }
+            return cache.draftMode;
+        },
+        resumeDataCache: resumeDataCache ?? null,
+        isHmrRefresh,
+        serverComponentsHmrCache: serverComponentsHmrCache || globalThis.__serverComponentsHmrCache,
+        hmrRefreshHash,
+        stagedFallbackParams,
+        usedDynamic: false
+    };
+}
+function synchronizeMutableCookies(store) {
+    // TODO: does this need to update headers as well?
+    store.cookies = _requestcookies.RequestCookiesAdapter.seal((0, _requestcookies.responseCookiesToRequestCookies)(store.mutableCookies));
+}
+
+//# sourceMappingURL=request-store.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/async-storage/with-store.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=with-store.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/async-storage/work-store.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createPrerenderWorkStore: null,
+    createWorkStore: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createPrerenderWorkStore: function() {
+        return createPrerenderWorkStore;
+    },
+    createWorkStore: function() {
+        return createWorkStore;
+    }
+});
+const _aftercontext = require("../after/after-context");
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
+const _lazyresult = require("../lib/lazy-result");
+const _handlers = require("../use-cache/handlers");
+const _asynclocalstorage = require("../app-render/async-local-storage");
+function createWorkStore(context) {
+    return createWorkStoreImpl(context, !!process.env.__NEXT_DEV_SERVER);
+}
+function createPrerenderWorkStore(context) {
+    return createWorkStoreImpl(context, !!process.env.__NEXT_DEV_SERVER || !!process.env.NEXT_DEBUG_BUILD || process.env.NEXT_SSG_FETCH_METRICS === '1');
+}
+function createWorkStoreImpl({ page, renderOpts, isPrefetchRequest, buildId, deploymentId, previouslyRevalidatedTags, nonce }, shouldTrackFetchMetrics) {
+    const store = {
+        page,
+        route: (0, _apppaths.normalizeAppPath)(page),
+        incrementalCache: // we fallback to a global incremental cache for edge-runtime locally
+        // so that it can access the fs cache without mocks
+        renderOpts.incrementalCache || globalThis.__incrementalCache,
+        cacheLifeProfiles: renderOpts.cacheLifeProfiles,
+        useCacheTimeout: renderOpts.experimental.useCacheTimeout,
+        durableUseCacheEntries: renderOpts.experimental.durableUseCacheEntries,
+        staticPageGenerationTimeout: renderOpts.staticPageGenerationTimeout,
+        isBuildTimePrerendering: renderOpts.isBuildTimePrerendering,
+        fetchCache: renderOpts.fetchCache,
+        isOnDemandRevalidate: renderOpts.isOnDemandRevalidate,
+        requestId: undefined,
+        htmlRequestId: undefined,
+        isDraftMode: renderOpts.isDraftMode,
+        isPrefetchRequest,
+        buildId,
+        deploymentId,
+        reactLoadableManifest: (renderOpts == null ? void 0 : renderOpts.reactLoadableManifest) || {},
+        assetPrefix: (renderOpts == null ? void 0 : renderOpts.assetPrefix) || '',
+        nonce,
+        afterContext: createAfterContext(renderOpts),
+        cacheComponentsEnabled: renderOpts.cacheComponents,
+        validationLevel: renderOpts.validationLevel,
+        previouslyRevalidatedTags,
+        requestStartTime: performance.timeOrigin + performance.now(),
+        refreshTagsByCacheKind: createRefreshTagsByCacheKind(),
+        runInCleanSnapshot: (0, _asynclocalstorage.createSnapshot)(),
+        shouldTrackFetchMetrics,
+        clientComponentLoadTracker: undefined,
+        reactServerErrorsByDigest: new Map()
+    };
+    // TODO: remove this when we resolve accessing the store outside the execution context
+    renderOpts.store = store;
+    return store;
+}
+function createAfterContext(renderOpts) {
+    const { waitUntil, onClose, onAfterTaskError } = renderOpts;
+    return new _aftercontext.AfterContext({
+        waitUntil,
+        onClose,
+        onTaskError: onAfterTaskError
+    });
+}
+/**
+ * Creates a map with lazy results that refresh tags for the respective cache
+ * kind when they're awaited for the first time.
+ */ function createRefreshTagsByCacheKind() {
+    const refreshTagsByCacheKind = new Map();
+    const cacheHandlers = (0, _handlers.getCacheHandlerEntries)();
+    if (cacheHandlers) {
+        for (const [kind, cacheHandler] of cacheHandlers){
+            if ('refreshTags' in cacheHandler) {
+                refreshTagsByCacheKind.set(kind, (0, _lazyresult.createLazyResult)(async ()=>cacheHandler.refreshTags()));
+            }
+        }
+    }
+    return refreshTagsByCacheKind;
+}
+
+//# sourceMappingURL=work-store.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/base-http/helpers.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isNodeNextRequest: null,
+    isNodeNextResponse: null,
+    isWebNextRequest: null,
+    isWebNextResponse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isNodeNextRequest: function() {
+        return isNodeNextRequest;
+    },
+    isNodeNextResponse: function() {
+        return isNodeNextResponse;
+    },
+    isWebNextRequest: function() {
+        return isWebNextRequest;
+    },
+    isWebNextResponse: function() {
+        return isWebNextResponse;
+    }
+});
+const isWebNextRequest = (req)=>process.env.NEXT_RUNTIME === 'edge';
+const isWebNextResponse = (res)=>process.env.NEXT_RUNTIME === 'edge';
+const isNodeNextRequest = (req)=>process.env.NEXT_RUNTIME !== 'edge';
+const isNodeNextResponse = (res)=>process.env.NEXT_RUNTIME !== 'edge';
+
+//# sourceMappingURL=helpers.js.map