@evoscientist/webui 0.2.5 → 0.2.6

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

@@ -41,8 +41,11 @@ function _interop_require_default(obj) {
 }
 const dynamicImportEsmDefault = (id)=>import(/* webpackIgnore: true */ /* turbopackIgnore: true */ id).then((mod)=>mod.default || mod);
 class RouteModule {
+    get userland() {
+        return this._userland;
+    }
     constructor({ userland, definition, distDir, relativeProjectDir }){
-        this.userland = userland;
+        this._userland = userland;
         this.definition = definition;
         this.isDev = !!process.env.__NEXT_DEV_SERVER;
         this.distDir = distDir;
@@ -122,6 +125,9 @@ class RouteModule {
                 serverActionsManifest: maybeJSONParse(self.__RSC_SERVER_MANIFEST),
                 subresourceIntegrityManifest: maybeJSONParse(self.__SUBRESOURCE_INTEGRITY_MANIFEST),
                 dynamicCssManifest: maybeJSONParse(self.__DYNAMIC_CSS_MANIFEST),
+                // Edge pages are always dynamic so prefetch inlining hints
+                // don't apply. The runtime handles missing hints gracefully.
+                prefetchHintsManifest: undefined,
                 interceptionRoutePatterns: (maybeJSONParse(self.__INTERCEPTION_ROUTE_REWRITE_MANIFEST) ?? []).map((rewrite)=>new RegExp(rewrite.regex))
             };
         } else {
@@ -136,7 +142,7 @@ class RouteModule {
             const { loadManifestFromRelativePath } = require('../load-manifest.external');
             const normalizedPagePath = (0, _normalizepagepath.normalizePagePath)(srcPage);
             const router = this.definition.kind === _routekind.RouteKind.PAGES || this.definition.kind === _routekind.RouteKind.PAGES_API ? 'pages' : 'app';
-            const [routesManifest, prerenderManifest, buildManifest, fallbackBuildManifest, reactLoadableManifest, nextFontManifest, clientReferenceManifest, serverActionsManifest, subresourceIntegrityManifest, serverFilesManifest, buildId, dynamicCssManifest] = [
+            const [routesManifest, prerenderManifest, buildManifest, fallbackBuildManifest, reactLoadableManifest, nextFontManifest, clientReferenceManifest, serverActionsManifest, subresourceIntegrityManifest, serverFilesManifest, buildId, dynamicCssManifest, prefetchHintsManifest] = [
                 loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
@@ -216,7 +222,14 @@ class RouteModule {
                     manifest: _constants.DYNAMIC_CSS_MANIFEST,
                     shouldCache: !this.isDev,
                     handleMissing: true
-                })
+                }),
+                router === 'app' ? loadManifestFromRelativePath({
+                    projectDir,
+                    distDir: this.distDir,
+                    manifest: `server/${_constants.PREFETCH_HINTS}`,
+                    shouldCache: !this.isDev,
+                    handleMissing: true
+                }) : undefined
             ];
             result = {
                 buildId,
@@ -231,6 +244,7 @@ class RouteModule {
                 serverActionsManifest,
                 subresourceIntegrityManifest,
                 dynamicCssManifest,
+                prefetchHintsManifest,
                 interceptionRoutePatterns: routesManifest.rewrites.beforeFiles.filter(_isinterceptionrouterewrite.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))
             };
         }
@@ -352,8 +366,11 @@ class RouteModule {
             }
             const { ensureInstrumentationRegistered } = await import('../lib/router-utils/instrumentation-globals.external.js');
             // ensure instrumentation is registered and pass
-            // onRequestError below
-            ensureInstrumentationRegistered(absoluteProjectDir, this.distDir);
+            // onRequestError below. Awaited so any caller of `RouteModule.prepare`
+            // that bypasses `BaseServer.handleRequest` (where this is also awaited
+            // via `prepareImpl`) still observes the instrumentation hook completing
+            // before the userland route handler runs.
+            await ensureInstrumentationRegistered(absoluteProjectDir, this.distDir);
         }
         const manifests = this.loadManifests(srcPage, absoluteProjectDir);
         const { routesManifest, prerenderManifest, serverFilesManifest } = manifests;
