qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/server/patch-error-inspect.js

@@ -151,10 +151,14 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
     let sourceMapPayload;
     if (sourceMapCacheEntry === undefined) {
         let sourceURL = frame.file;
-        // e.g. "/APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js"
+        // e.g. "/Users/foo/APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js"
+        // or "C:\Users\foo\APP\.next\server\chunks\ssr\[root-of-the-server]__2934a0._.js"
         // will be keyed by Node.js as "file:///APP/.next/server/chunks/ssr/[root-of-the-server]__2934a0._.js".
         // This is likely caused by `callsite.toString()` in `Error.prepareStackTrace converting file URLs to paths.
-        if (sourceURL.startsWith('/')) {
+        //
+        // But frame.file might also be "webpack-internal:///(rsc)/./app/bad-sourcemap/page.js" or
+        // "<anonymous>" or "node:internal/process/task_queues" here
+        if (_path.isAbsolute(frame.file)) {
             sourceURL = _url.pathToFileURL(frame.file).toString();
         }
         let maybeSourceMapPayload;
@@ -278,8 +282,7 @@ function ignoreListAnonymousStackFramesIfSandwiched(sourceMappedFrames) {
     });
 }
 function parseAndSourceMap(error, inspectOptions) {
-    // TODO(veil): Expose as CLI arg or config option. Useful for local debugging.
-    const showIgnoreListed = false;
+    const showIgnoreListed = process.env.__NEXT_SHOW_IGNORE_LISTED === 'true';
     // We overwrote Error.prepareStackTrace earlier so error.stack is not sourcemapped.
     let unparsedStack = String(error.stack);
     // We could just read it from `error.stack`.

qalita/_frontend/node_modules/next/dist/server/request/fallback-params.js

@@ -20,17 +20,10 @@ _export(exports, {
         return getFallbackRouteParams;
     }
 });
-const _appsegments = require("../../build/segment-config/app/app-segments");
-const _invarianterror = require("../../shared/lib/invariant-error");
-const _routematcher = require("../../shared/lib/router/utils/route-matcher");
-const _routeregex = require("../../shared/lib/router/utils/route-regex");
+const _utils = require("../../build/static-paths/utils");
 const _getshortdynamicparamtype = require("../app-render/get-short-dynamic-param-type");
