@evoscientist/webui 0.3.0 → 0.3.2

package/dist/node_modules/next/dist/server/lib/router-utils/block-cross-site-dev.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "blockCrossSiteDEV", {
 const _url = require("../../../lib/url");
 const _log = require("../../../build/output/log");
 const _csrfprotection = require("../../app-render/csrf-protection");
+const _parsepath = require("../../../shared/lib/router/utils/parse-path");
 const allowedDevOriginsDocs = 'https://nextjs.org/docs/app/api-reference/config/next-config-js/allowedDevOrigins';
 function getBlockedResourcePath(req) {
     var _parseUrl;
@@ -62,17 +63,14 @@ function parseHostnameFromHeader(header) {
 }
 function isInternalEndpoint(req) {
     if (!req.url) return false;
-    try {
-        // TODO: We should standardize on a single prefix for this
-        const isMiddlewareRequest = req.url.includes('/__nextjs');
-        const isInternalAsset = req.url.includes('/_next');
-        // Static media requests are excluded, as they might be loaded via CSS and would fail
-        // CORS checks.
-        const isIgnoredRequest = req.url.includes('/_next/image') || req.url.includes('/_next/static/media') || req.url.includes('/_next/static/immutable/media');
-        return !isIgnoredRequest && (isInternalAsset || isMiddlewareRequest);
-    } catch (err) {
-        return false;
-    }
+    const { pathname } = (0, _parsepath.parsePath)(req.url);
+    // TODO: We should standardize on a single prefix for this
+    const isMiddlewareRequest = pathname.includes('/__nextjs');
+    const isInternalAsset = pathname.includes('/_next');
+    // Static media requests are excluded, as they might be loaded via CSS and would fail
+    // CORS checks.
+    const isIgnoredRequest = pathname.includes('/_next/image') || pathname.includes('/_next/static/media') || pathname.includes('/_next/static/immutable/media');
+    return !isIgnoredRequest && (isInternalAsset || isMiddlewareRequest);
 }
 const blockCrossSiteDEV = (req, res, allowedDevOrigins, hostname)=>{
     const allowedOrigins = [

package/dist/node_modules/next/dist/server/lib/start-server.js

@@ -177,7 +177,7 @@ async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server
 async function startServer(serverOptions) {
     const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate, serverFastRefresh } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"16.3.3"})`;
+    process.title = `next-server (v${"16.3.8"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{

package/dist/node_modules/next/dist/server/mcp/get-mcp-middleware.js

@@ -10,11 +10,13 @@ Object.defineProperty(exports, "getMcpMiddleware", {
 });
 const _getorcreatemcpserver = require("./get-or-create-mcp-server");
 const _parsebody = require("../api-utils/node/parse-body");
+const _parsepath = require("../../shared/lib/router/utils/parse-path");
+const _removetrailingslash = require("../../shared/lib/router/utils/remove-trailing-slash");
 const _streamableHttp = require("next/dist/compiled/@modelcontextprotocol/sdk/server/streamableHttp");
 function getMcpMiddleware(options) {
     return async function(req, res, next) {
-        const { pathname } = new URL(req.url || '', 'http://n');
-        if (!pathname.startsWith('/_next/mcp')) {
+        const { pathname } = (0, _parsepath.parsePath)(req.url || '');
+        if ((0, _removetrailingslash.removeTrailingSlash)(pathname) !== '/_next/mcp') {
             return next();
         }
         const mcpServer = (0, _getorcreatemcpserver.getOrCreateMcpServer)(options);

package/dist/node_modules/next/dist/server/next-server.js

@@ -462,7 +462,10 @@ class NextNodeServer extends _baseserver.default {
             delete process.env.__NEXT_REQUEST_INSIGHTS;
         }
         if (!this.minimalMode) {
-            this.imageResponseCache = new _responsecache.default(this.minimalMode);
+            this.imageResponseCache = new _responsecache.default({
+                minimalMode: this.minimalMode,
+                route: 'image'
+            });
         }
         if (!options.dev && !this.minimalMode && this.nextConfig.experimental.preloadEntriesOnStart) {
             this.unstable_preloadEntries();
@@ -594,6 +597,7 @@ class NextNodeServer extends _baseserver.default {
         }
     }
     async getIncrementalCache({ requestHeaders }) {
+        var _this_nextConfig_i18n;
         const dev = !!this.dev;
         let CacheHandler;
         const { cacheHandler } = this.nextConfig;
@@ -615,6 +619,7 @@ class NextNodeServer extends _baseserver.default {
             maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
             flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
             getPrerenderManifest: ()=>this.getPrerenderManifest(),
+            locales: (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales,
             CurCacheHandler: CacheHandler
         });
     }
@@ -801,8 +806,7 @@ class NextNodeServer extends _baseserver.default {
             const isAppPath = Array.isArray(appPaths);
             let page = ctx.pathname;
             if (isAppPath) {
-                // When it's an array, we need to pass all parallel routes to the loader.
-                page = appPaths[0];
+                page = (0, _apppaths.selectAppPageEntry)(ctx.pathname, appPaths);
             }
             for (const edgeFunctionsPage of edgeFunctionsPages){
                 if (edgeFunctionsPage === page) {

package/dist/node_modules/next/dist/server/response-cache/index.js

@@ -9,12 +9,13 @@ Object.defineProperty(exports, "default", {
     }
 });
 0 && __export(require("./types"));
+const _types = _export_star(require("./types"), exports);
+const _invarianterror = require("../../shared/lib/invariant-error");
 const _batcher = require("../../lib/batcher");
 const _lrucache = require("../lib/lru-cache");
 const _log = require("../../build/output/log");
 const _scheduler = require("../../lib/scheduler");
 const _utils = require("./utils");
-_export_star(require("./types"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
@@ -74,7 +75,7 @@ function _export_star(from, to) {
     return invocationID === TTL_SENTINEL ? undefined : invocationID;
 }
 class ResponseCache {
-    constructor(minimal_mode, maxSize = DEFAULT_MAX_SIZE, ttl = DEFAULT_TTL_MS){
+    constructor({ minimalMode, route, maxSize = DEFAULT_MAX_SIZE, ttl = DEFAULT_TTL_MS }){
         this.getBatcher = _batcher.Batcher.create({
             // Ensure on-demand revalidate doesn't block normal requests, it should be
             // safe to run an on-demand revalidate for the same key as a normal request.
@@ -95,7 +96,11 @@ class ResponseCache {
    * Used to detect when the cache size may be too small.
    * Bounded to prevent memory growth.
    */ this.evictedInvocationIDs = new Set();
-        this.minimal_mode = minimal_mode;
+        if (!route) {
+            throw new _invarianterror.InvariantError('Response cache requires a source route');
+        }
+        this.route = route;
+        this.minimal_mode = minimalMode;
         this.maxSize = maxSize;
         this.ttl = ttl;
         // Create the LRU cache with eviction tracking
@@ -157,7 +162,7 @@ class ResponseCache {
                 (0, _log.warnOnce)(`Response cache entry was evicted for invocation ${context.invocationID}. ` + `Consider increasing NEXT_PRIVATE_RESPONSE_CACHE_MAX_SIZE (current: ${this.maxSize}).`);
             }
         }
-        const { incrementalCache, isOnDemandRevalidate = false, isFallback = false, isRoutePPREnabled = false, isPrefetch = false, waitUntil, routeKind, invocationID } = context;
+        const { incrementalCache, isOnDemandRevalidate = false, isFallback = false, isRoutePPREnabled = false, isPrefetch = false, waitUntil, invocationID } = context;
         const response = await this.getBatcher.batch({
             key,
             isOnDemandRevalidate
@@ -168,7 +173,6 @@ class ResponseCache {
                 isFallback,
                 isRoutePPREnabled,
                 isPrefetch,
-                routeKind,
                 invocationID
             }, resolve);
             // We need to ensure background revalidates are passed to waitUntil.
@@ -197,11 +201,7 @@ class ResponseCache {
         let resolved = false;
         try {
             // Get the previous cache entry if not in minimal mode
-            previousIncrementalCacheEntry = !this.minimal_mode ? await context.incrementalCache.get(key, {
-                kind: (0, _utils.routeKindToIncrementalCacheKind)(context.routeKind),
-                isRoutePPREnabled: context.isRoutePPREnabled,
-                isFallback: context.isFallback
-            }) : null;
+            previousIncrementalCacheEntry = !this.minimal_mode ? await context.incrementalCache.get(key, this.getCacheContext(context.isRoutePPREnabled, context.isFallback)) : null;
             // `isStale === -1` signals that the entry is past its `expire` (either
             // via an expired tag or, with `cacheLife({ expire })`, past the route's
             // expire time in the prerender manifest). In that case we must NOT
@@ -293,9 +293,8 @@ class ResponseCache {
             // every caller — including batched invocations — populates the cache.
             if (incrementalResponseCacheEntry.cacheControl && !this.minimal_mode) {
                 await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
-                    cacheControl: incrementalResponseCacheEntry.cacheControl,
-                    isRoutePPREnabled,
-                    isFallback
+                    ...this.getCacheContext(isRoutePPREnabled, isFallback),
+                    cacheControl: incrementalResponseCacheEntry.cacheControl
                 });
             }
             return incrementalResponseCacheEntry;
@@ -306,18 +305,35 @@ class ResponseCache {
                 const revalidate = Math.min(Math.max(previousIncrementalCacheEntry.cacheControl.revalidate || 3, 3), 30);
                 const expire = previousIncrementalCacheEntry.cacheControl.expire === undefined ? undefined : Math.max(revalidate + 3, previousIncrementalCacheEntry.cacheControl.expire);
                 await incrementalCache.set(key, previousIncrementalCacheEntry.value, {
+                    ...this.getCacheContext(isRoutePPREnabled, isFallback),
                     cacheControl: {
                         revalidate: revalidate,
                         expire: expire
-                    },
-                    isRoutePPREnabled,
-                    isFallback
+                    }
                 });
             }
             // We haven't resolved yet, so let's throw to indicate an error.
             throw err;
         }
     }
+    getCacheContext(isRoutePPREnabled, isFallback) {
+        if (this.route === 'image') {
+            return {
+                kind: _types.IncrementalCacheKind.IMAGE,
+                isFallback: false
+            };
+        }
+        const kind = (0, _utils.routeKindToIncrementalCacheKind)(this.route.kind);
+        if (kind === _types.IncrementalCacheKind.IMAGE) {
+            throw new _invarianterror.InvariantError('Images must use the image response cache');
+        }
+        return {
+            route: this.route,
+            kind,
+            isRoutePPREnabled,
+            isFallback
+        };
+    }
 }
 
 //# sourceMappingURL=index.js.map

package/dist/node_modules/next/dist/server/route-matcher-providers/app-page-route-matcher-provider.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "AppPageRouteMatcherProvider", {
         return AppPageRouteMatcherProvider;
     }
 });
+const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _isapppageroute = require("../../lib/is-app-page-route");
 const _constants = require("../../shared/lib/constants");
 const _app = require("../normalizers/built/app");
@@ -35,8 +36,7 @@ class AppPageRouteMatcherProvider extends _manifestroutematcherprovider.Manifest
         // Format the routes.
         const matchers = [];
         for (const [pathname, appPaths] of Object.entries(allAppPaths)){
-            // TODO-APP: (wyattjoh) this is a hack right now, should be more deterministic
-            const page = appPaths[0];
+            const page = (0, _apppaths.selectAppPageEntry)(pathname, appPaths, (appPath)=>this.normalizers.pathname.normalize(appPath));
             const filename = this.normalizers.filename.normalize(manifest[page]);
             const bundlePath = this.normalizers.bundlePath.normalize(page);
             matchers.push(new _apppageroutematcher.AppPageRouteMatcher({

package/dist/node_modules/next/dist/server/route-modules/pages/pages-handler.js

@@ -30,6 +30,7 @@ const _redirectstatuscode = require("../../../client/components/redirect-status-
 const _isbot = require("../../../shared/lib/router/utils/is-bot");
 const _addpathprefix = require("../../../shared/lib/router/utils/add-path-prefix");
 const _removetrailingslash = require("../../../shared/lib/router/utils/remove-trailing-slash");
+const _routecachekey = require("../../lib/route-cache-key");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -106,8 +107,12 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
             cacheKey = cacheKey === '/index' ? '/' : cacheKey;
         }
         if (hasStaticPaths && !isDraftMode) {
+            var _nextConfig_i18n;
             const decodedPathname = (0, _removetrailingslash.removeTrailingSlash)(locale ? (0, _addpathprefix.addPathPrefix)(resolvedPathname, `/${locale}`) : resolvedPathname);
-            const isPrerendered = Boolean(prerenderManifest.routes[decodedPathname]) || prerenderManifest.notFoundRoutes.includes(decodedPathname);
+            const isPrerendered = (Boolean(prerenderManifest.routes[decodedPathname]) || prerenderManifest.notFoundRoutes.includes(decodedPathname)) && // A sibling's positive or negative prerender cannot admit parameters
+            // that this route excluded. Development computes static paths on demand
+            // instead of reading build-time prerender metadata.
+            (routeModule.isDev || (0, _routecachekey.isRouteCacheOwner)(decodedPathname, routeModule.cacheOwner, prerenderManifest.routes[decodedPathname], (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.locales));
             const prerenderInfo = prerenderManifest.dynamicRoutes[srcPage];
             if (prerenderInfo) {
                 if (prerenderInfo.fallback === false && !isPrerendered) {

package/dist/node_modules/next/dist/server/route-modules/route-module.js

@@ -28,6 +28,7 @@ const _incrementalcache = require("../lib/incremental-cache");
 const _handlers = require("../use-cache/handlers");
 const _interopdefault = require("../app-render/interop-default");
 const _routekind = require("../route-kind");
+const _routecachekey = require("../lib/route-cache-key");
 const _responsecache = /*#__PURE__*/ _interop_require_default(require("../response-cache"));
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _routerservercontext = require("../lib/router-utils/router-server-context");
@@ -47,6 +48,7 @@ class RouteModule {
     constructor({ userland, definition, distDir, relativeProjectDir }){
         this._userland = userland;
         this.definition = definition;
+        this.cacheOwner = (0, _routecachekey.getResponseCacheOwner)(definition);
         this.isDev = !!process.env.__NEXT_DEV_SERVER;
         this.distDir = distDir;
         this.relativeProjectDir = relativeProjectDir;
@@ -270,6 +272,7 @@ class RouteModule {
         if (process.env.NEXT_RUNTIME === 'edge') {
             return globalThis.__incrementalCache;
         } else {
+            var _nextConfig_i18n;
             let CacheHandler;
             const { cacheHandler } = nextConfig;
             if (cacheHandler) {
@@ -293,7 +296,8 @@ class RouteModule {
                 maxMemoryCacheSize: nextConfig.cacheMaxMemorySize,
                 flushToDisk: !isMinimalMode && nextConfig.experimental.isrFlushToDisk,
                 getPrerenderManifest: ()=>prerenderManifest,
-                CurCacheHandler: CacheHandler
+                CurCacheHandler: CacheHandler,
+                locales: (_nextConfig_i18n = nextConfig.i18n) == null ? void 0 : _nextConfig_i18n.locales
             });
             globalThis.__incrementalCache = incrementalCache;
             return incrementalCache;
@@ -651,7 +655,10 @@ class RouteModule {
     getResponseCache(req) {
         if (!this.responseCache) {
             const minimalMode = (0, _requestmeta.getRequestMeta)(req, 'minimalMode') ?? false;
-            this.responseCache = new _responsecache.default(minimalMode);
+            this.responseCache = new _responsecache.default({
+                minimalMode,
+                route: this.cacheOwner
+            });
         }
         return this.responseCache;
     }

package/dist/node_modules/next/dist/server/use-cache/use-cache-wrapper.js

@@ -87,9 +87,10 @@ function _interop_require_wildcard(obj, nodeInterop) {
  * tee-ing (via fork()) and metadata access for both intra-request and
  * cross-request joiners.
  */ class SharedCacheEntry {
-    constructor(stream, pendingMetadata){
+    constructor(stream, pendingMetadata, pendingWrite){
         this.stream = stream;
         this.pendingMetadata = pendingMetadata;
+        this.pendingCompletion = pendingWrite === undefined ? pendingMetadata : pendingWrite.then(()=>pendingMetadata, ()=>pendingMetadata);
     }
     /**
    * Tee the stream: returns a copy for the caller, replaces the internal stream
@@ -106,10 +107,9 @@ function ignoreReject() {}
  * Manages the deferred promise for a shared cache result, tracks which maps
  * it's registered in, and drives cleanup from resolve/reject.
  *
- * For 'cached' results, cleanup is lazy: entries stay in the maps until
- * metadata/collection resolves, giving late-arriving invocations a chance to
- * join while the leader streams. For 'prerender-dynamic' and errors, cleanup
- * is immediate.
+ * Cached results stay in the maps until collection finishes and handler writes
+ * settle. Later invocations can join while either remains pending. For
+ * 'prerender-dynamic' and errors, cleanup is immediate.
  */ class ResolvableSharedCacheResult {
     registerIn(map, key, retentionMap) {
         map.set(key, this.deferred.promise);
@@ -125,7 +125,7 @@ function ignoreReject() {}
             // Retain only an entry that collected successfully. A failed collection
             // leaves metadata a later invocation cannot read, so it is dropped like
             // any other failure and the next invocation regenerates.
-            result.entry.pendingMetadata.then(()=>this.cleanupAndRetain(), ()=>this.cleanup());
+            result.entry.pendingCompletion.then(()=>this.cleanupAndRetain(), ()=>this.cleanup());
         } else {
             this.cleanup();
         }
@@ -337,17 +337,16 @@ function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCache
     // which case it must save here; otherwise the RDC lookup during the final
     // prerender will miss.
     saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheEntry, resumeDataCache);
-    // End the cache signal read when the result is fully collected, not when the
-    // stream is available. A failed collection has no metadata to propagate but
-    // must still balance the read, so both settlements end it; leaving it open
-    // would stall a prerender waiting for its cache reads. The trailing .catch()
-    // covers propagation itself throwing after the rendering stream resolved.
+    // End the cache read after collection and metadata propagation, not when the
+    // value stream becomes available. This does not wait for handler persistence.
+    // A failed collection or propagation must still end the read so it cannot
+    // stall prerendering. The catch prevents an unhandled rejection after the
+    // stream has been returned.
     sharedCacheEntry.pendingMetadata.then((metadata)=>{
-        cacheSignal == null ? void 0 : cacheSignal.endRead();
         maybePropagateCacheEntryMetadata(cacheContext, metadata);
-    }, ()=>{
+    }).finally(()=>{
         cacheSignal == null ? void 0 : cacheSignal.endRead();
-    }).catch(()=>{});
+    }).catch(ignoreReject);
     return stream;
 }
 function saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, savedCacheResult, rootParams) {
@@ -860,7 +859,12 @@ async function generateCacheEntryImpl(workStore, cacheContext, innerCacheStore,
                     }
                 });
                 clearTimeout(timer);
-                if (timeoutAbortController.signal.aborted) {
+                const didTimeout = timeoutAbortController.signal.aborted;
+                if (dynamicAccessAbortSignal) {
+                    // Release React's listener from the composite signal.
+                    timeoutAbortController.abort();
+                }
+                if (didTimeout) {
                     // When the timeout is reached we always error the stream. Even for
                     // fallback shell prerenders we don't want to return a hanging promise,
                     // which would allow the function to become a dynamic hole. Because that
@@ -2042,7 +2046,13 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         // headers, so concurrent requests with identical request data should share
         // a fill too; that request-scoped `cacheHandlerKey` keeps requests with
         // different cookies or headers in separate entries.
-        const skipCrossRequestDedupe = isPrivate && !process.env.__NEXT_DEV_SERVER;
+        //
+        // Draft mode requests are skipped as well, in both directions. A fill that
+        // runs with draft mode enabled can contain unpublished content, so it must
+        // not be registered for other requests to join. And a draft mode request
+        // must not join a pending public fill, because it would be served the
+        // published content instead of the draft.
+        const skipCrossRequestDedupe = isPrivate && !process.env.__NEXT_DEV_SERVER || workStore.isDraftMode;
         try {
             // The loop handles cross-request root param mismatches: when a
             // cross-request joiner discovers that the leader's root params differ
@@ -2057,10 +2067,11 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                     debug == null ? void 0 : debug('joining pending cross-request invocation', cacheHandlerKey);
                     const sharedCacheResult = await crossRequestPendingCacheInvocation;
                     if (sharedCacheResult.type === 'cached') {
-                        // Root param verification: wait for metadata, then check key. MUST
-                        // happen before fork() — if key mismatches, we retry without having
-                        // used the stream.
-                        const metadata = await sharedCacheResult.entry.pendingMetadata;
+                        // Verify root params before forking the stream. The shared
+                        // invocation must complete first, including collection and write
+                        // settlement. A changed key retries the handler lookup, which must
+                        // not run before the write settles.
+                        const metadata = await sharedCacheResult.entry.pendingCompletion;
                         // Ensure known root param names are up-to-date before verifying the
                         // key, since the leader's save path may not have updated them yet
                         // at this point.
@@ -2324,21 +2335,16 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         return result.hangingPromise;
                     }
                     const { stream: newStream, pendingCacheResult } = result;
-                    // Cross-request joiners derive their metadata from this promise. By
-                    // default it's the collected result, but when we write to a cache
-                    // handler we swap in a promise that resolves only after the write has
-                    // landed, so a joiner that re-reads its recomputed key finds the
-                    // entry.
-                    let metadataSource = pendingCacheResult;
+                    let pendingWrite;
                     // When draft mode is enabled, we must not save the cache entry.
                     if (!workStore.isDraftMode) {
                         const savedCacheResult = saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCacheResult);
                         if (cacheHandler) {
-                            metadataSource = saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, savedCacheResult, rootParams);
+                            pendingWrite = saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, savedCacheResult, rootParams);
                         }
                     }
                     debug == null ? void 0 : debug('leader resolved with generated entry', cacheHandlerKey);
-                    const pendingMetadata = metadataSource.then((collected)=>({
+                    const pendingMetadata = pendingCacheResult.then((collected)=>({
                             tags: collected.entry.tags,
                             revalidate: collected.entry.revalidate,
                             expire: collected.entry.expire,
@@ -2349,7 +2355,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                             readRootParamNames: collected.readRootParamNames,
                             dynamicNestedCacheError: collected.dynamicNestedCacheError
                         }));
-                    const sharedCacheEntry = new SharedCacheEntry(newStream, pendingMetadata);
+                    const sharedCacheEntry = new SharedCacheEntry(newStream, pendingMetadata, pendingWrite);
                     stream = sharedCacheEntry.fork();
                     resolvableSharedCacheResult.resolve({
                         type: 'cached',
@@ -2405,7 +2411,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
                         cacheSignal == null ? void 0 : cacheSignal.endRead();
                     }
                     debug == null ? void 0 : debug('leader resolved with cache handler hit', cacheHandlerKey);
-                    const sharedCacheEntry = new SharedCacheEntry(stream, Promise.resolve(entryMetadata));
+                    const sharedCacheEntry = new SharedCacheEntry(stream, Promise.resolve(entryMetadata), undefined);
                     stream = sharedCacheEntry.fork();
                     resolvableSharedCacheResult.resolve({
                         type: 'cached',

package/dist/node_modules/next/dist/shared/lib/router/utils/app-paths.js

@@ -5,7 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     compareAppPaths: null,
     normalizeAppPath: null,
-    normalizeRscURL: null
+    normalizeRscURL: null,
+    selectAppPageEntry: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -22,6 +23,9 @@ _export(exports, {
     },
     normalizeRscURL: function() {
         return normalizeRscURL;
+    },
+    selectAppPageEntry: function() {
+        return selectAppPageEntry;
     }
 });
 const _ensureleadingslash = require("../../page-path/ensure-leading-slash");
@@ -54,6 +58,19 @@ function compareAppPaths(a, b) {
     if (!aHasSlot && bHasSlot) return 1;
     return a.localeCompare(b);
 }
+function selectAppPageEntry(pathname, appPaths, normalizePathname = (appPath)=>normalizeAppPath(appPath).replace(/%5F/g, '_')) {
+    let entry;
+    for (const appPath of appPaths){
+        if (normalizePathname(appPath) !== pathname) continue;
+        if (entry === undefined || compareAppPaths(entry, appPath) < 0) {
+            entry = appPath;
+        }
+    }
+    if (entry === undefined) {
+        throw new Error(`Invariant: no direct app page entry found for ${pathname}`);
+    }
+    return entry;
+}
 function normalizeRscURL(url) {
     return url.replace(/\.rsc($|\?)/, // $1 ensures `?` is preserved
     '$1');

package/dist/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -82,7 +82,7 @@ async function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "16.3.3",
+        nextVersion: "16.3.8",
         agentName: await (0, _agentname.getAgentName)()
     };
     return traits;

package/dist/node_modules/next/dist/telemetry/events/swc-load-failure.js

@@ -38,7 +38,7 @@ async function eventSwcLoadFailure(event) {
     telemetry.record({
         eventName: EVENT_PLUGIN_PRESENT,
         payload: {
-            nextVersion: "16.3.3",
+            nextVersion: "16.3.8",
             glibcVersion,
             installedSwcPackages,
             arch: process.arch,

package/dist/node_modules/next/dist/telemetry/events/version.js

@@ -12,12 +12,12 @@ const EVENT_VERSION = 'NEXT_CLI_SESSION_STARTED';
 function eventCliSession(nextConfig, event) {
     var _nextConfig_experimental, _nextConfig_experimental_staleTimes, _nextConfig_experimental_staleTimes1, _nextConfig_reactCompiler, _nextConfig_reactCompiler1;
     // This should be an invariant, if it fails our build tooling is broken.
-    if (typeof "16.3.3" !== 'string') {
+    if (typeof "16.3.8" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.3.3",
+        nextVersion: "16.3.8",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,

package/dist/node_modules/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "16.3.3",
+  "version": "16.3.8",
   "description": "The React Framework",
   "main": "./dist/server/next.js",
   "license": "MIT",
@@ -81,7 +81,7 @@
     "next": "./dist/bin/next"
   },
   "dependencies": {
-    "@next/env": "16.3.3",
+    "@next/env": "16.3.8",
     "@swc/helpers": "0.5.23",
     "baseline-browser-mapping": "^2.9.19",
     "caniuse-lite": "^1.0.30001579",
@@ -111,15 +111,15 @@
     }
   },
   "optionalDependencies": {
-    "sharp": "^0.35.3",
-    "@next/swc-darwin-arm64": "16.3.3",
-    "@next/swc-darwin-x64": "16.3.3",
-    "@next/swc-linux-arm64-gnu": "16.3.3",
-    "@next/swc-linux-arm64-musl": "16.3.3",
-    "@next/swc-linux-x64-gnu": "16.3.3",
-    "@next/swc-linux-x64-musl": "16.3.3",
-    "@next/swc-win32-arm64-msvc": "16.3.3",
-    "@next/swc-win32-x64-msvc": "16.3.3"
+    "sharp": "^0.35.4",
+    "@next/swc-darwin-arm64": "16.3.8",
+    "@next/swc-darwin-x64": "16.3.8",
+    "@next/swc-linux-arm64-gnu": "16.3.8",
+    "@next/swc-linux-arm64-musl": "16.3.8",
+    "@next/swc-linux-x64-gnu": "16.3.8",
+    "@next/swc-linux-x64-musl": "16.3.8",
+    "@next/swc-win32-arm64-msvc": "16.3.8",
+    "@next/swc-win32-x64-msvc": "16.3.8"
   },
   "keywords": [
     "react",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evoscientist/webui",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Web UI for EvoScientist — a self-evolving AI scientist built on DeepAgents/LangGraph.",
   "author": "Xi Zhang <zacharyzhang2022@gmail.com>",
   "type": "module",
@@ -30,7 +30,7 @@
     "dist/"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=20.9.0"
   },
   "packageManager": "npm@11.16.0",
   "publishConfig": {
@@ -66,7 +66,7 @@
     "katex": "^0.16.47",
     "lucide-react": "^0.539.0",
     "mermaid": "^11.15.0",
-    "next": "^16.3.3",
+    "next": "^16.3.8",
     "nuqs": "^2.8.8",
     "react": "19.1.0",
     "react-dom": "19.1.0",