@codelionapps/unharness 0.0.0-stage → 0.1.1

package/dashboard/.next/standalone/node_modules/next/dist/client/components/router-reducer/reducers/server-action-reducer.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serverActionReducer", {
+    enumerable: true,
+    get: function() {
+        return serverActionReducer;
+    }
+});
+const _appcallserver = require("../../../app-call-server");
+const _appfindsourcemapurl = require("../../../app-find-source-map-url");
+const _approuterheaders = require("../../app-router-headers");
+const _unrecognizedactionerror = require("../../unrecognized-action-error");
+const _fetch = require("../../segment-cache/fetch");
+const _client = require("react-server-dom-webpack/client");
+const _routerreducertypes = require("../router-reducer-types");
+const _assignlocation = require("../../../assign-location");
+const _createhreffromurl = require("../create-href-from-url");
+const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
+const _flightdatahelpers = require("../../../flight-data-helpers");
+const _redirect = require("../../redirect");
+const _removebasepath = require("../../../remove-base-path");
+const _hasbasepath = require("../../../has-base-path");
+const _serverreferenceinfo = require("../../../../shared/lib/server-reference-info");
+const _cache = require("../../segment-cache/cache");
+const _scheduler = require("../../segment-cache/scheduler");
+const _deploymentid = require("../../../../shared/lib/deployment-id");
+const _navigationbuildid = require("../../../navigation-build-id");
+const _constants = require("../../../../lib/constants");
+const _approuterstate = require("../../app-router-state");
+const _decodeserverresponse = require("../../segment-cache/decode-server-response");
+const _optimisticroutes = require("../../segment-cache/optimistic-routes");
+const _actionrevalidationkind = require("../../../../shared/lib/action-revalidation-kind");
+const _approuterutils = require("../../app-router-utils");
+const _rendertree = require("../../render-tree");
+const _fetchserverresponse = require("../fetch-server-response");
+const _bfcache = require("../../segment-cache/bfcache");
+const createFromFetch = _client.createFromFetch;
+let createDebugChannel;
+if (process.env.__NEXT_DEV_SERVER && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
+    createDebugChannel = require('../../../dev/debug-channel').createDebugChannel;
+}
+async function fetchServerAction(state, nextUrl, action) {
+    const { actionId, actionArgs } = action;
+    const temporaryReferences = (0, _client.createTemporaryReferenceSet)();
+    const info = (0, _serverreferenceinfo.extractInfoFromServerReferenceId)(actionId);
+    const usedArgs = (0, _serverreferenceinfo.omitUnusedArgs)(actionArgs, info);
+    const body = await (0, _client.encodeReply)(usedArgs, {
+        temporaryReferences
+    });
+    const headers = {
+        Accept: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
+        [_approuterheaders.ACTION_HEADER]: actionId,
+        [_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]: (0, _flightdatahelpers.prepareFlightRouterStateForRequest)(state.tree)
+    };
+    const deploymentId = (0, _deploymentid.getDeploymentId)();
+    if (deploymentId) {
+        headers['x-deployment-id'] = deploymentId;
+    }
+    if (nextUrl) {
+        headers[_approuterheaders.NEXT_URL] = nextUrl;
+    }
+    if (process.env.__NEXT_DEV_SERVER) {
+        if (self.__next_r) {
+            headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] = self.__next_r;
+        }
+        // Create a new request ID for the server action request. The server uses
+        // this to tag debug information sent via WebSocket to the client, which
+        // then routes those chunks to the debug channel associated with this ID.
+        headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] = crypto.getRandomValues(new Uint32Array(1))[0].toString(16);
+    }
+    let res;
+    try {
+        res = await (0, _fetch.fetch)(state.canonicalUrl, {
+            method: 'POST',
+            headers,
+            body
+        });
+        // If the fetch succeeds while we're in the offline state, notify the
+        // offline module so it can short-circuit the polling loop.
+        if (process.env.__NEXT_USE_OFFLINE) {
+            const { notifyOnline } = require('../../offline');
+            notifyOnline();
+        }
+    } catch (err) {
+        if (process.env.__NEXT_USE_OFFLINE) {
+            const { checkOfflineError, getOffline, waitForConnection } = require('../../offline');
+            if (checkOfflineError(err)) {
+                // It's safe to replay the action because the fetch rejection
+                // means the request never reached the server — there are no
+                // side effects to duplicate.
+                const offline = getOffline();
+                if (offline !== null) {
+                    await waitForConnection(offline);
+                }
+                return fetchServerAction(state, nextUrl, action);
+            }
+        }
+        throw err;
+    }
+    // Handle server actions that the server didn't recognize.
+    const unrecognizedActionHeader = res.headers.get(_approuterheaders.NEXT_ACTION_NOT_FOUND_HEADER);
+    if (unrecognizedActionHeader === '1') {
+        throw new _unrecognizedactionerror.UnrecognizedActionError(`Server Action "${actionId}" was not found on the server. \nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`);
+    }
+    const redirectHeader = res.headers.get('x-action-redirect');
+    const [location1, _redirectType] = redirectHeader?.split(';') || [];
+    let redirectType;
+    switch(_redirectType){
+        case 'push':
+            redirectType = 'push';
+            break;
+        case 'replace':
+            redirectType = 'replace';
+            break;
+        default:
+            redirectType = undefined;
+    }
+    const isPrerender = !!res.headers.get(_approuterheaders.NEXT_IS_PRERENDER_HEADER);
+    let revalidationKind = _actionrevalidationkind.ActionDidNotRevalidate;
+    try {
+        const revalidationHeader = res.headers.get('x-action-revalidated');
+        if (revalidationHeader) {
+            const parsedKind = JSON.parse(revalidationHeader);
+            if (parsedKind === _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic || parsedKind === _actionrevalidationkind.ActionDidRevalidateDynamicOnly) {
+                revalidationKind = parsedKind;
+            }
+        }
+    } catch  {}
+    const redirectLocation = location1 ? (0, _assignlocation.assignLocation)(location1, new URL(state.canonicalUrl, window.location.href)) : undefined;
+    const contentType = res.headers.get('content-type');
+    const isRscResponse = !!(contentType && contentType.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER));
+    // Handle invalid server action responses.
+    // A valid response must have `content-type: text/x-component`, unless it's an external redirect.
+    // (external redirects have an 'x-action-redirect' header, but the body is an empty 'text/plain')
+    if (!isRscResponse && !redirectLocation) {
+        // The server can respond with a text/plain error message, but we'll fallback to something generic
+        // if there isn't one.
+        const message = res.status >= 400 && contentType === 'text/plain' ? await res.text() : 'An unexpected response was received from the server.';
+        throw new Error(message);
+    }
+    let actionResult;
+    let actionFlightData;
+    let actionFlightDataRenderedSearch;
+    let couldBeIntercepted = false;
+    if (isRscResponse) {
+        // Server action redirect responses carry the Flight data of the redirect
+        // target, which may be prerendered with a completeness marker byte
+        // prepended. Strip it before passing to Flight.
+        const responsePromise = redirectLocation ? (0, _fetchserverresponse.processFetch)(res).then(({ response: r })=>r) : Promise.resolve(res);
+        const response = await createFromFetch(responsePromise, {
+            callServer: _appcallserver.callServer,
+            findSourceMapURL: _appfindsourcemapurl.findSourceMapURL,
+            temporaryReferences,
+            debugChannel: createDebugChannel && createDebugChannel(headers)
+        });
+        // An internal redirect can send an RSC response, but does not have a useful `actionResult`.
+        actionResult = redirectLocation ? undefined : response.a;
+        couldBeIntercepted = response.i;
+        // Check if the response build ID matches the client build ID.
+        // In a multi-zone setup, when a server action triggers a redirect,
+        // the server pre-fetches the redirect target as RSC. If the redirect
+        // target is served by a different Next.js zone (different build), the
+        // pre-fetched RSC data will have a foreign build ID. We must discard
+        // the flight data in that case so the redirect triggers an MPA
+        // navigation (full page load) instead of trying to apply the foreign
+        // RSC payload — which would result in a blank page.
+        const responseBuildId = res.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? response.b;
+        if (responseBuildId !== undefined && responseBuildId !== (0, _navigationbuildid.getNavigationBuildId)()) {
+        // Build ID mismatch — discard the flight data. The redirect will
+        // still be processed, and the absence of flight data will cause an
+        // MPA navigation via completeHardNavigation().
+        } else {
+            if (response.t !== undefined) {
+                actionFlightData = response.t;
+                actionFlightDataRenderedSearch = response.q;
+            } else if (response.n !== undefined) {
+                // The server responded with an MPA navigation URL.
+                actionFlightData = response.n;
+            }
+        }
+    } else {
+        // An external redirect doesn't contain RSC data.
+        actionResult = undefined;
+        actionFlightData = undefined;
+        actionFlightDataRenderedSearch = undefined;
+    }
+    return {
+        actionResult,
+        actionFlightData,
+        actionFlightDataRenderedSearch,
+        redirectLocation,
+        redirectType,
+        revalidationKind,
+        isPrerender,
+        couldBeIntercepted
+    };
+}
+function serverActionReducer(state, action) {
+    const { resolve, reject } = action;
+    // only pass along the `nextUrl` param (used for interception routes) if the current route was intercepted.
+    // If the route has been intercepted, the action should be as well.
+    // Otherwise the server action might be intercepted with the wrong action id
+    // (ie, one that corresponds with the intercepted route)
+    const nextUrl = // We always send the last next-url, not the current when
+    // performing a dynamic request. This is because we update
+    // the next-url after a navigation, but we want the same
+    // interception route to be matched that used the last
+    // next-url.
+    (state.previousNextUrl || state.nextUrl) && (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree) ? state.previousNextUrl || state.nextUrl : null;
+    return fetchServerAction(state, nextUrl, action).then(async ({ revalidationKind, actionResult, actionFlightData: flightData, actionFlightDataRenderedSearch: flightDataRenderedSearch, redirectLocation, redirectType, isPrerender, couldBeIntercepted })=>{
+        if (revalidationKind !== _actionrevalidationkind.ActionDidNotRevalidate) {
+            // There was either a revalidation or a refresh, or maybe both.
+            // Evict the BFCache, which may contain dynamic data.
+            (0, _bfcache.invalidateBfCache)();
+            // Store whether this action triggered any revalidation
+            // The action queue will use this information to potentially
+            // trigger a refresh action if the action was discarded
+            // (ie, due to a navigation, before the action completed)
+            action.didRevalidate = true;
+            // If there was a revalidation, evict the prefetch cache.
+            // TODO: Evict only segments with matching tags and/or paths.
+            // TODO: We should only invalidate the route cache if cookies were
+            // mutated, since route trees may vary based on cookies. For now we
+            // invalidate both caches until we have a way to detect cookie
+            // mutations on the client.
+            if (revalidationKind === _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic) {
+                (0, _cache.invalidateEntirePrefetchCache)(nextUrl, state.root);
+            }
+            // Start a cooldown before re-prefetching to allow CDN cache
+            // propagation.
+            (0, _scheduler.startRevalidationCooldown)();
+        }
+        const navigateType = redirectType || 'push';
+        if (redirectLocation !== undefined) {
+            // If the action triggered a redirect, the action promise will be rejected with
+            // a redirect so that it's handled by RedirectBoundary as we won't have a valid
+            // action result to resolve the promise with. This will effectively reset the state of
+            // the component that called the action as the error boundary will remount the tree.
+            // The status code doesn't matter here as the action handler will have already sent
+            // a response with the correct status code.
+            if ((0, _approuterutils.isExternalURL)(redirectLocation)) {
+                // External redirect. Triggers an MPA navigation.
+                const redirectHref = redirectLocation.href;
+                const redirectError = createRedirectErrorForAction(redirectHref, navigateType);
+                reject(redirectError);
+                return (0, _approuterstate.completeHardNavigation)(state, redirectLocation, navigateType);
+            } else {
+                // Internal redirect. Triggers an SPA navigation.
+                const redirectWithBasepath = (0, _createhreffromurl.createHrefFromUrl)(redirectLocation, false);
+                const redirectHref = (0, _hasbasepath.hasBasePath)(redirectWithBasepath) ? (0, _removebasepath.removeBasePath)(redirectWithBasepath) : redirectWithBasepath;
+                const redirectError = createRedirectErrorForAction(redirectHref, navigateType);
+                reject(redirectError);
+            }
+        } else {
+            // If there's no redirect, resolve the action with the result.
+            resolve(actionResult);
+        }
+        // Check if we can bail out without updating any state.
+        if (// Did the action trigger a redirect?
+        redirectLocation === undefined && // Did the action revalidate any data?
+        revalidationKind === _actionrevalidationkind.ActionDidNotRevalidate && // Did the server render new data?
+        flightData === undefined) {
+            // The action did not trigger any revalidations or redirects. No
+            // navigation is required.
+            return state;
+        }
+        if (flightData === undefined && redirectLocation !== undefined) {
+            // The server redirected, but did not send any Flight data. This implies
+            // an external redirect.
+            // TODO: We should refactor the action response type to be more explicit
+            // about the various response types.
+            return (0, _approuterstate.completeHardNavigation)(state, redirectLocation, navigateType);
+        }
+        if (typeof flightData === 'string') {
+            // If the flight data is just a string, something earlier in the
+            // response handling triggered an external redirect.
+            return (0, _approuterstate.completeHardNavigation)(state, new URL(flightData, location.origin), navigateType);
+        }
+        // The action triggered a navigation — either a redirect, a revalidation,
+        // or both.
+        // If there was no redirect, then the target URL is the same as the
+        // current URL.
+        const currentUrl = new URL(state.canonicalUrl, location.origin);
+        const currentRenderedSearch = state.renderedSearch;
+        const redirectUrl = redirectLocation !== undefined ? redirectLocation : currentUrl;
+        const currentFlightRouterState = state.tree;
+        const scrollBehavior = _routerreducertypes.ScrollBehavior.Default;
+        // If the action triggered a revalidation of the cache, we should also
+        // refresh all the dynamic data.
+        const freshnessPolicy = revalidationKind === _actionrevalidationkind.ActionDidNotRevalidate ? _rendertree.FreshnessPolicy.Default : _rendertree.FreshnessPolicy.RefreshAll;
+        // The server may have sent back new data. If so, we will perform a
+        // "seeded" navigation that uses the data from the response.
+        // TODO: Currently the server always renders from the root in
+        // response to a Server Action. In the case of a normal redirect
+        // with no revalidation, it should skip over the shared layouts.
+        if (flightData !== undefined && flightDataRenderedSearch !== undefined) {
+            // The server sent back new route data as part of the response. We
+            // will use this to render the new page. If this happens to be only a
+            // subset of the data needed to render the new page, we'll initiate a
+            // new fetch, like we would for a normal navigation.
+            const redirectCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(redirectUrl);
+            const now = Date.now();
+            // TODO: Store the dynamic stale time on the top-level state so it's
+            // known during restores and refreshes.
+            const redirectSeed = (0, _decodeserverresponse.createNavigationSeed)(now, currentFlightRouterState, flightData, // Action responses stream in incrementally, so their vary params
+            // can't be drained here — and nothing consumes them from a
+            // navigation seed (only segment-cache writes read vary params, and
+            // those decode their own, buffered, payloads).
+            null, // Same for partiality: only segment-cache writes consume it, and
+            // action responses are never written to the segment cache. Pass
+            // the conservative value.
+            true, // Navigation responses always include the param values in the
+            // tree, so there's no pathname to parse them from (nor a need to).
+            null, flightDataRenderedSearch, null, _bfcache.UnknownDynamicStaleTime);
+            // Learn the route pattern so we can predict it for future navigations.
+            (0, _optimisticroutes.discoverKnownRoute)(now, redirectUrl.pathname, redirectUrl.search, nextUrl, null, redirectSeed.root, couldBeIntercepted, redirectCanonicalUrl, redirectSeed.renderedSearch, isPrerender, false // hasDynamicRewrite
+            );
+            const navigationLock = (0, _rendertree.getCurrentNavigationLock)();
+            return (0, _approuterstate.navigateToKnownRoute)(now, state, redirectUrl, redirectCanonicalUrl, redirectSeed, currentUrl, currentRenderedSearch, state.root, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, // A server-action redirect navigation is bound to the shared map.
+            _cache.segmentCacheMap, null, // Server action redirects don't use route prediction - we already
+            // have the route tree from the server response. If a mismatch occurs
+            // during dynamic data fetch, the retry handler will traverse the
+            // known route tree to mark the entry as having a dynamic rewrite.
+            null, // Not an HMR refresh, so there's no request generation to cancel.
+            undefined);
+        }
+        // The server did not send back new data. We'll perform a regular, non-
+        // seeded navigation — effectively the same as <Link> or router.push().
+        return (0, _approuterstate.navigate)(state, redirectUrl, currentUrl, currentRenderedSearch, state.root, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType);
+    }, (e)=>{
+        // When the server action is rejected we don't update the state and instead call the reject handler of the promise.
+        reject(e);
+        return state;
+    });
+}
+function createRedirectErrorForAction(redirectHref, resolvedRedirectType) {
+    const redirectError = (0, _redirect.getRedirectError)(redirectHref, resolvedRedirectType);
+    redirectError.handled = true;
+    return redirectError;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=server-action-reducer.js.map

package/dashboard/.next/standalone/node_modules/next/dist/client/components/router-reducer/reducers/server-patch-reducer.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serverPatchReducer", {
+    enumerable: true,
+    get: function() {
+        return serverPatchReducer;
+    }
+});
+const _createhreffromurl = require("../create-href-from-url");
+const _routerreducertypes = require("../router-reducer-types");
+const _approuterstate = require("../../app-router-state");
+const _cache = require("../../segment-cache/cache");
+const _refreshreducer = require("./refresh-reducer");
+const _rendertree = require("../../render-tree");
+function serverPatchReducer(state, action) {
+    // A "retry" is a navigation that happens due to a route mismatch. It's
+    // similar to a refresh, because we will omit any existing dynamic data on
+    // the page. But we seed the retry navigation with the exact tree that the
+    // server just responded with.
+    const retryMpa = action.mpa;
+    const retryUrl = new URL(action.url, location.origin);
+    const retrySeed = action.seed;
+    const navigateType = action.navigateType;
+    if (retryMpa || retrySeed === null) {
+        // If the server did not send back data during the mismatch, fall back to
+        // an MPA navigation.
+        return (0, _approuterstate.completeHardNavigation)(state, retryUrl, navigateType);
+    }
+    const currentUrl = new URL(state.canonicalUrl, location.origin);
+    const currentRenderedSearch = state.renderedSearch;
+    if (action.previousTree !== state.tree) {
+        // There was another, more recent navigation since the once that
+        // mismatched. We can abort the retry, but we still need to refresh the
+        // page to evict any stale dynamic data.
+        return (0, _refreshreducer.refreshReducer)(state, {
+            type: _routerreducertypes.ACTION_REFRESH
+        });
+    }
+    // There have been no new navigations since the mismatched one. Refresh,
+    // using the tree we just received from the server.
+    //
+    // The freshness policy comes from the action: a genuine tree mismatch
+    // re-fetches the dynamic data (`RefreshAll`), whereas a redirect that only
+    // changed the canonical URL reuses the data already in the tree
+    // (`HistoryTraversal`), since the data we received is correct.
+    const retryCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(retryUrl);
+    const retryNextUrl = action.nextUrl;
+    const scrollBehavior = _routerreducertypes.ScrollBehavior.Default;
+    const navigationLock = (0, _rendertree.getCurrentNavigationLock)();
+    const now = Date.now();
+    return (0, _approuterstate.navigateToKnownRoute)(now, state, retryUrl, retryCanonicalUrl, retrySeed, currentUrl, currentRenderedSearch, state.root, action.freshnessPolicy, retryNextUrl, scrollBehavior, navigateType, navigationLock, // A server-patch retry navigation is bound to the shared map.
+    _cache.segmentCacheMap, null, // Server patch (retry) navigations don't use route prediction. This is
+    // typically a retry after a previous mismatch, so the route was already
+    // marked as having a dynamic rewrite when the mismatch was detected.
+    null, // Not an HMR refresh, so there's no request generation to cancel.
+    undefined);
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=server-patch-reducer.js.map

package/dashboard/.next/standalone/node_modules/next/dist/client/components/router-reducer/router-reducer-types.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ACTION_HMR_REFRESH: null,
+    ACTION_NAVIGATE: null,
+    ACTION_REFRESH: null,
+    ACTION_RESTORE: null,
+    ACTION_SERVER_ACTION: null,
+    ACTION_SERVER_PATCH: null,
+    PrefetchKind: null,
+    ScrollBehavior: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ACTION_HMR_REFRESH: function() {
+        return ACTION_HMR_REFRESH;
+    },
+    ACTION_NAVIGATE: function() {
+        return ACTION_NAVIGATE;
+    },
+    ACTION_REFRESH: function() {
+        return ACTION_REFRESH;
+    },
+    ACTION_RESTORE: function() {
+        return ACTION_RESTORE;
+    },
+    ACTION_SERVER_ACTION: function() {
+        return ACTION_SERVER_ACTION;
+    },
+    ACTION_SERVER_PATCH: function() {
+        return ACTION_SERVER_PATCH;
+    },
+    PrefetchKind: function() {
+        return PrefetchKind;
+    },
+    ScrollBehavior: function() {
+        return ScrollBehavior;
+    }
+});
+const ACTION_REFRESH = 'refresh';
+const ACTION_NAVIGATE = 'navigate';
+const ACTION_RESTORE = 'restore';
+const ACTION_SERVER_PATCH = 'server-patch';
+const ACTION_HMR_REFRESH = 'hmr-refresh';
+const ACTION_SERVER_ACTION = 'server-action';
+var PrefetchKind = /*#__PURE__*/ function(PrefetchKind) {
+    PrefetchKind["AUTO"] = "auto";
+    PrefetchKind["FULL"] = "full";
+    return PrefetchKind;
+}({});
+var ScrollBehavior = /*#__PURE__*/ function(ScrollBehavior) {
+    /** Use per-node ScrollRef to decide whether to scroll. */ ScrollBehavior[ScrollBehavior["Default"] = 0] = "Default";
+    /** Suppress scroll entirely (e.g. scroll={false} on Link or router.push). */ ScrollBehavior[ScrollBehavior["NoScroll"] = 1] = "NoScroll";
+    return ScrollBehavior;
+}({});
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=router-reducer-types.js.map

