@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/server/app-render/instant-validation/instant-samples.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    assertRootParamInSamples: null,
+    createCookiesFromSample: null,
+    createDraftModeForValidation: null,
+    createExhaustiveParamsProxy: null,
+    createExhaustiveSearchParamsProxy: null,
+    createExhaustiveURLSearchParamsProxy: null,
+    createHeadersFromSample: null,
+    createRelativeURLFromSamples: null,
+    createValidationSampleTracking: null,
+    trackMissingSampleError: null,
+    trackMissingSampleErrorAndThrow: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    assertRootParamInSamples: function() {
+        return assertRootParamInSamples;
+    },
+    createCookiesFromSample: function() {
+        return createCookiesFromSample;
+    },
+    createDraftModeForValidation: function() {
+        return createDraftModeForValidation;
+    },
+    createExhaustiveParamsProxy: function() {
+        return createExhaustiveParamsProxy;
+    },
+    createExhaustiveSearchParamsProxy: function() {
+        return createExhaustiveSearchParamsProxy;
+    },
+    createExhaustiveURLSearchParamsProxy: function() {
+        return createExhaustiveURLSearchParamsProxy;
+    },
+    createHeadersFromSample: function() {
+        return createHeadersFromSample;
+    },
+    createRelativeURLFromSamples: function() {
+        return createRelativeURLFromSamples;
+    },
+    createValidationSampleTracking: function() {
+        return createValidationSampleTracking;
+    },
+    trackMissingSampleError: function() {
+        return trackMissingSampleError;
+    },
+    trackMissingSampleErrorAndThrow: function() {
+        return trackMissingSampleErrorAndThrow;
+    }
+});
+const _cookies = require("../../web/spec-extension/cookies");
+const _requestcookies = require("../../web/spec-extension/adapters/request-cookies");
+const _headers = require("../../web/spec-extension/adapters/headers");
+const _getsegmentparam = require("../../../shared/lib/router/utils/get-segment-param");
+const _parserelativeurl = require("../../../shared/lib/router/utils/parse-relative-url");
+const _invarianterror = require("../../../shared/lib/invariant-error");
+const _instantvalidationerror = require("./instant-validation-error");
+const _workunitasyncstorageexternal = require("../work-unit-async-storage.external");
+const _reflectutils = require("../../../shared/lib/utils/reflect-utils");
+function createValidationSampleTracking() {
+    return {
+        missingSampleErrors: []
+    };
+}
+function getExpectedSampleTracking() {
+    let validationSampleTracking = null;
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workUnitStore) {
+        switch(workUnitStore.type){
+            case 'request':
+            case 'validation-client':
+                // TODO(instant-validation-build): do we need any special handling for caches?
+                validationSampleTracking = workUnitStore.validationSampleTracking ?? null;
+                break;
+            case 'cache':
+            case 'private-cache':
+            case 'unstable-cache':
+            case 'prerender-legacy':
+            case 'prerender-ppr':
+            case 'prerender-client':
+            case 'prerender':
+            case 'prerender-runtime':
+            case 'generate-static-params':
+                break;
+            default:
+                workUnitStore;
+        }
+    }
+    if (!validationSampleTracking) {
+        throw Object.defineProperty(new _invarianterror.InvariantError('Expected to have a workUnitStore that provides validationSampleTracking'), "__NEXT_ERROR_CODE", {
+            value: "E1110",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return validationSampleTracking;
+}
+function trackMissingSampleError(error) {
+    const validationSampleTracking = getExpectedSampleTracking();
+    validationSampleTracking.missingSampleErrors.push(error);
+}
+function trackMissingSampleErrorAndThrow(error) {
+    // TODO(instant-validation-build): this should abort the render
+    trackMissingSampleError(error);
+    throw error;
+}
+function createCookiesFromSample(sampleCookies, route) {
+    const declaredNames = new Set();
+    const cookies = new _cookies.RequestCookies(new Headers());
+    if (sampleCookies) {
+        for (const cookie of sampleCookies){
+            declaredNames.add(cookie.name);
+            if (cookie.value !== null) {
+                cookies.set(cookie.name, cookie.value);
+            }
+        }
+    }
+    const sealed = _requestcookies.RequestCookiesAdapter.seal(cookies);
+    return new Proxy(sealed, {
+        get (target, prop, receiver) {
+            if (prop === 'has') {
+                const originalMethod = Reflect.get(target, prop, receiver);
+                const wrappedMethod = function(name) {
+                    if (!declaredNames.has(name)) {
+                        trackMissingSampleErrorAndThrow(createMissingCookieSampleError(route, name));
+                    }
+                    return originalMethod.call(target, name);
+                };
+                return wrappedMethod;
+            }
+            if (prop === 'get') {
+                const originalMethod = Reflect.get(target, prop, receiver);
+                const wrappedMethod = function(nameOrCookie) {
+                    let name;
+                    if (typeof nameOrCookie === 'string') {
+                        name = nameOrCookie;
+                    } else if (nameOrCookie && typeof nameOrCookie === 'object' && typeof nameOrCookie.name === 'string') {
+                        name = nameOrCookie.name;
+                    } else {
+                        // This is an invalid input. Pass it through to the original method so it can error.
+                        return originalMethod.call(target, nameOrCookie);
+                    }
+                    if (!declaredNames.has(name)) {
+                        trackMissingSampleErrorAndThrow(createMissingCookieSampleError(route, name));
+                    }
+                    return originalMethod.call(target, name);
+                };
+                return wrappedMethod;
+            }
+            // TODO(instant-validation-build): what should getAll do?
+            // Maybe we should only allow it if there's an array (possibly empty?)
+            return Reflect.get(target, prop, receiver);
+        }
+    });
+}
+function createMissingCookieSampleError(route, name) {
+    return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed cookie "${name}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`cookies\` array, ` + `or \`{ name: "${name}", value: null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
+        value: "E1115",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createHeadersFromSample(rawSampleHeaders, sampleCookies, route) {
+    // If we have cookie samples, add a `cookie` header to match.
+    // Accessing it will be implicitly allowed by the proxy --
+    // if the user defined some cookies, accessing the "cookie" header is also fine.
+    const sampleHeaders = rawSampleHeaders ? [
+        ...rawSampleHeaders
+    ] : [];
+    if (sampleHeaders.find(([name])=>name.toLowerCase() === 'cookie')) {
+        throw Object.defineProperty(new _instantvalidationerror.InstantValidationError('Invalid sample: Defining cookies via a "cookie" header is not supported. Use `cookies: [{ name: ..., value: ... }]` instead.'), "__NEXT_ERROR_CODE", {
+            value: "E1111",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    if (sampleCookies) {
+        const cookieHeaderValue = sampleCookies.toString();
+        sampleHeaders.push([
+            'cookie',
+            // if the `cookies` samples were empty, or they were all `null`, then we have no cookies,
+            // and the header isn't present, but should remains readable, so we set it to null.
+            cookieHeaderValue !== '' ? cookieHeaderValue : null
+        ]);
+    }
+    const declaredNames = new Set();
+    const headersInit = {};
+    for (const [name, value] of sampleHeaders){
+        declaredNames.add(name.toLowerCase());
+        if (value !== null) {
+            headersInit[name.toLowerCase()] = value;
+        }
+    }
+    const sealed = _headers.HeadersAdapter.seal(_headers.HeadersAdapter.from(headersInit));
+    return new Proxy(sealed, {
+        get (target, prop, receiver) {
+            if (prop === 'get' || prop === 'has') {
+                const originalMethod = Reflect.get(target, prop, receiver);
+                const patchedMethod = function(rawName) {
+                    const name = rawName.toLowerCase();
+                    if (!declaredNames.has(name)) {
+                        trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed header "${name}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`headers\` array, ` + `or \`["${name}", null]\` if it should be absent.`), "__NEXT_ERROR_CODE", {
+                            value: "E1116",
+                            enumerable: false,
+                            configurable: true
+                        }));
+                    }
+                    // typescript can't reconcile a union of functions with a union of return types,
+                    // so we have to cast the original return type away
+                    return originalMethod.call(target, name);
+                };
+                return patchedMethod;
+            }
+            return Reflect.get(target, prop, receiver);
+        }
+    });
+}
+function createDraftModeForValidation() {
+    // Create a minimal DraftModeProvider-compatible object
+    // that always reports draft mode as disabled.
+    //
+    // private properties that can't be set from outside the class.
+    return {
+        get isEnabled () {
+            return false;
+        },
+        enable () {
+            throw Object.defineProperty(new Error('Draft mode cannot be enabled during build-time instant validation.'), "__NEXT_ERROR_CODE", {
+                value: "E1092",
+                enumerable: false,
+                configurable: true
+            });
+        },
+        disable () {
+            throw Object.defineProperty(new Error('Draft mode cannot be disabled during build-time instant validation.'), "__NEXT_ERROR_CODE", {
+                value: "E1094",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    };
+}
+function createExhaustiveParamsProxy(underlyingParams, declaredParamNames, route) {
+    return new Proxy(underlyingParams, {
+        get (target, prop, receiver) {
+            if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop) && // Only error when accessing a param that is part of the route but wasn't provided.
+            // accessing properties that aren't expected to be a valid param value is fine.
+            prop in underlyingParams && !declaredParamNames.has(prop)) {
+                trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed param "${prop}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
+                    value: "E1095",
+                    enumerable: false,
+                    configurable: true
+                }));
+            }
+            return Reflect.get(target, prop, receiver);
+        }
+    });
+}
+function createExhaustiveSearchParamsProxy(searchParams, declaredSearchParamNames, route) {
+    return new Proxy(searchParams, {
+        get (target, prop, receiver) {
+            if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop) && !declaredSearchParamNames.has(prop)) {
+                trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, prop));
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+        has (target, prop) {
+            if (typeof prop === 'string' && !_reflectutils.wellKnownProperties.has(prop) && !declaredSearchParamNames.has(prop)) {
+                trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, prop));
+            }
+            return Reflect.has(target, prop);
+        }
+    });
+}
+function createExhaustiveURLSearchParamsProxy(searchParams, declaredSearchParamNames, route) {
+    return new Proxy(searchParams, {
+        get (target, prop, receiver) {
+            // Intercept method calls that access specific param names
+            if (prop === 'get' || prop === 'getAll' || prop === 'has') {
+                const originalMathod = Reflect.get(target, prop, receiver);
+                return (name)=>{
+                    if (typeof name === 'string' && !declaredSearchParamNames.has(name)) {
+                        trackMissingSampleErrorAndThrow(createMissingSearchParamSampleError(route, name));
+                    }
+                    return originalMathod.call(target, name);
+                };
+            }
+            const value = Reflect.get(target, prop, receiver);
+            // Prevent `TypeError: Value of "this" must be of type URLSearchParams` for methods
+            if (typeof value === 'function' && !Object.hasOwn(target, prop)) {
+                return value.bind(target);
+            }
+            return value;
+        }
+    });
+}
+function createMissingSearchParamSampleError(route, name) {
+    return Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed searchParam "${name}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`searchParams\` object, ` + `or \`{ "${name}": null }\` if it should be absent.`), "__NEXT_ERROR_CODE", {
+        value: "E1098",
+        enumerable: false,
+        configurable: true
+    });
+}
+function createRelativeURLFromSamples(route, sampleParams, sampleSearchParams) {
+    // Build searchParams query object and URL search string from sample
+    const pathname = createPathnameFromRouteAndSampleParams(route, sampleParams ?? {});
+    let search = '';
+    if (sampleSearchParams) {
+        const qs = createURLSearchParamsFromSample(sampleSearchParams).toString();
+        if (qs) {
+            search = '?' + qs;
+        }
+    }
+    return (0, _parserelativeurl.parseRelativeUrl)(pathname + search, undefined, true);
+}
+function createURLSearchParamsFromSample(sampleSearchParams) {
+    const result = new URLSearchParams();
+    if (sampleSearchParams) {
+        for (const [key, value] of Object.entries(sampleSearchParams)){
+            if (value === null || value === undefined) continue;
+            if (Array.isArray(value)) {
+                for (const v of value){
+                    result.append(key, v);
+                }
+            } else {
+                result.set(key, value);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Substitute sample params into `workStore.route` to create a plausible pathname.
+ * TODO(instant-validation-build): this logic is somewhat hacky and likely incomplete,
+ * but it should be good enough for some initial testing.
+ */ function createPathnameFromRouteAndSampleParams(route, params) {
+    let interpolatedSegments = [];
+    const rawSegments = route.split('/');
+    for (const rawSegment of rawSegments){
+        const param = (0, _getsegmentparam.getSegmentParam)(rawSegment);
+        if (param) {
+            switch(param.paramType){
+                case 'catchall':
+                case 'optional-catchall':
+                    {
+                        let paramValue = params[param.paramName];
+                        if (paramValue === undefined) {
+                            // The value for the param was not provided. `usePathname` will detect this and throw
+                            // before this can surface to userspace. Use `[...NAME]` as a placeholder for the param value
+                            // in case it pops up somewhere unexpectedly.
+                            paramValue = [
+                                rawSegment
+                            ];
+                        } else if (!Array.isArray(paramValue)) {
+                            // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`
+                            throw Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be an array of strings, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
+                                value: "E1104",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        interpolatedSegments.push(...paramValue.map((v)=>encodeURIComponent(v)));
+                        break;
+                    }
+                case 'dynamic':
+                    {
+                        let paramValue = params[param.paramName];
+                        if (paramValue === undefined) {
+                            // The value for the param was not provided. `usePathname` will detect this and throw
+                            // before this can surface to userspace. Use `[NAME]` as a placeholder for the param value
+                            // in case it pops up somewhere unexpectedly.
+                            paramValue = rawSegment;
+                        } else if (typeof paramValue !== 'string') {
+                            // NOTE: this happens outside of render, so we don't need `trackMissingSampleErrorAndThrow`
+                            throw Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Expected sample param value for segment '${rawSegment}' to be a string, got ${typeof paramValue}`), "__NEXT_ERROR_CODE", {
+                                value: "E1108",
+                                enumerable: false,
+                                configurable: true
+                            });
+                        }
+                        interpolatedSegments.push(encodeURIComponent(paramValue));
+                        break;
+                    }
+                case 'catchall-intercepted-(..)(..)':
+                case 'catchall-intercepted-(.)':
+                case 'catchall-intercepted-(..)':
+                case 'catchall-intercepted-(...)':
+                case 'dynamic-intercepted-(..)(..)':
+                case 'dynamic-intercepted-(.)':
+                case 'dynamic-intercepted-(..)':
+                case 'dynamic-intercepted-(...)':
+                    {
+                        // TODO(instant-validation-build): i don't know how these are supposed to work, or if we can even get them here
+                        throw Object.defineProperty(new _invarianterror.InvariantError('Not implemented: Validation of interception routes'), "__NEXT_ERROR_CODE", {
+                            value: "E1106",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                default:
+                    {
+                        param.paramType;
+                    }
+            }
+        } else {
+            interpolatedSegments.push(rawSegment);
+        }
+    }
+    return interpolatedSegments.join('/');
+}
+function assertRootParamInSamples(workStore, sampleParams, paramName) {
+    if (sampleParams && paramName in sampleParams) {
+    // The param is defined in the samples.
+    } else {
+        const route = workStore.route;
+        trackMissingSampleErrorAndThrow(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${route}" accessed root param "${paramName}" which is not defined in the \`samples\` ` + `of \`unstable_instant\`. Add it to the sample's \`params\` object.`), "__NEXT_ERROR_CODE", {
+            value: "E1114",
+            enumerable: false,
+            configurable: true
+        }));
+    }
+}
+
+//# sourceMappingURL=instant-samples.js.map

package/standalone/node_modules/next/dist/server/app-render/instant-validation/instant-validation-error.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    InstantValidationError: null,
+    isInstantValidationError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    InstantValidationError: function() {
+        return InstantValidationError;
+    },
+    isInstantValidationError: function() {
+        return isInstantValidationError;
+    }
+});
+const INSTANT_VALIDATION_ERROR_DIGEST = 'INSTANT_VALIDATION_ERROR';
+function isInstantValidationError(err) {
+    return !!(err && typeof err === 'object' && err instanceof Error && err.digest === INSTANT_VALIDATION_ERROR_DIGEST);
+}
+class InstantValidationError extends Error {
+    constructor(...args){
+        super(...args), this.digest = INSTANT_VALIDATION_ERROR_DIGEST;
+    }
+}
+
+//# sourceMappingURL=instant-validation-error.js.map

package/standalone/node_modules/next/dist/server/app-render/instant-validation/stream-utils.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createNodeStreamFromChunks: null,
+    createNodeStreamWithLateRelease: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createNodeStreamFromChunks: function() {
+        return createNodeStreamFromChunks;
+    },
+    createNodeStreamWithLateRelease: function() {
+        return createNodeStreamWithLateRelease;
+    }
+});
+const _invarianterror = require("../../../shared/lib/invariant-error");
+function createNodeStreamWithLateRelease(partialChunks, allChunks, releaseSignal) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamWithLateRelease cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
+            value: "E993",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        const { Readable } = require('node:stream');
+        let nextIndex = 0;
+        const readable = new Readable({
+            read () {
+                while(nextIndex < partialChunks.length){
+                    this.push(partialChunks[nextIndex]);
+                    nextIndex++;
+                }
+            }
+        });
+        releaseSignal.addEventListener('abort', ()=>{
+            // Flush any remaining chunks from the original set
+            while(nextIndex < partialChunks.length){
+                readable.push(partialChunks[nextIndex]);
+                nextIndex++;
+            }
+            // Flush all chunks since we're now aborted and can't schedule
+            // any new work but these chunks might unblock debugInfo
+            while(nextIndex < allChunks.length){
+                readable.push(allChunks[nextIndex]);
+                nextIndex++;
+            }
+            setImmediate(()=>{
+                readable.push(null);
+            });
+        }, {
+            once: true
+        });
+        return readable;
+    }
+}
+function createNodeStreamFromChunks(chunks, signal) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw Object.defineProperty(new _invarianterror.InvariantError('createNodeStreamFromChunks cannot be used in the edge runtime'), "__NEXT_ERROR_CODE", {
+            value: "E945",
+            enumerable: false,
+            configurable: true
+        });
+    } else {
+        const { Readable } = require('node:stream');
+        // If there's a signal, delay closing until it fires
+        if (signal) {
+            signal.addEventListener('abort', ()=>{
+                readable.push(null);
+            }, {
+                once: true
+            });
+        }
+        let nextIndex = 0;
+        const readable = new Readable({
+            read () {
+                while(nextIndex < chunks.length){
+                    this.push(chunks[nextIndex]);
+                    nextIndex++;
+                }
+                if (!signal) {
+                    this.push(null);
+                }
+            }
+        });
+        return readable;
+    }
+}
+
+//# sourceMappingURL=stream-utils.js.map

