@codelionapps/unharness 0.0.0-stage → 0.1.0

package/dashboard/.next/standalone/node_modules/next/dist/server/web/spec-extension/revalidate.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    refresh: null,
+    revalidatePath: null,
+    revalidateTag: null,
+    updateTag: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    refresh: function() {
+        return refresh;
+    },
+    revalidatePath: function() {
+        return revalidatePath;
+    },
+    revalidateTag: function() {
+        return revalidateTag;
+    },
+    updateTag: function() {
+        return updateTag;
+    }
+});
+const _dynamicrendering = require("../../app-render/dynamic-rendering");
+const _utils = require("../../../shared/lib/router/utils");
+const _constants = require("../../../lib/constants");
+const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
+const _hooksservercontext = require("../../../client/components/hooks-server-context");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _actionrevalidationkind = require("../../../shared/lib/action-revalidation-kind");
+const _removetrailingslash = require("../../../shared/lib/router/utils/remove-trailing-slash");
+const _encodeheadersafe = require("../../lib/encode-header-safe");
+const _usecachemessages = require("../../use-cache/use-cache-messages");
+const _cachelifeprofile = require("../../use-cache/cache-life-profile");
+function revalidateTag(tag, profile) {
+    if (!profile) {
+        console.warn('"revalidateTag" without the second argument is now deprecated, add second argument of "max" or use "updateTag". See more info here: https://nextjs.org/docs/messages/revalidate-tag-single-arg');
+    } else if (typeof profile === 'object') {
+        profile = (0, _cachelifeprofile.validateAndNormalizeCacheLifeProfile)(profile, {
+            kind: 'inline'
+        });
+    }
+    return revalidate([
+        (0, _encodeheadersafe.encodeHeaderSafe)(tag)
+    ], `revalidateTag(${JSON.stringify(tag)})`, profile);
+}
+function updateTag(tag) {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    // TODO: change this after investigating why phase: 'action' is
+    // set for route handlers
+    if (!workStore || workStore.page.endsWith('/route')) {
+        throw new Error('updateTag can only be called from within a Server Action. ' + 'To invalidate cache tags in Route Handlers or other contexts, use revalidateTag instead. ' + 'See more info here: https://nextjs.org/docs/app/api-reference/functions/updateTag');
+    }
+    // updateTag uses immediate expiration (no profile) without deprecation warning
+    return revalidate([
+        (0, _encodeheadersafe.encodeHeaderSafe)(tag)
+    ], `updateTag(${JSON.stringify(tag)})`, undefined);
+}
+function refresh() {
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!workStore || workStore.page.endsWith('/route') || (workUnitStore == null ? void 0 : workUnitStore.phase) !== 'action') {
+        throw new Error('refresh can only be called from within a Server Action. ' + 'See more info here: https://nextjs.org/docs/app/api-reference/functions/refresh');
+    }
+    if (workStore) {
+        // The Server Action version of refresh() only revalidates the dynamic data
+        // on the client. It doesn't affect cached data.
+        workStore.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateDynamicOnly;
+    }
+}
+function revalidatePath(originalPath, type) {
+    if (originalPath.length > _constants.NEXT_CACHE_SOFT_TAG_MAX_LENGTH) {
+        console.warn(`Warning: revalidatePath received "${originalPath}" which exceeded max length of ${_constants.NEXT_CACHE_SOFT_TAG_MAX_LENGTH}. See more info here https://nextjs.org/docs/app/api-reference/functions/revalidatePath`);
+        return;
+    }
+    let normalizedPath = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${(0, _encodeheadersafe.encodeHeaderSafe)((0, _removetrailingslash.removeTrailingSlash)(originalPath))}`;
+    if (type) {
+        normalizedPath += `${normalizedPath.endsWith('/') ? '' : '/'}${type}`;
+    } else if ((0, _utils.isDynamicRoute)(originalPath)) {
+        console.warn(`Warning: a dynamic page path "${originalPath}" was passed to "revalidatePath", but the "type" parameter is missing. This has no effect by default, see more info here https://nextjs.org/docs/app/api-reference/functions/revalidatePath`);
+    }
+    const tags = [
+        normalizedPath
+    ];
+    if (normalizedPath === `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`) {
+        tags.push(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/index`);
+    } else if (normalizedPath === `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/index`) {
+        tags.push(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`);
+    }
+    return revalidate(tags, `revalidatePath(${JSON.stringify(originalPath)})`);
+}
+function revalidate(tags, expression, profile) {
+    const store = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!store || !store.incrementalCache) {
+        throw new Error(`Invariant: static generation store missing in ${expression}`);
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        // Prefer the more specific contexts over the general render-phase error.
+        switch(workUnitStore.type){
+            case 'build-time-generator':
+                throw (0, _usecachemessages.createRevalidateInBuildTimeGeneratorError)(store.route, expression, workUnitStore.functionName);
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+                throw (0, _usecachemessages.createRevalidateInCachedFunctionError)(store.route, expression);
+            case 'prerender':
+            case 'prerender-runtime':
+            case 'prerender-client':
+            case 'validation-client':
+            case 'prerender-legacy':
+            case 'request':
+                break;
+            default:
+                workUnitStore;
+        }
+        if (workUnitStore.phase === 'render') {
+            throw (0, _usecachemessages.createRevalidateDuringRenderError)(store.route, expression);
+        }
+        switch(workUnitStore.type){
+            case 'prerender':
+            case 'prerender-runtime':
+                // cacheComponents Prerender
+                const error = new Error(`Route ${store.route} used ${expression} without first calling \`await connection()\`.`);
+                return (0, _dynamicrendering.abortAndThrowOnSynchronousRequestDataAccess)(store.route, expression, error, workUnitStore);
+            case 'prerender-client':
+            case 'validation-client':
+                throw new _invarianterror.InvariantError(`${expression} must not be used within a client component. Next.js should be preventing ${expression} from being included in client components statically, but did not in this case.`);
+            case 'prerender-legacy':
+                workUnitStore.revalidate = 0;
+                const err = new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`);
+                store.dynamicUsageDescription = expression;
+                store.dynamicUsageStack = err.stack;
+                throw err;
+            case 'request':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    if (!store.pendingRevalidatedTags) {
+        store.pendingRevalidatedTags = [];
+    }
+    const revalidatedAt = performance.timeOrigin + performance.now();
+    for (const tag of tags){
+        const existingIndex = store.pendingRevalidatedTags.findIndex((item)=>{
+            if (item.tag !== tag) return false;
+            // Compare profiles: both strings, both objects, or both undefined
+            if (typeof item.profile === 'string' && typeof profile === 'string') {
+                return item.profile === profile;
+            }
+            if (typeof item.profile === 'object' && typeof profile === 'object') {
+                return JSON.stringify(item.profile) === JSON.stringify(profile);
+            }
+            return item.profile === profile;
+        });
+        if (existingIndex === -1) {
+            store.pendingRevalidatedTags.push({
+                tag,
+                profile,
+                revalidatedAt
+            });
+        } else {
+            // Revalidating a tag again invalidates everything produced up to now, so
+            // the latest revalidation is the one that decides which entries are
+            // stale.
+            store.pendingRevalidatedTags[existingIndex].revalidatedAt = revalidatedAt;
+        }
+    }
+    // if profile is provided and this is a stale-while-revalidate
+    // update we do not mark the path as revalidated so that server
+    // actions don't pull their own writes
+    const cacheLife = profile && typeof profile === 'object' ? profile : profile && typeof profile === 'string' && (store == null ? void 0 : store.cacheLifeProfiles[profile]) ? store.cacheLifeProfiles[profile] : undefined;
+    if (!profile || (cacheLife == null ? void 0 : cacheLife.expire) === 0) {
+        // TODO: only revalidate if the path matches
+        store.pathWasRevalidated = _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic;
+    }
+}
+
+//# sourceMappingURL=revalidate.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/web/spec-extension/unstable-cache.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "unstable_cache", {
+    enumerable: true,
+    get: function() {
+        return unstable_cache;
+    }
+});
+const _constants = require("../../../lib/constants");
+const _patchfetch = require("../../lib/patch-fetch");
+const _encodeheadersafe = require("../../lib/encode-header-safe");
+const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
+const _responsecache = require("../../response-cache");
+let noStoreFetchIdx = 0;
+async function cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl) {
+    await incrementalCache.set(cacheKey, {
+        kind: _responsecache.CachedRouteKind.FETCH,
+        data: {
+            headers: {},
+            // TODO: handle non-JSON values?
+            body: JSON.stringify(result),
+            status: 200,
+            url: ''
+        },
+        revalidate: typeof revalidate !== 'number' ? _constants.CACHE_ONE_YEAR_SECONDS : revalidate
+    }, {
+        fetchCache: true,
+        tags,
+        fetchIdx,
+        fetchUrl
+    });
+    return;
+}
+function unstable_cache(cb, keyParts, options = {}) {
+    if (options.revalidate === 0) {
+        throw new Error(`Invariant revalidate: 0 can not be passed to unstable_cache(), must be "false" or "> 0" ${cb.toString()}`);
+    }
+    // Validate the tags provided are valid
+    const tags = options.tags ? (0, _patchfetch.validateTags)(options.tags, `unstable_cache ${cb.toString()}`) : [];
+    // Validate the revalidate option, and adopt the normalized value, which
+    // maps `false` and `Infinity` to INFINITE_CACHE so that the stored value
+    // survives JSON serialization.
+    const revalidate = (0, _patchfetch.validateRevalidate)(options.revalidate, `unstable_cache ${cb.name || cb.toString()}`);
+    // Stash the fixed part of the key at construction time. The invocation key will combine
+    // the fixed key with the arguments when actually called
+    // @TODO if cb.toString() is long we should hash it
+    // @TODO come up with a collision-free way to combine keyParts
+    // @TODO consider validating the keyParts are all strings. TS can't provide runtime guarantees
+    // and the error produced by accidentally using something that cannot be safely coerced is likely
+    // hard to debug
+    const fixedKey = `${cb.toString()}-${Array.isArray(keyParts) && keyParts.join(',')}`;
+    const cachedCb = async (...args)=>{
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+        // We must be able to find the incremental cache otherwise we throw
+        const maybeIncrementalCache = (workStore == null ? void 0 : workStore.incrementalCache) || globalThis.__incrementalCache;
+        if (!maybeIncrementalCache) {
+            throw new Error(`Invariant: incrementalCache missing in unstable_cache ${cb.toString()}`);
+        }
+        const incrementalCache = maybeIncrementalCache;
+        const cacheSignal = workUnitStore ? (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore) : null;
+        if (cacheSignal) {
+            cacheSignal.beginRead();
+        }
+        try {
+            // If there's no request store, we aren't in a request (or we're not in
+            // app router) and if there's no static generation store, we aren't in app
+            // router. Default to an empty pathname and search params when there's no
+            // request store or static generation store available.
+            const fetchUrlPrefix = workStore && workUnitStore ? getFetchUrlPrefix(workStore, workUnitStore) : '';
+            // Construct the complete cache key for this function invocation
+            // @TODO stringify is likely not safe here. We will coerce undefined to null which will make
+            // the keyspace smaller than the execution space
+            const invocationKey = `${fixedKey}-${JSON.stringify(args)}`;
+            const cacheKey = await incrementalCache.generateSimpleCacheKey(invocationKey);
+            // $urlWithPath,$sortedQueryStringKeys,$hashOfEveryThingElse
+            //
+            // A cache implementation may serialize this name into an HTTP request
+            // header, so it is encoded here. Both parts can carry a character above
+            // U+00FF: the search parameters are decoded, and a JavaScript identifier
+            // may hold one. The character class leaves the separating spaces and the
+            // URL punctuation untouched, so the shape above is preserved.
+            //
+            // `toWellFormed` replaces lone surrogates, which `cb.name` can hold and
+            // which `encodeURIComponent` rejects. The name identifies the call for
+            // debug metrics, so a replacement character is an acceptable trade for
+            // not failing the render.
+            const fetchUrl = (0, _encodeheadersafe.encodeHeaderSafe)(`unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`.toWellFormed());
+            const fetchIdx = (workStore ? workStore.nextFetchId : noStoreFetchIdx) ?? 1;
+            const implicitTags = workUnitStore == null ? void 0 : workUnitStore.implicitTags;
+            const innerCacheStore = {
+                type: 'unstable-cache',
+                phase: 'render',
+                consumerWillServerCache: true,
+                implicitTags,
+                draftMode: workUnitStore && workStore && (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, workUnitStore),
+                rootParams: undefined
+            };
+            if (workStore) {
+                workStore.nextFetchId = fetchIdx + 1;
+                // We are in an App Router context. We try to return the cached entry if it exists and is valid
+                // If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
+                // the background. If the entry is missing or invalid we generate a new entry and return it.
+                let isNestedUnstableCache = false;
+                if (workUnitStore) {
+                    switch(workUnitStore.type){
+                        case 'cache':
+                        case 'private-cache':
+                        case 'prerender':
+                        case 'prerender-runtime':
+                        case 'prerender-legacy':
+                            // We update the store's revalidate property if the revalidate option is a higher precedence
+                            // revalidate === undefined doesn't affect timing.
+                            // revalidate === INFINITE_CACHE (from `false` or `Infinity`) doesn't shrink timing. it stays at the maximum.
+                            if (typeof revalidate === 'number') {
+                                if (workUnitStore.revalidate < revalidate) {
+                                // The store is already revalidating on a shorter time interval, leave it alone
+                                } else {
+                                    workUnitStore.revalidate = revalidate;
+                                }
+                            }
+                            // We need to accumulate the tags for this invocation within the store
+                            const collectedTags = workUnitStore.tags;
+                            if (collectedTags === null) {
+                                workUnitStore.tags = tags.slice();
+                            } else {
+                                for (const tag of tags){
+                                    // @TODO refactor tags to be a set to avoid this O(n) lookup
+                                    if (!collectedTags.includes(tag)) {
+                                        collectedTags.push(tag);
+                                    }
+                                }
+                            }
+                            break;
+                        case 'unstable-cache':
+                            isNestedUnstableCache = true;
+                            break;
+                        case 'prerender-client':
+                        case 'validation-client':
+                        case 'request':
+                        case 'build-time-generator':
+                            break;
+                        default:
+                            workUnitStore;
+                    }
+                }
+                if (// when we are nested inside of other unstable_cache's
+                // we should bypass cache similar to fetches
+                !isNestedUnstableCache && workStore.fetchCache !== 'force-no-store' && !workStore.isOnDemandRevalidate && !incrementalCache.isOnDemandRevalidate && !workStore.isDraftMode) {
+                    // We attempt to get the current cache entry from the incremental cache.
+                    const cacheEntry = await incrementalCache.get(cacheKey, {
+                        kind: _responsecache.IncrementalCacheKind.FETCH,
+                        revalidate,
+                        tags,
+                        softTags: implicitTags == null ? void 0 : implicitTags.tags,
+                        fetchIdx,
+                        fetchUrl
+                    });
+                    if (cacheEntry && cacheEntry.value) {
+                        // The entry exists and has a value
+                        if (cacheEntry.value.kind !== _responsecache.CachedRouteKind.FETCH) {
+                            // The entry is invalid and we need a special warning
+                            // @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
+                            // so bugs can be reported
+                            // @TODO the invocation key can have sensitive data in it. we should not log this entire object
+                            console.error(`Invariant invalid cacheEntry returned for ${invocationKey}`);
+                        // will fall through to generating a new cache entry below
+                        } else {
+                            // We have a valid cache entry so we will be returning it. We also check to see if we need
+                            // to background revalidate it by checking if it is stale.
+                            const cachedResponse = cacheEntry.value.data.body !== undefined ? JSON.parse(cacheEntry.value.data.body) : undefined;
+                            if (cacheEntry.isStale) {
+                                if (!workStore.pendingRevalidates) {
+                                    workStore.pendingRevalidates = {};
+                                }
+                                // Check if there's already a pending revalidation to avoid duplicate work
+                                if (!workStore.pendingRevalidates[invocationKey]) {
+                                    // Create the revalidation promise
+                                    const revalidationPromise = _workunitasyncstorageexternal.workUnitAsyncStorage.run(innerCacheStore, cb, ...args).then(async (result)=>{
+                                        await cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl);
+                                        return result;
+                                    }).catch((err)=>{
+                                        // @TODO This error handling seems wrong. We swallow the error?
+                                        console.error(`revalidating cache with key: ${invocationKey}`, err);
+                                        // Return the stale value on error for foreground revalidation
+                                        return cachedResponse;
+                                    });
+                                    // Attach the empty catch here so we don't get a "unhandled promise
+                                    // rejection" warning. (Behavior is matched with patch-fetch)
+                                    if ((0, _workunitasyncstorageexternal.willConsumerServerCache)(workUnitStore)) {
+                                        revalidationPromise.catch(()=>{});
+                                    }
+                                    workStore.pendingRevalidates[invocationKey] = revalidationPromise;
+                                }
+                                // Check if we need to do foreground revalidation
+                                if ((0, _workunitasyncstorageexternal.willConsumerServerCache)(workUnitStore)) {
+                                    // When the consumer will persist this result in a server
+                                    // cache, wait for fresh data so it doesn't persist a stale
+                                    // value. The `await` here also keeps `cacheSignal.endRead` (in
+                                    // the outer `finally`) suspended until the recompute +
+                                    // cacheNewResult actually complete, so a prospective
+                                    // prerender's `cacheSignal` doesn't resolve `cacheReady`
+                                    // prematurely.
+                                    return await workStore.pendingRevalidates[invocationKey];
+                                }
+                            // Otherwise, we're doing background revalidation - return stale immediately
+                            }
+                            // We had a valid cache entry so we return it here
+                            return cachedResponse;
+                        }
+                    }
+                }
+                // If we got this far then we had an invalid cache entry and need to generate a new one
+                const result = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(innerCacheStore, cb, ...args);
+                if (!workStore.isDraftMode) {
+                    if (!workStore.pendingRevalidates) {
+                        workStore.pendingRevalidates = {};
+                    }
+                    // We need to push the cache result promise to pending
+                    // revalidates otherwise it won't be awaited and is just
+                    // dangling
+                    workStore.pendingRevalidates[invocationKey] = cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl);
+                }
+                return result;
+            } else {
+                noStoreFetchIdx += 1;
+                // We are in Pages Router or were called outside of a render. We don't have a store
+                // so we just call the callback directly when it needs to run.
+                // If the entry is fresh we return it. If the entry is stale we return it but revalidate the entry in
+                // the background. If the entry is missing or invalid we generate a new entry and return it.
+                if (!incrementalCache.isOnDemandRevalidate) {
+                    // We aren't doing an on demand revalidation so we check use the cache if valid
+                    const cacheEntry = await incrementalCache.get(cacheKey, {
+                        kind: _responsecache.IncrementalCacheKind.FETCH,
+                        revalidate,
+                        tags,
+                        fetchIdx,
+                        fetchUrl,
+                        softTags: implicitTags == null ? void 0 : implicitTags.tags
+                    });
+                    if (cacheEntry && cacheEntry.value) {
+                        // The entry exists and has a value
+                        if (cacheEntry.value.kind !== _responsecache.CachedRouteKind.FETCH) {
+                            // The entry is invalid and we need a special warning
+                            // @TODO why do we warn this way? Should this just be an error? How are these errors surfaced
+                            // so bugs can be reported
+                            console.error(`Invariant invalid cacheEntry returned for ${invocationKey}`);
+                        // will fall through to generating a new cache entry below
+                        } else if (!cacheEntry.isStale) {
+                            // We have a valid cache entry and it is fresh so we return it
+                            return cacheEntry.value.data.body !== undefined ? JSON.parse(cacheEntry.value.data.body) : undefined;
+                        }
+                    }
+                }
+                // If we got this far then we had an invalid cache entry and need to generate a new one
+                const result = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(innerCacheStore, cb, ...args);
+                // we need to wait setting the new cache result here as
+                // we don't have pending revalidates on workStore to
+                // push to and we can't have a dangling promise
+                await cacheNewResult(result, incrementalCache, cacheKey, tags, revalidate, fetchIdx, fetchUrl);
+                return result;
+            }
+        } finally{
+            if (cacheSignal) {
+                cacheSignal.endRead();
+            }
+        }
+    };
+    // TODO: once AsyncLocalStorage.run() returns the correct types this override will no longer be necessary
+    return cachedCb;
+}
+function getFetchUrlPrefix(workStore, workUnitStore) {
+    switch(workUnitStore.type){
+        case 'request':
+            const pathname = workUnitStore.url.pathname;
+            const searchParams = new URLSearchParams(workUnitStore.url.search);
+            const sortedSearch = [
+                ...searchParams.keys()
+            ].sort((a, b)=>a.localeCompare(b)).map((key)=>`${key}=${searchParams.get(key)}`).join('&');
+            return `${pathname}${sortedSearch.length ? '?' : ''}${sortedSearch}`;
+        case 'prerender':
+        case 'prerender-client':
+        case 'validation-client':
+        case 'prerender-runtime':
+        case 'prerender-legacy':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'build-time-generator':
+            return workStore.route;
+        default:
+            return workUnitStore;
+    }
+}
+
+//# sourceMappingURL=unstable-cache.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/web/spec-extension/unstable-no-store.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "unstable_noStore", {
+    enumerable: true,
+    get: function() {
+        return unstable_noStore;
+    }
+});
+const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
+const _dynamicrendering = require("../../app-render/dynamic-rendering");
+function unstable_noStore() {
+    const callingExpression = 'unstable_noStore()';
+    const store = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!store) {
+        // This generally implies we are being called in Pages router. We should probably not support
+        // unstable_noStore in contexts outside of `react-server` condition but since we historically
+        // have not errored here previously, we maintain that behavior for now.
+        return;
+    } else if (store.forceStatic) {
+        return;
+    } else {
+        store.isUnstableNoStore = true;
+        if (workUnitStore) {
+            switch(workUnitStore.type){
+                case 'prerender':
+                case 'prerender-client':
+                case 'validation-client':
+                case 'prerender-runtime':
+                    // unstable_noStore() is a noop in Dynamic I/O.
+                    return;
+                case 'prerender-legacy':
+                case 'request':
+                case 'cache':
+                case 'private-cache':
+                case 'unstable-cache':
+                case 'build-time-generator':
+                    break;
+                default:
+                    workUnitStore;
+            }
+        }
+        (0, _dynamicrendering.markCurrentScopeAsDynamic)(store, workUnitStore, callingExpression);
+    }
+}
+
+//# sourceMappingURL=unstable-no-store.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/web/spec-extension/url-pattern.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "URLPattern", {
+    enumerable: true,
+    get: function() {
+        return GlobalURLPattern;
+    }
+});
+const GlobalURLPattern = typeof URLPattern === 'undefined' ? undefined : URLPattern;
+
+//# sourceMappingURL=url-pattern.js.map

package/dashboard/.next/standalone/node_modules/next/dist/server/web/spec-extension/user-agent.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isBot: null,
+    userAgent: null,
+    userAgentFromString: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isBot: function() {
+        return isBot;
+    },
+    userAgent: function() {
+        return userAgent;
+    },
+    userAgentFromString: function() {
+        return userAgentFromString;
+    }
+});
+const _uaparserjs = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ua-parser-js"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function isBot(input) {
+    return /Googlebot|Mediapartners-Google|AdsBot-Google|googleweblight|Storebot-Google|Google-PageRenderer|Google-InspectionTool|Bingbot|BingPreview|Slurp|DuckDuckBot|baiduspider|yandex|sogou|LinkedInBot|bitlybot|tumblr|vkShare|quora link preview|facebookexternalhit|facebookcatalog|Twitterbot|applebot|redditbot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|ia_archiver|GPTBot/i.test(input);
+}
+function userAgentFromString(input) {
+    return {
+        ...(0, _uaparserjs.default)(input),
+        isBot: input === undefined ? false : isBot(input)
+    };
+}
+function userAgent({ headers }) {
+    return userAgentFromString(headers.get('user-agent') || undefined);
+}
+
+//# sourceMappingURL=user-agent.js.map

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

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