@evoscientist/webui 0.2.4 → 0.2.6

package/dist/node_modules/next/dist/lib/metadata/metadata.js

@@ -15,8 +15,6 @@ const _httpaccessfallback = require("../../client/components/http-access-fallbac
 const _searchparams = require("../../server/request/search-params");
 const _pathname = require("../../server/request/pathname");
 const _ispostpone = require("../../server/lib/router-utils/is-postpone");
-const _workunitasyncstorageexternal = require("../../server/app-render/work-unit-async-storage.external");
-const _stagedrendering = require("../../server/app-render/staged-rendering");
 const _boundarycomponents = require("../framework/boundary-components");
 const _utils = require("./generate/utils");
 const _iconmark = require("./generate/icon-mark");
@@ -61,23 +59,11 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext, interpolatedParams, errorType, serveStreamingMetadata, isRuntimePrefetchable }) {
-    const searchParams = (0, _searchparams.createServerSearchParamsForMetadata)(parsedQuery, isRuntimePrefetchable);
+function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext, interpolatedParams, errorType, serveStreamingMetadata }) {
+    const searchParams = (0, _searchparams.createServerSearchParamsForMetadata)(parsedQuery);
     const pathnameForMetadata = (0, _pathname.createServerPathnameForMetadata)(pathname);
     async function Viewport() {
-        // Gate metadata to the correct render stage. If the page is not
-        // runtime-prefetchable, defer until the Static stage so that
-        // prefetchable segments get a head start.
-        if (!isRuntimePrefetchable) {
-            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            if (workUnitStore) {
-                const stagedRendering = (0, _workunitasyncstorageexternal.getStagedRenderingController)(workUnitStore);
-                if (stagedRendering) {
-                    await stagedRendering.waitForStage(_stagedrendering.RenderStage.Static);
-                }
-            }
-        }
-        const tags = await getResolvedViewport(tree, searchParams, interpolatedParams, isRuntimePrefetchable, errorType).catch((viewportErr)=>{
+        const tags = await getResolvedViewport(tree, searchParams, interpolatedParams, errorType).catch((viewportErr)=>{
             // When Legacy PPR is enabled viewport can reject with a Postpone type
             // This will go away once Legacy PPR is removed and dynamic metadata will
             // stay pending until after the prerender is complete when it is dynamic
@@ -85,7 +71,7 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
                 throw viewportErr;
             }
             if (!errorType && (0, _httpaccessfallback.isHTTPAccessFallbackError)(viewportErr)) {
-                return getNotFoundViewport(tree, searchParams, interpolatedParams, isRuntimePrefetchable).catch(()=>null);
+                return getNotFoundViewport(tree, searchParams, interpolatedParams).catch(()=>null);
             }
             // We're going to throw the error from the metadata outlet so we just render null here instead
             return null;
@@ -99,19 +85,7 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
         });
     }
     async function Metadata() {
-        // Gate metadata to the correct render stage. If the page is not
-        // runtime-prefetchable, defer until the Static stage so that
-        // prefetchable segments get a head start.
-        if (!isRuntimePrefetchable) {
-            const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-            if (workUnitStore) {
-                const stagedRendering = (0, _workunitasyncstorageexternal.getStagedRenderingController)(workUnitStore);
-                if (stagedRendering) {
-                    await stagedRendering.waitForStage(_stagedrendering.RenderStage.Static);
-                }
-            }
-        }
-        const tags = await getResolvedMetadata(tree, pathnameForMetadata, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable, errorType).catch((metadataErr)=>{
+        const tags = await getResolvedMetadata(tree, pathnameForMetadata, searchParams, interpolatedParams, metadataContext, errorType).catch((metadataErr)=>{
             // When Legacy PPR is enabled metadata can reject with a Postpone type
             // This will go away once Legacy PPR is removed and dynamic metadata will
             // stay pending until after the prerender is complete when it is dynamic
@@ -119,7 +93,7 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
                 throw metadataErr;
             }
             if (!errorType && (0, _httpaccessfallback.isHTTPAccessFallbackError)(metadataErr)) {
-                return getNotFoundMetadata(tree, pathnameForMetadata, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable).catch(()=>null);
+                return getNotFoundMetadata(tree, pathnameForMetadata, searchParams, interpolatedParams, metadataContext).catch(()=>null);
             }
             // We're going to throw the error from the metadata outlet so we just render null here instead
             return null;
@@ -148,8 +122,8 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
     }
     function MetadataOutlet() {
         const pendingOutlet = Promise.all([
-            getResolvedMetadata(tree, pathnameForMetadata, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable, errorType),
-            getResolvedViewport(tree, searchParams, interpolatedParams, isRuntimePrefetchable, errorType)
+            getResolvedMetadata(tree, pathnameForMetadata, searchParams, interpolatedParams, metadataContext, errorType),
+            getResolvedViewport(tree, searchParams, interpolatedParams, errorType)
         ]).then(()=>null);
         // TODO: We shouldn't change what we render based on whether we are streaming or not.
         // If we aren't streaming we should just block the response until we have resolved the
@@ -174,33 +148,33 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
     };
 }
 const getResolvedMetadata = (0, _react.cache)(getResolvedMetadataImpl);
-async function getResolvedMetadataImpl(tree, pathname, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable, errorType) {
+async function getResolvedMetadataImpl(tree, pathname, searchParams, interpolatedParams, metadataContext, errorType) {
     const errorConvention = errorType === 'redirect' ? undefined : errorType;
-    return renderMetadata(tree, pathname, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable, errorConvention);
+    return renderMetadata(tree, pathname, searchParams, interpolatedParams, metadataContext, errorConvention);
 }
 const getNotFoundMetadata = (0, _react.cache)(getNotFoundMetadataImpl);
-async function getNotFoundMetadataImpl(tree, pathname, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable) {
+async function getNotFoundMetadataImpl(tree, pathname, searchParams, interpolatedParams, metadataContext) {
     const notFoundErrorConvention = 'not-found';
-    return renderMetadata(tree, pathname, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable, notFoundErrorConvention);
+    return renderMetadata(tree, pathname, searchParams, interpolatedParams, metadataContext, notFoundErrorConvention);
 }
 const getResolvedViewport = (0, _react.cache)(getResolvedViewportImpl);
-async function getResolvedViewportImpl(tree, searchParams, interpolatedParams, isRuntimePrefetchable, errorType) {
+async function getResolvedViewportImpl(tree, searchParams, interpolatedParams, errorType) {
     const errorConvention = errorType === 'redirect' ? undefined : errorType;
-    return renderViewport(tree, searchParams, interpolatedParams, isRuntimePrefetchable, errorConvention);
+    return renderViewport(tree, searchParams, interpolatedParams, errorConvention);
 }
 const getNotFoundViewport = (0, _react.cache)(getNotFoundViewportImpl);
-async function getNotFoundViewportImpl(tree, searchParams, interpolatedParams, isRuntimePrefetchable) {
+async function getNotFoundViewportImpl(tree, searchParams, interpolatedParams) {
     const notFoundErrorConvention = 'not-found';
-    return renderViewport(tree, searchParams, interpolatedParams, isRuntimePrefetchable, notFoundErrorConvention);
+    return renderViewport(tree, searchParams, interpolatedParams, notFoundErrorConvention);
 }
-async function renderMetadata(tree, pathname, searchParams, interpolatedParams, metadataContext, isRuntimePrefetchable, errorConvention) {
-    const resolvedMetadata = await (0, _resolvemetadata.resolveMetadata)(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, isRuntimePrefetchable);
+async function renderMetadata(tree, pathname, searchParams, interpolatedParams, metadataContext, errorConvention) {
+    const resolvedMetadata = await (0, _resolvemetadata.resolveMetadata)(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext);
     return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
         children: createMetadataElements(resolvedMetadata)
     });
 }
-async function renderViewport(tree, searchParams, interpolatedParams, isRuntimePrefetchable, errorConvention) {
-    const resolvedViewport = await (0, _resolvemetadata.resolveViewport)(tree, searchParams, errorConvention, interpolatedParams, isRuntimePrefetchable);
+async function renderViewport(tree, searchParams, interpolatedParams, errorConvention) {
+    const resolvedViewport = await (0, _resolvemetadata.resolveViewport)(tree, searchParams, errorConvention, interpolatedParams);
     return /*#__PURE__*/ (0, _jsxruntime.jsx)(_jsxruntime.Fragment, {
         children: createViewportElements(resolvedViewport)
     });

package/dist/node_modules/next/dist/lib/metadata/resolve-metadata.js

@@ -472,7 +472,7 @@ async function collectViewport({ tree, viewportItems, errorViewportItemRef, prop
         errorViewportItemRef.current = errorViewportExport;
     }
 }
-const resolveMetadataItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, interpolatedParams, isRuntimePrefetchable) {
+const resolveMetadataItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, interpolatedParams) {
     const parentParams = {};
     const metadataItems = [];
     const errorMetadataItem = [
@@ -480,9 +480,9 @@ const resolveMetadataItems = (0, _react.cache)(async function(tree, searchParams
         null
     ];
     const treePrefix = undefined;
-    return resolveMetadataItemsImpl(metadataItems, tree, treePrefix, parentParams, null, searchParams, errorConvention, errorMetadataItem, interpolatedParams, isRuntimePrefetchable);
+    return resolveMetadataItemsImpl(metadataItems, tree, treePrefix, parentParams, null, searchParams, errorConvention, errorMetadataItem, interpolatedParams);
 });
-async function resolveMetadataItemsImpl(metadataItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, parentOptionalCatchAllParamName, searchParams, errorConvention, errorMetadataItem, interpolatedParams, isRuntimePrefetchable) {
+async function resolveMetadataItemsImpl(metadataItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, parentOptionalCatchAllParamName, searchParams, errorConvention, errorMetadataItem, interpolatedParams) {
     const [segment, parallelRoutes, { page }] = tree;
     const currentTreePrefix = treePrefix && treePrefix.length ? [
         ...treePrefix,
@@ -506,7 +506,7 @@ async function resolveMetadataItemsImpl(metadataItems, tree, /** Provided tree c
     // Track optional catch-all params with no value (see comment in
     // create-component-tree.tsx for full explanation).
     const optionalCatchAllParamName = (segmentParam == null ? void 0 : segmentParam.paramType) === 'optional-catchall' && (interpolatedParams[segmentParam.paramName] === null || interpolatedParams[segmentParam.paramName] === undefined) ? segmentParam.paramName : parentOptionalCatchAllParamName;
-    const params = (0, _params.createServerParamsForMetadata)(currentParams, optionalCatchAllParamName, isRuntimePrefetchable);
+    const params = (0, _params.createServerParamsForMetadata)(currentParams, optionalCatchAllParamName);
     const props = isPage ? {
         params,
         searchParams
@@ -524,7 +524,7 @@ async function resolveMetadataItemsImpl(metadataItems, tree, /** Provided tree c
     });
     for(const key in parallelRoutes){
         const childTree = parallelRoutes[key];
-        await resolveMetadataItemsImpl(metadataItems, childTree, currentTreePrefix, currentParams, optionalCatchAllParamName, searchParams, errorConvention, errorMetadataItem, interpolatedParams, isRuntimePrefetchable);
+        await resolveMetadataItemsImpl(metadataItems, childTree, currentTreePrefix, currentParams, optionalCatchAllParamName, searchParams, errorConvention, errorMetadataItem, interpolatedParams);
     }
     if (Object.keys(parallelRoutes).length === 0 && errorConvention) {
         // If there are no parallel routes, place error metadata as the last item.
@@ -533,16 +533,16 @@ async function resolveMetadataItemsImpl(metadataItems, tree, /** Provided tree c
     }
     return metadataItems;
 }
-const resolveViewportItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, interpolatedParams, isRuntimePrefetchable) {
+const resolveViewportItems = (0, _react.cache)(async function(tree, searchParams, errorConvention, interpolatedParams) {
     const parentParams = {};
     const viewportItems = [];
     const errorViewportItemRef = {
         current: null
     };
     const treePrefix = undefined;
-    return resolveViewportItemsImpl(viewportItems, tree, treePrefix, parentParams, null, searchParams, errorConvention, errorViewportItemRef, interpolatedParams, isRuntimePrefetchable);
+    return resolveViewportItemsImpl(viewportItems, tree, treePrefix, parentParams, null, searchParams, errorConvention, errorViewportItemRef, interpolatedParams);
 });
-async function resolveViewportItemsImpl(viewportItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, parentOptionalCatchAllParamName, searchParams, errorConvention, errorViewportItemRef, interpolatedParams, isRuntimePrefetchable) {
+async function resolveViewportItemsImpl(viewportItems, tree, /** Provided tree can be nested subtree, this argument says what is the path of such subtree */ treePrefix, parentParams, parentOptionalCatchAllParamName, searchParams, errorConvention, errorViewportItemRef, interpolatedParams) {
     const [segment, parallelRoutes, { page }] = tree;
     const currentTreePrefix = treePrefix && treePrefix.length ? [
         ...treePrefix,
@@ -566,7 +566,7 @@ async function resolveViewportItemsImpl(viewportItems, tree, /** Provided tree c
     // Track optional catch-all params with no value (see comment in
     // create-component-tree.tsx for full explanation).
     const optionalCatchAllParamName = (segmentParam == null ? void 0 : segmentParam.paramType) === 'optional-catchall' && (interpolatedParams[segmentParam.paramName] === null || interpolatedParams[segmentParam.paramName] === undefined) ? segmentParam.paramName : parentOptionalCatchAllParamName;
-    const params = (0, _params.createServerParamsForMetadata)(currentParams, optionalCatchAllParamName, isRuntimePrefetchable);
+    const params = (0, _params.createServerParamsForMetadata)(currentParams, optionalCatchAllParamName);
     let layerProps;
     if (isPage) {
         layerProps = {
@@ -589,7 +589,7 @@ async function resolveViewportItemsImpl(viewportItems, tree, /** Provided tree c
     });
     for(const key in parallelRoutes){
         const childTree = parallelRoutes[key];
-        await resolveViewportItemsImpl(viewportItems, childTree, currentTreePrefix, currentParams, optionalCatchAllParamName, searchParams, errorConvention, errorViewportItemRef, interpolatedParams, isRuntimePrefetchable);
+        await resolveViewportItemsImpl(viewportItems, childTree, currentTreePrefix, currentParams, optionalCatchAllParamName, searchParams, errorConvention, errorViewportItemRef, interpolatedParams);
     }
     if (Object.keys(parallelRoutes).length === 0 && errorConvention) {
         // If there are no parallel routes, place error metadata as the last item.
@@ -861,8 +861,8 @@ async function accumulateViewport(viewportItems) {
     }
     return resolvedViewport;
 }
-async function resolveMetadata(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext, isRuntimePrefetchable) {
-    const metadataItems = await resolveMetadataItems(tree, searchParams, errorConvention, interpolatedParams, isRuntimePrefetchable);
+async function resolveMetadata(tree, pathname, searchParams, errorConvention, interpolatedParams, metadataContext) {
+    const metadataItems = await resolveMetadataItems(tree, searchParams, errorConvention, interpolatedParams);
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
         throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
@@ -873,8 +873,8 @@ async function resolveMetadata(tree, pathname, searchParams, errorConvention, in
     }
     return accumulateMetadata(workStore.route, metadataItems, pathname, metadataContext);
 }
-async function resolveViewport(tree, searchParams, errorConvention, interpolatedParams, isRuntimePrefetchable) {
-    const viewportItems = await resolveViewportItems(tree, searchParams, errorConvention, interpolatedParams, isRuntimePrefetchable);
+async function resolveViewport(tree, searchParams, errorConvention, interpolatedParams) {
+    const viewportItems = await resolveViewportItems(tree, searchParams, errorConvention, interpolatedParams);
     return accumulateViewport(viewportItems);
 }
 function isPromiseLike(value) {

package/dist/node_modules/next/dist/lib/needs-experimental-react.js

@@ -9,8 +9,8 @@ Object.defineProperty(exports, "needsExperimentalReact", {
     }
 });
 function needsExperimentalReact(config) {
-    const { taint, transitionIndicator, gestureTransition } = config.experimental || {};
-    return Boolean(taint || transitionIndicator || gestureTransition);
+    const { blockingSSR, taint, transitionIndicator, gestureTransition } = config.experimental || {};
+    return Boolean(blockingSSR || taint || transitionIndicator || gestureTransition);
 }
 
 //# sourceMappingURL=needs-experimental-react.js.map

package/dist/node_modules/next/dist/lib/patch-incorrect-lockfile.js

@@ -72,7 +72,7 @@ async function fetchPkgInfo(pkg) {
         });
     }
     const data = await res.json();
-    const versionData = data.versions["16.2.6"];
+    const versionData = data.versions["16.3.3"];
     return {
         os: versionData.os,
         cpu: versionData.cpu,
@@ -92,7 +92,7 @@ async function patchIncorrectLockfile(dir) {
         // if no lockfile present there is no action to take
         return;
     }
-    const content = await _fs.promises.readFile(lockfilePath, 'utf8');
+    const content = (0, _fs.readFileSync)(lockfilePath, 'utf8');
     // maintain current line ending
     const endingNewline = content.endsWith('\r\n') ? '\r\n' : content.endsWith('\n') ? '\n' : '';
     const lockfileParsed = JSON.parse(content);
@@ -100,7 +100,7 @@ async function patchIncorrectLockfile(dir) {
     const expectedSwcPkgs = Object.keys(_packagejson.optionalDependencies || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
     const patchDependency = (pkg, pkgData)=>{
         lockfileParsed.dependencies[pkg] = {
-            version: "16.2.6",
+            version: "16.3.3",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             optional: true
@@ -108,7 +108,7 @@ async function patchIncorrectLockfile(dir) {
     };
     const patchPackage = (pkg, pkgData)=>{
         lockfileParsed.packages[pkg] = {
-            version: "16.2.6",
+            version: "16.3.3",
             resolved: pkgData.tarball,
             integrity: pkgData.integrity,
             cpu: pkgData.cpu,
@@ -174,7 +174,7 @@ async function patchIncorrectLockfile(dir) {
                 patchPackage(`${pkgPrefix}${pkg}`, pkgData);
             }
         }
-        await _fs.promises.writeFile(lockfilePath, JSON.stringify(lockfileParsed, null, 2) + endingNewline);
+        (0, _fs.writeFileSync)(lockfilePath, JSON.stringify(lockfileParsed, null, 2) + endingNewline);
         _log.warn('Lockfile was successfully patched, please run "npm install" to ensure @next/swc dependencies are downloaded');
     } catch (err) {
         _log.error(`Failed to patch lockfile, please try uninstalling and reinstalling next in this workspace`);

package/dist/node_modules/next/dist/lib/profiles-dir.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    PROFILES_DIR_NAME: null,
+    ensureProfilesDir: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    PROFILES_DIR_NAME: function() {
+        return PROFILES_DIR_NAME;
+    },
+    ensureProfilesDir: function() {
+        return ensureProfilesDir;
+    }
+});
+const _fs = require("fs");
+const _path = require("path");
+const PROFILES_DIR_NAME = '.next-profiles';
+const GITIGNORE_CONTENTS = `# Created automatically by Next.js. Profiling output should not be committed.
+*
+`;
+function ensureProfilesDir(dir) {
+    const profilesDir = (0, _path.join)(dir, PROFILES_DIR_NAME);
+    (0, _fs.mkdirSync)(profilesDir, {
+        recursive: true
+    });
+    const gitignorePath = (0, _path.join)(profilesDir, '.gitignore');
+    if (!(0, _fs.existsSync)(gitignorePath)) {
+        try {
+            (0, _fs.writeFileSync)(gitignorePath, GITIGNORE_CONTENTS);
+        } catch  {
+        // A missing .gitignore must not abort a profiling run.
+        }
+    }
+    return profilesDir;
+}
+
+//# sourceMappingURL=profiles-dir.js.map

package/dist/node_modules/next/dist/lib/require-instrumentation-client.js

@@ -1,14 +1,17 @@
 /**
- * This module imports the client instrumentation hook from the project root.
+ * This module imports the configured client instrumentation modules.
  *
  * The `private-next-instrumentation-client` module is automatically aliased to
- * the `instrumentation-client.ts` file in the project root by webpack or turbopack.
+ * either the user's instrumentation module or a generated module array.
  */ "use strict";
 if (process.env.NODE_ENV === 'development') {
     const measureName = 'Client Instrumentation Hook';
     const startTime = performance.now();
     // eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
-    module.exports = require('private-next-instrumentation-client');
+    const instrumentationClient = require('private-next-instrumentation-client');
+    module.exports = Array.isArray(instrumentationClient) ? instrumentationClient : [
+        instrumentationClient
+    ];
     const endTime = performance.now();
     const duration = endTime - startTime;
     // Using 16ms threshold as it represents one frame (1000ms/60fps)
@@ -20,7 +23,10 @@ if (process.env.NODE_ENV === 'development') {
     }
 } else {
     // eslint-disable-next-line @next/internal/typechecked-require -- Not a module.
-    module.exports = require('private-next-instrumentation-client');
+    const instrumentationClient = require('private-next-instrumentation-client');
+    module.exports = Array.isArray(instrumentationClient) ? instrumentationClient : [
+        instrumentationClient
+    ];
 }
 
 //# sourceMappingURL=require-instrumentation-client.js.map

package/dist/node_modules/next/dist/lib/resolve-build-paths.js

@@ -26,6 +26,7 @@ const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/lo
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 const _iserror = /*#__PURE__*/ _interop_require_default(require("./is-error"));
+const _findpagefile = require("../server/lib/find-page-file");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -82,18 +83,24 @@ const glob = (0, _util.promisify)(_glob.default);
     // Match Next.js dynamic route patterns: [name], [...name], [[...name]]
     return pattern.replace(/\[\[?\.\.\.[^\]]+\]?\]|\[[^\]]+\]/g, (match)=>match.replace(/\[/g, '\\[').replace(/\]/g, '\\]'));
 }
-async function resolveBuildPaths(patterns, projectDir) {
+async function resolveBuildPaths(patterns, projectDir, pageExtensions) {
     const appPaths = new Set();
     const pagePaths = new Set();
+    const validFileMatcher = (0, _findpagefile.createValidFileMatcher)(pageExtensions, undefined);
+    // Detect whether the project keeps its routes under `src/` so we can accept
+    // patterns written with or without that prefix (e.g. both `app/foo/page.tsx`
+    // and `src/app/foo/page.tsx`).
+    const useSrcApp = _fs.default.existsSync(_path.default.join(projectDir, 'src', 'app'));
+    const useSrcPages = _fs.default.existsSync(_path.default.join(projectDir, 'src', 'pages'));
     const includePatterns = [];
     const excludePatterns = [];
     for (const pattern of patterns){
         const trimmed = pattern.trim();
         if (!trimmed) continue;
         if (trimmed.startsWith('!')) {
-            excludePatterns.push(escapeBrackets(trimmed.slice(1)));
+            excludePatterns.push(escapeBrackets(addSrcPrefixIfNeeded(trimmed.slice(1), useSrcApp, useSrcPages)));
         } else {
-            includePatterns.push(escapeBrackets(trimmed));
+            includePatterns.push(escapeBrackets(addSrcPrefixIfNeeded(trimmed, useSrcApp, useSrcPages)));
         }
     }
     // Default to matching all files when only negation patterns are provided.
@@ -112,7 +119,7 @@ async function resolveBuildPaths(patterns, projectDir) {
         }
         for (const file of matches){
             if (!_fs.default.statSync(_path.default.join(projectDir, file)).isDirectory()) {
-                categorizeAndAddPath(file, appPaths, pagePaths);
+                categorizeAndAddPath(file, appPaths, pagePaths, validFileMatcher);
             }
         }
     } catch (error) {
@@ -127,20 +134,41 @@ async function resolveBuildPaths(patterns, projectDir) {
         pagePaths: Array.from(pagePaths).sort()
     };
 }
+/**
+ * When the project keeps its `app/` or `pages/` directory under `src/`, prepend
+ * `src/` to bare patterns so the glob actually matches files on disk. Patterns
+ * that already include the `src/` prefix are returned unchanged.
+ */ function addSrcPrefixIfNeeded(pattern, useSrcApp, useSrcPages) {
+    const normalized = pattern.replace(/\\/g, '/');
+    if (useSrcApp && /^app\//.test(normalized)) {
+        return 'src/' + normalized;
+    }
+    if (useSrcPages && /^pages\//.test(normalized)) {
+        return 'src/' + normalized;
+    }
+    return pattern;
+}
 /**
  * Categorizes a file path to either app or pages router based on its prefix.
- * For app router, only route-defining files (page.*, route.*) are included.
+ * For app router, only route-defining files are included.
+ *
+ * Accepts both top-level (`app/...`, `pages/...`) and src-prefixed
+ * (`src/app/...`, `src/pages/...`) project structures.
  *
  * Examples:
  * - "app/page.tsx" → appPaths.add("/page.tsx")
+ * - "src/app/page.tsx" → appPaths.add("/page.tsx")
  * - "app/layout.tsx" → skipped (not a route file)
  * - "pages/index.tsx" → pagePaths.add("/index.tsx")
- */ function categorizeAndAddPath(filePath, appPaths, pagePaths) {
-    const normalized = filePath.replace(/\\/g, '/');
+ */ function categorizeAndAddPath(filePath, appPaths, pagePaths, validFileMatcher) {
+    let normalized = filePath.replace(/\\/g, '/');
+    if (normalized.startsWith('src/')) {
+        normalized = normalized.slice(4);
+    }
     if (normalized.startsWith('app/')) {
-        // Only include route-defining files (page.* or route.*)
-        if (/\/(page|route)\.[^/]+$/.test(normalized)) {
-            appPaths.add('/' + normalized.slice(4));
+        const appRelativePath = '/' + normalized.slice(4);
+        if (validFileMatcher.isAppRouterPage(appRelativePath)) {
+            appPaths.add(appRelativePath);
         }
     } else if (normalized.startsWith('pages/')) {
         pagePaths.add('/' + normalized.slice(6));

package/dist/node_modules/next/dist/lib/turbopack-cache-seed.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "seedTurbopackCacheIfNeeded", {
+    enumerable: true,
+    get: function() {
+        return seedTurbopackCacheIfNeeded;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+const _swc = require("../build/swc");
+const _gitworktree = require("./git-worktree");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function seedTurbopackCacheIfNeeded({ projectDir, distDir }) {
+    // This gets the version assuming that nothing is dirty.
+    // If things are dirty, turbopack would write things
+    // in a different location. There are other circumstances
+    // as well. This only matters for people developing turbopack
+    // see handle_db_versioning in turbotask backend for more details.
+    const version = (0, _swc.getTurbopackCacheVersion)();
+    if (!version) return;
+    const worktreeInfo = (0, _gitworktree.getGitWorktreeInfo)(projectDir);
+    if (!worktreeInfo) return;
+    const cacheDir = _path.default.join(distDir, 'cache', 'turbopack');
+    const targetVersionDir = _path.default.join(cacheDir, version);
+    if (dirHasEntries(targetVersionDir)) return;
+    let sourceVersionDir;
+    try {
+        sourceVersionDir = findSeedSource(worktreeInfo, projectDir, distDir, version);
+    } catch  {
+        return;
+    }
+    if (!sourceVersionDir) return;
+    const tmpDir = `${targetVersionDir}.seeding`;
+    // Making sure we don't copy partial data if process interrupted
+    // There is a potential race condition here
+    // if someone wrote to the cache while we were seeding it
+    // but with the immutable design and all that, I'm not super worried
+    try {
+        _fs.default.mkdirSync(cacheDir, {
+            recursive: true
+        });
+        _fs.default.rmSync(tmpDir, {
+            recursive: true,
+            force: true
+        });
+        seedCacheDir(sourceVersionDir, tmpDir);
+        _fs.default.renameSync(tmpDir, targetVersionDir);
+        _log.info(`Seeded Turbopack cache from ${sourceVersionDir}.`);
+    } catch  {
+        _fs.default.rmSync(tmpDir, {
+            recursive: true,
+            force: true
+        });
+        _log.warn(`Failed to seed Turbopack cache from ${sourceVersionDir} to ${targetVersionDir}.`);
+    }
+}
+function findSeedSource(worktreeInfo, projectDir, distDir, version) {
+    const projectRelToWorktree = _path.default.relative(worktreeInfo.worktreeRoot, projectDir);
+    const distRelToProject = _path.default.relative(projectDir, distDir);
+    const currentWorktree = _path.default.resolve(worktreeInfo.worktreeRoot);
+    // We are going to find the best candidate worktree
+    // based on the most recently written cache directory.
+    // We only look at our version
+    let best;
+    for (const root of [
+        worktreeInfo.mainRepoRoot,
+        ...(0, _gitworktree.listLinkedWorktreeRoots)(worktreeInfo.mainRepoRoot)
+    ]){
+        if (_path.default.resolve(root) === currentWorktree) continue;
+        const versionDir = _path.default.join(root, projectRelToWorktree, distRelToProject, 'cache', 'turbopack', version);
+        const commitTimeMs = currentCommitTimeMs(versionDir);
+        if (commitTimeMs === undefined) continue;
+        if (!best || commitTimeMs > best.commitTimeMs) {
+            best = {
+                versionDir,
+                commitTimeMs
+            };
+        }
+    }
+    return best == null ? void 0 : best.versionDir;
+}
+// When the cache in `versionDir` was last committed to, in epoch milliseconds, or undefined if
+// there is no usable cache there. Read from the `commit_time` the persistence layer records in
+// CURRENT.
+function currentCommitTimeMs(versionDir) {
+    let commitTime;
+    try {
+        commitTime = JSON.parse(_fs.default.readFileSync(_path.default.join(versionDir, 'CURRENT'), 'utf8')).commit_time;
+    } catch  {
+        // missing, unreadable, or not valid JSON - treat it as not a seed candidate
+        return undefined;
+    }
+    if (typeof commitTime !== 'string') return undefined;
+    const parsed = Date.parse(commitTime);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function dirHasEntries(dir) {
+    try {
+        return _fs.default.readdirSync(dir).length > 0;
+    } catch  {
+        return false;
+    }
+}
+const IMMUTABLE_CACHE_FILE = /\.(sst|blob|meta|del)$/;
+function seedCacheDir(src, dst) {
+    const stat = _fs.default.lstatSync(src);
+    if (stat.isDirectory()) {
+        _fs.default.mkdirSync(dst, {
+            recursive: true
+        });
+        for (const name of _fs.default.readdirSync(src)){
+            seedCacheDir(_path.default.join(src, name), _path.default.join(dst, name));
+        }
+    } else if (IMMUTABLE_CACHE_FILE.test(src)) {
+        _fs.default.linkSync(src, dst);
+    } else {
+        // Mutable/unknown (CURRENT, LOG, …) - copy so it gets its own inode.
+        _fs.default.copyFileSync(src, dst);
+    }
+}
+
+//# sourceMappingURL=turbopack-cache-seed.js.map