@@ -526,6 +543,20 @@ class RouteModule {
                     }
                 }
             }
+            // When partial nxtP* params are provided (e.g. background
+            // revalidation for intermediate PPR shells), both
+            // normalizeDynamicRouteParams calls above fail because not all
+            // route params are present. Merge the normalized query params
+            // (from nxtP*) into the current params to override placeholders
+            // with concrete values.
+            if (params && routeParamKeys.size > 0 && !paramsResult.hasValidParams && !queryResult.hasValidParams) {
+                for (const key of routeParamKeys){
+                    if (query[key] !== undefined) {
+                        params[key] = query[key];
+                    }
+                }
+                (0, _requestmeta.addRequestMeta)(req, 'resolvedRouteParamKeys', routeParamKeys);
+            }
         }
         // Remove any normalized params from the query if they
         // weren't present as non-prefixed query key e.g.
@@ -540,7 +571,7 @@ class RouteModule {
                 query[key] = originalQuery[key];
             }
         }
-        const { isOnDemandRevalidate, revalidateOnlyGenerated } = (0, _apiutils.checkIsOnDemandRevalidate)(req, prerenderManifest.preview);
+        const { isOnDemandRevalidate, revalidateOnlyGenerated } = (0, _apiutils.checkIsOnDemandRevalidate)(req.headers, prerenderManifest.preview);
         let isDraftMode = false;
         let previewData;
         // preview data relies on non-edge utils
@@ -614,7 +645,7 @@ class RouteModule {
             nextConfig: nextConfig,
             routerServerContext,
             deploymentId,
-            clientAssetToken: nextConfig.experimental.immutableAssetToken || deploymentId
+            clientAssetToken: nextConfig.supportsImmutableAssets ? '' : deploymentId
         };
     }
     getResponseCache(req) {
@@ -631,7 +662,13 @@ class RouteModule {
             isFallback,
             isRoutePPREnabled,
             isOnDemandRevalidate,
-            isPrefetch: req.headers.purpose === 'prefetch',
+            // A Next.js Segment Cache prefetch uses the `Next-Router-Prefetch`
+            // header (surfaced as the `isPrefetchRSCRequest` request meta), not the
+            // standard browser `purpose: prefetch` header. Recognize both so the
+            // response cache treats segment prefetches as prefetches — most
+            // importantly, so a prefetch that misses serves a fallback shell rather
+            // than joining an in-flight background (concrete) revalidation.
+            isPrefetch: req.headers.purpose === 'prefetch' || (0, _requestmeta.getRequestMeta)(req, 'isPrefetchRSCRequest') === true,
             // Use x-invocation-id header to scope the in-memory cache to a single
             // revalidation request in minimal mode.
             invocationID: req.headers['x-invocation-id'],

package/dist/node_modules/next/dist/server/stream-utils/node-buffered-transform-stream.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createNodeBufferedTransformStream", {
+    enumerable: true,
+    get: function() {
+        return createNodeBufferedTransformStream;
+    }
+});
+const _nodestream = require("node:stream");
+function createNodeBufferedTransformStream(maxBufferByteLength = Infinity) {
+    let bufferedChunks = [];
+    let bufferByteLength = 0;
+    let flushScheduled = false;
+    function flushBuffered(stream) {
+        if (bufferedChunks.length === 0) return;
+        const merged = new Uint8Array(bufferByteLength);
+        let copiedBytes = 0;
+        for(let i = 0; i < bufferedChunks.length; i++){
+            const bufferedChunk = bufferedChunks[i];
+            merged.set(bufferedChunk, copiedBytes);
+            copiedBytes += bufferedChunk.byteLength;
+        }
+        bufferedChunks.length = 0;
+        bufferByteLength = 0;
+        stream.push(merged);
+    }
+    return new _nodestream.Transform({
+        transform (chunk, _encoding, callback) {
+            bufferedChunks.push(chunk);
+            bufferByteLength += chunk.byteLength;
+            if (bufferByteLength >= maxBufferByteLength) {
+                flushBuffered(this);
+            } else if (!flushScheduled) {
+                flushScheduled = true;
+                queueMicrotask(()=>{
+                    flushScheduled = false;
+                    flushBuffered(this);
+                });
+            }
+            callback();
+        },
+        flush (callback) {
+            flushBuffered(this);
+            callback();
+        }
+    });
+}
+
+//# sourceMappingURL=node-buffered-transform-stream.js.map