package/dashboard/.next/standalone/node_modules/next/dist/client/components/router-reducer/router-reducer.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "reducer", {
+    enumerable: true,
+    get: function() {
+        return reducer;
+    }
+});
+const _routerreducertypes = require("./router-reducer-types");
+const _navigatereducer = require("./reducers/navigate-reducer");
+const _serverpatchreducer = require("./reducers/server-patch-reducer");
+const _restorereducer = require("./reducers/restore-reducer");
+const _refreshreducer = require("./reducers/refresh-reducer");
+const _serveractionreducer = require("./reducers/server-action-reducer");
+/**
+ * Reducer that handles the app-router state updates.
+ */ function clientReducer(state, action) {
+    switch(action.type){
+        case _routerreducertypes.ACTION_NAVIGATE:
+            {
+                return (0, _navigatereducer.navigateReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_SERVER_PATCH:
+            {
+                return (0, _serverpatchreducer.serverPatchReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_RESTORE:
+            {
+                return (0, _restorereducer.restoreReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_REFRESH:
+            {
+                return (0, _refreshreducer.refreshReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_HMR_REFRESH:
+            {
+                if (process.env.NODE_ENV === 'development') {
+                    const { hmrRefreshReducer } = require('./reducers/hmr-refresh-reducer');
+                    return hmrRefreshReducer(state, action);
+                } else {
+                    throw new Error('hmrRefresh can only be used in development mode. Please use refresh instead.');
+                }
+            }
+        case _routerreducertypes.ACTION_SERVER_ACTION:
+            {
+                return (0, _serveractionreducer.serverActionReducer)(state, action);
+            }
+        // This case should never be hit as dispatch is strongly typed.
+        default:
+            throw new Error('Unknown action');
+    }
+}
+function serverReducer(state, _action) {
+    return state;
+}
+const reducer = typeof window === 'undefined' ? serverReducer : clientReducer;
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=router-reducer.js.map

package/dashboard/.next/standalone/node_modules/next/dist/client/components/router-reducer/set-cache-busting-search-param.js

@@ -0,0 +1,66 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    setCacheBustingSearchParam: null,
+    setCacheBustingSearchParamWithHash: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    setCacheBustingSearchParam: function() {
+        return setCacheBustingSearchParam;
+    },
+    setCacheBustingSearchParamWithHash: function() {
+        return setCacheBustingSearchParamWithHash;
+    }
+});
+const _cachebustingsearchparam = require("../../../shared/lib/router/utils/cache-busting-search-param");
+const _approuterheaders = require("../app-router-headers");
+async function computeClientCacheBustingSearchParam(headers) {
+    if (typeof globalThis.crypto?.subtle?.digest === 'function') {
+        return (0, _cachebustingsearchparam.computeCacheBustingSearchParam)(headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER], headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER], headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER], headers[_approuterheaders.NEXT_URL]);
+    }
+    return (0, _cachebustingsearchparam.computeLegacyCacheBustingSearchParam)(headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER], headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER], headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER], headers[_approuterheaders.NEXT_URL]);
+}
+const setCacheBustingSearchParam = async (url, headers)=>{
+    const uniqueCacheKey = await computeClientCacheBustingSearchParam(headers);
+    setCacheBustingSearchParamWithHash(url, uniqueCacheKey);
+};
+const setCacheBustingSearchParamWithHash = (url, hash)=>{
+    /**
+   * Note that we intentionally do not use `url.searchParams.set` here:
+   *
+   * const url = new URL('https://example.com/search?q=custom%20spacing');
+   * url.searchParams.set('_rsc', 'abc123');
+   * console.log(url.toString()); // Outputs: https://example.com/search?q=custom+spacing&_rsc=abc123
+   *                                                                             ^ <--- this is causing confusion
+   * This is in fact intended based on https://url.spec.whatwg.org/#interface-urlsearchparams, but
+   * we want to preserve the %20 as %20 if that's what the user passed in, hence the custom
+   * logic below.
+   */ const existingSearch = url.search;
+    const rawQuery = existingSearch.startsWith('?') ? existingSearch.slice(1) : existingSearch;
+    // Always remove any existing cache busting param and add a fresh one to ensure
+    // we have the correct value based on current request headers
+    const pairs = rawQuery.split('&').filter((pair)=>pair && !pair.startsWith(`${_approuterheaders.NEXT_RSC_UNION_QUERY}=`));
+    if (hash.length > 0) {
+        pairs.push(`${_approuterheaders.NEXT_RSC_UNION_QUERY}=${hash}`);
+    } else {
+        pairs.push(`${_approuterheaders.NEXT_RSC_UNION_QUERY}`);
+    }
+    url.search = pairs.length ? `?${pairs.join('&')}` : '';
+};
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=set-cache-busting-search-param.js.map