-function getParamKeys(page) {
-    const pattern = (0, _routeregex.getRouteRegex)(page);
-    const matcher = (0, _routematcher.getRouteMatcher)(pattern);
-    // Get the default list of allowed params.
-    return Object.keys(matcher(page));
-}
+const _app = require("../../shared/lib/router/routes/app");
+const _extractpathnamerouteparamsegmentsfromloadertree = require("../../build/static-paths/app/extract-pathname-route-param-segments-from-loader-tree");
 function createOpaqueFallbackRouteParams(fallbackRouteParams) {
     // If there are no fallback route params, we can return early.
     if (fallbackRouteParams.length === 0) return null;
@@ -50,62 +43,26 @@ function createOpaqueFallbackRouteParams(fallbackRouteParams) {
     return keys;
 }
 function getFallbackRouteParams(page, routeModule) {
-    // First, get the fallback route params based on the provided page.
-    const unknownParamKeys = new Set(getParamKeys(page));
-    // Needed when processing fallback route params for catchall routes in
-    // parallel segments, derive from pathname. This is similar to
-    // getDynamicParam's pagePath parsing logic.
-    const pathSegments = page.split('/').filter(Boolean);
-    const collected = (0, _appsegments.collectFallbackRouteParams)(routeModule);
-    // Then, we have to get the fallback route params from the segments that are
-    // associated with parallel route segments.
-    const fallbackRouteParams = [];
-    for (const fallbackRouteParam of collected){
-        if (fallbackRouteParam.isParallelRouteParam) {
-            // Try to see if we can resolve this parameter from the page that was
-            // passed in.
-            if (unknownParamKeys.has(fallbackRouteParam.paramName)) {
-                continue;
-            }
-            if (fallbackRouteParam.paramType === 'optional-catchall' || fallbackRouteParam.paramType === 'catchall') {
-                // If there are any fallback route segments then we can't use the
-                // pathname to derive the value because it's not complete. We can
-                // make this assumption because the routes are always resolved left
-                // to right and the catchall is always the last segment, so any
-                // route parameters that are unknown will always contribute to the
-                // pathname and therefore the catchall param too.
-                if (collected.some((param)=>!param.isParallelRouteParam && unknownParamKeys.has(param.paramName))) {
-                    fallbackRouteParams.push(fallbackRouteParam);
-                    continue;
-                }
-                if (pathSegments.length === 0 && fallbackRouteParam.paramType !== 'optional-catchall') {
-                    // We shouldn't be able to match a catchall segment without any path
-                    // segments if it's not an optional catchall.
-                    throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected empty path segments match for a pathname "${page}" with param "${fallbackRouteParam.paramName}" of type "${fallbackRouteParam.paramType}"`), "__NEXT_ERROR_CODE", {
-                        value: "E792",
-                        enumerable: false,
-                        configurable: true
-                    });
-                }
-            // The path segments are not empty, and the segments didn't contain any
-            // unknown params, so we know that this particular fallback route param
-            // route param is not actually unknown, and is known. We can skip adding
-            // it to the fallback route params.
-            } else {
-                // This is some other type of route param that shouldn't get resolved
-                // statically.
-                throw Object.defineProperty(new _invarianterror.InvariantError(`Unexpected match for a pathname "${page}" with a param "${fallbackRouteParam.paramName}" of type "${fallbackRouteParam.paramType}"`), "__NEXT_ERROR_CODE", {
-                    value: "E791",
-                    enumerable: false,
-                    configurable: true
-                });
-            }
-        } else if (unknownParamKeys.has(fallbackRouteParam.paramName)) {
-            // As this is a non-parallel route segment, and it exists in the unknown
-            // param keys, we know it's a fallback route param.
-            fallbackRouteParams.push(fallbackRouteParam);
-        }
-    }
+    const route = (0, _app.parseAppRoute)(page, true);
+    // Extract the pathname-contributing segments from the loader tree. This
+    // mirrors the logic in buildAppStaticPaths where we determine which segments
+    // actually contribute to the pathname.
+    const { pathnameRouteParamSegments, params } = (0, _extractpathnamerouteparamsegmentsfromloadertree.extractPathnameRouteParamSegmentsFromLoaderTree)(routeModule.userland.loaderTree, route);
+    // Create fallback route params for the pathname segments.
+    const fallbackRouteParams = pathnameRouteParamSegments.map(({ paramName, paramType })=>({
+            paramName,
+            paramType
+        }));
+    // Resolve route params from the loader tree. This mutates the
+    // fallbackRouteParams array to add any route params that are
+    // unknown at request time.
+    //
+    // The page parameter contains placeholders like [slug], which helps
+    // resolveRouteParamsFromTree determine which params are unknown.
+    (0, _utils.resolveRouteParamsFromTree)(routeModule.userland.loaderTree, params, route, fallbackRouteParams // Will be mutated to add route params
+    );
+    // Convert the fallback route params to an opaque format that can be safely
+    // used in the postponed state without exposing implementation details.
     return createOpaqueFallbackRouteParams(fallbackRouteParams);
 }
 

qalita/_frontend/node_modules/next/dist/server/route-modules/app-route/module.js

@@ -291,7 +291,7 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
                             // there is no need to try again
                             prospectiveRenderIsDynamic = true;
                         } else if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
-                            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                            (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
                         }
                     }
                     if (typeof prospectiveResult === 'object' && prospectiveResult !== null && typeof prospectiveResult.then === 'function') {
@@ -304,7 +304,7 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
                                 // there is no need to try again
                                 prospectiveRenderIsDynamic = true;
                             } else if (process.env.NEXT_DEBUG_BUILD) {
-                                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route);
+                                (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(err, workStore.route, _prospectiverenderutils.Phase.ProspectiveRender);
                             }
                         });
                     }

qalita/_frontend/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 _deploymentid = require("../../../shared/lib/deployment-id");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -146,7 +147,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                                 sharedContext: {
                                     buildId,
                                     customServer: Boolean(routerServerContext == null ? void 0 : routerServerContext.isCustomServer) || undefined,
-                                    deploymentId: process.env.NEXT_DEPLOYMENT_ID
+                                    deploymentId: (0, _deploymentid.getDeploymentId)()
                                 },
                                 renderOpts: {
                                     params,
@@ -261,6 +262,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                             // if this is a background revalidate we need to report
                             // the request error here as it won't be bubbled
                             if (previousCacheEntry == null ? void 0 : previousCacheEntry.isStale) {
+                                const silenceLog = false;
                                 await routeModule.onRequestError(req, err, {
                                     routerKind: 'Pages Router',
                                     routePath: srcPage,
@@ -269,7 +271,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                                         isStaticGeneration: hasStaticProps,
                                         isOnDemandRevalidate
                                     })
-                                }, routerServerContext);
+                                }, silenceLog, routerServerContext);
                             }
                             throw err;
                         }
@@ -500,6 +502,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
             }
         } catch (err) {
             if (!(err instanceof _nofallbackerrorexternal.NoFallbackError)) {
+                const silenceLog = false;
                 await routeModule.onRequestError(req, err, {
                     routerKind: 'Pages Router',
                     routePath: srcPage,
@@ -508,7 +511,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                         isStaticGeneration: hasStaticProps,
                         isOnDemandRevalidate
                     })
-                }, routerServerContext);
+                }, silenceLog, routerServerContext);
             }
             // rethrow so that we can handle serving error page
             throw err;

qalita/_frontend/node_modules/next/dist/server/route-modules/route-module.js

@@ -61,11 +61,12 @@ class RouteModule {
         }
     }
     loadManifests(srcPage, projectDir) {
+        let result;
         if (process.env.NEXT_RUNTIME === 'edge') {
             var _self___RSC_MANIFEST;
             const { getEdgePreviewProps } = require('../web/get-edge-preview-props');
             const maybeJSONParse = (str)=>str ? JSON.parse(str) : undefined;
-            return {
+            result = {
                 buildId: process.env.__NEXT_BUILD_ID || '',
                 buildManifest: self.__BUILD_MANIFEST,
                 fallbackBuildManifest: {},
@@ -92,9 +93,7 @@ class RouteModule {
                     i18n: process.env.__NEXT_I18N_CONFIG || undefined,
                     skipProxyUrlNormalize: Boolean(process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE)
                 },
-                serverFilesManifest: {
-                    config: globalThis.nextConfig || {}
-                },
+                serverFilesManifest: self.__SERVER_FILES_MANIFEST,
                 clientReferenceManifest: (_self___RSC_MANIFEST = self.__RSC_MANIFEST) == null ? void 0 : _self___RSC_MANIFEST[srcPage],
                 serverActionsManifest: maybeJSONParse(self.__RSC_SERVER_MANIFEST),
                 subresourceIntegrityManifest: maybeJSONParse(self.__SUBRESOURCE_INTEGRITY_MANIFEST),
@@ -174,10 +173,10 @@ class RouteModule {
                     handleMissing: true,
                     shouldCache: !this.isDev
                 }),
-                this.isDev ? {} : loadManifestFromRelativePath({
+                this.isDev ? undefined : loadManifestFromRelativePath({
                     projectDir,
                     distDir: this.distDir,
-                    manifest: _constants.SERVER_FILES_MANIFEST
+                    manifest: `${_constants.SERVER_FILES_MANIFEST}.json`
                 }),
                 this.isDev ? 'development' : loadManifestFromRelativePath({
                     projectDir,
@@ -192,7 +191,7 @@ class RouteModule {
                     handleMissing: true
                 })
             ];
-            return {
+            result = {
                 buildId,
                 buildManifest,
                 fallbackBuildManifest,
@@ -208,6 +207,7 @@ class RouteModule {
                 interceptionRoutePatterns: routesManifest.rewrites.beforeFiles.filter(_generateinterceptionroutesrewrites.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))
             };
         }
+        return result;
     }
     async loadCustomCacheHandlers(req, nextConfig) {
         if (process.env.NEXT_RUNTIME !== 'edge') {
@@ -258,11 +258,13 @@ class RouteModule {
             return incrementalCache;
         }
     }
-    async onRequestError(req, err, errorContext, routerServerContext) {
-        if (routerServerContext == null ? void 0 : routerServerContext.logErrorWithOriginalStack) {
-            routerServerContext.logErrorWithOriginalStack(err, 'app-dir');
-        } else {
-            console.error(err);
+    async onRequestError(req, err, errorContext, silenceLog, routerServerContext) {
+        if (!silenceLog) {
+            if (routerServerContext == null ? void 0 : routerServerContext.logErrorWithOriginalStack) {
+                routerServerContext.logErrorWithOriginalStack(err, 'app-dir');
+            } else {
+                console.error(err);
+            }
         }
         await this.instrumentationOnRequestError(req, err, {
             path: req.url || '/',
@@ -270,8 +272,46 @@ class RouteModule {
             method: req.method || 'GET'
         }, errorContext);
     }
+    /** A more lightweight version of `prepare()` for only retrieving the config on edge */ getNextConfigEdge(req) {
+        var _routerServerGlobal_RouterServerContextSymbol, _nextConfig_experimental;
+        if (process.env.NEXT_RUNTIME !== 'edge') {
+            throw Object.defineProperty(new Error('Invariant: getNextConfigEdge must only be called in edge runtime'), "__NEXT_ERROR_CODE", {
+                value: "E968",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        let serverFilesManifest = self.__SERVER_FILES_MANIFEST;
+        const relativeProjectDir = (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir;
+        const routerServerContext = (_routerServerGlobal_RouterServerContextSymbol = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) == null ? void 0 : _routerServerGlobal_RouterServerContextSymbol[relativeProjectDir];
+        const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || (serverFilesManifest == null ? void 0 : serverFilesManifest.config);
+        if (!nextConfig) {
+            throw Object.defineProperty(new Error("Invariant: nextConfig couldn't be loaded"), "__NEXT_ERROR_CODE", {
+                value: "E969",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        let deploymentId;
+        if ((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.runtimeServerDeploymentId) {
+            if (!process.env.NEXT_DEPLOYMENT_ID) {
+                throw Object.defineProperty(new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'), "__NEXT_ERROR_CODE", {
+                    value: "E970",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            deploymentId = process.env.NEXT_DEPLOYMENT_ID;
+        } else {
+            deploymentId = nextConfig.deploymentId || '';
+        }
+        return {
+            nextConfig,
+            deploymentId
+        };
+    }
     async prepare(req, res, { srcPage, multiZoneDraftMode }) {
-        var _routerServerGlobal_RouterServerContextSymbol;
+        var _routerServerGlobal_RouterServerContextSymbol, _nextConfig_experimental;
         let absoluteProjectDir;
         // edge runtime handles loading instrumentation at the edge adapter level
         if (process.env.NEXT_RUNTIME !== 'edge') {
@@ -454,7 +494,14 @@ class RouteModule {
         }
         const relativeProjectDir = (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir;
         const routerServerContext = (_routerServerGlobal_RouterServerContextSymbol = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol]) == null ? void 0 : _routerServerGlobal_RouterServerContextSymbol[relativeProjectDir];
-        const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || serverFilesManifest.config;
+        const nextConfig = (routerServerContext == null ? void 0 : routerServerContext.nextConfig) || (serverFilesManifest == null ? void 0 : serverFilesManifest.config);
+        if (!nextConfig) {
+            throw Object.defineProperty(new Error("Invariant: nextConfig couldn't be loaded"), "__NEXT_ERROR_CODE", {
+                value: "E969",
+                enumerable: false,
+                configurable: true
+            });
+        }
         let resolvedPathname = normalizedSrcPage;
         if ((0, _utils.isDynamicRoute)(resolvedPathname) && params) {
             resolvedPathname = serverUtils.interpolateDynamicPath(resolvedPathname, params);
@@ -469,6 +516,19 @@ class RouteModule {
             resolvedPathname = (0, _decodepathparams.decodePathParams)(resolvedPathname);
         } catch (_) {}
         resolvedPathname = (0, _removetrailingslash.removeTrailingSlash)(resolvedPathname);
+        let deploymentId;
+        if ((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.runtimeServerDeploymentId) {
+            if (!process.env.NEXT_DEPLOYMENT_ID) {
+                throw Object.defineProperty(new Error('process.env.NEXT_DEPLOYMENT_ID is missing but runtimeServerDeploymentId is enabled'), "__NEXT_ERROR_CODE", {
+                    value: "E970",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            deploymentId = process.env.NEXT_DEPLOYMENT_ID;
+        } else {
+            deploymentId = nextConfig.deploymentId || '';
+        }
         return {
             query,
             originalQuery,
@@ -487,10 +547,11 @@ class RouteModule {
             isOnDemandRevalidate,
             revalidateOnlyGenerated,
             ...manifests,
-            serverActionsManifest: manifests.serverActionsManifest,
-            clientReferenceManifest: manifests.clientReferenceManifest,
-            nextConfig,
-            routerServerContext
+            // loadManifest returns a readonly object, but we don't want to propagate that throughout the
+            // whole codebase (for now)
+            nextConfig: nextConfig,
+            routerServerContext,
+            deploymentId
         };
     }
     getResponseCache(req) {

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

@@ -16,7 +16,8 @@ Object.defineProperty(exports, "__esModule", {
     streamFromBuffer: null,
     streamFromString: null,
     streamToBuffer: null,
-    streamToString: null
+    streamToString: null,
+    streamToUint8Array: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -66,6 +67,9 @@ _export(exports, {
     },
     streamToString: function() {
         return streamToString;
+    },
+    streamToUint8Array: function() {
+        return streamToUint8Array;
     }
 });
 const _tracer = require("../lib/trace/tracer");
@@ -139,7 +143,7 @@ function streamFromBuffer(chunk) {
         }
     });
 }
-async function streamToBuffer(stream) {
+async function streamToChunks(stream) {
     const reader = stream.getReader();
     const chunks = [];
     while(true){
@@ -149,7 +153,23 @@ async function streamToBuffer(stream) {
         }
         chunks.push(value);
     }
-    return Buffer.concat(chunks);
+    return chunks;
+}
+function concatUint8Arrays(chunks) {
+    const totalLength = chunks.reduce((sum, chunk)=>sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks){
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+async function streamToUint8Array(stream) {
+    return concatUint8Arrays(await streamToChunks(stream));
+}
+async function streamToBuffer(stream) {
+    return Buffer.concat(await streamToChunks(stream));
 }
 async function streamToString(stream, signal) {
     const decoder = new TextDecoder('utf-8', {
@@ -645,9 +665,13 @@ function chainTransformers(readable, transformers) {
 async function continueFizzStream(renderStream, { suffix, inlinedDataStream, isStaticGeneration, isBuildTimePrerendering, buildId, getServerInsertedHTML, getServerInsertedMetadata, validateRootLayout }) {
     // Suffix itself might contain close tags at the end, so we need to split it.
     const suffixUnclosed = suffix ? suffix.split(CLOSE_TAG, 1)[0] : null;
-    // If we're generating static HTML we need to wait for it to resolve before continuing.
     if (isStaticGeneration) {
+        // If we're generating static HTML we need to wait for it to resolve before continuing.
         await renderStream.allReady;
+    } else {
+        // Otherwise, we want to make sure Fizz is done with all microtasky work
+        // before we start pulling the stream and cause a flush.
+        await (0, _scheduler.waitAtLeastOneReactRenderTask)();
     }
     return chainTransformers(renderStream, [
         // Buffer everything to avoid flushing too frequently

qalita/_frontend/node_modules/next/dist/server/typescript/rules/config.js

@@ -211,10 +211,43 @@ const config = {
                 kind: 'text',
                 text: `\n\nRead more about the "${entryConfig}" option: ` + API_DOCS[entryConfig].link
             };
-            if (value && (0, _utils.isPositionInsideNode)(position, value)) {
+            // When the value is a flexible type (like a function), also compute its
+            // inferred type so we can surface it alongside the docs. This is useful
+            // even when the value is considered invalid by the config validation,
+            // as long as it's not a direct literal export.
+            let displayParts = [];
+            const typeChecker = (0, _utils.getTypeChecker)();
+            const isString = !!value && ts.isStringLiteral(value);
+            const isFunctionValue = !!value && !isString && (ts.isArrowFunction(value) || ts.isFunctionExpression(value) || ts.isFunctionDeclaration(value));
+            if (typeChecker && value && isFunctionValue) {
+                try {
+                    // If we're hovering the config identifier, ask for the type at the
+                    // identifier; otherwise, ask at the value node. This makes sure
+                    // highlighting `generateMetadata` itself also shows the inferred type.
+                    const typeTarget = (0, _utils.isPositionInsideNode)(position, name) ? name : value;
+                    const type = typeChecker.getTypeAtLocation(typeTarget);
+                    if (type) {
+                        const typeString = typeChecker.typeToString(type, typeTarget);
+                        if (typeString) {
+                            displayParts = [
+                                {
+                                    text: typeString,
+                                    kind: 'typeName'
+                                }
+                            ];
+                        }
+                    }
+                } catch  {
+                // If type checking fails, continue without type info.
+                }
+            }
+            // For non-function values (like literals), hovering the value should show
+            // option-specific docs. For function-valued configs (e.g. `generateMetadata`),
+            // we let TypeScript handle hover anywhere in the initializer except for the
+            // export identifier itself.
+            if (value && !isFunctionValue && (0, _utils.isPositionInsideNode)(position, value)) {
                 var _API_DOCS_entryConfig_isValid, _API_DOCS_entryConfig, _API_DOCS_entryConfig_options;
-                // Hovers the value of the config
-                const isString = ts.isStringLiteral(value);
+                // Hovering the value of the config
                 const text = (0, _utils.removeStringQuotes)(value.getText());
                 const key = isString ? `"${text}"` : text;
                 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]);
@@ -237,7 +270,8 @@ const config = {
                         ]
                     };
                 } else {
-                    // Wrong value, display the docs link
+                    // Wrong value: still show the docs link, and when available, the
+                    // inferred type for non-literal (i.e. non-direct) exports.
                     overridden = {
                         kind: ts.ScriptElementKind.enumElement,
                         kindModifiers: ts.ScriptElementKindModifier.none,
@@ -245,13 +279,23 @@ const config = {
                             start: value.getStart(),
                             length: value.getWidth()
                         },
-                        displayParts: [],
+                        displayParts,
                         documentation: [
                             docsLink
                         ]
                     };
                 }
             } else {
+                // For function-valued configs, if we're hovering anywhere within the
+                // initializer (including `async`, parameters, or the body) but not on
+                // the export identifier itself, don't override TypeScript's default
+                // hover. We only want to override when hovering the config identifier
+                // (e.g. `generateMetadata`), not arbitrary tokens within the function.
+                if (isFunctionValue && (0, _utils.isPositionInsideNode)(position, value) && // hover is somewhere within the function initializer
+                !(0, _utils.isPositionInsideNode)(position, name) // ...but not on the export identifier itself
+                ) {
+                    return;
+                }
                 // Hovers the name of the config
                 overridden = {
                     kind: ts.ScriptElementKind.enumElement,
@@ -260,7 +304,7 @@ const config = {
                         start: name.getStart(),
                         length: name.getWidth()
                     },
-                    displayParts: [],
+                    displayParts,
                     documentation: [
                         {
                             kind: 'text',