package/dist/node_modules/next/dist/server/stream-utils/node-web-streams-helper.js

@@ -3,23 +3,32 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    CLOSE_TAG: null,
     chainStreams: null,
+    chainTransformers: null,
     continueDynamicHTMLResume: null,
     continueDynamicPrerender: null,
     continueFizzStream: null,
     continueStaticFallbackPrerender: null,
     continueStaticPrerender: null,
     createBufferedTransformStream: null,
+    createDeferredSuffixStream: null,
     createDocumentClosingStream: null,
-    createInstantTestScriptInsertionTransformStream: null,
+    createFlightDataInjectionTransformStream: null,
+    createHeadInsertionTransformStream: null,
+    createHtmlDataDplIdTransformStream: null,
+    createMetadataTransformStream: null,
+    createMoveSuffixStream: null,
     createRootLayoutValidatorStream: null,
     createRuntimePrefetchTransformStream: null,
+    nodestreamToUint8Array: null,
     renderToInitialFizzStream: null,
     streamFromBuffer: null,
     streamFromString: null,
     streamToBuffer: null,
     streamToString: null,
-    streamToUint8Array: null
+    streamToUint8Array: null,
+    webstreamToUint8Array: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -28,9 +37,15 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    CLOSE_TAG: function() {
+        return CLOSE_TAG;
+    },
     chainStreams: function() {
         return chainStreams;
     },
+    chainTransformers: function() {
+        return chainTransformers;
+    },
     continueDynamicHTMLResume: function() {
         return continueDynamicHTMLResume;
     },
@@ -49,11 +64,26 @@ _export(exports, {
     createBufferedTransformStream: function() {
         return createBufferedTransformStream;
     },
+    createDeferredSuffixStream: function() {
+        return createDeferredSuffixStream;
+    },
     createDocumentClosingStream: function() {
         return createDocumentClosingStream;
     },
-    createInstantTestScriptInsertionTransformStream: function() {
-        return createInstantTestScriptInsertionTransformStream;
+    createFlightDataInjectionTransformStream: function() {
+        return createFlightDataInjectionTransformStream;
+    },
+    createHeadInsertionTransformStream: function() {
+        return createHeadInsertionTransformStream;
+    },
+    createHtmlDataDplIdTransformStream: function() {
+        return createHtmlDataDplIdTransformStream;
+    },
+    createMetadataTransformStream: function() {
+        return createMetadataTransformStream;
+    },
+    createMoveSuffixStream: function() {
+        return createMoveSuffixStream;
     },
     createRootLayoutValidatorStream: function() {
         return createRootLayoutValidatorStream;
@@ -61,6 +91,9 @@ _export(exports, {
     createRuntimePrefetchTransformStream: function() {
         return createRuntimePrefetchTransformStream;
     },
+    nodestreamToUint8Array: function() {
+        return nodestreamToUint8Array;
+    },
     renderToInitialFizzStream: function() {
         return renderToInitialFizzStream;
     },
@@ -78,6 +111,9 @@ _export(exports, {
     },
     streamToUint8Array: function() {
         return streamToUint8Array;
+    },
+    webstreamToUint8Array: function() {
+        return webstreamToUint8Array;
     }
 });
 const _tracer = require("../lib/trace/tracer");
@@ -172,9 +208,57 @@ function concatUint8Arrays(chunks) {
     }
     return result;
 }
-async function streamToUint8Array(stream) {
+async function webstreamToUint8Array(stream) {
     return concatUint8Arrays(await streamToChunks(stream));
 }
+function webToReadable(stream) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new Error('webToReadable cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
+            value: "E1148",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        let Readable;
+        if (process.env.TURBOPACK) {
+            Readable = require('node:stream').Readable;
+        } else if (process.env.__NEXT_BUNDLER === 'Webpack' || process.env.__NEXT_BUNDLER === 'Rspack') {
+            Readable = __non_webpack_require__('node:stream').Readable;
+        } else {
+            Readable = require('node:stream').Readable;
+        }
+        if (stream instanceof Readable) {
+            return stream;
+        }
+        return Readable.fromWeb(stream);
+    }
+}
+async function nodestreamToUint8Array(stream) {
+    const chunks = [];
+    for await (const chunk of webToReadable(stream)){
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks);
+}
+async function streamToUint8Array(stream) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        // Edge runtime always uses web streams
+        return webstreamToUint8Array(stream);
+    } else {
+        let Readable;
+        if (process.env.TURBOPACK) {
+            Readable = require('node:stream').Readable;
+        } else if (process.env.__NEXT_BUNDLER === 'Webpack' || process.env.__NEXT_BUNDLER === 'Rspack') {
+            Readable = __non_webpack_require__('node:stream').Readable;
+        } else {
+            Readable = require('node:stream').Readable;
+        }
+        if (stream instanceof Readable) {
+            return nodestreamToUint8Array(stream);
+        }
+        return webstreamToUint8Array(stream);
+    }
+}
 async function streamToBuffer(stream) {
     return Buffer.concat(await streamToChunks(stream));
 }
@@ -442,65 +526,6 @@ async function createClientResumeScriptInsertionTransformStream() {
         }
     });
 }
