@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/client/components/segment-cache/types.js

@@ -0,0 +1,93 @@
+/**
+ * Shared types and constants for the Segment Cache.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    FetchStrategy: null,
+    NavigationResultTag: null,
+    PrefetchPriority: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    FetchStrategy: function() {
+        return FetchStrategy;
+    },
+    NavigationResultTag: function() {
+        return NavigationResultTag;
+    },
+    PrefetchPriority: function() {
+        return PrefetchPriority;
+    }
+});
+var NavigationResultTag = /*#__PURE__*/ function(NavigationResultTag) {
+    NavigationResultTag[NavigationResultTag["MPA"] = 0] = "MPA";
+    NavigationResultTag[NavigationResultTag["Success"] = 1] = "Success";
+    NavigationResultTag[NavigationResultTag["NoOp"] = 2] = "NoOp";
+    NavigationResultTag[NavigationResultTag["Async"] = 3] = "Async";
+    return NavigationResultTag;
+}({});
+var PrefetchPriority = /*#__PURE__*/ function(PrefetchPriority) {
+    /**
+   * Assigned to the most recently hovered/touched link. Special network
+   * bandwidth is reserved for this task only. There's only ever one Intent-
+   * priority task at a time; when a new Intent task is scheduled, the previous
+   * one is bumped down to Default.
+   */ PrefetchPriority[PrefetchPriority["Intent"] = 2] = "Intent";
+    /**
+   * The default priority for prefetch tasks.
+   */ PrefetchPriority[PrefetchPriority["Default"] = 1] = "Default";
+    /**
+   * Assigned to tasks when they spawn non-blocking background work, like
+   * revalidating a partially cached entry to see if more data is available.
+   */ PrefetchPriority[PrefetchPriority["Background"] = 0] = "Background";
+    return PrefetchPriority;
+}({});
+var FetchStrategy = /*#__PURE__*/ function(FetchStrategy) {
+    // Deliberately ordered so we can easily compare two segments
+    // and determine if one segment is "more specific" than another
+    // (i.e. if it's likely that it contains more data). See
+    // canNewFetchStrategyProvideMoreContent in cache.ts for what each tier can
+    // contain relative to the others.
+    //
+    // Full and LoadingBoundary belong to the non-Partial-Prefetching regime:
+    // they're only relevant in modes where the staging concepts (shell tiers,
+    // runtime prefetches) don't apply. They sit on this single ordered ladder
+    // as an accepted convenience, because cross-regime comparisons exist
+    // (e.g. canNewFetchStrategyProvideMoreContent).
+    //
+    // These numeric values are client-internal and never cross the wire — the
+    // `next-router-prefetch` request header values are mapped explicitly in
+    // fetchSegmentPrefetchesUsingRuntimeRequest (cache.ts) — so the members can
+    // be renumbered freely as long as the relative order is preserved.
+    FetchStrategy[FetchStrategy["LoadingBoundary"] = 0] = "LoadingBoundary";
+    // The shell-stage variant extracted from a static per-segment prefetch
+    // response: every segment's param-dependent content is reduced to pending
+    // references that render as the param fallback, keyed at the shell vary
+    // paths (only root params kept concrete). The Shell PHASE that issues
+    // these requests targets the conceptual App Shell; the strategy itself is
+    // just this mechanical truncation and keying. Less complete than
+    // RuntimeShell — a static response can't include content that depends on
+    // session data (cookies, headers) — and less complete than PPR at concrete
+    // paths, which includes prerendered param-dependent content.
+    FetchStrategy[FetchStrategy["StaticShell"] = 1] = "StaticShell";
+    FetchStrategy[FetchStrategy["RuntimeShell"] = 2] = "RuntimeShell";
+    FetchStrategy[FetchStrategy["PPR"] = 3] = "PPR";
+    FetchStrategy[FetchStrategy["PPRRuntime"] = 4] = "PPRRuntime";
+    FetchStrategy[FetchStrategy["Full"] = 5] = "Full";
+    return FetchStrategy;
+}({});
+
+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=types.js.map