package/standalone/node_modules/next/dist/server/app-render/manifests-singleton.js

@@ -212,8 +212,15 @@ function selectWorkerForForwarding(actionId, pageName) {
     // Otherwise, grab the first worker that has a handler for this action id.
     return denormalizeWorkerPageName(Object.keys(workers)[0]);
 }
-function setManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest }) {
+function setManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest: rawServerActionsManifest }) {
     const existingSingleton = globalThisWithManifests[MANIFESTS_SINGLETON];
+    const serverActionsManifest = {
+        encryptionKey: rawServerActionsManifest.encryptionKey,
+        // Use null-prototypes for the action objects to prevent prototype pollution
+        // from affecting action ID lookups.
+        node: Object.assign(Object.create(null), rawServerActionsManifest.node),
+        edge: Object.assign(Object.create(null), rawServerActionsManifest.edge)
+    };
     if (existingSingleton) {
         existingSingleton.clientReferenceManifestsPerRoute.set((0, _apppaths.normalizeAppPath)(page), clientReferenceManifest);
         existingSingleton.serverActionsManifest = serverActionsManifest;

package/standalone/node_modules/next/dist/server/app-render/postponed-state.js

@@ -116,7 +116,8 @@ function parsePostponedState(state, interpolatedParams, maxPostponedStateSizeByt
                     const { treeSegment: [, // This is the same value that'll be used in the postponed state
                     // as it's part of the tree data. That's why we use it as the
                     // replacement value.
-                    value] } = (0, _getdynamicparam.getDynamicParam)(interpolatedParams, segmentKey, dynamicParamType, null);
+                    value] } = (0, _getdynamicparam.getDynamicParam)(interpolatedParams, segmentKey, dynamicParamType, null, null // staticSiblings not needed for postponed state
+                    );
                     postponed = postponed.replaceAll(searchValue, value);
                 }
                 return {

package/standalone/node_modules/next/dist/server/app-render/prospective-render-utils.js

@@ -25,6 +25,7 @@ const _reactlargeshellerror = require("./react-large-shell-error");
 var Phase = /*#__PURE__*/ function(Phase) {
     Phase["ProspectiveRender"] = "the prospective render";
     Phase["SegmentCollection"] = "segment collection";
+    Phase["InstantValidation"] = "instant validation";
     return Phase;
 }({});
 function printDebugThrownValueForProspectiveRender(thrownValue, route, phase) {

package/standalone/node_modules/next/dist/server/app-render/segment-explorer-path.js

@@ -12,7 +12,8 @@ Object.defineProperty(exports, "__esModule", {
     isBuiltinBoundaryFile: null,
     isNextjsBuiltinFilePath: null,
     normalizeBoundaryFilename: null,
-    normalizeConventionFilePath: null
+    normalizeConventionFilePath: null,
+    normalizeFilePath: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -50,29 +51,53 @@ _export(exports, {
     },
     normalizeConventionFilePath: function() {
         return normalizeConventionFilePath;
+    },
+    normalizeFilePath: function() {
+        return normalizeFilePath;
     }
 });
 const BUILTIN_PREFIX = '__next_builtin__';
 const nextInternalPrefixRegex = /^(.*[\\/])?next[\\/]dist[\\/]client[\\/]components[\\/]builtin[\\/]/;
-function normalizeConventionFilePath(projectDir, conventionPath) {
+function normalizeFilePath(projectDir, filePath) {
     // Turbopack project path is formed as: "<project root>/<cwd>".
     // When project root is not the working directory, we can extract the relative project root path.
     // This is mostly used for running Next.js inside a monorepo.
     const cwd = process.env.NEXT_RUNTIME === 'edge' ? '' : process.cwd();
-    const relativeProjectRoot = projectDir.replace(cwd, '');
-    let relativePath = (conventionPath || '')// remove turbopack [project] prefix
-    .replace(/^\[project\]/, '')// remove turbopack relative project path, everything after [project] and before the working directory.
-    .replace(relativeProjectRoot, '')// remove the project root from the path
-    .replace(projectDir, '')// remove cwd prefix
-    .replace(cwd, '')// remove /(src/)?app/ dir prefix
-    .replace(/^([\\/])*(src[\\/])?app[\\/]/, '');
+    const relativeProjectRoot = projectDir.replace(cwd, '').replace(/^[\\/]/, '');
+    let relativePath = (filePath || '')// remove turbopack [project] prefix
+    .replace(/^\[project\][\\/]?/, '')// remove the project root from the path (absolute)
+    .replace(projectDir, '')// remove cwd prefix (absolute)
+    .replace(cwd, '')// normalize path separators and remove leading slash
+    .replace(/\\/g, '/').replace(/^\//, '');
+    // remove relative project path prefix (e.g., "test/e2e/app-dir/actions/")
+    if (relativeProjectRoot && relativePath.startsWith(relativeProjectRoot)) {
+        relativePath = relativePath.slice(relativeProjectRoot.length).replace(/^\//, '');
+    }
+    // Handle case where filename is relative to a parent of projectDir
+    // (e.g., in tests where filename is "test/tmp/next-test-XXX/app/page.js"
+    // but projectDir is the test temp directory)
+    if (relativePath.includes('/')) {
+        const projectDirName = projectDir.split(/[\\/]/).pop() || '';
+        if (projectDirName) {
+            const projectDirWithSlash = projectDirName + '/';
+            const idx = relativePath.indexOf(projectDirWithSlash);
+            if (idx >= 0) {
+                relativePath = relativePath.slice(idx + projectDirWithSlash.length);
+            }
+        }
+    }
+    return relativePath;
+}
+function normalizeConventionFilePath(projectDir, conventionPath) {
+    let relativePath = normalizeFilePath(projectDir, conventionPath)// remove /(src/)?app/ dir prefix
+    .replace(/^(src\/)?app\//, '');
     // If it's internal file only keep the filename, strip nextjs internal prefix
     if (nextInternalPrefixRegex.test(relativePath)) {
         relativePath = relativePath.replace(nextInternalPrefixRegex, '');
         // Add a special prefix to let segment explorer know it's a built-in component
         relativePath = `${BUILTIN_PREFIX}${relativePath}`;
     }
-    return relativePath.replace(/\\/g, '/');
+    return relativePath;
 }
 const isNextjsBuiltinFilePath = (filePath)=>{
     return nextInternalPrefixRegex.test(filePath);