-async function createInstantTestScriptInsertionTransformStream(requestId) {
-    // Kick off a fetch for the static RSC payload. This is the hydration
-    // source for the locked static shell — same as the __NEXT_CLIENT_RESUME
-    // fetch used for fallback routes, but with NEXT_INSTANT_PREFETCH_HEADER
-    // so the server returns static-only data.
-    //
-    // The fetch promise is stored as self.__next_instant_test, which doubles
-    // as the feature flag (truthy = instant test mode). The client processes
-    // this as a fallback prerender payload for hydration.
-    const segmentPath = '/_full';
-    const cacheBustingHeader = await (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', segmentPath, undefined, undefined);
-    const searchStr = `${_approuterheaders.NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`;
-    // In dev mode, inject self.__next_r (request ID) so that HMR WebSocket
-    // and debug channel initialization don't crash. The static shell
-    // bypasses renderToFizzStream which normally injects this via
-    // bootstrapScriptContent.
-    const requestIdScript = requestId !== null ? `self.__next_r=${JSON.stringify(requestId)};` : '';
-    const INSTANT_TEST_SCRIPT = `<script>${requestIdScript}self.__next_instant_test=fetch(location.pathname+'?${searchStr}',{credentials:'same-origin',headers:{'${_approuterheaders.RSC_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}':'1','${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}':'${segmentPath}','${_approuterheaders.NEXT_INSTANT_PREFETCH_HEADER}':'1'}})</script>`;
-    let didAlreadyInsert = false;
-    return new TransformStream({
-        transform (chunk, controller) {
-            if (didAlreadyInsert) {
-                // Already inserted the script into the head. Pass through.
-                controller.enqueue(chunk);
-                return;
-            }
-            // Find the opening <head tag (may have attributes like <head class="...">)
-            const headOpenIndex = (0, _uint8arrayhelpers.indexOfUint8Array)(chunk, _encodedtags.ENCODED_TAGS.OPENING.HEAD);
-            if (headOpenIndex === -1) {
-                controller.enqueue(chunk);
-                return;
-            }
-            // Find the closing > of the <head ...> tag
-            const headCloseAngle = chunk.indexOf(62, headOpenIndex + _encodedtags.ENCODED_TAGS.OPENING.HEAD.length);
-            if (headCloseAngle === -1) {
-                controller.enqueue(chunk);
-                return;
-            }
-            const encodedInsertion = encoder.encode(INSTANT_TEST_SCRIPT);
-            const insertionPoint = headCloseAngle + 1;
-            // e.g.
-            // chunk = <!DOCTYPE html><html><head><meta charset="utf-8">...
-            // insertion = <script>self.__next_instant_test=fetch(...)</script>
-            // output = <!DOCTYPE html><html><head> [ <script>...</script> ] <meta charset="utf-8">...
-            const insertedHeadContent = new Uint8Array(chunk.length + encodedInsertion.length);
-            insertedHeadContent.set(chunk.slice(0, insertionPoint));
-            insertedHeadContent.set(encodedInsertion, insertionPoint);
-            insertedHeadContent.set(chunk.slice(insertionPoint), insertionPoint + encodedInsertion.length);
-            controller.enqueue(insertedHeadContent);
-            didAlreadyInsert = true;
-        },
-        flush (controller) {
-            // Append closing tags so the browser can parse the full document.
-            controller.enqueue(_encodedtags.ENCODED_TAGS.CLOSED.BODY_AND_HTML);
-        }
-    });
-}
-// Suffix after main body content - scripts before </body>,
-// but wait for the major chunks to be enqueued.
 function createDeferredSuffixStream(suffix) {
     let flushed = false;
     let pending;
@@ -603,11 +628,7 @@ function createFlightDataInjectionTransformStream(stream, delayDataUntilFirstHtm
     });
 }
 const CLOSE_TAG = '</body></html>';
