@codelionapps/unharness 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getCacheHandler: null,
+    getCacheHandlerEntries: null,
+    getCacheHandlers: null,
+    getDevTieredCacheHandler: null,
+    getPrivateCacheHandler: null,
+    initializeCacheHandlers: null,
+    isBuiltInCacheHandler: null,
+    isCustomCacheHandler: null,
+    isMemoryCacheDisabled: null,
+    registerCustomCacheHandlers: null,
+    setCacheHandler: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getCacheHandler: function() {
+        return getCacheHandler;
+    },
+    getCacheHandlerEntries: function() {
+        return getCacheHandlerEntries;
+    },
+    getCacheHandlers: function() {
+        return getCacheHandlers;
+    },
+    getDevTieredCacheHandler: function() {
+        return getDevTieredCacheHandler;
+    },
+    getPrivateCacheHandler: function() {
+        return getPrivateCacheHandler;
+    },
+    initializeCacheHandlers: function() {
+        return initializeCacheHandlers;
+    },
+    isBuiltInCacheHandler: function() {
+        return isBuiltInCacheHandler;
+    },
+    isCustomCacheHandler: function() {
+        return isCustomCacheHandler;
+    },
+    isMemoryCacheDisabled: function() {
+        return isMemoryCacheDisabled;
+    },
+    registerCustomCacheHandlers: function() {
+        return registerCustomCacheHandlers;
+    },
+    setCacheHandler: function() {
+        return setCacheHandler;
+    }
+});
+const _default = require("../lib/cache-handlers/default");
+const _tieredcachehandler = require("./tiered-cache-handler");
+const debug = process.env.NEXT_PRIVATE_DEBUG_CACHE ? (message, ...args)=>{
+    console.log(`use-cache: ${message}`, ...args);
+} : undefined;
+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');
+const devTieredHandlersSymbol = Symbol.for('@next/cache-handlers-dev-tiered');
+const memoryCacheDisabledSymbol = Symbol.for('@next/cache-handlers-memory-disabled');
+/**
+ * The in-memory size used for the dev-only built-in handlers (the private
+ * handler, the size-0 replacement, and the per-kind front handlers for custom
+ * kinds). Mirrors the framework default so `cacheMaxMemorySize: 0` does not
+ * disable caching in development.
+ */ const DEV_MEMORY_CACHE_SIZE = 50 * 1024 * 1024;
+/**
+ * The reference to the cache handlers. We store the cache handlers on the
+ * global object so that we can access the same instance across different
+ * boundaries (such as different copies of the same module).
+ */ const reference = globalThis;
+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;
+    }
+    debug == null ? void 0 : debug('initializing cache handlers');
+    const handlersMap = new Map();
+    reference[handlersMapSymbol] = handlersMap;
+    const builtInHandlers = new Set();
+    reference[builtInHandlersSymbol] = builtInHandlers;
+    // In development, `cacheMaxMemorySize: 0` would make the built-in default
+    // handler a no-op, so every reload would miss. Use a real in-memory size
+    // instead so dev stays fast; the "use cache" wrapper forces a dynamic cache
+    // life for this case so it still behaves close to "no cache" (serve stale,
+    // regenerate in the background). Production keeps the no-op handler.
+    const builtInSize = process.env.__NEXT_DEV_SERVER && cacheMaxMemorySize === 0 ? DEV_MEMORY_CACHE_SIZE : cacheMaxMemorySize;
+    // Initialize the cache from the symbol contents first.
+    if (reference[handlersSymbol]) {
+        let fallback;
+        if (reference[handlersSymbol].DefaultCache) {
+            debug == null ? void 0 : debug('setting "default" cache handler from symbol');
+            fallback = reference[handlersSymbol].DefaultCache;
+        } else {
+            debug == null ? void 0 : debug('setting "default" cache handler from default');
+            fallback = (0, _default.createDefaultCacheHandler)(builtInSize);
+            builtInHandlers.add(fallback);
+        }
+        handlersMap.set('default', fallback);
+        if (reference[handlersSymbol].RemoteCache) {
+            debug == null ? void 0 : debug('setting "remote" cache handler from symbol');
+            handlersMap.set('remote', reference[handlersSymbol].RemoteCache);
+        } else {
+            debug == null ? void 0 : debug('setting "remote" cache handler from default');
+            handlersMap.set('remote', fallback);
+        }
+    } else {
+        const handler = (0, _default.createDefaultCacheHandler)(builtInSize);
+        builtInHandlers.add(handler);
+        debug == null ? void 0 : debug('setting "default" cache handler from default');
+        handlersMap.set('default', handler);
+        debug == null ? void 0 : debug('setting "remote" cache handler from default');
+        handlersMap.set('remote', handler);
+    }
+    // Create a set of the cache handlers.
+    reference[handlersSetSymbol] = new Set(handlersMap.values());
+    // In development we add dedicated built-in in-memory handlers so that reloads
+    // are fast. These are always built-in handlers, never a user-configured one,
+    // and are gated on the dev server so production behaves exactly as
+    // configured.
+    if (process.env.__NEXT_DEV_SERVER) {
+        reference[memoryCacheDisabledSymbol] = cacheMaxMemorySize === 0;
+        // Private caches are persisted here so reloads are fast. Private entries
+        // can hold data specific to the incoming request (for example, derived from
+        // its cookies or headers), so this is never the user-configured `default`
+        // alias. Sized so it still caches under `cacheMaxMemorySize: 0` (otherwise
+        // it would become the no-op stub and private reloads would miss).
+        reference[privateHandlerSymbol] = (0, _default.createDefaultCacheHandler)(DEV_MEMORY_CACHE_SIZE);
+        // Built-in front handlers, one per custom kind, and the tiered handlers
+        // that place a front in front of a (possibly slow or remote) backing
+        // handler so cache hits resolve in a microtask, are both created per kind
+        // in `setCacheHandler`.
+        reference[devFrontHandlersSymbol] = new Map();
+        reference[devTieredHandlersSymbol] = new Map();
+    }
+}
+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 new Error('Cache handlers not initialized');
+    }
+    return reference[handlersMapSymbol].get(kind);
+}
+function getPrivateCacheHandler() {
+    // This should never be called before initializeCacheHandlers.
+    if (!reference[handlersMapSymbol]) {
+        throw new Error('Cache handlers not initialized');
+    }
+    return reference[privateHandlerSymbol];
+}
+function isMemoryCacheDisabled() {
+    return reference[memoryCacheDisabledSymbol] ?? false;
+}
+function isCustomCacheHandler(kind) {
+    var _reference_devFrontHandlersSymbol;
+    if (!process.env.__NEXT_DEV_SERVER) {
+        return false;
+    }
+    return ((_reference_devFrontHandlersSymbol = reference[devFrontHandlersSymbol]) == null ? void 0 : _reference_devFrontHandlersSymbol.has(kind)) ?? false;
+}
+function isBuiltInCacheHandler(kind) {
+    var _reference_handlersMapSymbol, _reference_builtInHandlersSymbol;
+    const handler = (_reference_handlersMapSymbol = reference[handlersMapSymbol]) == null ? void 0 : _reference_handlersMapSymbol.get(kind);
+    return handler !== undefined && Boolean((_reference_builtInHandlersSymbol = reference[builtInHandlersSymbol]) == null ? void 0 : _reference_builtInHandlersSymbol.has(handler));
+}
+function getDevTieredCacheHandler(kind) {
+    var _reference_devTieredHandlersSymbol;
+    if (!process.env.__NEXT_DEV_SERVER) {
+        return undefined;
+    }
+    return (_reference_devTieredHandlersSymbol = reference[devTieredHandlersSymbol]) == null ? void 0 : _reference_devTieredHandlersSymbol.get(kind);
+}
+function getCacheHandlers() {
+    const handlersSet = reference[handlersSetSymbol];
+    if (!handlersSet) {
+        return undefined;
+    }
+    const handlers = Array.from(handlersSet);
+    if (process.env.__NEXT_DEV_SERVER) {
+        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];
+    if (!handlersMap) {
+        return undefined;
+    }
+    if (process.env.__NEXT_DEV_SERVER) {
+        return iterateCacheHandlerEntriesWithDevBuiltIns(handlersMap);
+    }
+    return handlersMap.entries();
+}
+/**
+ * Yields the registered entries plus the dev-only private handler under its
+ * kind, so that per-kind tag operations (`refreshTags` / `getExpiration` for
+ * implicit tags) apply to private entries. Custom-kind front handlers are
+ * intentionally omitted: the backing handler (already in the map) is
+ * authoritative for that kind's `getExpiration`, and a front entry is discarded
+ * via that same value.
+ */ function* iterateCacheHandlerEntriesWithDevBuiltIns(handlersMap) {
+    yield* handlersMap.entries();
+    const privateHandler = reference[privateHandlerSymbol];
+    if (privateHandler) {
+        const privateEntry = [
+            'private',
+            privateHandler
+        ];
+        yield privateEntry;
+    }
+}
+function setCacheHandler(kind, cacheHandler) {
+    // This should never be called before initializeCacheHandlers.
+    if (!reference[handlersMapSymbol] || !reference[handlersSetSymbol]) {
+        throw new Error('Cache handlers not initialized');
+    }
+    debug == null ? void 0 : debug('setting cache handler for "%s"', kind);
+    reference[handlersMapSymbol].set(kind, cacheHandler);
+    reference[handlersSetSymbol].add(cacheHandler);
+    // A user-configured handler may be slow or remote. In development, give it a
+    // dedicated built-in in-memory front handler so cache hits resolve in a
+    // microtask, and pair the two into a tiered handler the wrapper reads
+    // through. Both are created alongside registration so their lifecycle matches
+    // the backing handler's, and the front handler's presence is the signal that
+    // this kind is backed by a real handler (see `isCustomCacheHandler`). Being a
+    // built-in default handler, the front inherits the dev minimum retention, so
+    // a short-`expire` value still hits the front instead of falling through to
+    // the slow backing on every read.
+    if (process.env.__NEXT_DEV_SERVER) {
+        var _reference_devFrontHandlersSymbol, _reference_devTieredHandlersSymbol;
+        const frontHandler = (0, _default.createDefaultCacheHandler)(DEV_MEMORY_CACHE_SIZE);
+        (_reference_devFrontHandlersSymbol = reference[devFrontHandlersSymbol]) == null ? void 0 : _reference_devFrontHandlersSymbol.set(kind, frontHandler);
+        (_reference_devTieredHandlersSymbol = reference[devTieredHandlersSymbol]) == null ? void 0 : _reference_devTieredHandlersSymbol.set(kind, (0, _tieredcachehandler.createTieredCacheHandler)(frontHandler, cacheHandler));
+    }
+}
+
+//# sourceMappingURL=handlers.js.map

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

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTieredCacheHandler", {
+    enumerable: true,
+    get: function() {
+        return createTieredCacheHandler;
+    }
+});
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _clonecacheentry = require("./clone-cache-entry");
+function createTieredCacheHandler(front, backing) {
+    // Holds the in-flight (or chained) background sync per key, so a sync for a
+    // key runs after any earlier one for that key rather than in parallel.
+    const inFlightSyncs = new Map();
+    function scheduleBackgroundSync(cacheKey, sync) {
+        // Serialize syncs per key: chain this one after any in-flight sync rather
+        // than running a second in parallel. The trailing sync still re-reads the
+        // backing, so the front converges to the latest state; a later read is
+        // never dropped in favor of an earlier, possibly stale, in-flight read.
+        const previous = inFlightSyncs.get(cacheKey);
+        let pending;
+        if (previous) {
+            pending = previous.then(sync);
+        } else {
+            pending = sync();
+        }
+        pending = pending.finally(()=>{
+            if (inFlightSyncs.get(cacheKey) === pending) {
+                inFlightSyncs.delete(cacheKey);
+            }
+        });
+        inFlightSyncs.set(cacheKey, pending);
+        // Register the sync on the current request's revalidation writes so it is
+        // awaited rather than left untracked. Reading the work store here (rather
+        // than capturing it at construction) is what lets the handler be a shared
+        // singleton; `get` always runs within the request's async context, so the
+        // store is present.
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        if (workStore) {
+            workStore.pendingRevalidateWrites ??= [];
+            workStore.pendingRevalidateWrites.push(pending);
+        }
+    }
+    return {
+        async get (cacheKey, softTags) {
+            const frontEntry = await front.get(cacheKey, softTags);
+            if (frontEntry) {
+                // Cache hit: serve immediately (in a microtask). A background reconcile
+                // keeps the front in sync with the backing for the next read;
+                // reconciles for the same key are serialized, so concurrent cache hits
+                // don't hit the backing in parallel.
+                scheduleBackgroundSync(cacheKey, ()=>reconcileFrontFromBacking(front, backing, cacheKey, softTags, frontEntry));
+                return frontEntry;
+            }
+            // Cold or evicted front entry: we pay the backing latency here (this is a
+            // read that may legitimately surface a cold cache indicator). A miss
+            // returns undefined and the "use cache" wrapper generates the entry and
+            // writes it through both tiers via `set`.
+            const backingEntry = await backing.get(cacheKey, softTags);
+            if (!backingEntry) {
+                return undefined;
+            }
+            // Mirror this freshly read backing entry into the front so the next read
+            // hits it. The mirror is serialized per key: if a sync is already
+            // running, this chains after it, so the front converges to this read even
+            // if the backing changed since that sync started.
+            const [servedEntry, mirroredEntry] = (0, _clonecacheentry.cloneCacheEntry)(backingEntry);
+            scheduleBackgroundSync(cacheKey, ()=>mirrorIntoFront(front, cacheKey, mirroredEntry));
+            return servedEntry;
+        },
+        async set (cacheKey, pendingEntry) {
+            // Write through to both tiers. The entry's value stream is single-use, so
+            // tee it into one entry per tier.
+            const entry = await pendingEntry;
+            const [frontEntry, backingEntry] = (0, _clonecacheentry.cloneCacheEntry)(entry);
+            await Promise.all([
+                front.set(cacheKey, Promise.resolve(frontEntry)),
+                backing.set(cacheKey, Promise.resolve(backingEntry))
+            ]);
+        }
+    };
+}
+/**
+ * After serving a cache hit from the front, consult the backing and mirror a
+ * newer entry into the front for the next read. Runs in the background;
+ * failures are non-fatal.
+ */ async function reconcileFrontFromBacking(front, backing, cacheKey, softTags, frontEntry) {
+    try {
+        const backingEntry = await backing.get(cacheKey, softTags);
+        if (!backingEntry) {
+            // The backing no longer has this entry (it was purged out-of-band). The
+            // cache-handler interface has no per-key delete, so evict the front entry
+            // by overwriting it with an already-expired copy: the next read sees a
+            // front miss, falls through to the (also empty) backing, and the wrapper
+            // regenerates. The entry we just served was the last stale read.
+            await front.set(cacheKey, Promise.resolve(toExpiredEntry(frontEntry)));
+            return;
+        }
+        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. 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  {
+    // Background warming; failures are non-fatal.
+    }
+}
+/**
+ * Mirror a backing entry into the front.
+ */ async function mirrorIntoFront(front, cacheKey, entry) {
+    try {
+        await front.set(cacheKey, Promise.resolve(entry));
+    } catch  {
+    // Background warming; failures are non-fatal.
+    }
+}
+/**
+ * Build an already-expired copy of an entry, used to evict it from the front
+ * handler (which has no per-key delete) once the backing no longer has it. The
+ * default handler treats a negative `expire` as an eviction sentinel and
+ * reports the entry as missing on the next read. A negative `expire` is used
+ * rather than `0` because the dev front handler enforces a minimum retention,
+ * so a `0` `expire` would be kept alive by that minimum instead of evicted. The
+ * value is never read once the entry is evicted, but it must carry at least one
+ * byte because the built-in LRU cache refuses to store size-0 entries.
+ */ function toExpiredEntry(entry) {
+    return {
+        ...entry,
+        expire: -1,
+        value: new ReadableStream({
+            start (controller) {
+                controller.enqueue(new Uint8Array(1));
+                controller.close();
+            }
+        })
+    };
+}
+
+//# sourceMappingURL=tiered-cache-handler.js.map

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    NestedDynamicUseCacheError: null,
+    UNEXPECTED_CACHE_MISS_MESSAGE: null,
+    UnexpectedCacheMissError: null,
+    UseCacheDeadlockError: null,
+    UseCacheTimeoutError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NestedDynamicUseCacheError: function() {
+        return NestedDynamicUseCacheError;
+    },
+    UNEXPECTED_CACHE_MISS_MESSAGE: function() {
+        return UNEXPECTED_CACHE_MISS_MESSAGE;
+    },
+    UnexpectedCacheMissError: function() {
+        return UnexpectedCacheMissError;
+    },
+    UseCacheDeadlockError: function() {
+        return UseCacheDeadlockError;
+    },
+    UseCacheTimeoutError: function() {
+        return UseCacheTimeoutError;
+    }
+});
+class UseCacheTimeoutError extends Error {
+    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(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.');
+        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/dashboard/.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