package/dashboard/.next/standalone/node_modules/next/dist/client/components/segment-cache/vary-path.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ParamsChange: null,
+    appendLayoutVaryPath: null,
+    cloneVaryPathWithNewSearchParams: null,
+    compareParams: null,
+    didReadChangedParam: null,
+    finalizeVaryPath: null,
+    getFulfilledRouteVaryPath: null,
+    getFulfilledSegmentVaryPath: null,
+    getPartialVaryPath: null,
+    getRenderedSearchFromVaryPath: null,
+    getRouteVaryPath: null,
+    getSegmentVaryPathForRequest: null,
+    getShellSegmentVaryPath: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ParamsChange: function() {
+        return ParamsChange;
+    },
+    appendLayoutVaryPath: function() {
+        return appendLayoutVaryPath;
+    },
+    cloneVaryPathWithNewSearchParams: function() {
+        return cloneVaryPathWithNewSearchParams;
+    },
+    compareParams: function() {
+        return compareParams;
+    },
+    didReadChangedParam: function() {
+        return didReadChangedParam;
+    },
+    finalizeVaryPath: function() {
+        return finalizeVaryPath;
+    },
+    getFulfilledRouteVaryPath: function() {
+        return getFulfilledRouteVaryPath;
+    },
+    getFulfilledSegmentVaryPath: function() {
+        return getFulfilledSegmentVaryPath;
+    },
+    getPartialVaryPath: function() {
+        return getPartialVaryPath;
+    },
+    getRenderedSearchFromVaryPath: function() {
+        return getRenderedSearchFromVaryPath;
+    },
+    getRouteVaryPath: function() {
+        return getRouteVaryPath;
+    },
+    getSegmentVaryPathForRequest: function() {
+        return getSegmentVaryPathForRequest;
+    },
+    getShellSegmentVaryPath: function() {
+        return getShellSegmentVaryPath;
+    }
+});
+const _types = require("./types");
+const _cachemap = require("./cache-map");
+const _varyparamsdecoding = require("../../../shared/lib/segment-cache/vary-params-decoding");
+function getRouteVaryPath(pathname, search, nextUrl) {
+    // requestKey -> searchParams -> nextUrl
+    const varyPath = {
+        id: null,
+        value: pathname,
+        isRootParam: false,
+        parent: {
+            id: _varyparamsdecoding.SEARCH_PARAMS_VARY_ID,
+            value: search,
+            isRootParam: false,
+            parent: {
+                id: null,
+                value: nextUrl,
+                isRootParam: false,
+                parent: null
+            }
+        }
+    };
+    return varyPath;
+}
+function getFulfilledRouteVaryPath(pathname, search, nextUrl, couldBeIntercepted) {
+    // This is called when a route's data is fulfilled. The cache entry will be
+    // re-keyed based on which inputs the response varies by.
+    // requestKey -> searchParams -> nextUrl
+    const varyPath = {
+        id: null,
+        value: pathname,
+        isRootParam: false,
+        parent: {
+            id: _varyparamsdecoding.SEARCH_PARAMS_VARY_ID,
+            value: search,
+            isRootParam: false,
+            parent: {
+                id: null,
+                value: couldBeIntercepted ? nextUrl : _cachemap.Fallback,
+                isRootParam: false,
+                parent: null
+            }
+        }
+    };
+    return varyPath;
+}
+function appendLayoutVaryPath(parentPath, cacheKey, paramName, isRootParam) {
+    const varyPathPart = {
+        id: paramName,
+        value: cacheKey,
+        isRootParam,
+        parent: parentPath
+    };
+    return varyPathPart;
+}
+function finalizeVaryPath(requestKey, // Non-null when the segment varies on search params: the search entry is
+// spliced in between the request key and the path params. Fallback keys an
+// entry that is reusable across all search strings.
+searchParams, partialVaryPath) {
+    // requestKey -> [searchParams] -> pathParams
+    let parent = partialVaryPath;
+    if (searchParams !== null) {
+        parent = {
+            id: _varyparamsdecoding.SEARCH_PARAMS_VARY_ID,
+            value: searchParams,
+            isRootParam: false,
+            parent: partialVaryPath
+        };
+    }
+    const varyPath = {
+        id: null,
+        value: requestKey,
+        isRootParam: false,
+        parent
+    };
+    return varyPath;
+}
+function getPartialVaryPath(finalizedVaryPath) {
+    // This is the inverse of finalizeVaryPath: strip the request key, and the
+    // search params entry if there is one.
+    const parent = finalizedVaryPath.parent;
+    if (parent !== null && parent.id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+        return parent.parent;
+    }
+    return parent;
+}
+function getSegmentVaryPathForRequest(fetchStrategy, tree) {
+    // This is used for storing pending requests in the cache. We want to choose
+    // the most generic vary path based on the strategy used to fetch it, i.e.
+    // static/PPR versus runtime prefetching, so that it can be reused as much
+    // as possible.
+    //
+    // We may be able to re-key the response to something even more generic once
+    // we receive it — for example, if the server tells us that the response
+    // doesn't vary on a particular param — but even before we send the request,
+    // we know some params are reusable based on the fetch strategy alone. For
+    // example, a static prefetch will never vary on search params.
+    //
+    // The original vary path with all the params filled in is stored on the
+    // route tree object. We will clone this one to create a new vary path
+    // where certain params are replaced with Fallback.
+    //
+    // This result of this function is not stored anywhere. It's only used to
+    // access the cache a single time.
+    //
+    // TODO: Rather than create a new list object just to access the cache, the
+    // plan is to add the concept of a "vary mask". This will represent all the
+    // params that can be treated as Fallback. (Or perhaps the inverse.)
+    const originalVaryPath = tree.varyPath;
+    if (fetchStrategy === _types.FetchStrategy.RuntimeShell || fetchStrategy === _types.FetchStrategy.StaticShell) {
+        // Both shell strategies produce the App Shell variant of a segment —
+        // RuntimeShell via a runtime render with non-root params omitted,
+        // StaticShell by truncating a static per-segment response at the shell
+        // byte boundary. Either way, the resulting entry is reusable across all
+        // concrete values of the non-root params, so we key it at the precomputed
+        // shell vary path (every non-root param substituted with Fallback; root
+        // params keep their concrete value).
+        return tree.shellVaryPath;
+    }
+    // The vary path includes a search params entry only when the segment varies
+    // on search params.
+    const searchParamsVaryPath = originalVaryPath.parent;
+    if (searchParamsVaryPath !== null && searchParamsVaryPath.id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+        // Only a runtime prefetch will include search params in the vary path.
+        // Static prefetches never include search params, so they can be reused
+        // across all possible search param values.
+        const doesVaryOnSearchParams = fetchStrategy === _types.FetchStrategy.Full || fetchStrategy === _types.FetchStrategy.PPRRuntime;
+        if (!doesVaryOnSearchParams) {
+            // The response from the the server will not vary on search params.
+            // Rebuild the vary path with the search params replaced by Fallback.
+            //
+            // requestKey -> searchParams -> pathParams
+            //               ^ This part gets replaced with Fallback
+            return finalizeVaryPath(originalVaryPath.value, _cachemap.Fallback, getPartialVaryPath(originalVaryPath));
+        }
+    }
+    // The request does vary on search params. We don't need to modify anything.
+    return originalVaryPath;
+}
+function cloneVaryPathWithNewSearchParams(originalVaryPath, newSearch) {
+    // requestKey -> searchParams -> pathParams
+    //               ^ This part gets replaced with newSearch
+    const searchParamsVaryPath = originalVaryPath.parent;
+    if (searchParamsVaryPath === null || searchParamsVaryPath.id !== _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+        // No search params entry; nothing to replace.
+        return originalVaryPath;
+    }
+    return finalizeVaryPath(originalVaryPath.value, newSearch, getPartialVaryPath(originalVaryPath));
+}
+function getRenderedSearchFromVaryPath(varyPath) {
+    let node = varyPath;
+    while(node !== null){
+        if (node.id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+            const search = node.value;
+            if (typeof search === 'string') {
+                return search;
+            }
+            return null;
+        }
+        node = node.parent;
+    }
+    return null;
+}
+var ParamsChange = /*#__PURE__*/ function(ParamsChange) {
+    ParamsChange[ParamsChange["None"] = 0] = "None";
+    ParamsChange[ParamsChange["SearchParams"] = 1] = "SearchParams";
+    ParamsChange[ParamsChange["PathParam"] = 2] = "PathParam";
+    return ParamsChange;
+}({});
+function compareParams(currentVaryPath, nextVaryPath) {
+    // Both vary paths are for the same segment, so they list the same params in
+    // the same order. Walk them together. This includes params inherited from
+    // parent layouts, since those may have changed, too.
+    let current = currentVaryPath;
+    let next = nextVaryPath;
+    let change = 0;
+    while(current !== null && next !== null){
+        if (current.value !== next.value) {
+            const id = current.id;
+            if (id === null) {
+            // The request key. Callers check that the route structure matches
+            // first, so it's always the same.
+            } else if (id === _varyparamsdecoding.SEARCH_PARAMS_VARY_ID) {
+                change = 1;
+            } else {
+                return 2;
+            }
+        }
+        current = current.parent;
+        next = next.parent;
+    }
+    return change;
+}
+function didReadChangedParam(currentVaryPath, nextVaryPath, varyParams) {
+    // Returns true if the output rendered with `currentVaryPath` read a param
+    // whose value is different in `nextVaryPath`. `varyParams` is the set of
+    // params the output read, or null if we don't know.
+    //
+    // Same traversal as compareParams. Only read the set if a param changed.
+    let current = currentVaryPath;
+    let next = nextVaryPath;
+    let total = null;
+    while(current !== null && next !== null){
+        if (current.value !== next.value) {
+            const id = current.id;
+            if (id === null) {
+            // The request key. Callers check that the route structure matches
+            // first, so it's always the same.
+            } else {
+                if (total === null) {
+                    if (varyParams === null) {
+                        // We don't know. Assume it read the param.
+                        return true;
+                    }
+                    total = (0, _varyparamsdecoding.readVaryParams)(varyParams);
+                    if (total === null) {
+                        // The render hasn't finished, or it aborted. Assume it read the
+                        // param.
+                        return true;
+                    }
+                }
+                if (total.has(id)) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+        next = next.parent;
+    }
+    return false;
+}
+function getFulfilledSegmentVaryPath(original, varyParams) {
+    // Re-keys a segment's vary path based on which params the segment actually
+    // depends on. Params that are NOT in the varyParams set are replaced with
+    // Fallback, allowing the cache entry to be reused across different values of
+    // those params.
+    // This is called when a segment is fulfilled with data from the server. The
+    // varyParams set comes from the server and indicates which params were
+    // accessed during rendering.
+    const clone = {
+        id: original.id,
+        // If the id is null, this node is not a param (e.g., it's a request key).
+        // If the id is in the varyParams set, keep the original value.
+        // Otherwise, replace with Fallback to make it reusable.
+        value: original.id === null || varyParams.has(original.id) ? original.value : _cachemap.Fallback,
+        isRootParam: original.isRootParam,
+        parent: original.parent === null ? null : getFulfilledSegmentVaryPath(original.parent, varyParams)
+    };
+    return clone;
+}
+function getShellSegmentVaryPath(original) {
+    // Re-keys a segment's vary path to identify the "App Shell" entry for this
+    // segment position — a reusable loading state that can be served for any
+    // concrete navigation to this segment. The shell is rendered with params
+    // omitted, with one exception: root params (path params at or above the root
+    // layout) may be accessed during the shell render, so the shell varies on
+    // them. Accordingly, we keep the concrete value of structural nodes (request
+    // keys, etc.) and root param nodes, and replace every other param node (non-
+    // root path params and search params) with Fallback.
+    const clone = {
+        id: original.id,
+        value: original.id === null || original.isRootParam === true ? original.value : _cachemap.Fallback,
+        isRootParam: original.isRootParam,
+        parent: original.parent === null ? null : getShellSegmentVaryPath(original.parent)
+    };
+    return clone;
+}
+
+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=vary-path.js.map

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

@@ -0,0 +1,163 @@
+// The sequential-router-queue implementation of the navigator interface
+// (navigator.ts). Callers must never import this module directly; they import
+// './navigator', which resolves here unless `experimental.
+// concurrentRouterQueue` swaps in `./concurrent-router-queue` at the bundler
+// level (see create-compiler-aliases.ts and next_import_map.rs).
+//
+// The legacy reducer action objects are an implementation detail of the
+// sequential action queue; they are constructed here and never by callers.
+//
+// This module must remain free of side effects at module scope: in addition
+// to the browser bundle, a statically-resolved copy is compiled into the
+// pre-compiled app-page runtime bundles (via app-render.tsx), where the
+// bundler alias cannot reach. Only the browser copy's operations ever run.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    hmrRefresh: null,
+    navigate: null,
+    push: null,
+    refresh: null,
+    replace: null,
+    restore: null,
+    traverse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    hmrRefresh: function() {
+        return hmrRefresh;
+    },
+    navigate: function() {
+        return navigate;
+    },
+    push: function() {
+        return push;
+    },
+    refresh: function() {
+        return refresh;
+    },
+    replace: function() {
+        return replace;
+    },
+    restore: function() {
+        return restore;
+    },
+    traverse: function() {
+        return traverse;
+    }
+});
+const _react = require("react");
+const _routerreducertypes = require("./router-reducer/router-reducer-types");
+const _useactionqueue = require("./use-action-queue");
+const _approuterinstance = require("./app-router-instance");
+const _links = require("./links");
+const _routertransition = require("./router-transition");
+const _addbasepath = require("../add-base-path");
+const _approuterutils = require("./app-router-utils");
+const _javascripturl = require("../lib/javascript-url");
+const _optimisticroutes = require("./segment-cache/optimistic-routes");
+function getRequiredAppRouterState() {
+    const state = (0, _approuterinstance.getCurrentAppRouterState)();
+    if (state === null) {
+        throw new Error('Internal Next.js error: Router action dispatched before initialization.');
+    }
+    return state;
+}
+function navigate(href, navigateType, scrollBehavior, linkInstanceRef, transitionTypes, prefetchIntent) {
+    if ((0, _javascripturl.isJavaScriptURLString)(href)) {
+        throw new Error('Next.js has blocked a javascript: URL as a security precaution.');
+    }
+    (0, _react.startTransition)(()=>{
+        // TODO: This stuff could just go into the reducer. Leaving as-is for now
+        // since we're about to rewrite all the router reducer stuff anyway.
+        if (transitionTypes) {
+            for (const type of transitionTypes){
+                (0, _react.addTransitionType)(type);
+            }
+        }
+        const url = new URL((0, _addbasepath.addBasePath)(href), location.href);
+        if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
+            window.next.__pendingUrl = url;
+        }
+        (0, _links.setLinkForCurrentNavigation)(linkInstanceRef);
+        (0, _routertransition.startRouterTransition)(href, navigateType, getRequiredAppRouterState().tree, prefetchIntent);
+        (0, _useactionqueue.dispatchAppRouterAction)({
+            type: _routerreducertypes.ACTION_NAVIGATE,
+            url,
+            isExternalUrl: (0, _approuterutils.isExternalURL)(url),
+            locationSearch: location.search,
+            scrollBehavior,
+            navigateType
+        });
+    });
+}
+function push(href, options) {
+    navigate(href, 'push', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes, null);
+}
+function replace(href, options) {
+    navigate(href, 'replace', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes, null);
+}
+function traverse(href, historyState) {
+    (0, _react.startTransition)(()=>{
+        (0, _routertransition.startRouterTransition)(href, 'traverse', getRequiredAppRouterState().tree, null);
+        restore(new URL(href), historyState);
+    });
+}
+function restore(url, historyState) {
+    (0, _react.startTransition)(()=>{
+        (0, _useactionqueue.dispatchAppRouterAction)({
+            type: _routerreducertypes.ACTION_RESTORE,
+            url,
+            historyState
+        });
+    });
+}
+function refresh() {
+    (0, _react.startTransition)(()=>{
+        (0, _useactionqueue.dispatchAppRouterAction)({
+            type: _routerreducertypes.ACTION_REFRESH
+        });
+    });
+}
+// Tracks the newest HMR refresh generation so that a newer refresh can abort
+// the request of the one it supersedes. Development only.
+let activeHmrRefreshController = null;
+function hmrRefresh() {
+    if (process.env.NODE_ENV !== 'development') {
+        throw new Error('hmrRefresh can only be used in development mode. Please use refresh instead.');
+    } else {
+        // Reset the known routes table so that route predictions are cleared
+        // when routes change during development.
+        (0, _optimisticroutes.resetKnownRoutes)();
+        let signal;
+        if (process.env.__NEXT_SERVER_COMPONENTS_HMR_CANCELLATION) {
+            // Abort the superseded generation before scheduling the new one, so its
+            // request is torn down as early as possible. Halting (not rejecting)
+            // makes the abort safe regardless of order.
+            activeHmrRefreshController?.abort();
+            activeHmrRefreshController = new AbortController();
+            signal = activeHmrRefreshController.signal;
+        }
+        (0, _react.startTransition)(()=>{
+            (0, _useactionqueue.dispatchAppRouterAction)({
+                type: _routerreducertypes.ACTION_HMR_REFRESH,
+                signal
+            });
+        });
+    }
+}
+
+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=sequential-router-queue.js.map