-/**
- * This transform stream moves the suffix to the end of the stream, so results
- * like `</body></html><script>...</script>` will be transformed to
- * `<script>...</script></body></html>`.
- */ function createMoveSuffixStream() {
+function createMoveSuffixStream() {
     let foundSuffix = false;
     return new TransformStream({
         transform (chunk, controller) {

package/dist/node_modules/next/dist/server/typescript/index.js

@@ -86,8 +86,8 @@ const createTSPlugin = ({ typescript: ts })=>{
             return info.languageService.getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data);
         };
         // Quick info
-        proxy.getQuickInfoAtPosition = (fileName, position)=>{
-            const prior = info.languageService.getQuickInfoAtPosition(fileName, position);
+        proxy.getQuickInfoAtPosition = (fileName, position, ...args)=>{
+            const prior = info.languageService.getQuickInfoAtPosition(fileName, position, ...args);
             if (!(0, _utils.isAppEntryFile)(fileName)) return prior;
             // Remove type suggestions for disallowed APIs in server components.
             const entryInfo = (0, _utils.getEntryInfo)(fileName);
@@ -97,7 +97,7 @@ const createTSPlugin = ({ typescript: ts })=>{
                     return;
                 }
             }
-            const overridden = _config.default.getQuickInfoAtPosition(fileName, position);
+            const overridden = _config.default.getQuickInfoAtPosition(fileName, position, prior);
             if (overridden) return overridden;
             return prior;
         };

package/dist/node_modules/next/dist/server/typescript/rules/client-boundary.js

@@ -58,11 +58,14 @@ const clientBoundary = {
                                     // negative is better than a false positive given how frequent the
                                     // false-positive would be.
                                     const maybeServerAction = propName === 'action' || /.+Action$/.test(propName);
-                                    // There's a special case for the error file that the `reset` prop
-                                    // is allowed to be a function:
+                                    // There's a special case for error files where the
+                                    // framework-injected `reset` and `retry` props are
+                                    // allowed to be functions. Next.js provides these props, the
+                                    // user doesn't pass them, so they don't need to be
+                                    // serializable.
                                     // https://github.com/vercel/next.js/issues/46573
-                                    const isErrorReset = (isErrorFile || isGlobalErrorFile) && propName === 'reset';
-                                    if (!maybeServerAction && !isErrorReset) {
+                                    const isErrorBoundaryFunctionProp = (isErrorFile || isGlobalErrorFile) && (propName === 'reset' || propName === 'retry');
+                                    if (!maybeServerAction && !isErrorBoundaryFunctionProp) {
                                         diagnostics.push({
                                             file: source,
                                             category: ts.DiagnosticCategory.Warning,

package/dist/node_modules/next/dist/server/typescript/rules/config.js

@@ -36,11 +36,11 @@ const API_DOCS = {
         link: 'https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#fetchcache'
     },
     preferredRegion: {
-        description: 'Specify the perferred region that this layout or page should be deployed to. If the region option is not specified, it inherits the option from the nearest parent layout. The root defaults to `"auto"`.\n\nYou can also specify a region, such as "iad1", or an array of regions, such as `["iad1", "sfo1"]`.',
+        description: '@deprecated\\n\\nThe `preferredRegion` route segment config is deprecated. Remove this export.',
         options: {
-            '"auto"': 'Next.js will first deploy to the `"home"` region. Then if it doesn\'t detect any waterfall requests after a few requests, it can upgrade that route, to be deployed globally. If it detects any waterfall requests after that, it can eventually downgrade back to `"home`".',
-            '"global"': 'Prefer deploying globally.',
-            '"home"': 'Prefer deploying to the Home region.'
+            '"auto"': '@deprecated\\n\\nNext.js will first deploy to the `"home"` region. Then if it doesn\'t detect any waterfall requests after a few requests, it can upgrade that route, to be deployed globally. If it detects any waterfall requests after that, it can eventually downgrade back to `"home`".',
+            '"global"': '@deprecated\\n\\nPrefer deploying globally.',
+            '"home"': '@deprecated\\n\\nPrefer deploying to the Home region.'
         },
         link: 'https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#preferredregion',
         isValid: (value)=>{
@@ -90,7 +90,7 @@ const API_DOCS = {
         description: 'The `runtime` option controls the preferred runtime to render this route.',
         options: {
             '"nodejs"': 'Prefer the Node.js runtime.',
-            '"edge"': 'Prefer the Edge runtime.',
+            '"edge"': `@deprecated\n\nThe Edge Runtime is deprecated. Use \`"nodejs"\` instead.`,
             '"experimental-edge"': `@deprecated\n\nThis option is no longer experimental. Use \`edge\` instead.`
         },
         link: 'https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#runtime'
@@ -109,18 +109,30 @@ const API_DOCS = {
         description: '`maxDuration` allows you to set max default execution time for your function. If it is not specified, the default value is dependent on your deployment platform and plan.',
         link: 'https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config#maxduration'
     },
-    unstable_instant: {
-        description: `Specifies the default prefetching behavior for this segment. This configuration is currently under development and will change.`,
-        link: '(docs coming soon)',
-        type: 'object | false',
+    instant: {
+        description: `Enables instant navigation validation for this segment.`,
+        link: 'https://nextjs.org/docs/app/api-reference/file-conventions/route-segment-config/instant',
+        type: 'true | object | false',
         // TODO: ideally, we'd validate the config object somehow, but this is difficult to do
         // with the way this plugin is currently structured.
         // For now, since we don't provide an `options` here, we won't do any validation in
         // `getSemanticDiagnosticsForExportVariableStatement` below, and only provide hover a tooltip + autocomplete.
-        insertText: 'unstable_instant = { prefetch: "static" };'
+        insertText: 'instant = true;'
+    },
+    prefetch: {
+        description: `Controls prefetching behavior for this segment. Some options are experimental and may change.`,
+        link: '(docs coming soon)',
+        type: `"auto" | "partial" | "unstable_eager" | "force-disabled"`,
+        options: {
+            auto: 'Default. Framework decides based on instant validation and segment configuration. You do not need to set this explicitly.',
+            partial: 'Enables Partial Prefetching for this segment. When a static prefetch is insufficient, Next.js may prefetch the segment with a runtime server request so it can access session data, such as cookies.',
+            unstable_eager: 'Like "partial", but adds an implied prop of prefetch={true} to ' + 'every Link. This option only exists to aid migration of apps that ' + 'adopted Partial Prefetching in canary before the behavior changed to ' + 'only fetch the shell by default.',
+            'force-disabled': 'Never prefetch this segment.'
+        },
+        insertText: `prefetch = 'partial';`
     },
     unstable_dynamicStaleTime: {
-        description: `Controls how long the client-side router cache retains dynamic page data (in seconds). Pages only — not allowed in layouts. Cannot be combined with \`unstable_instant\`.`,
+        description: `Controls how long the client-side router cache retains dynamic page data (in seconds). Pages only — not allowed in layouts. Cannot be combined with \`instant\`.`,
         link: '(docs coming soon)',
         type: 'number',
         isValid: (value)=>{
@@ -211,7 +223,7 @@ const config = {
         });
     },
     // Show docs when hovering on the exported configs.
-    getQuickInfoAtPosition (fileName, position) {
+    getQuickInfoAtPosition (fileName, position, prior) {
         const ts = (0, _utils.getTs)();
         let overridden;
         visitEntryConfig(fileName, position, (entryConfig, declaration)=>{
@@ -264,7 +276,18 @@ const config = {
                 const isValid = API_DOCS[entryConfig].isValid ? (_API_DOCS_entryConfig_isValid = (_API_DOCS_entryConfig = API_DOCS[entryConfig]).isValid) == null ? void 0 : _API_DOCS_entryConfig_isValid.call(_API_DOCS_entryConfig, key) : !!((_API_DOCS_entryConfig_options = API_DOCS[entryConfig].options) == null ? void 0 : _API_DOCS_entryConfig_options[key]);
                 if (isValid) {
                     var _API_DOCS_entryConfig_options1, _API_DOCS_entryConfig_getHint, _API_DOCS_entryConfig1;
-                    overridden = {
+                    const documentation = [
+                        ...(prior == null ? void 0 : prior.documentation) || [],
+                        {
+                            kind: 'text',
+                            text: ((_API_DOCS_entryConfig_options1 = API_DOCS[entryConfig].options) == null ? void 0 : _API_DOCS_entryConfig_options1[key]) || ((_API_DOCS_entryConfig_getHint = (_API_DOCS_entryConfig1 = API_DOCS[entryConfig]).getHint) == null ? void 0 : _API_DOCS_entryConfig_getHint.call(_API_DOCS_entryConfig1, key)) || ''
+                        },
+                        docsLink
+                    ];
+                    overridden = prior ? {
+                        ...prior,
+                        documentation
+                    } : {
                         kind: ts.ScriptElementKind.enumElement,
                         kindModifiers: ts.ScriptElementKindModifier.none,
                         textSpan: {
@@ -272,13 +295,7 @@ const config = {
                             length: value.getWidth()
                         },
                         displayParts: [],
-                        documentation: [
-                            {
-                                kind: 'text',
-                                text: ((_API_DOCS_entryConfig_options1 = API_DOCS[entryConfig].options) == null ? void 0 : _API_DOCS_entryConfig_options1[key]) || ((_API_DOCS_entryConfig_getHint = (_API_DOCS_entryConfig1 = API_DOCS[entryConfig]).getHint) == null ? void 0 : _API_DOCS_entryConfig_getHint.call(_API_DOCS_entryConfig1, key)) || ''
-                            },
-                            docsLink
-                        ]
+                        documentation
                     };
                 } else {
                     // Wrong value: still show the docs link, and when available, the
@@ -308,7 +325,18 @@ const config = {
                     return;
                 }
                 // Hovers the name of the config
-                overridden = {
+                const documentation = [
+                    ...(prior == null ? void 0 : prior.documentation) || [],
+                    {
+                        kind: 'text',
+                        text: getAPIDescription(entryConfig)
+                    },
+                    docsLink
+                ];
+                overridden = prior ? {
+                    ...prior,
+                    documentation
+                } : {
                     kind: ts.ScriptElementKind.enumElement,
                     kindModifiers: ts.ScriptElementKindModifier.none,
                     textSpan: {
@@ -316,13 +344,7 @@ const config = {
                         length: name.getWidth()
                     },
                     displayParts,
-                    documentation: [
-                        {
-                            kind: 'text',
-                            text: getAPIDescription(entryConfig)
-                        },
-                        docsLink
-                    ]
+                    documentation
                 };
             }
         });