failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/server/use-cache/cache-life.js

@@ -10,14 +10,11 @@ Object.defineProperty(exports, "cacheLife", {
 });
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _usecachemessages = require("./use-cache-messages");
 const _cachelifeprofile = require("./cache-life-profile");
 function cacheLife(profile) {
     if (!process.env.__NEXT_USE_CACHE) {
-        throw Object.defineProperty(new Error('`cacheLife()` is only available with the `cacheComponents` config.'), "__NEXT_ERROR_CODE", {
-            value: "E887",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('`cacheLife()` is only available with the `cacheComponents` config.');
     }
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     switch(workUnitStore == null ? void 0 : workUnitStore.type){
@@ -25,17 +22,13 @@ function cacheLife(profile) {
         case 'prerender-client':
         case 'validation-client':
         case 'prerender-runtime':
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'request':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
         case undefined:
-            throw Object.defineProperty(new Error('`cacheLife()` can only be called inside a "use cache" function.'), "__NEXT_ERROR_CODE", {
-                value: "E818",
-                enumerable: false,
-                configurable: true
-            });
+            var _workAsyncStorage_getStore;
+            throw (0, _usecachemessages.createCacheLifeOutsideUseCacheError)((_workAsyncStorage_getStore = _workasyncstorageexternal.workAsyncStorage.getStore()) == null ? void 0 : _workAsyncStorage_getStore.route);
         case 'cache':
         case 'private-cache':
             break;
@@ -45,35 +38,19 @@ function cacheLife(profile) {
     if (typeof profile === 'string') {
         const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
         if (!workStore) {
-            throw Object.defineProperty(new Error('`cacheLife()` can only be called during App Router rendering at the moment.'), "__NEXT_ERROR_CODE", {
-                value: "E820",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('`cacheLife()` can only be called during App Router rendering at the moment.');
         }
         // TODO: This should be globally available and not require an AsyncLocalStorage.
         const configuredProfile = workStore.cacheLifeProfiles[profile];
         if (configuredProfile === undefined) {
             if (workStore.cacheLifeProfiles[profile.trim()]) {
-                throw Object.defineProperty(new Error(`Unknown \`cacheLife()\` profile "${profile}" is not configured in next.config.js\n` + `Did you mean "${profile.trim()}" without the spaces?`), "__NEXT_ERROR_CODE", {
-                    value: "E816",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Unknown \`cacheLife()\` profile "${profile}" is not configured in next.config.js\n` + `Did you mean "${profile.trim()}" without the spaces?`);
             }
-            throw Object.defineProperty(new Error(`Unknown \`cacheLife()\` profile "${profile}" is not configured in next.config.js\n` + 'module.exports = {\n' + '  cacheLife: {\n' + `    "${profile}": ...\n` + '  }\n' + '}'), "__NEXT_ERROR_CODE", {
-                value: "E888",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Unknown \`cacheLife()\` profile "${profile}" is not configured in next.config.js\n` + 'module.exports = {\n' + '  cacheLife: {\n' + `    "${profile}": ...\n` + '  }\n' + '}');
         }
         profile = configuredProfile;
     } else if (typeof profile !== 'object' || profile === null || Array.isArray(profile)) {
-        throw Object.defineProperty(new Error('Invalid `cacheLife()` option. Either pass a profile name or object.'), "__NEXT_ERROR_CODE", {
-            value: "E814",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invalid `cacheLife()` option. Either pass a profile name or object.');
     } else {
         profile = (0, _cachelifeprofile.validateAndNormalizeCacheLifeProfile)(profile, {
             kind: 'inline'

package/.next/standalone/node_modules/next/dist/server/use-cache/cache-tag.js

@@ -8,15 +8,13 @@ Object.defineProperty(exports, "cacheTag", {
         return cacheTag;
     }
 });
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _patchfetch = require("../lib/patch-fetch");
+const _usecachemessages = require("./use-cache-messages");
 function cacheTag(...tags) {
     if (!process.env.__NEXT_USE_CACHE) {
-        throw Object.defineProperty(new Error('`cacheTag()` is only available with the `cacheComponents` config.'), "__NEXT_ERROR_CODE", {
-            value: "E886",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('`cacheTag()` is only available with the `cacheComponents` config.');
     }
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     switch(workUnitStore == null ? void 0 : workUnitStore.type){
@@ -24,17 +22,13 @@ function cacheTag(...tags) {
         case 'prerender-client':
         case 'validation-client':
         case 'prerender-runtime':
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'request':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
         case undefined:
-            throw Object.defineProperty(new Error('`cacheTag()` can only be called inside a "use cache" function.'), "__NEXT_ERROR_CODE", {
-                value: "E819",
-                enumerable: false,
-                configurable: true
-            });
+            var _workAsyncStorage_getStore;
+            throw (0, _usecachemessages.createCacheTagOutsideUseCacheError)((_workAsyncStorage_getStore = _workasyncstorageexternal.workAsyncStorage.getStore()) == null ? void 0 : _workAsyncStorage_getStore.route);
         case 'cache':
         case 'private-cache':
             break;

package/.next/standalone/node_modules/next/dist/server/use-cache/constants.js

@@ -33,11 +33,7 @@ const MIN_SHELL_STALE = 300 // 5 minutes
 ;
 if (process.env.NODE_ENV !== 'production') {
     if (MIN_PREFETCHABLE_STALE > MIN_SHELL_STALE) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('MIN_PREFETCHABLE_STALE must not exceed MIN_SHELL_STALE.'), "__NEXT_ERROR_CODE", {
-            value: "E1422",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('MIN_PREFETCHABLE_STALE must not exceed MIN_SHELL_STALE.');
     }
 }
 

package/.next/standalone/node_modules/next/dist/server/use-cache/handlers.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", {
     isBuiltInCacheHandler: null,
     isCustomCacheHandler: null,
     isMemoryCacheDisabled: null,
+    registerCustomCacheHandlers: null,
     setCacheHandler: null
 });
 function _export(target, all) {
@@ -48,6 +49,9 @@ _export(exports, {
     isMemoryCacheDisabled: function() {
         return isMemoryCacheDisabled;
     },
+    registerCustomCacheHandlers: function() {
+        return registerCustomCacheHandlers;
+    },
     setCacheHandler: function() {
         return setCacheHandler;
     }
@@ -60,6 +64,7 @@ const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? (message, ...args)=>{
 const handlersSymbol = Symbol.for('@next/cache-handlers');
 const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
 const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+const customCacheHandlersRegistrationSymbol = Symbol.for('@next/custom-cache-handlers-registration');
 const privateHandlerSymbol = Symbol.for('@next/cache-handlers-private');
 const builtInHandlersSymbol = Symbol.for('@next/cache-handlers-built-in');
 const devFrontHandlersSymbol = Symbol.for('@next/cache-handlers-dev-fronts');
@@ -80,7 +85,7 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
     // If the cache handlers have already been initialized, don't do it again.
     if (reference[handlersMapSymbol]) {
         debug == null ? void 0 : debug('cache handlers already initialized');
-        return false;
+        return;
     }
     debug == null ? void 0 : debug('initializing cache handlers');
     const handlersMap = new Map();
@@ -141,27 +146,26 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
         reference[devFrontHandlersSymbol] = new Map();
         reference[devTieredHandlersSymbol] = new Map();
     }
-    return true;
+}
+function registerCustomCacheHandlers(register) {
+    let pendingPromise = reference[customCacheHandlersRegistrationSymbol];
+    if (!pendingPromise) {
+        pendingPromise = register();
+        reference[customCacheHandlersRegistrationSymbol] = pendingPromise;
+    }
+    return pendingPromise;
 }
 function getCacheHandler(kind) {
     // This should never be called before initializeCacheHandlers.
     if (!reference[handlersMapSymbol]) {
-        throw Object.defineProperty(new Error('Cache handlers not initialized'), "__NEXT_ERROR_CODE", {
-            value: "E649",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Cache handlers not initialized');
     }
     return reference[handlersMapSymbol].get(kind);
 }
 function getPrivateCacheHandler() {
     // This should never be called before initializeCacheHandlers.
     if (!reference[handlersMapSymbol]) {
-        throw Object.defineProperty(new Error('Cache handlers not initialized'), "__NEXT_ERROR_CODE", {
-            value: "E649",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Cache handlers not initialized');
     }
     return reference[privateHandlerSymbol];
 }
@@ -192,27 +196,18 @@ function getCacheHandlers() {
     if (!handlersSet) {
         return undefined;
     }
+    const handlers = Array.from(handlersSet);
     if (process.env.__NEXT_DEV_SERVER) {
-        return iterateCacheHandlersWithDevBuiltIns(handlersSet);
-    }
-    return handlersSet.values();
-}
-/**
- * Yields the registered handlers plus the dev-only built-in handlers (the
- * private handler and the per-kind front handlers). The built-in handlers are
- * not part of the registered set, but tag operations must still reach them:
- * their `updateTags` writes the shared tags manifest that their `get` consults,
- * so `revalidateTag` can invalidate their entries.
- */ function* iterateCacheHandlersWithDevBuiltIns(handlersSet) {
-    yield* handlersSet;
-    const privateHandler = reference[privateHandlerSymbol];
-    if (privateHandler) {
-        yield privateHandler;
-    }
-    const devFrontHandlers = reference[devFrontHandlersSymbol];
-    if (devFrontHandlers) {
-        yield* devFrontHandlers.values();
+        const privateHandler = reference[privateHandlerSymbol];
+        if (privateHandler) {
+            handlers.push(privateHandler);
+        }
+        const devFrontHandlers = reference[devFrontHandlersSymbol];
+        if (devFrontHandlers) {
+            handlers.push(...devFrontHandlers.values());
+        }
     }
+    return handlers;
 }
 function getCacheHandlerEntries() {
     const handlersMap = reference[handlersMapSymbol];
@@ -245,11 +240,7 @@ function getCacheHandlerEntries() {
 function setCacheHandler(kind, cacheHandler) {
     // This should never be called before initializeCacheHandlers.
     if (!reference[handlersMapSymbol] || !reference[handlersSetSymbol]) {
-        throw Object.defineProperty(new Error('Cache handlers not initialized'), "__NEXT_ERROR_CODE", {
-            value: "E649",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Cache handlers not initialized');
     }
     debug == null ? void 0 : debug('setting cache handler for "%s"', kind);
     reference[handlersMapSymbol].set(kind, cacheHandler);

package/.next/standalone/node_modules/next/dist/server/use-cache/tiered-cache-handler.js

@@ -101,10 +101,12 @@ function createTieredCacheHandler(front, backing) {
         if (backingEntry.timestamp > frontEntry.timestamp) {
             await front.set(cacheKey, Promise.resolve(backingEntry));
         } else {
-            // The front is already up to date, so the backing entry goes unused.
-            // Release its stream without awaiting: a teed stream's `cancel()` only
-            // settles once the sibling branch (retained by the backing handler) is
-            // also cancelled, so awaiting it here would hang the reconcile.
+            // The front is already up to date, so the backing entry goes unused. This
+            // code releases its stream and does not await the result. The backing
+            // handler is user-configured, and it can return one branch of a teed
+            // stream. `cancel()` on such a branch settles only after the sibling
+            // branch is cancelled too, and the handler retains that sibling, so an
+            // await here would hang the reconcile.
             void backingEntry.value.cancel();
         }
     } catch  {

package/.next/standalone/node_modules/next/dist/server/use-cache/use-cache-errors.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     NestedDynamicUseCacheError: null,
+    UNEXPECTED_CACHE_MISS_MESSAGE: null,
+    UnexpectedCacheMissError: null,
     UseCacheDeadlockError: null,
     UseCacheTimeoutError: null
 });
@@ -17,6 +19,12 @@ _export(exports, {
     NestedDynamicUseCacheError: function() {
         return NestedDynamicUseCacheError;
     },
+    UNEXPECTED_CACHE_MISS_MESSAGE: function() {
+        return UNEXPECTED_CACHE_MISS_MESSAGE;
+    },
+    UnexpectedCacheMissError: function() {
+        return UnexpectedCacheMissError;
+    },
     UseCacheDeadlockError: function() {
         return UseCacheDeadlockError;
     },
@@ -25,35 +33,26 @@ _export(exports, {
     }
 });
 class UseCacheTimeoutError extends Error {
-    constructor(){
-        super('Filling a cache during prerender timed out, likely because request-specific arguments such as params, searchParams, cookies() or dynamic data were used inside "use cache".');
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E236",
-            enumerable: false,
-            configurable: true
-        });
+    constructor(route){
+        super(`Route "${route}": ` + `A \`"use cache"\` function took too long during prerendering. The most common cause is passing unresolved request-specific arguments, such as \`params\` or \`searchParams\`, into the cached function. Resolve the data before calling the function and pass only the values you need.\nLearn more: https://nextjs.org/docs/messages/next-request-in-use-cache`);
     }
 }
 class UseCacheDeadlockError extends Error {
-    constructor(){
-        super('Filling a "use cache" entry appears to be stuck on shared state from the outer render scope. The same function completed when run in isolation, which usually means a module-scoped value (for example a top-level Map used to dedupe fetches) is joining a promise created outside the cache. "use cache" already dedupes calls with the same arguments — within a request and across requests on the same server instance — so the surrounding dedupe layer is both unnecessary and the likely cause. Remove it and rely on "use cache" alone for deduping.');
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E1181",
-            enumerable: false,
-            configurable: true
-        });
+    constructor(route){
+        super(`Route "${route}": ` + `A \`"use cache"\` function is awaiting a promise created outside it. The same call completed when run in isolation, so a module-scoped value (often a top-level \`Map\` used to dedupe fetches) is most likely blocking it. \`"use cache"\` already dedupes calls with the same arguments. Remove the surrounding dedupe layer.\nLearn more: https://nextjs.org/docs/messages/next-request-in-use-cache`);
     }
 }
 class NestedDynamicUseCacheError extends Error {
     constructor(){
         super('This "use cache" has a dynamic cache life that was propagated to its parent.');
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E1243",
-            enumerable: false,
-            configurable: true
-        });
         this.name = 'Nested dynamic "use cache"';
     }
 }
+const UNEXPECTED_CACHE_MISS_MESSAGE = `Unexpected cache miss after cache warming phase during prerendering. This is likely caused by non-deterministic arguments that differ between the cache warming phase and the final prerender phase (e.g. unstable array order). Ensure that arguments passed to cached functions are deterministic.`;
+class UnexpectedCacheMissError extends Error {
+    constructor(route){
+        super(`Route "${route}": ` + UNEXPECTED_CACHE_MISS_MESSAGE);
+    }
+}
 
 //# sourceMappingURL=use-cache-errors.js.map

package/.next/standalone/node_modules/next/dist/server/use-cache/use-cache-messages.js

@@ -0,0 +1,190 @@
+/**
+ * Centralized error factories for cached function and revalidation misuse.
+ * State the scope and constraint, explain non-obvious boundaries, give the
+ * immediate fix, then link to the relevant docs.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createCacheLifeOutsideUseCacheError: null,
+    createCacheTagOutsideUseCacheError: null,
+    createConnectionInPrivateUseCacheError: null,
+    createConnectionInPublicUseCacheError: null,
+    createConnectionInUnstableCacheError: null,
+    createCookiesInUnstableCacheError: null,
+    createCookiesInUseCacheError: null,
+    createDraftModeMutationInUnstableCacheError: null,
+    createDraftModeMutationInUseCacheError: null,
+    createHeadersInUnstableCacheError: null,
+    createHeadersInUseCacheError: null,
+    createNestedCacheShortExpireError: null,
+    createNestedCacheZeroRevalidateError: null,
+    createRevalidateDuringRenderError: null,
+    createRevalidateInBuildTimeGeneratorError: null,
+    createRevalidateInCachedFunctionError: null,
+    createRouteHandlerRequestInUnstableCacheError: null,
+    createRouteHandlerRequestInUseCacheError: null,
+    createSearchParamsInUseCacheError: null,
+    createUseCachePrivateInsidePublicUseCacheError: null,
+    createUseCachePrivateInsideUnstableCacheError: null,
+    createUseCachePrivateOutsideRequestContextError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createCacheLifeOutsideUseCacheError: function() {
+        return createCacheLifeOutsideUseCacheError;
+    },
+    createCacheTagOutsideUseCacheError: function() {
+        return createCacheTagOutsideUseCacheError;
+    },
+    createConnectionInPrivateUseCacheError: function() {
+        return createConnectionInPrivateUseCacheError;
+    },
+    createConnectionInPublicUseCacheError: function() {
+        return createConnectionInPublicUseCacheError;
+    },
+    createConnectionInUnstableCacheError: function() {
+        return createConnectionInUnstableCacheError;
+    },
+    createCookiesInUnstableCacheError: function() {
+        return createCookiesInUnstableCacheError;
+    },
+    createCookiesInUseCacheError: function() {
+        return createCookiesInUseCacheError;
+    },
+    createDraftModeMutationInUnstableCacheError: function() {
+        return createDraftModeMutationInUnstableCacheError;
+    },
+    createDraftModeMutationInUseCacheError: function() {
+        return createDraftModeMutationInUseCacheError;
+    },
+    createHeadersInUnstableCacheError: function() {
+        return createHeadersInUnstableCacheError;
+    },
+    createHeadersInUseCacheError: function() {
+        return createHeadersInUseCacheError;
+    },
+    createNestedCacheShortExpireError: function() {
+        return createNestedCacheShortExpireError;
+    },
+    createNestedCacheZeroRevalidateError: function() {
+        return createNestedCacheZeroRevalidateError;
+    },
+    createRevalidateDuringRenderError: function() {
+        return createRevalidateDuringRenderError;
+    },
+    createRevalidateInBuildTimeGeneratorError: function() {
+        return createRevalidateInBuildTimeGeneratorError;
+    },
+    createRevalidateInCachedFunctionError: function() {
+        return createRevalidateInCachedFunctionError;
+    },
+    createRouteHandlerRequestInUnstableCacheError: function() {
+        return createRouteHandlerRequestInUnstableCacheError;
+    },
+    createRouteHandlerRequestInUseCacheError: function() {
+        return createRouteHandlerRequestInUseCacheError;
+    },
+    createSearchParamsInUseCacheError: function() {
+        return createSearchParamsInUseCacheError;
+    },
+    createUseCachePrivateInsidePublicUseCacheError: function() {
+        return createUseCachePrivateInsidePublicUseCacheError;
+    },
+    createUseCachePrivateInsideUnstableCacheError: function() {
+        return createUseCachePrivateInsideUnstableCacheError;
+    },
+    createUseCachePrivateOutsideRequestContextError: function() {
+        return createUseCachePrivateOutsideRequestContextError;
+    }
+});
+const NEXT_REQUEST_IN_USE_CACHE = 'https://nextjs.org/docs/messages/next-request-in-use-cache';
+const UNSTABLE_CACHE_API_DOCS = 'https://nextjs.org/docs/app/api-reference/functions/unstable_cache';
+const USE_CACHE_PRIVATE_API_DOCS = 'https://nextjs.org/docs/app/api-reference/directives/use-cache-private';
+const CACHE_TAG_OUTSIDE_USE_CACHE = 'https://nextjs.org/docs/messages/cache-tag-outside-use-cache';
+const CACHE_LIFE_OUTSIDE_USE_CACHE = 'https://nextjs.org/docs/messages/cache-life-outside-use-cache';
+const USE_CACHE_PRIVATE_COMPOSITION = 'https://nextjs.org/docs/messages/use-cache-private-composition';
+const REVALIDATE_IN_USE_CACHE = 'https://nextjs.org/docs/messages/revalidate-in-use-cache';
+const NESTED_USE_CACHE_NO_EXPLICIT_CACHELIFE = 'https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife';
+function createCookiesInUseCacheError(route) {
+    return new Error(`Route "${route}": \`cookies()\` can't be read inside \`"use cache"\`. Read it outside the cached function and pass what you need as an argument.\nLearn more: ${NEXT_REQUEST_IN_USE_CACHE}`);
+}
+function createCookiesInUnstableCacheError(route) {
+    return new Error(`Route "${route}": \`cookies()\` can't be read inside \`unstable_cache()\`. Read it outside the cached function and pass what you need as an argument.\nLearn more: ${UNSTABLE_CACHE_API_DOCS}`);
+}
+function createHeadersInUseCacheError(route) {
+    return new Error(`Route "${route}": \`headers()\` can't be read inside \`"use cache"\`. Read it outside the cached function and pass what you need as an argument.\nLearn more: ${NEXT_REQUEST_IN_USE_CACHE}`);
+}
+function createHeadersInUnstableCacheError(route) {
+    return new Error(`Route "${route}": \`headers()\` can't be read inside \`unstable_cache()\`. Read it outside the cached function and pass what you need as an argument.\nLearn more: ${UNSTABLE_CACHE_API_DOCS}`);
+}
+function createSearchParamsInUseCacheError(route) {
+    return new Error(`Route "${route}": \`searchParams\` can't be read inside \`"use cache"\`. Await it outside the cached function and pass what you need as an argument.\nLearn more: ${NEXT_REQUEST_IN_USE_CACHE}`);
+}
+function createConnectionInPublicUseCacheError(route) {
+    return new Error(`Route "${route}": \`connection()\` can't be called inside \`"use cache"\` because cached functions may run during prerendering, without an incoming request. Call it outside the cached function.\nLearn more: ${NEXT_REQUEST_IN_USE_CACHE}`);
+}
+function createConnectionInPrivateUseCacheError(route) {
+    return new Error(`Route "${route}": \`connection()\` can't be called inside \`"use cache: private"\` because private cached functions may run during prefetching, without a navigation request. Call it outside the cached function.\nLearn more: ${USE_CACHE_PRIVATE_API_DOCS}`);
+}
+function createConnectionInUnstableCacheError(route) {
+    return new Error(`Route "${route}": \`connection()\` can't be called inside \`unstable_cache()\` because cached functions may run during prerendering, without an incoming request. Call it outside the cached function.\nLearn more: ${UNSTABLE_CACHE_API_DOCS}`);
+}
+function createRouteHandlerRequestInUseCacheError(route, expression) {
+    return new Error(`Route "${route}": \`${expression}\` can't be read inside \`"use cache"\`. Read it outside the cached function and pass what you need as an argument.\nLearn more: ${NEXT_REQUEST_IN_USE_CACHE}`);
+}
+function createRouteHandlerRequestInUnstableCacheError(route, expression) {
+    return new Error(`Route "${route}": \`${expression}\` can't be read inside \`unstable_cache()\`. Read it outside the cached function and pass what you need as an argument.\nLearn more: ${UNSTABLE_CACHE_API_DOCS}`);
+}
+function createDraftModeMutationInUseCacheError(route, expression) {
+    return new Error(`Route "${route}": \`${expression}\` can't be called inside \`"use cache"\`. Draft mode can be read inside a cached function, but enabling or disabling it must happen outside.\nLearn more: ${NEXT_REQUEST_IN_USE_CACHE}`);
+}
+function createDraftModeMutationInUnstableCacheError(route, expression) {
+    return new Error(`Route "${route}": \`${expression}\` can't be called inside \`unstable_cache()\`. Draft mode can be read inside a cached function, but enabling or disabling it must happen outside.\nLearn more: ${UNSTABLE_CACHE_API_DOCS}`);
+}
+function createRevalidateDuringRenderError(route, expression) {
+    return new Error(`Route "${route}": \`${expression}\` can't be called during render. Call it from a Server Action or Route Handler instead.\nLearn more: ${REVALIDATE_IN_USE_CACHE}`);
+}
+function createRevalidateInCachedFunctionError(route, expression) {
+    return new Error(`Route "${route}": \`${expression}\` can't be called inside a cached function. Call it from a Server Action or Route Handler instead.\nLearn more: ${REVALIDATE_IN_USE_CACHE}`);
+}
+function createRevalidateInBuildTimeGeneratorError(route, expression, generatorName) {
+    return new Error(`Route "${route}": \`${expression}\` can't be called inside \`${generatorName}\`. Call it from a Server Action or Route Handler instead.\nLearn more: ${REVALIDATE_IN_USE_CACHE}`);
+}
+// Cache configuration and nesting
+function routePrefix(route) {
+    return route === undefined ? '' : `Route "${route}": `;
+}
+function createCacheTagOutsideUseCacheError(route) {
+    return new Error(`${routePrefix(route)}\`cacheTag()\` can only be called inside a \`"use cache"\` or \`"use cache: private"\` function.\nLearn more: ${CACHE_TAG_OUTSIDE_USE_CACHE}`);
+}
+function createCacheLifeOutsideUseCacheError(route) {
+    return new Error(`${routePrefix(route)}\`cacheLife()\` can only be called inside a \`"use cache"\` or \`"use cache: private"\` function.\nLearn more: ${CACHE_LIFE_OUTSIDE_USE_CACHE}`);
+}
+function createNestedCacheZeroRevalidateError(route, cause) {
+    return new Error(`Route "${route}": A nested \`"use cache"\` with \`revalidate: 0\` is inside an outer \`"use cache"\` that has no \`cacheLife()\`. Add \`cacheLife()\` to the outer one to choose whether to prerender it with a non-zero \`revalidate\` or keep it dynamic with \`revalidate: 0\`.\nLearn more: ${NESTED_USE_CACHE_NO_EXPLICIT_CACHELIFE}`, {
+        cause
+    });
+}
+function createNestedCacheShortExpireError(route, cause) {
+    return new Error(`Route "${route}": A nested \`"use cache"\` with a short \`expire\` (under 5 minutes) is inside an outer \`"use cache"\` that has no \`cacheLife()\`. Add \`cacheLife()\` to the outer one to choose whether to prerender it with a longer \`expire\` or keep it dynamic with a short \`expire\`.\nLearn more: ${NESTED_USE_CACHE_NO_EXPLICIT_CACHELIFE}`, {
+        cause
+    });
+}
+function createUseCachePrivateInsidePublicUseCacheError(route) {
+    return new Error(`Route "${route}": \`"use cache: private"\` can't be nested inside \`"use cache"\` because a shared cached function can't depend on private request data. Nest it only inside another \`"use cache: private"\`.\nLearn more: ${USE_CACHE_PRIVATE_COMPOSITION}`);
+}
+function createUseCachePrivateInsideUnstableCacheError(route) {
+    return new Error(`Route "${route}": \`"use cache: private"\` can't be used inside \`unstable_cache()\` because \`unstable_cache()\` uses a shared cache that can't contain private request data. Call the private cached function outside \`unstable_cache()\`.\nLearn more: ${USE_CACHE_PRIVATE_COMPOSITION}`);
+}
+function createUseCachePrivateOutsideRequestContextError(route, functionName) {
+    return new Error(`Route "${route}": \`"use cache: private"\` needs an active request, so it can't be used during \`${functionName}\` or other build-time contexts. Move it to a request-time component or function.\nLearn more: ${USE_CACHE_PRIVATE_COMPOSITION}`);
+}
+
+//# sourceMappingURL=use-cache-messages.js.map