@evoscientist/webui 0.2.5 → 0.2.7

package/dist/node_modules/next/dist/server/lib/implicit-tags.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "getImplicitTags", {
 });
 const _constants = require("../../lib/constants");
 const _handlers = require("../use-cache/handlers");
+const _encodeheadersafe = require("./encode-header-safe");
 const _lazyresult = require("./lazy-result");
 const getDerivedTags = (pathname)=>{
     const derivedTags = [
@@ -18,9 +19,12 @@ const getDerivedTags = (pathname)=>{
     // we automatically add the current path segments as tags
     // for revalidatePath handling
     if (pathname.startsWith('/')) {
-        const pathnameParts = pathname.split('/');
-        for(let i = 1; i < pathnameParts.length + 1; i++){
-            let curPathname = pathnameParts.slice(0, i).join('/');
+        let end = pathname.indexOf('/', 1);
+        while(true){
+            if (end === -1) {
+                end = pathname.length;
+            }
+            let curPathname = pathname.slice(0, end);
             if (curPathname) {
                 // all derived tags other than the page are layout tags
                 if (!curPathname.endsWith('/page') && !curPathname.endsWith('/route')) {
@@ -28,6 +32,10 @@ const getDerivedTags = (pathname)=>{
                 }
                 derivedTags.push(curPathname);
             }
+            if (end === pathname.length) {
+                break;
+            }
+            end = pathname.indexOf('/', end + 1);
         }
     }
     return derivedTags;
@@ -49,16 +57,18 @@ const getDerivedTags = (pathname)=>{
 }
 async function getImplicitTags(page, pathname, fallbackRouteParams) {
     const tags = new Set();
-    // Add the derived tags from the page.
+    // Add the derived tags from the page. Encode each tag so a non-ASCII
+    // pathname doesn't trip header validation when written to
+    // `x-next-cache-tags`. Idempotent on already-ASCII input.
     const derivedTags = getDerivedTags(page);
     for (let tag of derivedTags){
-        tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`;
+        tag = (0, _encodeheadersafe.encodeHeaderSafe)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`);
         tags.add(tag);
     }
     // Add the tags from the pathname. If the route has unknown params, we don't
     // want to add the pathname as a tag, as it will be invalid.
     if (pathname && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
-        const tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`;
+        const tag = (0, _encodeheadersafe.encodeHeaderSafe)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`);
         tags.add(tag);
     }
     if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {

package/dist/node_modules/next/dist/server/lib/incremental-cache/file-system-cache.js

@@ -310,18 +310,22 @@ class FileSystemCache {
         // Wait for all FS operations to complete.
         await writer.wait();
     }
-    getFilePath(pathname, kind) {
+    getFilePath(key, kind) {
+        let rootDir;
         switch(kind){
             case _responsecache.IncrementalCacheKind.FETCH:
                 // we store in .next/cache/fetch-cache so it can be persisted
                 // across deploys
-                return _path.default.join(this.serverDistDir, '..', 'cache', 'fetch-cache', pathname);
+                rootDir = _path.default.join(this.serverDistDir, '..', 'cache', 'fetch-cache');
+                break;
             case _responsecache.IncrementalCacheKind.PAGES:
-                return _path.default.join(this.serverDistDir, 'pages', pathname);
+                rootDir = _path.default.join(this.serverDistDir, 'pages');
+                break;
             case _responsecache.IncrementalCacheKind.IMAGE:
             case _responsecache.IncrementalCacheKind.APP_PAGE:
             case _responsecache.IncrementalCacheKind.APP_ROUTE:
-                return _path.default.join(this.serverDistDir, 'app', pathname);
+                rootDir = _path.default.join(this.serverDistDir, 'app');
+                break;
             default:
                 throw Object.defineProperty(new Error(`Unexpected file path kind: ${kind}`), "__NEXT_ERROR_CODE", {
                     value: "E479",
@@ -329,6 +333,15 @@ class FileSystemCache {
                     configurable: true
                 });
         }
+        const filePath = _path.default.join(rootDir, key);
+        if (!(filePath.startsWith(rootDir + _path.default.sep) || filePath === rootDir)) {
+            throw Object.defineProperty(new Error(`Invalid file path: ${filePath}`), "__NEXT_ERROR_CODE", {
+                value: "E1468",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return filePath;
     }
 }
 

package/dist/node_modules/next/dist/server/lib/incremental-cache/index.js

@@ -37,6 +37,33 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+function toHex(buffer) {
+    // Hex-encode body bytes losslessly: decoding as UTF-8 would collapse
+    // distinct bytes (0xff/0xfe to U+FFFD) and collide; Buffer isn't on edge.
+    const bytes = isArrayBuffer(buffer) ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let hex = '';
+    for (const byte of bytes){
+        hex += byte.toString(16).padStart(2, '0');
+    }
+    return hex;
+}
+// Duck typing to support Edge runtime
+// TODO: Switch to instanceof checks once Edge runtime is removed.
+function isArrayBuffer(buffer) {
+    return !('buffer' in buffer);
+}
+function isBodyByteSequence(body) {
+    return typeof body === 'object' && 'byteLength' in body;
+}
+function isBodyReadableStream(body) {
+    return typeof body.getReader === 'function';
+}
+function isBodyFormDataOrURLSearchParams(body) {
+    return typeof body.keys === 'function';
+}
+function isBodyBlob(body) {
+    return typeof body.arrayBuffer === 'function';
+}
 class CacheHandler {
     // eslint-disable-next-line
     constructor(_ctx){}
@@ -47,6 +74,19 @@ class CacheHandler {
     async revalidateTag(_tags, _durations) {}
     resetRequestCache() {}
 }
+async function hashString(cacheString) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        const encoder = new TextEncoder();
+        const buffer = encoder.encode(cacheString);
+        return toHex(await crypto.subtle.digest('SHA-256', buffer));
+    } else {
+        const crypto1 = require('crypto');
+        return crypto1.createHash('sha256').update(cacheString).digest('hex');
+    }
+}
+// this should be bumped anytime a fix is made to cache entries
+// that should bust the cache
+const MAIN_KEY_PREFIX = 'v4';
 class IncrementalCache {
     static #_ = this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE;
     constructor({ fs, dev, flushToDisk, minimalMode, serverDistDir, requestHeaders, maxMemoryCacheSize, getPrerenderManifest, fetchCacheKeyPrefix, CurCacheHandler, allowedRevalidateHeaderKeys }){
@@ -161,38 +201,34 @@ class IncrementalCache {
         var _this_cacheHandler;
         return (_this_cacheHandler = this.cacheHandler) == null ? void 0 : _this_cacheHandler.revalidateTag(tags, durations);
     }
+    async generateSimpleCacheKey(input) {
+        const cacheString = JSON.stringify([
+            MAIN_KEY_PREFIX,
+            this.fetchCacheKeyPrefix || '',
+            input
+        ]);
+        return hashString(cacheString);
+    }
     // x-ref: https://github.com/facebook/react/blob/2655c9354d8e1c54ba888444220f63e836925caa/packages/react/src/ReactFetch.js#L23
     async generateCacheKey(url, init = {}) {
-        // this should be bumped anytime a fix is made to cache entries
-        // that should bust the cache
-        const MAIN_KEY_PREFIX = 'v3';
         const bodyChunks = [];
         const encoder = new TextEncoder();
-        const decoder = new TextDecoder();
-        if (init.body) {
-            // handle Uint8Array body
-            if (init.body instanceof Uint8Array) {
-                bodyChunks.push(decoder.decode(init.body));
-                init._ogBody = init.body;
-            } else if (typeof init.body.getReader === 'function') {
-                const readableBody = init.body;
+        // Will be set implementing https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+        let bodyType = null;
+        const body = init.body;
+        if (body) {
+            if (isBodyByteSequence(body)) {
+                bodyChunks.push(`bytes:${toHex(body)}`);
+                init._ogBody = body;
+            } else if (isBodyReadableStream(body)) {
+                const readableBody = body;
                 const chunks = [];
                 try {
                     await readableBody.pipeTo(new WritableStream({
                         write (chunk) {
-                            if (typeof chunk === 'string') {
-                                chunks.push(encoder.encode(chunk));
-                                bodyChunks.push(chunk);
-                            } else {
-                                chunks.push(chunk);
-                                bodyChunks.push(decoder.decode(chunk, {
-                                    stream: true
-                                }));
-                            }
+                            chunks.push(typeof chunk === 'string' ? encoder.encode(chunk) : chunk);
                         }
                     }));
-                    // Flush the decoder.
-                    bodyChunks.push(decoder.decode());
                     // Create a new buffer with all the chunks.
                     const length = chunks.reduce((total, arr)=>total + arr.length, 0);
                     const arrayBuffer = new Uint8Array(length);
@@ -202,39 +238,46 @@ class IncrementalCache {
                         arrayBuffer.set(chunk, offset);
                         offset += chunk.length;
                     }
-                    ;
+                    bodyChunks.push(`bytes:${toHex(arrayBuffer)}`);
                     init._ogBody = arrayBuffer;
                 } catch (err) {
                     console.error('Problem reading body', err);
                 }
-            } else if (typeof init.body.keys === 'function') {
-                const formData = init.body;
-                init._ogBody = init.body;
-                for (const key of new Set([
-                    ...formData.keys()
-                ])){
-                    const values = formData.getAll(key);
-                    bodyChunks.push(`${key}=${(await Promise.all(values.map(async (val)=>{
-                        if (typeof val === 'string') {
-                            return val;
-                        } else {
-                            return await val.text();
-                        }
-                    }))).join(',')}`);
+            } else if (isBodyFormDataOrURLSearchParams(body)) {
+                bodyType = String(body) === '[object FormData]' ? 'multipart/form-data; boundary=' : 'application/x-www-form-urlencoded;charset=UTF-8';
+                const iterable = body;
+                init._ogBody = body;
+                // Separate, tagged chunks so `["a","b"]` can't collide with `["a,b"]`.
+                for (const [key, val] of iterable.entries()){
+                    bodyChunks.push(`key:${key}`);
+                    if (typeof val === 'string') {
+                        bodyChunks.push(`str:${val}`);
+                    } else {
+                        bodyChunks.push('file', val.name, val.type, `bytes:${toHex(await val.arrayBuffer())}`);
+                    }
                 }
             // handle blob body
-            } else if (typeof init.body.arrayBuffer === 'function') {
-                const blob = init.body;
+            } else if (isBodyBlob(body)) {
+                const blob = body;
                 const arrayBuffer = await blob.arrayBuffer();
-                bodyChunks.push(await blob.text());
+                bodyChunks.push('blob', blob.type, `bytes:${toHex(arrayBuffer)}`);
                 init._ogBody = new Blob([
                     arrayBuffer
                 ], {
                     type: blob.type
                 });
-            } else if (typeof init.body === 'string') {
-                bodyChunks.push(init.body);
-                init._ogBody = init.body;
+                bodyType = blob.type;
+            } else if (typeof body === 'string') {
+                bodyChunks.push(`str:${body}`);
+                init._ogBody = body;
+                bodyType = 'text/plain;charset=UTF-8';
+            } else {
+                body;
+                throw Object.defineProperty(new Error(`Unsupported body type: ${typeof body}`), "__NEXT_ERROR_CODE", {
+                    value: "E1443",
+                    enumerable: false,
+                    configurable: true
+                });
             }
         }
         const headers = typeof (init.headers || {}).keys === 'function' ? Object.fromEntries(init.headers) : Object.assign({}, init.headers);
@@ -247,6 +290,9 @@ class IncrementalCache {
             this.fetchCacheKeyPrefix || '',
             url,
             init.method,
+            // Ensures default Content-Type is part of the cache key
+            // TODO: Only necessary when headers are not used from the Request instance
+            bodyType,
             headers,
             init.mode,
             init.redirect,
@@ -257,16 +303,7 @@ class IncrementalCache {
             init.cache,
             bodyChunks
         ]);
-        if (process.env.NEXT_RUNTIME === 'edge') {
-            function bufferToHex(buffer) {
-                return Array.prototype.map.call(new Uint8Array(buffer), (b)=>b.toString(16).padStart(2, '0')).join('');
-            }
-            const buffer = encoder.encode(cacheString);
-            return bufferToHex(await crypto.subtle.digest('SHA-256', buffer));
-        } else {
-            const crypto1 = require('crypto');
-            return crypto1.createHash('sha256').update(cacheString).digest('hex');
-        }
+        return hashString(cacheString);
     }
     async get(cacheKey, ctx) {
         var _this_cacheHandler, _cacheData_value;
@@ -274,7 +311,7 @@ class IncrementalCache {
         // testmode would normally disable it or if requestHeaders say 'no-cache'.
         if (ctx.kind === _responsecache.IncrementalCacheKind.FETCH) {
             const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            const resumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getRenderResumeDataCache)(workUnitStore) : null;
+            const resumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getResumeDataCache)(workUnitStore) : null;
             if (resumeDataCache) {
                 const memoryCacheData = resumeDataCache.fetch.get(cacheKey);
                 if ((memoryCacheData == null ? void 0 : memoryCacheData.kind) === _responsecache.CachedRouteKind.FETCH) {
@@ -358,12 +395,12 @@ class IncrementalCache {
             // and it won't have to reach into the fetch cache implementation.
             const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
             if (workUnitStore) {
-                const prerenderResumeDataCache = (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore);
-                if (prerenderResumeDataCache) {
+                const resumeDataCache = (0, _workunitasyncstorageexternal.getResumeDataCache)(workUnitStore);
+                if (resumeDataCache == null ? void 0 : resumeDataCache.mutable) {
                     if (IncrementalCache.debug) {
                         console.log('IncrementalCache: rdc:set', cacheKey);
                     }
-                    prerenderResumeDataCache.fetch.set(cacheKey, cacheData.value);
+                    resumeDataCache.fetch.set(cacheKey, cacheData.value);
                 }
             }
             const revalidate = ctx.revalidate || cacheData.value.revalidate;
@@ -399,23 +436,32 @@ class IncrementalCache {
             isStale = -1;
             revalidateAfter = -1 * _constants.CACHE_ONE_YEAR_SECONDS * 1000;
         } else {
-            var _cacheData_value3, _cacheData_value4;
             const now = performance.timeOrigin + performance.now();
             const lastModified = (cacheData == null ? void 0 : cacheData.lastModified) || now;
             revalidateAfter = this.calculateRevalidate(cacheKey, lastModified, this.dev ?? false, ctx.isFallback);
-            isStale = revalidateAfter !== false && revalidateAfter < now ? true : undefined;
-            // If the stale time couldn't be determined based on the revalidation
-            // time, we check if the tags are expired or stale.
-            if (isStale === undefined && ((cacheData == null ? void 0 : (_cacheData_value3 = cacheData.value) == null ? void 0 : _cacheData_value3.kind) === _responsecache.CachedRouteKind.APP_PAGE || (cacheData == null ? void 0 : (_cacheData_value4 = cacheData.value) == null ? void 0 : _cacheData_value4.kind) === _responsecache.CachedRouteKind.APP_ROUTE)) {
-                var _cacheData_value_headers;
-                const tagsHeader = (_cacheData_value_headers = cacheData.value.headers) == null ? void 0 : _cacheData_value_headers[_constants.NEXT_CACHE_TAGS_HEADER];
-                if (typeof tagsHeader === 'string') {
-                    const cacheTags = tagsHeader.split(',');
-                    if (cacheTags.length > 0) {
-                        if ((0, _tagsmanifestexternal.areTagsExpired)(cacheTags, lastModified)) {
-                            isStale = -1;
-                        } else if ((0, _tagsmanifestexternal.areTagsStale)(cacheTags, lastModified)) {
-                            isStale = true;
+            // If the route's `expire` time has passed, force a blocking revalidation
+            // by signalling `isStale = -1`. The response cache treats `-1` as "skip
+            // the early SWR resolve" and awaits a fresh render before the user sees a
+            // response.
+            const expireAfter = typeof (cacheControl == null ? void 0 : cacheControl.expire) === 'number' ? cacheControl.expire * 1000 + lastModified : undefined;
+            if (expireAfter !== undefined && expireAfter < now) {
+                isStale = -1;
+            } else {
+                var _cacheData_value3, _cacheData_value4;
+                isStale = revalidateAfter !== false && revalidateAfter < now ? true : undefined;
+                // If the stale time couldn't be determined based on the revalidation
+                // time, we check if the tags are expired or stale.
+                if (isStale === undefined && ((cacheData == null ? void 0 : (_cacheData_value3 = cacheData.value) == null ? void 0 : _cacheData_value3.kind) === _responsecache.CachedRouteKind.APP_PAGE || (cacheData == null ? void 0 : (_cacheData_value4 = cacheData.value) == null ? void 0 : _cacheData_value4.kind) === _responsecache.CachedRouteKind.APP_ROUTE)) {
+                    var _cacheData_value_headers;
+                    const tagsHeader = (_cacheData_value_headers = cacheData.value.headers) == null ? void 0 : _cacheData_value_headers[_constants.NEXT_CACHE_TAGS_HEADER];
+                    if (typeof tagsHeader === 'string') {
+                        const cacheTags = tagsHeader.split(',');
+                        if (cacheTags.length > 0) {
+                            if ((0, _tagsmanifestexternal.areTagsExpired)(cacheTags, lastModified)) {
+                                isStale = -1;
+                            } else if ((0, _tagsmanifestexternal.areTagsStale)(cacheTags, lastModified)) {
+                                isStale = true;
+                            }
                         }
                     }
                 }
@@ -458,12 +504,12 @@ class IncrementalCache {
         // debug info to have the right environment associated to it.
         if ((data == null ? void 0 : data.kind) === _responsecache.CachedRouteKind.FETCH) {
             const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            const prerenderResumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getPrerenderResumeDataCache)(workUnitStore) : null;
-            if (prerenderResumeDataCache) {
+            const resumeDataCache = workUnitStore ? (0, _workunitasyncstorageexternal.getResumeDataCache)(workUnitStore) : null;
+            if (resumeDataCache == null ? void 0 : resumeDataCache.mutable) {
                 if (IncrementalCache.debug) {
                     console.log('IncrementalCache: rdc:set', pathname);
                 }
-                prerenderResumeDataCache.fetch.set(pathname, data);
+                resumeDataCache.fetch.set(pathname, data);
             }
         }
         if (this.disableForTestmode || this.dev && !ctx.fetchCache) return;

package/dist/node_modules/next/dist/server/lib/incremental-cache/memory-cache.external.js

@@ -26,12 +26,12 @@ function getSegmentDataSize(segmentData) {
 }
 function getMemoryCache(maxMemoryCacheSize) {
     if (!memoryCache) {
-        memoryCache = new _lrucache.LRUCache(maxMemoryCacheSize, function length({ value }) {
-            var _JSON_stringify;
+        memoryCache = new _lrucache.LRUCache(maxMemoryCacheSize, function length({ value }, cacheKey) {
+            let valueSize;
             if (!value) {
-                return 25;
+                valueSize = 25;
             } else if (value.kind === _types.CachedRouteKind.REDIRECT) {
-                return JSON.stringify(value.props).length;
+                valueSize = JSON.stringify(value.props).length;
             } else if (value.kind === _types.CachedRouteKind.IMAGE) {
                 throw Object.defineProperty(new Error('invariant image should not be incremental-cache'), "__NEXT_ERROR_CODE", {
                     value: "E501",
@@ -39,16 +39,18 @@ function getMemoryCache(maxMemoryCacheSize) {
                     configurable: true
                 });
             } else if (value.kind === _types.CachedRouteKind.FETCH) {
-                return JSON.stringify(value.data || '').length;
+                valueSize = JSON.stringify(value.data || '').length;
             } else if (value.kind === _types.CachedRouteKind.APP_ROUTE) {
-                return value.body.length;
-            }
-            // rough estimate of size of cache value
-            if (value.kind === _types.CachedRouteKind.APP_PAGE) {
+                valueSize = value.body.length;
+            } else if (value.kind === _types.CachedRouteKind.APP_PAGE) {
                 var _value_postponed;
-                return Math.max(1, value.html.length + getBufferSize(value.rscData) + (((_value_postponed = value.postponed) == null ? void 0 : _value_postponed.length) || 0) + getSegmentDataSize(value.segmentData));
+                // rough estimate of size of cache value
+                valueSize = Math.max(1, value.html.length + getBufferSize(value.rscData) + (((_value_postponed = value.postponed) == null ? void 0 : _value_postponed.length) || 0) + getSegmentDataSize(value.segmentData));
+            } else {
+                var _JSON_stringify;
+                valueSize = value.html.length + (((_JSON_stringify = JSON.stringify(value.pageData)) == null ? void 0 : _JSON_stringify.length) || 0);
             }
-            return value.html.length + (((_JSON_stringify = JSON.stringify(value.pageData)) == null ? void 0 : _JSON_stringify.length) || 0);
+            return cacheKey.length + valueSize;
         });
     }
     return memoryCache;

package/dist/node_modules/next/dist/server/lib/incremental-cache/tags-manifest.external.js

@@ -30,7 +30,7 @@ const areTagsExpired = (tags, timestamp)=>{
         const entry = tagsManifest.get(tag);
         const expiredAt = entry == null ? void 0 : entry.expired;
         if (typeof expiredAt === 'number') {
-            const now = Date.now();
+            const now = performance.timeOrigin + performance.now();
             // For immediate expiration (expiredAt <= now) and tag was invalidated after entry was created
             // OR for future expiration that has now passed (expiredAt > timestamp && expiredAt <= now)
             const isImmediatelyExpired = expiredAt <= now && expiredAt > timestamp;

package/dist/node_modules/next/dist/server/lib/is-non-html-sec-fetch-dest.js

@@ -0,0 +1,38 @@
+/**
+ * `Sec-Fetch-Dest` values for subresource requests that can never render an
+ * HTML response. Excludes destinations that can display HTML (`document`,
+ * `iframe`, etc.) and `empty` (`fetch()`/XHR, including RSC requests).
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isNonHtmlSecFetchDest", {
+    enumerable: true,
+    get: function() {
+        return isNonHtmlSecFetchDest;
+    }
+});
+const NON_HTML_SEC_FETCH_DESTS = new Set([
+    'audio',
+    'audioworklet',
+    'font',
+    'image',
+    'json',
+    'manifest',
+    'paintworklet',
+    'report',
+    'script',
+    'serviceworker',
+    'sharedworker',
+    'style',
+    'track',
+    'video',
+    'webidentity',
+    'worker',
+    'xslt'
+]);
+function isNonHtmlSecFetchDest(value) {
+    return typeof value === 'string' && NON_HTML_SEC_FETCH_DESTS.has(value);
+}
+
+//# sourceMappingURL=is-non-html-sec-fetch-dest.js.map

package/dist/node_modules/next/dist/server/lib/lazy-module.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LazyModule", {
+    enumerable: true,
+    get: function() {
+        return LazyModule;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+class LazyModule {
+    constructor(load, onLoad){
+        this.load = load;
+        this.onLoad = onLoad;
+        this.state = {
+            status: 'uninitialized'
+        };
+    }
+    loadIfNeeded() {
+        if (this.state.status !== 'uninitialized') {
+            return;
+        }
+        const result = this.load();
+        if (!(result instanceof Promise)) {
+            this.onLoad(result);
+            this.state = {
+                status: 'resolved',
+                module: result
+            };
+            return;
+        }
+        this.state = {
+            status: 'pending',
+            promise: result.then((module)=>{
+                this.onLoad(module);
+                const resolved = {
+                    status: 'resolved',
+                    module
+                };
+                this.state = resolved;
+                return resolved;
+            }).catch((reason)=>{
+                const rejected = {
+                    status: 'rejected',
+                    reason
+                };
+                this.state = rejected;
+                return rejected;
+            })
+        };
+    }
+    async waitUntilLoaded() {
+        this.loadIfNeeded();
+        let state = this.state;
+        if (state.status === 'pending') {
+            state = await state.promise;
+        }
+        if (state.status === 'rejected') {
+            throw state.reason;
+        }
+    }
+    assertLoaded() {
+        this.loadIfNeeded();
+        const state = this.state;
+        if (state.status === 'resolved') {
+            return state.module;
+        }
+        if (state.status === 'rejected') {
+            throw state.reason;
+        }
+        throw Object.defineProperty(new _invarianterror.InvariantError('The lazy module is still loading. It must be awaited with `waitUntilLoaded()` before it can be accessed.'), "__NEXT_ERROR_CODE", {
+            value: "E1421",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=lazy-module.js.map

package/dist/node_modules/next/dist/server/lib/lru-cache.js

@@ -89,7 +89,7 @@ class LRUCache {
    * - O(1) for uniform item sizes
    * - O(k) where k is the number of items evicted (can be O(N) for variable sizes)
    */ set(key, value) {
-        const size = (this.calculateSize == null ? void 0 : this.calculateSize.call(this, value)) ?? 1;
+        const size = (this.calculateSize == null ? void 0 : this.calculateSize.call(this, value, key)) ?? 1;
         if (size <= 0) {
             throw Object.defineProperty(new Error(`LRUCache: calculateSize returned ${size}, but size must be > 0. ` + `Items with size 0 would never be evicted, causing unbounded cache growth.`), "__NEXT_ERROR_CODE", {
                 value: "E1045",

package/dist/node_modules/next/dist/server/lib/mock-request.js

@@ -201,7 +201,7 @@ class MockedResponse extends _stream.default.Writable {
             this.totalSize += buffer.byteLength;
             if (this.totalSize > this.maximumResponseBody) {
                 const error = Object.defineProperty(new Error(`Response body exceeded maximum size of ${this.maximumResponseBody} bytes`), "__NEXT_ERROR_CODE", {
-                    value: "E1143",
+                    value: "E1171",
                     enumerable: false,
                     configurable: true
                 });

package/dist/node_modules/next/dist/server/lib/params-utils.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    allParamsAreRootParams: null,
+    hasFallbackRouteParams: null,
+    hasNonRootStaticParams: null,
+    isEmptyParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    allParamsAreRootParams: function() {
+        return allParamsAreRootParams;
+    },
+    hasFallbackRouteParams: function() {
+        return hasFallbackRouteParams;
+    },
+    hasNonRootStaticParams: function() {
+        return hasNonRootStaticParams;
+    },
+    isEmptyParams: function() {
+        return isEmptyParams;
+    }
+});
+function hasNonRootStaticParams(params, rootParams, fallbackParams) {
+    for(const paramName in params){
+        if (!Object.hasOwn(rootParams, paramName) && isStaticParam(paramName, fallbackParams)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isStaticParam(paramName, fallbackParams) {
+    // NOTE: Assume that undefined fallback params mean that all of the params are static.
+    if (!fallbackParams) return true;
+    // If the param isn't a fallback param, it must be static.
+    return !fallbackParams.has(paramName);
+}
+function allParamsAreRootParams(underlyingParams, rootParams) {
+    for(const paramName in underlyingParams){
+        if (!Object.hasOwn(rootParams, paramName)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isEmptyParams(params) {
+    for(const _paramKey in params){
+        return false;
+    }
+    return true;
+}
+function hasFallbackRouteParams(underlyingParams, fallbackParams) {
+    if (fallbackParams) {
+        for(let key in underlyingParams){
+            if (fallbackParams.has(key)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+//# sourceMappingURL=params-utils.js.map