package/dashboard/.next/standalone/node_modules/next/dist/client/components/server-async-storage.js

@@ -0,0 +1,43 @@
+// Client-safe access to the server-only async-storage singletons. On the
+// server these re-export the real storages; in the browser bundle this module
+// is aliased to `./server-async-storage.browser` (see
+// scripts/generate-browser-variant-aliases.mjs), which exports `undefined`
+// stubs so the AsyncLocalStorage modules are never bundled into the client.
+// Consumers must guard usage so the stubs are not dereferenced in the browser.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    actionAsyncStorage: null,
+    workAsyncStorage: null,
+    workUnitAsyncStorage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    actionAsyncStorage: function() {
+        return _actionasyncstorageexternal.actionAsyncStorage;
+    },
+    workAsyncStorage: function() {
+        return _workasyncstorageexternal.workAsyncStorage;
+    },
+    workUnitAsyncStorage: function() {
+        return _workunitasyncstorageexternal.workUnitAsyncStorage;
+    }
+});
+const _actionasyncstorageexternal = require("../../server/app-render/action-async-storage.external");
+const _workasyncstorageexternal = require("../../server/app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../../server/app-render/work-unit-async-storage.external");
+
+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-async-storage.js.map

package/dashboard/.next/standalone/node_modules/next/dist/client/components/static-generation-bailout.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    StaticGenBailoutError: null,
+    isStaticGenBailoutError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    StaticGenBailoutError: function() {
+        return StaticGenBailoutError;
+    },
+    isStaticGenBailoutError: function() {
+        return isStaticGenBailoutError;
+    }
+});
+const NEXT_STATIC_GEN_BAILOUT = 'NEXT_STATIC_GEN_BAILOUT';
+class StaticGenBailoutError extends Error {
+    constructor(...args){
+        super(...args), this.code = NEXT_STATIC_GEN_BAILOUT;
+    }
+}
+function isStaticGenBailoutError(error) {
+    if (typeof error !== 'object' || error === null || !('code' in error)) {
+        return false;
+    }
+    return error.code === NEXT_STATIC_GEN_BAILOUT;
+}
+
+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=static-generation-bailout.js.map