@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/server/dev/middleware-turbopack.js

@@ -81,8 +81,8 @@ const currentSourcesByFile = new Map();
     let source = null;
     const originalFile = sourceFrame.originalFile;
     // Don't look up source for node_modules or internals. These can often be large bundled files.
-    const ignored = shouldIgnorePath(originalFile ?? sourceFrame.file) || // isInternal means resource starts with turbopack:///[turbopack]
-    !!sourceFrame.isInternal;
+    const ignored = // Check the sourcemap's ignoreList (e.g. from 3rd party packages)
+    !!sourceFrame.isIgnored || shouldIgnorePath(originalFile ?? sourceFrame.file);
     if (originalFile && !ignored) {
         let sourcePromise = currentSourcesByFile.get(originalFile);
         if (!sourcePromise) {
@@ -96,7 +96,6 @@ const currentSourcesByFile = new Map();
         }
         source = await sourcePromise;
     }
-    // TODO: get ignoredList from turbopack source map
     const ignorableFrame = {
         file: sourceFrame.file,
         line1: sourceFrame.line ?? null,
@@ -246,16 +245,23 @@ async function createOriginalStackFrame(project, projectPath, frame) {
     if (normalizedStackFrameLocation !== null && normalizedStackFrameLocation.startsWith('file://')) {
         normalizedStackFrameLocation = _path.default.relative(projectPath, (0, _nodeurl.fileURLToPath)(normalizedStackFrameLocation));
     }
+    /** undefined = not yet computed */ let originalCodeFrame;
+    const tracedFrame = traced.frame;
     return {
         originalStackFrame: {
-            arguments: traced.frame.arguments,
+            arguments: tracedFrame.arguments,
             file: normalizedStackFrameLocation,
-            line1: traced.frame.line1,
-            column1: traced.frame.column1,
-            ignored: traced.frame.ignored,
-            methodName: traced.frame.methodName
+            line1: tracedFrame.line1,
+            column1: tracedFrame.column1,
+            ignored: tracedFrame.ignored,
+            methodName: tracedFrame.methodName
         },
-        originalCodeFrame: (0, _shared.getOriginalCodeFrame)(traced.frame, traced.source)
+        get originalCodeFrame () {
+            if (originalCodeFrame === undefined) {
+                originalCodeFrame = (0, _shared.getOriginalCodeFrame)(tracedFrame, traced.source);
+            }
+            return originalCodeFrame;
+        }
     };
 }
 function getOverlayMiddleware({ project, projectPath, isSrcDir }) {
@@ -375,9 +381,13 @@ async function getOriginalStackFrames({ project, projectPath, frames, isServer,
                     reason: 'Failed to create original stack frame'
                 };
             }
+            const originalStackFrame = stackFrame.originalStackFrame;
             return {
                 status: 'fulfilled',
-                value: stackFrame
+                value: {
+                    originalStackFrame,
+                    originalCodeFrame: (originalStackFrame == null ? void 0 : originalStackFrame.ignored) ?? true ? null : stackFrame.originalCodeFrame
+                }
             };
         } catch (error) {
             return {

package/standalone/node_modules/next/dist/server/dev/middleware-webpack.js

@@ -109,7 +109,7 @@ function getIgnoredSources(sourceMap) {
         // bundlerFilePath case: webpack://./app/page.tsx
         const webpackSourceURL = moduleFilenames[index];
         // Format the path to the normal file path
-        const formattedFilePath = (0, _webpackmodulepath.formatFrameSourceFile)(webpackSourceURL);
+        const formattedFilePath = (0, _webpackmodulepath.formatStackFrameFile)(webpackSourceURL);
         if (shouldIgnoreSource(formattedFilePath)) {
             ignoreList.add(index);
         }
@@ -180,9 +180,15 @@ async function createOriginalStackFrame({ ignoredByDefault, source, rootDirector
         arguments: [],
         ignored
     };
+    /** undefined = not yet computed */ let originalCodeFrame;
     return {
         originalStackFrame: traced,
-        originalCodeFrame: (0, _shared.getOriginalCodeFrame)(traced, sourceContent)
+        get originalCodeFrame () {
+            if (originalCodeFrame === undefined) {
+                originalCodeFrame = (0, _shared.getOriginalCodeFrame)(traced, sourceContent);
+            }
+            return originalCodeFrame;
+        }
     };
 }
 async function getSourceMapFromCompilation(id, compilation) {
@@ -361,7 +367,11 @@ async function getOriginalStackFrame({ isServer, isEdgeServer, isAppDirectory, f
             originalCodeFrame: null
         };
     }
-    return originalStackFrameResponse;
+    const originalStackFrame = originalStackFrameResponse.originalStackFrame;
+    return {
+        originalStackFrame,
+        originalCodeFrame: (originalStackFrame == null ? void 0 : originalStackFrame.ignored) ?? true ? null : originalStackFrameResponse.originalCodeFrame
+    };
 }
 function getOverlayMiddleware(options) {
     const { rootDirectory, isSrcDir, clientStats, serverStats, edgeServerStats } = options;

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

@@ -145,12 +145,12 @@ class DevServer extends _nextserver.default {
         this.nextConfig = options.conf;
         this.bundlerService = options.bundlerService;
         this.startServerSpan = options.startServerSpan ?? (0, _trace.trace)('start-next-dev-server');
-        this.renderOpts.dev = true;
         this.renderOpts.ErrorDebug = ReactDevOverlay;
         this.staticPathsCache = new _lrucache.LRUCache(// 5MB
         5 * 1024 * 1024, function length(value) {
             var _JSON_stringify;
-            return ((_JSON_stringify = JSON.stringify(value.staticPaths)) == null ? void 0 : _JSON_stringify.length) ?? 0;
+            // Ensure minimum size of 1 for LRU eviction to work correctly
+            return ((_JSON_stringify = JSON.stringify(value.staticPaths)) == null ? void 0 : _JSON_stringify.length) || 1;
         });
         const { pagesDir, appDir } = (0, _findpagesdir.findPagesDir)(this.dir);
         this.pagesDir = pagesDir;
@@ -370,6 +370,13 @@ class DevServer extends _nextserver.default {
                         }
                         const requestEnd = process.hrtime.bigint();
                         (0, _logrequests.logRequests)(request, response, loggingConfig, requestStart, requestEnd, (0, _requestmeta.getRequestMeta)(req, 'devRequestTimingMiddlewareStart'), (0, _requestmeta.getRequestMeta)(req, 'devRequestTimingMiddlewareEnd'), (0, _requestmeta.getRequestMeta)(req, 'devRequestTimingInternalsEnd'), (0, _requestmeta.getRequestMeta)(req, 'devGenerateStaticParamsDuration'));
+                        // Create trace span for render phase
+                        const devRequestTimingInternalsEnd = (0, _requestmeta.getRequestMeta)(req, 'devRequestTimingInternalsEnd');
+                        if (devRequestTimingInternalsEnd) {
+                            this.startServerSpan.manualTraceChild('render-path', (0, _trace.hrtimeToEpochNanoseconds)(devRequestTimingInternalsEnd), (0, _trace.hrtimeToEpochNanoseconds)(requestEnd), {
+                                path: req.url || ''
+                            });
+                        }
                     });
                 }
             }
@@ -541,6 +548,7 @@ class DevServer extends _nextserver.default {
                     pathname,
                     config: {
                         pprConfig: this.nextConfig.experimental.ppr,
+                        partialFallbacks: this.nextConfig.experimental.partialFallbacks === true,
                         configFileName,
                         cacheComponents: Boolean(this.nextConfig.cacheComponents)
                     },
@@ -591,9 +599,9 @@ class DevServer extends _nextserver.default {
                     }
                 }
                 // Since generateStaticParams run on the background, when accessing the
-                // devFallbackParams during the render, it is still set to the previous
+                // fallbackParams during the render, it is still set to the previous
                 // result from the cache. Therefore when the result has changed, re-render
-                // the Server Component to sync the devFallbackParams with the new result.
+                // the Server Component to sync the fallbackParams with the new result.
                 if (isAppPath && this.nextConfig.cacheComponents && // Ensure this is not the first invocation.
                 result && ((_result_prerenderedRoutes = result.prerenderedRoutes) == null ? void 0 : _result_prerenderedRoutes.length) !== (prerenderedRoutes == null ? void 0 : prerenderedRoutes.length)) {
                     this.bundlerService.sendHmrMessage({
@@ -631,6 +639,11 @@ class DevServer extends _nextserver.default {
                 for (const staticPath of value.staticPaths || []){
                     existingManifest.routes[staticPath] = {};
                 }
+                // Find the fallback route from the prerendered routes. This is
+                // the route whose pathname matches the page pattern (e.g.
+                // /dynamic-params/[slug]) and has fallback route params describing
+                // which params are unknown at build time.
+                const fallbackPrerenderedRoute = prerenderedRoutes == null ? void 0 : prerenderedRoutes.find((route)=>route.pathname === pathname);
                 existingManifest.dynamicRoutes[pathname] = {
                     dataRoute: null,
                     dataRouteRegex: null,
@@ -639,8 +652,8 @@ class DevServer extends _nextserver.default {
                     fallbackExpire: undefined,
                     fallbackHeaders: undefined,
                     fallbackStatus: undefined,
-                    fallbackRootParams: undefined,
-                    fallbackRouteParams: undefined,
+                    fallbackRootParams: fallbackPrerenderedRoute == null ? void 0 : fallbackPrerenderedRoute.fallbackRootParams,
+                    fallbackRouteParams: fallbackPrerenderedRoute == null ? void 0 : fallbackPrerenderedRoute.fallbackRouteParams,
                     fallbackSourceRoute: pathname,
                     prefetchDataRoute: undefined,
                     prefetchDataRouteRegex: undefined,

package/standalone/node_modules/next/dist/server/dev/on-demand-entry-handler.js

@@ -367,9 +367,60 @@ function onDemandEntryHandler({ hotReloader, maxInactiveAge, multiCompiler, next
         curInvalidator = new Invalidator(multiCompiler);
         invalidators.set(multiCompiler.outputPath, curInvalidator);
     }
+    // Deferred entries state management
+    const deferredEntriesConfig = nextConfig.experimental.deferredEntries;
+    const hasDeferredEntriesConfig = deferredEntriesConfig && deferredEntriesConfig.length > 0;
+    let onBeforeDeferredEntriesCalled = false;
+    let onBeforeDeferredEntriesPromise = null;
+    // Function to wait for all non-deferred entries to be built
+    async function waitForNonDeferredEntries() {
+        return new Promise((resolve)=>{
+            const checkEntries = ()=>{
+                // Check if there are any non-deferred entries that are still building or added
+                const hasNonDeferredEntriesBuilding = Object.entries(curEntries).some(([, entry])=>{
+                    const entryData = entry;
+                    if (entryData.type !== 0) return false;
+                    const isDeferred = (0, _entries.isDeferredEntry)(entryData.absolutePagePath.replace(appDir || '', '').replace(pagesDir || '', '').replace(rootDir, ''), deferredEntriesConfig);
+                    return !isDeferred && (entryData.status === ADDED || entryData.status === BUILDING);
+                });
+                if (!hasNonDeferredEntriesBuilding) {
+                    resolve();
+                } else {
+                    // Check again after a short delay
+                    setTimeout(checkEntries, 100);
+                }
+            };
+            checkEntries();
+        });
+    }
+    // Function to handle deferred entry processing
+    async function processDeferredEntry() {
+        if (!hasDeferredEntriesConfig) return;
+        // Wait for all non-deferred entries to be built
+        await waitForNonDeferredEntries();
+        // Call the onBeforeDeferredEntries callback once
+        if (!onBeforeDeferredEntriesCalled) {
+            onBeforeDeferredEntriesCalled = true;
+            if (nextConfig.experimental.onBeforeDeferredEntries) {
+                debug('calling onBeforeDeferredEntries callback');
+                if (!onBeforeDeferredEntriesPromise) {
+                    onBeforeDeferredEntriesPromise = nextConfig.experimental.onBeforeDeferredEntries();
+                }
+                await onBeforeDeferredEntriesPromise;
+                debug('onBeforeDeferredEntries callback completed');
+            }
+        } else if (onBeforeDeferredEntriesPromise) {
+            // Wait for any in-progress callback
+            await onBeforeDeferredEntriesPromise;
+        }
+    }
     const startBuilding = (compilation)=>{
         const compilationName = compilation.name;
         curInvalidator.startBuilding(compilationName);
+        // Reset deferred entries state for this compilation cycle
+        // This ensures onBeforeDeferredEntries will be called again during HMR
+        onBeforeDeferredEntriesCalled = false;
+        onBeforeDeferredEntriesPromise = null;
     };
     for (const compiler of multiCompiler.compilers){
         compiler.hooks.make.tap('NextJsOnDemandEntries', startBuilding);
@@ -418,6 +469,15 @@ function onDemandEntryHandler({ hotReloader, maxInactiveAge, multiCompiler, next
         (_getInvalidator = getInvalidator(multiCompiler.outputPath)) == null ? void 0 : _getInvalidator.doneBuilding([
             ...COMPILER_KEYS
         ]);
+        // Call onBeforeDeferredEntries after compilation completes during HMR
+        // This ensures the callback is invoked even when non-deferred entries change
+        if (hasDeferredEntriesConfig && !onBeforeDeferredEntriesCalled) {
+            onBeforeDeferredEntriesCalled = true;
+            if (nextConfig.experimental.onBeforeDeferredEntries) {
+                debug('calling onBeforeDeferredEntries callback after HMR');
+                onBeforeDeferredEntriesPromise = nextConfig.experimental.onBeforeDeferredEntries();
+            }
+        }
     });
     const pingIntervalTime = Math.max(1000, Math.min(5000, maxInactiveAge));
     setInterval(function() {
@@ -498,6 +558,15 @@ function onDemandEntryHandler({ hotReloader, maxInactiveAge, multiCompiler, next
                 route = await findPagePathData(rootDir, page, nextConfig.pageExtensions, pagesDir, appDir, !!nextConfig.experimental.globalNotFound);
             }
             const isInsideAppDir = !!appDir && route.filename.startsWith(appDir);
+            // Check if this is a deferred entry and wait for non-deferred entries first
+            if (hasDeferredEntriesConfig) {
+                const isDeferred = (0, _entries.isDeferredEntry)(route.page, deferredEntriesConfig);
+                if (isDeferred) {
+                    debug(`Page ${page} is a deferred entry, waiting for other entries`);
+                    await processDeferredEntry();
+                    debug(`Deferred entry ${page} can now be processed`);
+                }
+            }
             if (typeof isApp === 'boolean' && isApp !== isInsideAppDir) {
                 Error.stackTraceLimit = 15;
                 throw Object.defineProperty(new Error(`Ensure bailed, found path "${route.page}" does not match ensure type (${isApp ? 'app' : 'pages'})`), "__NEXT_ERROR_CODE", {

package/standalone/node_modules/next/dist/server/dev/require-cache.js

@@ -16,34 +16,64 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-function deleteFromRequireCache(filePath) {
-    try {
-        filePath = (0, _realpath.realpathSync)(filePath);
-    } catch (e) {
-        if ((0, _iserror.default)(e) && e.code !== 'ENOENT') throw e;
+/**
+ * Batch delete modules from require.cache with a single scan.
+ *
+ * When deleting N modules, this performs ONE scan of require.cache
+ * instead of N scans, reducing complexity from O(N * C) to O(C + N)
+ * where C = size of require.cache.
+ */ function deleteFromRequireCache(filePaths) {
+    // Phase 1: Resolve all paths and collect modules to delete
+    const resolvedPaths = [];
+    const modsToDelete = new Set();
+    for (let filePath of filePaths){
+        try {
+            filePath = (0, _realpath.realpathSync)(filePath);
+        } catch (e) {
+            if ((0, _iserror.default)(e) && e.code !== 'ENOENT') throw e;
+        }
+        const mod = require.cache[filePath];
+        if (mod) {
+            resolvedPaths.push(filePath);
+            modsToDelete.add(mod);
+        }
     }
-    const mod = require.cache[filePath];
-    if (mod) {
-        // remove the child reference from all parent modules
-        for (const parent of Object.values(require.cache)){
-            if (parent == null ? void 0 : parent.children) {
-                const idx = parent.children.indexOf(mod);
-                if (idx >= 0) parent.children.splice(idx, 1);
+    if (modsToDelete.size === 0) return;
+    // Phase 2: Single scan of require.cache to remove child references
+    const modules = Object.values(require.cache);
+    for(let m = 0; m < modules.length; m++){
+        var _modules_m;
+        const children = (_modules_m = modules[m]) == null ? void 0 : _modules_m.children;
+        if (children && children.length) {
+            let len = children.length;
+            for(let i = 0; i < len; i++){
+                if (modsToDelete.has(children[i])) {
+                    children[i] = children[--len];
+                    i-- // re-check swapped element
+                    ;
+                }
             }
+            children.length = len;
         }
-        // remove parent references from external modules
-        for (const child of mod.children){
-            child.parent = null;
+    }
+    // Phase 3: Clear parent references from children and delete cache entries
+    for (const mod of modsToDelete){
+        const children = mod.children;
+        for(let i = 0; i < children.length; i++){
+            if (children[i].parent === mod) {
+                children[i].parent = null;
+            }
         }
+    }
+    for (const filePath of resolvedPaths){
         delete require.cache[filePath];
-        return true;
     }
-    return false;
 }
-function deleteCache(filePath) {
-    // try to clear it from the fs cache
-    (0, _loadmanifestexternal.clearManifestCache)(filePath);
-    deleteFromRequireCache(filePath);
+function deleteCache(filePaths) {
+    for (const filePath of filePaths){
+        (0, _loadmanifestexternal.clearManifestCache)(filePath);
+    }
+    deleteFromRequireCache(filePaths);
 }
 
 //# sourceMappingURL=require-cache.js.map

package/standalone/node_modules/next/dist/server/dev/server-action-logger.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "formatArgs", {
+    enumerable: true,
+    get: function() {
+        return formatArgs;
+    }
+});
+const _safestablestringify = require("next/dist/compiled/safe-stable-stringify");
+// Configure stringify with reasonable limits for action logging
+const stringify = (0, _safestablestringify.configure)({
+    maximumDepth: 2,
+    maximumBreadth: 3
+});
+/**
+ * Format a single argument for display in server action logs.
+ */ function formatArg(arg) {
+    try {
+        return stringify(arg) ?? String(arg);
+    } catch  {
+        // String(arg) can throw for temporary client references (e.g., class instances
+        // passed from client to server) because accessing .toString() on them throws
+        // "Cannot access toString on the server"
+        try {
+            return String(arg);
+        } catch  {
+            return '[unserializable]';
+        }
+    }
+}
+function formatArgs(args) {
+    return args.map((a)=>formatArg(a)).join(', ');
+}
+
+//# sourceMappingURL=server-action-logger.js.map

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

@@ -78,6 +78,7 @@ async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOption
             ComponentMod: components.ComponentMod,
             nextConfigOutput,
             isRoutePPREnabled,
+            partialFallbacksEnabled: config.partialFallbacks,
             buildId,
             authInterrupts,
             rootParamKeys

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

@@ -45,7 +45,7 @@ _export(exports, {
         return hasEntrypointForKey;
     },
     msToNs: function() {
-        return msToNs;
+        return _compilationevents.msToNs;
     },
     normalizedPageToTurbopackStructureRoute: function() {
         return normalizedPageToTurbopackStructureRoute;
@@ -66,6 +66,7 @@ const _entrykey = require("../../shared/lib/turbopack/entry-key");
 const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
 const _utils = require("../../shared/lib/turbopack/utils");
 const _constants = require("../../lib/constants");
+const _compilationevents = require("../../shared/lib/turbopack/compilation-events");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -141,12 +142,7 @@ function processTopLevelIssues(currentTopLevelIssues, result) {
         currentTopLevelIssues.set(issueKey, issue);
     }
 }
-const MILLISECONDS_IN_NANOSECOND = BigInt(1000000);
-function msToNs(ms) {
-    return BigInt(Math.floor(ms)) * MILLISECONDS_IN_NANOSECOND;
-}
 async function handleRouteType({ dev, page, pathname, route, currentEntryIssues, entrypoints, manifestLoader, readyIds, devRewrites, productionRewrites, hooks, logErrors }) {
-    const shouldCreateWebpackStats = process.env.TURBOPACK_STATS != null;
     switch(route.type){
         case 'page':
             {
@@ -186,9 +182,6 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                     }
                     await manifestLoader.loadFontManifest('/_app', 'pages');
                     await manifestLoader.loadFontManifest(page, 'pages');
-                    if (shouldCreateWebpackStats) {
-                        await manifestLoader.loadWebpackStats(page, 'pages');
-                    }
                     manifestLoader.writeManifests({
                         devRewrites,
                         productionRewrites,
@@ -298,9 +291,6 @@ async function handleRouteType({ dev, page, pathname, route, currentEntryIssues,
                 manifestLoader.loadAppPathsManifest(page);
                 manifestLoader.loadActionManifest(page);
                 manifestLoader.loadFontManifest(page, 'app');
-                if (shouldCreateWebpackStats) {
-                    manifestLoader.loadWebpackStats(page, 'app');
-                }
                 manifestLoader.writeManifests({
                     devRewrites,
                     productionRewrites,
@@ -683,9 +673,10 @@ function normalizedPageToTurbopackStructureRoute(route, ext) {
             if (entrypointKey.endsWith('/[__metadata_id__]')) {
                 entrypointKey = entrypointKey.slice(0, -'/[__metadata_id__]'.length);
             }
-            if (entrypointKey.endsWith('/sitemap.xml') && ext !== '.xml') {
-                // For dynamic sitemap route, remove the extension
-                entrypointKey = entrypointKey.slice(0, -'.xml'.length);
+            // After stripping [__metadata_id__], add .xml for dynamic sitemap routes
+            // to match the Turbopack entry key from normalize_metadata_route
+            if (entrypointKey.endsWith('/sitemap') && ext !== '.xml') {
+                entrypointKey = entrypointKey + '.xml';
             }
         }
         entrypointKey = entrypointKey + '/route';

package/standalone/node_modules/next/dist/server/dynamic-rendering-utils.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    delayUntilRuntimeStage: null,
+    getRuntimeStage: null,
     isHangingPromiseRejectionError: null,
     makeDevtoolsIOAwarePromise: null,
     makeHangingPromise: null
@@ -14,6 +16,12 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    delayUntilRuntimeStage: function() {
+        return delayUntilRuntimeStage;
+    },
+    getRuntimeStage: function() {
+        return getRuntimeStage;
+    },
     isHangingPromiseRejectionError: function() {
         return isHangingPromiseRejectionError;
     },
@@ -24,6 +32,7 @@ _export(exports, {
         return makeHangingPromise;
     }
 });
+const _stagedrendering = require("./app-render/staged-rendering");
 function isHangingPromiseRejectionError(err) {
     if (typeof err !== 'object' || err === null || !('digest' in err)) {
         return false;
@@ -82,5 +91,18 @@ function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
         }, 0);
     });
 }
+function getRuntimeStage(stagedRendering) {
+    if (stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyStatic || stagedRendering.currentStage === _stagedrendering.RenderStage.EarlyRuntime) {
+        return _stagedrendering.RenderStage.EarlyRuntime;
+    }
+    return _stagedrendering.RenderStage.Runtime;
+}
+function delayUntilRuntimeStage(prerenderStore, result) {
+    const { stagedRendering } = prerenderStore;
+    if (!stagedRendering) {
+        return result;
+    }
+    return stagedRendering.waitForStage(getRuntimeStage(stagedRendering)).then(()=>result);
+}
 
 //# sourceMappingURL=dynamic-rendering-utils.js.map