@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/dev/runtime-error-state.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createRuntimeErrorStateHandler: null,
+    formatRuntimeErrors: null,
+    isRuntimeErrorStateUpdate: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createRuntimeErrorStateHandler: function() {
+        return createRuntimeErrorStateHandler;
+    },
+    formatRuntimeErrors: function() {
+        return formatRuntimeErrors;
+    },
+    isRuntimeErrorStateUpdate: function() {
+        return isRuntimeErrorStateUpdate;
+    }
+});
+const _crypto = require("crypto");
+const _hotreloadertypes = require("./hot-reloader-types");
+const _formaterrors = require("../mcp/tools/utils/format-errors");
+const formatStackFrameToObject = (frame)=>{
+    return {
+        file: frame.file || '<unknown>',
+        methodName: frame.methodName || '<anonymous>',
+        line: frame.line1,
+        column: frame.column1
+    };
+};
+const resolveErrorFrames = async (frames, context)=>{
+    try {
+        const resolvedFrames = await (0, _formaterrors.resolveStackFrames)({
+            frames: frames.map((frame)=>({
+                    file: frame.file || null,
+                    methodName: frame.methodName || '<anonymous>',
+                    arguments: [],
+                    line1: frame.line1 || null,
+                    column1: frame.column1 || null
+                })),
+            isServer: context.isServer,
+            isEdgeServer: context.isEdgeServer,
+            isAppDirectory: context.isAppDirectory
+        });
+        return resolvedFrames.flatMap((resolvedFrame, index)=>{
+            var _resolvedFrame_value_originalStackFrame;
+            if (resolvedFrame.status === 'fulfilled' && ((_resolvedFrame_value_originalStackFrame = resolvedFrame.value.originalStackFrame) == null ? void 0 : _resolvedFrame_value_originalStackFrame.ignored)) {
+                return [];
+            }
+            return [
+                resolvedFrame.status === 'fulfilled' && resolvedFrame.value.originalStackFrame ? formatStackFrameToObject(resolvedFrame.value.originalStackFrame) : formatStackFrameToObject(frames[index])
+            ];
+        });
+    } catch  {
+        return frames.map(formatStackFrameToObject);
+    }
+};
+async function formatRuntimeErrors(errors, isAppDirectory) {
+    const formattedErrors = [];
+    for (const error of errors){
+        var _error_error, _error_error1, _error_frames;
+        const errorName = ((_error_error = error.error) == null ? void 0 : _error_error.name) || 'Error';
+        const message = ((_error_error1 = error.error) == null ? void 0 : _error_error1.message) || 'Unknown error';
+        let stack = [];
+        if ((_error_frames = error.frames) == null ? void 0 : _error_frames.length) {
+            var _error_error2;
+            const errorSource = (_error_error2 = error.error) == null ? void 0 : _error_error2.source;
+            stack = await resolveErrorFrames(error.frames, {
+                isServer: errorSource === 'server',
+                isEdgeServer: errorSource === 'edge-server',
+                isAppDirectory
+            });
+        }
+        formattedErrors.push({
+            type: error.type,
+            errorName,
+            message,
+            fatal: error.fatal,
+            ...error.boundary ? {
+                boundary: error.boundary
+            } : {},
+            stack
+        });
+    }
+    return formattedErrors;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isNullableString(value) {
+    return value === null || typeof value === 'string';
+}
+function isNullableNumber(value) {
+    return value === null || typeof value === 'number' && Number.isFinite(value);
+}
+function isRuntimeErrorStateError(value) {
+    if (!isRecord(value) || typeof value.id !== 'number' || !Number.isFinite(value.id) || value.type !== 'runtime' && value.type !== 'recoverable' && value.type !== 'console' || typeof value.fatal !== 'boolean' || value.boundary !== undefined && (!isRecord(value.boundary) || ![
+        'default-global',
+        'custom-global',
+        'custom'
+    ].includes(value.boundary.kind) || value.boundary.name !== undefined && typeof value.boundary.name !== 'string') || !Array.isArray(value.frames)) {
+        return false;
+    }
+    if (value.error !== null) {
+        if (!isRecord(value.error)) {
+            return false;
+        }
+        if (value.error.name !== undefined && typeof value.error.name !== 'string' || value.error.message !== undefined && typeof value.error.message !== 'string' || value.error.stack !== undefined && typeof value.error.stack !== 'string' || value.error.source !== null && value.error.source !== 'server' && value.error.source !== 'edge-server') {
+            return false;
+        }
+    }
+    return value.frames.every((frame)=>isRecord(frame) && isNullableString(frame.file) && typeof frame.methodName === 'string' && isNullableNumber(frame.line1) && isNullableNumber(frame.column1));
+}
+function isRuntimeErrorStateUpdate(value) {
+    if (!isRecord(value) || value.event !== _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.RUNTIME_ERRORS || typeof value.pathname !== 'string' || !value.pathname.startsWith('/') || value.pathname.includes('?') || value.pathname.includes('#') || !isRecord(value.errorState) || !Array.isArray(value.errorState.errors) || value.errorState.routerType !== 'app') {
+        return false;
+    }
+    return value.errorState.errors.every(isRuntimeErrorStateError);
+}
+function createRuntimeErrorStateHandler(sendHmrMessage, format = formatRuntimeErrors, clientId = (0, _crypto.randomUUID)()) {
+    let generation = 0;
+    let disposed = false;
+    let lastPublishedMessage = null;
+    const formattedErrorCache = new Map();
+    async function formatWithCache(errors, isAppDirectory) {
+        const keys = errors.map((error)=>`${isAppDirectory ? 'app' : 'pages'}:${JSON.stringify(error)}`);
+        const activeKeys = new Set(keys);
+        const pending = [];
+        const missing = [];
+        for(let index = 0; index < errors.length; index++){
+            const key = keys[index];
+            const cached = formattedErrorCache.get(key);
+            if (cached) {
+                pending[index] = cached;
+            } else {
+                missing.push({
+                    error: errors[index],
+                    key,
+                    outputIndex: index
+                });
+            }
+        }
+        if (missing.length > 0) {
+            const batch = format(missing.map(({ error })=>error), isAppDirectory);
+            for(let index = 0; index < missing.length; index++){
+                const { key, outputIndex } = missing[index];
+                const formatted = batch.then((result)=>{
+                    const error = result[index];
+                    if (!error) {
+                        throw new Error('Runtime error formatter returned no result');
+                    }
+                    return error;
+                }).catch((error)=>{
+                    if (formattedErrorCache.get(key) === formatted) {
+                        formattedErrorCache.delete(key);
+                    }
+                    throw error;
+                });
+                formattedErrorCache.set(key, formatted);
+                pending[outputIndex] = formatted;
+            }
+        }
+        for (const key of formattedErrorCache.keys()){
+            if (!activeKeys.has(key)) {
+                formattedErrorCache.delete(key);
+            }
+        }
+        return Promise.all(pending.map((formatted)=>{
+            if (!formatted) {
+                throw new Error('Runtime error formatter cache is incomplete');
+            }
+            return formatted;
+        }));
+    }
+    return {
+        async handle (update) {
+            if (disposed || !isRuntimeErrorStateUpdate(update)) {
+                return;
+            }
+            const currentGeneration = ++generation;
+            const errors = await formatWithCache(update.errorState.errors, update.errorState.routerType === 'app');
+            if (disposed || currentGeneration !== generation) {
+                return;
+            }
+            const message = {
+                type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.RUNTIME_ERRORS,
+                clientId,
+                pathname: update.pathname,
+                errors
+            };
+            sendHmrMessage(message);
+            lastPublishedMessage = message;
+        },
+        dispose () {
+            if (disposed) {
+                return;
+            }
+            const clearMessage = lastPublishedMessage && lastPublishedMessage.errors.length > 0 ? {
+                ...lastPublishedMessage,
+                errors: []
+            } : null;
+            disposed = true;
+            generation++;
+            formattedErrorCache.clear();
+            lastPublishedMessage = null;
+            if (clearMessage) {
+                sendHmrMessage(clearMessage);
+            }
+        }
+    };
+}
+
+//# sourceMappingURL=runtime-error-state.js.map

package/app/node_modules/next/dist/server/dev/serialized-errors.js

@@ -38,12 +38,8 @@ function sendSerializedErrorsToClient(errorsRscStream, sendToClient) {
             serializedErrors
         });
     }, (err)=>{
-        console.error(Object.defineProperty(new Error('Failed to serialize errors.', {
+        console.error(new Error('Failed to serialize errors.', {
             cause: err
-        }), "__NEXT_ERROR_CODE", {
-            value: "E948",
-            enumerable: false,
-            configurable: true
         }));
     });
 }

package/app/node_modules/next/dist/server/dev/static-paths-worker.js

@@ -14,14 +14,13 @@ const _appsegments = require("../../build/segment-config/app/app-segments");
 const _loadcomponents = require("../load-components");
 const _setuphttpagentenv = require("../setup-http-agent-env");
 const _checks = require("../route-modules/checks");
-const _ppr = require("../lib/experimental/ppr");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _collectrootparamkeys = require("../../build/segment-config/app/collect-root-param-keys");
 const _app = require("../../build/static-paths/app");
 const _pages = require("../../build/static-paths/pages");
 const _createincrementalcache = require("../../export/helpers/create-incremental-cache");
 const _app1 = require("../../shared/lib/router/routes/app");
-async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOptions, locales, defaultLocale, isAppPath, page, isrFlushToDisk, fetchCacheKeyPrefix, cacheMaxMemorySize, requestHeaders, cacheHandler, cacheHandlers, cacheLifeProfiles, nextConfigOutput, buildId, deploymentId, authInterrupts, useCacheTimeout, staticPageGenerationTimeout, sriEnabled }) {
+async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOptions, locales, defaultLocale, isAppPath, page, isrFlushToDisk, fetchCacheKeyPrefix, cacheMaxMemorySize, requestHeaders, cacheHandler, cacheHandlers, cacheLifeProfiles, nextConfigOutput, buildId, deploymentId, authInterrupts, useCacheTimeout, durableUseCacheEntries, staticPageGenerationTimeout, sriEnabled }) {
     // this needs to be initialized before loadComponents otherwise
     // "use cache" could be missing it's cache handlers
     await (0, _createincrementalcache.createIncrementalCache)({
@@ -49,18 +48,21 @@ async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOption
     });
     if (isAppPath) {
         const routeModule = components.routeModule;
-        const segments = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we checked
+        const { segments, segmentTree } = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we checked
         // above that the page type is 'app'.
-        routeModule);
+        routeModule, {
+            cacheComponents: config.cacheComponents,
+            partialPrefetching: config.partialPrefetching
+        });
         const route = (0, _app1.parseNormalizedAppRoute)(pathname);
         if (route.dynamicSegments.length === 0) {
-            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a dynamic route, but got a static route: ${pathname}`), "__NEXT_ERROR_CODE", {
-                value: "E930",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError(`Expected a dynamic route, but got a static route: ${pathname}`);
         }
-        const isRoutePPREnabled = (0, _checks.isAppPageRouteModule)(routeModule) && (0, _ppr.checkIsRoutePPREnabled)(config.pprConfig);
+        const isRoutePPREnabled = (0, _checks.isAppPageRouteModule)(routeModule) && config.cacheComponents;
+        const isEnsureStaticPage = config.cacheComponents && isRoutePPREnabled && segments.some((segment)=>{
+            var _segment_config;
+            return ((_segment_config = segment.config) == null ? void 0 : _segment_config.ensureStatic) === 'navigation';
+        });
         const rootParamKeys = (0, _collectrootparamkeys.collectRootParamKeys)(routeModule);
         return (0, _app.buildAppStaticPaths)({
             dir,
@@ -68,6 +70,7 @@ async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOption
             route,
             cacheComponents: config.cacheComponents,
             segments,
+            segmentTree,
             distDir,
             requestHeaders,
             cacheHandler,
@@ -78,21 +81,19 @@ async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOption
             ComponentMod: components.ComponentMod,
             nextConfigOutput,
             isRoutePPREnabled,
+            isEnsureStaticPage,
             buildId,
             deploymentId,
             authInterrupts,
             useCacheTimeout,
+            durableUseCacheEntries,
             staticPageGenerationTimeout,
             rootParamKeys
         });
     } else if (!components.getStaticPaths) {
         // We shouldn't get to this point since the worker should only be called for
         // SSG pages with getStaticPaths.
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Failed to load page with getStaticPaths for ${pathname}`), "__NEXT_ERROR_CODE", {
-            value: "E605",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Failed to load page with getStaticPaths for ${pathname}`);
     }
     return (0, _pages.buildPagesStaticPaths)({
         page: pathname,

package/app/node_modules/next/dist/server/dev/turbopack-utils.js

@@ -172,7 +172,7 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                     await manifestLoader.loadPagesManifest('_document');
                     const writtenEndpoint = await route.htmlEndpoint.writeToDisk();
                     hooks == null ? void 0 : hooks.handleWrittenEndpoint(serverKey, writtenEndpoint, documentOrAppChanged);
-                    const type = writtenEndpoint == null ? void 0 : writtenEndpoint.type;
+                    const type = writtenEndpoint.value.type;
                     await manifestLoader.loadClientBuildManifest(page);
                     await manifestLoader.loadBuildManifest(page);
                     await manifestLoader.loadPagesManifest(page);
@@ -241,7 +241,7 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                 const key = (0, _entrykey.getEntryKey)('pages', 'server', page);
                 const writtenEndpoint = await route.endpoint.writeToDisk();
                 hooks == null ? void 0 : hooks.handleWrittenEndpoint(key, writtenEndpoint, false);
-                const type = writtenEndpoint.type;
+                const type = writtenEndpoint.value.type;
                 await manifestLoader.loadPagesManifest(page);
                 if (type === 'edge') {
                     (0, _warnaboutedgeruntime.warnAboutEdgeRuntime)();
@@ -266,7 +266,7 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                     // TODO subscriptions should only be caused by the WebSocket connections
                     // otherwise we don't known when to unsubscribe and this leaking
                     hooks == null ? void 0 : hooks.subscribeToChanges(key, /** includeIssues=*/ true, route.rscHmrEndpoint, (change)=>{
-                        var _globalThis___turbopack_server_hmr_handlers__, _hooks_handleServerComponentChanges;
+                        var _hooks_handleServerComponentChanges;
                         if (change.issues.some((issue)=>issue.severity === 'error')) {
                             // Ignore any updates that has errors
                             // There will be another update without errors eventually
@@ -274,20 +274,6 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                         }
                         // Report the next compilation again
                         readyIds == null ? void 0 : readyIds.delete(pathname);
-                        // When server fast refresh is enabled, the aggregate server-HMR
-                        // subscription sends SERVER_COMPONENT_CHANGES after applying the
-                        // update in-process. Sending here too would double the refresh.
-                        //
-                        // But the aggregate subscription only fires when there is a live
-                        // server-HMR handler registered (i.e. the page has rendered at
-                        // least once). When recovering from a build error the page never
-                        // rendered, so no handler exists, the aggregate stays silent, and
-                        // this per-page send is the only thing that clears the redbox.
-                        // Only suppress when a handler is actually live to own the refresh.
-                        const hasLiveServerHmrHandler = (((_globalThis___turbopack_server_hmr_handlers__ = globalThis.__turbopack_server_hmr_handlers__) == null ? void 0 : _globalThis___turbopack_server_hmr_handlers__.size) ?? 0) > 0;
-                        if ((hooks == null ? void 0 : hooks.serverFastRefresh) && hasLiveServerHmrHandler) {
-                            return;
-                        }
                         hooks == null ? void 0 : (_hooks_handleServerComponentChanges = hooks.handleServerComponentChanges) == null ? void 0 : _hooks_handleServerComponentChanges.call(hooks);
                     }, (e)=>{
                         return {
@@ -296,7 +282,7 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                         };
                     });
                 }
-                const type = writtenEndpoint.type;
+                const type = writtenEndpoint.value.type;
                 if (type === 'edge') {
                     (0, _warnaboutedgeruntime.warnAboutEdgeRuntime)();
                     manifestLoader.loadMiddlewareManifest(page, 'app');
@@ -334,17 +320,16 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                         // nothing to send the browser when it fails. `subscribeToChanges`
                         // drops the subscription on error and re-creates it the next time
                         // this route is ensured, so just log it.
-                        console.error(Object.defineProperty(new Error(`Error in the "${page}" app-route HMR subscription`, {
+                        console.error(new Error(`Error in the "${page}" app-route HMR subscription`, {
                             cause: error
-                        }), "__NEXT_ERROR_CODE", {
-                            value: "E1448",
-                            enumerable: false,
-                            configurable: true
                         }));
                     });
                 }
-                const type = writtenEndpoint.type;
+                const type = writtenEndpoint.value.type;
                 manifestLoader.loadAppPathsManifest(page);
+                if (route.hasActionManifest) {
+                    manifestLoader.loadActionManifest(page);
+                }
                 if (type === 'edge') {
                     (0, _warnaboutedgeruntime.warnAboutEdgeRuntime)();
                     manifestLoader.loadMiddlewareManifest(page, 'app');
@@ -361,11 +346,7 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
             }
         default:
             {
-                throw Object.defineProperty(new Error(`unknown route type ${route.type} for ${page}`), "__NEXT_ERROR_CODE", {
-                    value: "E316",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`unknown route type ${route.type} for ${page}`);
             }
     }
 }
@@ -455,13 +436,14 @@ function hasEntrypointForKey(entrypoints, key, assetMapper) {
     }
 }
 async function handleEntrypoints({ entrypoints, currentEntrypoints, currentEntryIssues, manifestLoader, devRewrites, logErrors, dev }) {
-    currentEntrypoints.global.app = entrypoints.pagesAppEndpoint;
-    currentEntrypoints.global.document = entrypoints.pagesDocumentEndpoint;
-    currentEntrypoints.global.error = entrypoints.pagesErrorEndpoint;
-    currentEntrypoints.global.instrumentation = entrypoints.instrumentation;
+    const value = entrypoints.value;
+    currentEntrypoints.global.app = value.pagesAppEndpoint;
+    currentEntrypoints.global.document = value.pagesDocumentEndpoint;
+    currentEntrypoints.global.error = value.pagesErrorEndpoint;
+    currentEntrypoints.global.instrumentation = value.instrumentation;
     currentEntrypoints.page.clear();
     currentEntrypoints.app.clear();
-    for (const [pathname, route] of entrypoints.routes){
+    for (const [pathname, route] of value.routes){
         switch(route.type){
             case 'page':
             case 'page-api':
@@ -493,10 +475,11 @@ async function handleEntrypoints({ entrypoints, currentEntrypoints, currentEntry
         await handleEntrypointsDevCleanup({
             currentEntryIssues,
             currentEntrypoints,
+            manifestLoader,
             ...dev
         });
     }
-    const { middleware, instrumentation } = entrypoints;
+    const { middleware, instrumentation } = value;
     // We check for explicit true/false, since it's initialized to
     // undefined during the first loop (middlewareChanges event is
     // unnecessary during the first serve)
@@ -593,11 +576,12 @@ async function handleEntrypoints({ entrypoints, currentEntrypoints, currentEntry
     await dev.hooks.propagateServerField('actualMiddlewareFile', dev.serverFields.actualMiddlewareFile);
     await dev.hooks.propagateServerField('middleware', dev.serverFields.middleware);
 }
-async function handleEntrypointsDevCleanup({ currentEntryIssues, currentEntrypoints, assetMapper, changeSubscriptions, clients, clientStates, hooks }) {
+async function handleEntrypointsDevCleanup({ currentEntryIssues, currentEntrypoints, manifestLoader, assetMapper, changeSubscriptions, clients, clientStates, hooks }) {
     // this needs to be first as `hasEntrypointForKey` uses the `assetMapper`
     for (const key of assetMapper.keys()){
         if (!hasEntrypointForKey(currentEntrypoints, key, assetMapper)) {
             assetMapper.delete(key);
+            manifestLoader.delete(key);
         }
     }
     for (const key of changeSubscriptions.keys()){

package/app/node_modules/next/dist/server/dev/use-cache-probe-pool.js

@@ -167,6 +167,7 @@ function installUseCacheProbe(options) {
                 httpAgentOptions: nextConfig.httpAgentOptions,
                 cacheLifeProfiles: nextConfig.cacheLife,
                 useCacheTimeout: nextConfig.experimental.useCacheTimeout,
+                durableUseCacheEntries: Boolean(nextConfig.experimental.durableUseCacheEntries),
                 staticPageGenerationTimeout: nextConfig.staticPageGenerationTimeout
             },
             timeoutMs: args.timeoutMs