failproofai 1.0.11-beta.0 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/unstable-cache.js

@@ -36,11 +36,7 @@ async function cacheNewResult(result, incrementalCache, cacheKey, tags, revalida
 }
 function unstable_cache(cb, keyParts, options = {}) {
     if (options.revalidate === 0) {
-        throw Object.defineProperty(new Error(`Invariant revalidate: 0 can not be passed to unstable_cache(), must be "false" or "> 0" ${cb.toString()}`), "__NEXT_ERROR_CODE", {
-            value: "E57",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant revalidate: 0 can not be passed to unstable_cache(), must be "false" or "> 0" ${cb.toString()}`);
     }
     // Validate the tags provided are valid
     const tags = options.tags ? (0, _patchfetch.validateTags)(options.tags, `unstable_cache ${cb.toString()}`) : [];
@@ -62,11 +58,7 @@ function unstable_cache(cb, keyParts, options = {}) {
         // We must be able to find the incremental cache otherwise we throw
         const maybeIncrementalCache = (workStore == null ? void 0 : workStore.incrementalCache) || globalThis.__incrementalCache;
         if (!maybeIncrementalCache) {
-            throw Object.defineProperty(new Error(`Invariant: incrementalCache missing in unstable_cache ${cb.toString()}`), "__NEXT_ERROR_CODE", {
-                value: "E469",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Invariant: incrementalCache missing in unstable_cache ${cb.toString()}`);
         }
         const incrementalCache = maybeIncrementalCache;
         const cacheSignal = workUnitStore ? (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore) : null;
@@ -102,6 +94,7 @@ function unstable_cache(cb, keyParts, options = {}) {
             const innerCacheStore = {
                 type: 'unstable-cache',
                 phase: 'render',
+                consumerWillServerCache: true,
                 implicitTags,
                 draftMode: workUnitStore && workStore && (0, _workunitasyncstorageexternal.getDraftModeProviderForCacheScope)(workStore, workUnitStore),
                 rootParams: undefined
@@ -118,7 +111,6 @@ function unstable_cache(cb, keyParts, options = {}) {
                         case 'private-cache':
                         case 'prerender':
                         case 'prerender-runtime':
-                        case 'prerender-ppr':
                         case 'prerender-legacy':
                             // We update the store's revalidate property if the revalidate option is a higher precedence
                             // revalidate === undefined doesn't affect timing.
@@ -149,7 +141,7 @@ function unstable_cache(cb, keyParts, options = {}) {
                         case 'prerender-client':
                         case 'validation-client':
                         case 'request':
-                        case 'generate-static-params':
+                        case 'build-time-generator':
                             break;
                         default:
                             workUnitStore;
@@ -198,19 +190,20 @@ function unstable_cache(cb, keyParts, options = {}) {
                                     });
                                     // Attach the empty catch here so we don't get a "unhandled promise
                                     // rejection" warning. (Behavior is matched with patch-fetch)
-                                    if (workStore.isStaticGeneration) {
+                                    if ((0, _workunitasyncstorageexternal.willConsumerServerCache)(workUnitStore)) {
                                         revalidationPromise.catch(()=>{});
                                     }
                                     workStore.pendingRevalidates[invocationKey] = revalidationPromise;
                                 }
                                 // Check if we need to do foreground revalidation
-                                if (workStore.isStaticGeneration) {
-                                    // When the page is revalidating and the cache entry is stale,
-                                    // we need to wait for fresh data (blocking revalidate). The
-                                    // `await` here keeps `cacheSignal.endRead` (in the outer
-                                    // `finally`) suspended until the recompute + cacheNewResult
-                                    // actually complete, so the prospective prerender's
-                                    // `cacheSignal` doesn't resolve `cacheReady` prematurely.
+                                if ((0, _workunitasyncstorageexternal.willConsumerServerCache)(workUnitStore)) {
+                                    // When the consumer will persist this result in a server
+                                    // cache, wait for fresh data so it doesn't persist a stale
+                                    // value. The `await` here also keeps `cacheSignal.endRead` (in
+                                    // the outer `finally`) suspended until the recompute +
+                                    // cacheNewResult actually complete, so a prospective
+                                    // prerender's `cacheSignal` doesn't resolve `cacheReady`
+                                    // prematurely.
                                     return await workStore.pendingRevalidates[invocationKey];
                                 }
                             // Otherwise, we're doing background revalidation - return stale immediately
@@ -292,12 +285,11 @@ function getFetchUrlPrefix(workStore, workUnitStore) {
         case 'prerender-client':
         case 'validation-client':
         case 'prerender-runtime':
-        case 'prerender-ppr':
         case 'prerender-legacy':
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
-        case 'generate-static-params':
+        case 'build-time-generator':
             return workStore.route;
         default:
             return workUnitStore;

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/unstable-no-store.js

@@ -32,13 +32,12 @@ function unstable_noStore() {
                 case 'prerender-runtime':
                     // unstable_noStore() is a noop in Dynamic I/O.
                     return;
-                case 'prerender-ppr':
                 case 'prerender-legacy':
                 case 'request':
                 case 'cache':
                 case 'private-cache':
                 case 'unstable-cache':
-                case 'generate-static-params':
+                case 'build-time-generator':
                     break;
                 default:
                     workUnitStore;

package/.next/standalone/node_modules/next/dist/server/web/utils.js

@@ -126,12 +126,8 @@ function validateURL(url) {
     try {
         return String(new URL(String(url)));
     } catch (error) {
-        throw Object.defineProperty(new Error(`URL is malformed "${String(url)}". Please use only absolute URLs - https://nextjs.org/docs/messages/middleware-relative-urls`, {
+        throw new Error(`URL is malformed "${String(url)}". Please use only absolute URLs - https://nextjs.org/docs/messages/middleware-relative-urls`, {
             cause: error
-        }), "__NEXT_ERROR_CODE", {
-            value: "E61",
-            enumerable: false,
-            configurable: true
         });
     }
 }

package/.next/standalone/node_modules/next/dist/server/web/web-on-close.js

@@ -55,22 +55,14 @@ function trackStreamConsumed(stream, onEnd) {
 class CloseController {
     onClose(callback) {
         if (this.isClosed) {
-            throw Object.defineProperty(new Error('Cannot subscribe to a closed CloseController'), "__NEXT_ERROR_CODE", {
-                value: "E365",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Cannot subscribe to a closed CloseController');
         }
         this.target.addEventListener('close', callback);
         this.listeners++;
     }
     dispatchClose() {
         if (this.isClosed) {
-            throw Object.defineProperty(new Error('Cannot close a CloseController multiple times'), "__NEXT_ERROR_CODE", {
-                value: "E229",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Cannot close a CloseController multiple times');
         }
         if (this.listeners > 0) {
             this.target.dispatchEvent(new Event('close'));

package/.next/standalone/node_modules/next/dist/shared/lib/app-router-types.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     PrefetchHint: null,
+    StaticAttemptHints: null,
     StaticPrefetchDisabled: null,
     SubtreePrefetchHints: null,
     propagateSubtreeBits: null
@@ -23,6 +24,9 @@ _export(exports, {
     PrefetchHint: function() {
         return PrefetchHint;
     },
+    StaticAttemptHints: function() {
+        return StaticAttemptHints;
+    },
     StaticPrefetchDisabled: function() {
         return StaticPrefetchDisabled;
     },
@@ -35,23 +39,24 @@ _export(exports, {
 });
 var PrefetchHint = /*#__PURE__*/ function(PrefetchHint) {
     // NOTE: The 0b00001 bit was previously HasRuntimePrefetch (prefetch:
-    // 'allow-runtime'). Partial Prefetching now implies runtime completeness
+    // 'allow-runtime'). Partial Prefetching allows using runtime requests
     // for every segment, so the bit was removed. Do not reuse it without
     // considering caches populated by older builds.
     // This segment or one of its descendants opts into Partial Prefetching, i.e.
     // uses the two-phase (Shell then Speculative) prefetch flow. Set when
-    // `prefetch` is 'partial' or 'unstable_eager' (including the defaults
-    // implied by the global `partialPrefetching` config). Propagates upward so
-    // the root segment reflects the entire subtree.
+    // `prefetch` is 'partial' (including the default implied by the global
+    // `partialPrefetching` config). Propagates upward so the root segment
+    // reflects the entire subtree.
     //
-    // Partial Prefetching segments require RUNTIME COMPLETENESS: a prefetch
-    // isn't considered done for such a segment until an entry at least as
-    // complete as a runtime response exists. This does NOT mean the segment
-    // lacks static data — the server emits static data unconditionally, and the
-    // scheduler may attempt a static prefetch first (per
-    // ShouldAttemptStaticPrefetch), issuing the runtime request only if the
-    // static response's own `needsRuntimeRequest` signal says it would
-    // return more.
+    // Partial Prefetching routes may use runtime requests for both shells
+    // and prefetches. They *may* be optimized to a use a static request
+    // if no runtime data was accessed during the prerender.
+    // However, If the route has `ensureStatic` configured to "shell", "prefetch",
+    // or "navigation", we *must* use static requests for the shell (and possibly the
+    // prefetch).
+    // Both of these cases are signalled to the scheduler via the
+    // `ShouldAttemptStatic{Shell,Prefetch}` hints and the `needsRuntimeRequest`
+    // promise.
     PrefetchHint[PrefetchHint["SubtreeHasPartialPrefetching"] = 2] = "SubtreeHasPartialPrefetching";
     // This segment itself has a loading.tsx boundary.
     PrefetchHint[PrefetchHint["SegmentHasLoadingBoundary"] = 4] = "SegmentHasLoadingBoundary";
@@ -69,7 +74,7 @@ var PrefetchHint = /*#__PURE__*/ function(PrefetchHint) {
     // it separately. Set at build time by the segment size measurement pass.
     PrefetchHint[PrefetchHint["InlinedIntoChild"] = 64] = "InlinedIntoChild";
     // On a __PAGE__: this page's response includes the head (metadata/viewport)
-    // at the end of its SegmentPrefetch[] array.
+    // in its transport data (PartialTransportData's `h`).
     PrefetchHint[PrefetchHint["HeadInlinedIntoSelf"] = 128] = "HeadInlinedIntoSelf";
     // On the root hint node: the head was NOT inlined into any page — fetch
     // it separately. Absence of this bit means the head is bundled into a page.
@@ -96,12 +101,9 @@ var PrefetchHint = /*#__PURE__*/ function(PrefetchHint) {
     // Partial Prefetching now implies runtime completeness for every segment
     // (see SubtreeHasPartialPrefetching), so the bit was removed. Do not reuse
     // it without considering caches populated by older builds.
-    // This segment or one of its descendants prefetches "eagerly" — i.e. its
-    // effective prefetch strategy is anything other than 'partial'. Used by
-    // App Shells: a non-eager subtree relies on the shared app shell and skips
-    // its Speculative prefetch. Propagates upward so the root reflects the
-    // entire subtree.
-    PrefetchHint[PrefetchHint["SubtreeHasEagerPrefetch"] = 4096] = "SubtreeHasEagerPrefetch";
+    // NOTE: The 0b1000000000000 bit was previously SubtreeHasEagerPrefetch
+    // (prefetch: 'unstable_eager', plus every segment that did not opt into
+    // Partial Prefetching). After `unstable_eager` was removed, it's no longer needed.
     // This segment or one of its descendants exports `instant = false`,
     // explicitly opting out of Partial Prefetching. Propagates upward so the root
     // reflects the entire subtree. Used only to suppress the dev-time
@@ -129,11 +131,21 @@ var PrefetchHint = /*#__PURE__*/ function(PrefetchHint) {
     // navigations alike. (Routes missing from the manifest — see the #91407
     // fallbacks — simply never carry it.) Set on every node of the tree, but
     // does not propagate.
-    PrefetchHint[PrefetchHint["ShouldAttemptStaticPrefetch"] = 16384] = "ShouldAttemptStaticPrefetch";
+    PrefetchHint[PrefetchHint["ShouldAttemptStaticShell"] = 16384] = "ShouldAttemptStaticShell";
+    PrefetchHint[PrefetchHint["ShouldAttemptStaticPrefetch"] = 32768] = "ShouldAttemptStaticPrefetch";
+    // This dynamic segment only accepts build-time parameter values. Kept on
+    // the affected node, without propagating or copying it to other segments.
+    // Until the client knows the allowed values, any such node prevents route
+    // prediction, even when the route's components never read the parameter.
+    PrefetchHint[PrefetchHint["IsClosedParam"] = 65536] = "IsClosedParam";
+    // A descendant segment (but not this one) has a closed parameter. Propagates
+    // upward so route prediction can check the root instead of walking the tree.
+    PrefetchHint[PrefetchHint["SubtreeHasClosedParams"] = 131072] = "SubtreeHasClosedParams";
     return PrefetchHint;
 }({});
 const StaticPrefetchDisabled = 1024;
-const SubtreePrefetchHints = 2 | 8 | 8192 | 4096;
+const StaticAttemptHints = 16384 | 32768;
+const SubtreePrefetchHints = 2 | 8 | 8192 | 131072;
 function propagateSubtreeBits(parentHints, childHints) {
     if (childHints & 2) {
         parentHints |= 2;
@@ -143,16 +155,14 @@ function propagateSubtreeBits(parentHints, childHints) {
     if (childHints & (4 | 8)) {
         parentHints |= 8;
     }
-    // And for eager prefetch. The bit is set directly on each eager segment, so
-    // there's no separate segment-local flag — propagate it as-is.
-    if (childHints & 4096) {
-        parentHints |= 4096;
-    }
-    // And for `instant = false`. Like eager prefetch, the bit is set directly on
-    // each opted-out segment, so propagate it as-is.
+    // And for `instant = false`. The bit is set directly on each opted-out
+    // segment, so there's no separate segment-local flag — propagate it as-is.
     if (childHints & 8192) {
         parentHints |= 8192;
     }
+    if (childHints & (65536 | 131072)) {
+        parentHints |= 131072;
+    }
     return parentHints;
 }
 

package/.next/standalone/node_modules/next/dist/shared/lib/constants.js

@@ -52,6 +52,7 @@ Object.defineProperty(exports, "__esModule", {
     PHASE_TEST: null,
     PREFETCH_HINTS: null,
     PRERENDER_MANIFEST: null,
+    PREVIEW_PROPS_MANIFEST: null,
     REACT_LOADABLE_MANIFEST: null,
     REQUEST_INSIGHTS_DEV_ENDPOINT: null,
     ROUTES_MANIFEST: null,
@@ -228,6 +229,9 @@ _export(exports, {
     PRERENDER_MANIFEST: function() {
         return PRERENDER_MANIFEST;
     },
+    PREVIEW_PROPS_MANIFEST: function() {
+        return PREVIEW_PROPS_MANIFEST;
+    },
     REACT_LOADABLE_MANIFEST: function() {
         return REACT_LOADABLE_MANIFEST;
     },
@@ -350,6 +354,7 @@ const EXPORT_MARKER = 'export-marker.json';
 const EXPORT_DETAIL = 'export-detail.json';
 const PRERENDER_MANIFEST = 'prerender-manifest.json';
 const PREFETCH_HINTS = 'prefetch-hints.json';
+const PREVIEW_PROPS_MANIFEST = 'preview-props.json';
 const ROUTES_MANIFEST = 'routes-manifest.json';
 const IMAGES_MANIFEST = 'images-manifest.json';
 const SERVER_FILES_MANIFEST = 'required-server-files';

package/.next/standalone/node_modules/next/dist/shared/lib/deployment-id.js

@@ -33,7 +33,7 @@ if (typeof window !== 'undefined') {
     deploymentId = document.documentElement.dataset.dplId;
     // Immediately remove the attribute to prevent hydration errors (the dplId was inserted into the
     // HTML only), React isn't aware of it at all.
-    delete document.documentElement.dataset.dplId;
+    document.documentElement.removeAttribute('data-dpl-id');
 } else {
     // Client side: replaced with globalThis.NEXT_DEPLOYMENT_ID
     // Server side: left as is or replaced with a string or replaced with false

package/.next/standalone/node_modules/next/dist/shared/lib/errors/code-frame.js

@@ -10,9 +10,10 @@ Object.defineProperty(exports, "codeFrameColumns", {
 });
 const _swc = require("../../../build/swc");
 function codeFrameColumns(file, location, options = {}) {
-    // Default to the terminal width
+    // Default to the terminal width. The CLI passes it on when it pipes this
+    // process's output for the upgrade menu.
     if (options.maxWidth === undefined) {
-        options.maxWidth = process.stdout.columns;
+        options.maxWidth = process.stdout.columns ?? (Number(process.env.NEXT_PRIVATE_TERMINAL_COLUMNS) || undefined);
     }
     return (0, _swc.getBindingsSync)().codeFrameColumns(file, location, options);
 }

package/.next/standalone/node_modules/next/dist/shared/lib/errors/empty-generate-static-params-error.js

@@ -21,11 +21,7 @@ createError) {
     // (e.g. a wildcard re-export). The stack points at framework internals, but
     // we keep it: those frames are ignore-listed in the output and stay available
     // for debugging.
-    throw Object.defineProperty(new Error('When using Cache Components, all `generateStaticParams` functions must return at least one result. ' + 'This is to ensure that we can perform build-time validation that there is no other dynamic accesses that would cause a runtime error.\n\n' + 'Learn more: https://nextjs.org/docs/messages/empty-generate-static-params'), "__NEXT_ERROR_CODE", {
-        value: "E898",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('When using Cache Components, all `generateStaticParams` functions must return at least one result. ' + 'This is to ensure that we can perform build-time validation that there is no other dynamic accesses that would cause a runtime error.\n\n' + 'Learn more: https://nextjs.org/docs/messages/empty-generate-static-params');
 }
 
 //# sourceMappingURL=empty-generate-static-params-error.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/errors/ensure-static-gsp-errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    throwIncompleteStaticParamsErrorInStaticRoute: null,
+    throwMissingGspErrorInStaticRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    throwIncompleteStaticParamsErrorInStaticRoute: function() {
+        return throwIncompleteStaticParamsErrorInStaticRoute;
+    },
+    throwMissingGspErrorInStaticRoute: function() {
+        return throwMissingGspErrorInStaticRoute;
+    }
+});
+function throwMissingGspErrorInStaticRoute(page) {
+    throw new Error(`Page "${page}": \`ensureStatic = "navigation"\` requires an exported \`generateStaticParams()\` function.\nLearn more: https://nextjs.org/docs/messages/generate-static-params#with-ensurestatic`);
+}
+function throwIncompleteStaticParamsErrorInStaticRoute(page, missingParamNames) {
+    throw new Error(`Page "${page}": \`generateStaticParams()\` returned incomplete params. Routes using \`ensureStatic = "navigation"\` must return every dynamic route parameter. Missing: ${missingParamNames.map((name)=>`"${name}"`).join(', ')}.\nLearn more: https://nextjs.org/docs/messages/generate-static-params#with-ensurestatic`);
+}
+
+//# sourceMappingURL=ensure-static-gsp-errors.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/errors/hard-deprecated-config-error.js

@@ -11,11 +11,6 @@ Object.defineProperty(exports, "HardDeprecatedConfigError", {
 class HardDeprecatedConfigError extends Error {
     constructor(message){
         super(message);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
         // This error is meant to interrupt the server start/build process
         // but the stack trace isn't meaningful, as it points to internal code.
         this.stack = undefined;

package/.next/standalone/node_modules/next/dist/shared/lib/html-context.shared-runtime.js

@@ -28,11 +28,7 @@ if (process.env.NODE_ENV !== 'production') {
 function useHtmlContext() {
     const context = (0, _react.useContext)(HtmlContext);
     if (!context) {
-        throw Object.defineProperty(new Error(`<Html> should not be imported outside of pages/_document.\n` + 'Read more: https://nextjs.org/docs/messages/no-document-import-in-page'), "__NEXT_ERROR_CODE", {
-            value: "E67",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`<Html> should not be imported outside of pages/_document.\n` + 'Read more: https://nextjs.org/docs/messages/no-document-import-in-page');
     }
     return context;
 }

package/.next/standalone/node_modules/next/dist/shared/lib/image-config.js

@@ -4,7 +4,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     VALID_LOADERS: null,
-    imageConfigDefault: null
+    imageConfigDefault: null,
+    prepareImageConfig: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -18,6 +19,9 @@ _export(exports, {
     },
     imageConfigDefault: function() {
         return imageConfigDefault;
+    },
+    prepareImageConfig: function() {
+        return prepareImageConfig;
     }
 });
 const VALID_LOADERS = [
@@ -27,6 +31,53 @@ const VALID_LOADERS = [
     'akamai',
     'custom'
 ];
+const missingImageConfig = {};
+const preparedImageConfigs = new WeakMap();
+function prepareImageConfig(envConfig, contextConfig) {
+    const envKey = envConfig ?? missingImageConfig;
+    const contextKey = contextConfig ?? missingImageConfig;
+    let preparedByContext = preparedImageConfigs.get(envKey);
+    if (preparedByContext) {
+        const cached = preparedByContext.get(contextKey);
+        if (cached) {
+            return cached;
+        }
+    }
+    const source = envConfig || contextConfig || imageConfigDefault;
+    const deviceSizes = [
+        ...source.deviceSizes
+    ].sort((a, b)=>a - b);
+    const imageSizes = [
+        ...source.imageSizes
+    ];
+    const prepared = {
+        deviceSizes,
+        imageSizes,
+        allSizes: [
+            ...deviceSizes,
+            ...imageSizes
+        ].sort((a, b)=>a - b),
+        qualities: source.qualities === undefined ? undefined : [
+            ...source.qualities
+        ].sort((a, b)=>a - b),
+        path: source.path,
+        loader: source.loader,
+        dangerouslyAllowSVG: source.dangerouslyAllowSVG,
+        unoptimized: source.unoptimized,
+        domains: source.domains,
+        remotePatterns: source.remotePatterns,
+        // The inlined browser options supply their own patterns. During SSR the
+        // context supplies security-sensitive patterns omitted from the inline data.
+        localPatterns: typeof window === 'undefined' && contextConfig !== undefined ? contextConfig.localPatterns : source.localPatterns,
+        output: source.output
+    };
+    if (!preparedByContext) {
+        preparedByContext = new WeakMap();
+        preparedImageConfigs.set(envKey, preparedByContext);
+    }
+    preparedByContext.set(contextKey, prepared);
+    return prepared;
+}
 const imageConfigDefault = {
     deviceSizes: [
         640,

package/.next/standalone/node_modules/next/dist/shared/lib/instant-messages.js

@@ -26,18 +26,10 @@ function createUnrenderedSegmentError(route, missingFiles) {
         const label = missingFiles.length === 1 ? 'Dropped segment' : 'Dropped segments';
         message += `\n\nThis segment was dropped from rendering. Issues that would prevent instant navigation will go undetected.` + `\n\n${label}:\n${missingFiles.map((p)=>`  ${p}`).join('\n')}` + `\n\nWays to fix this:` + `\n  - [render] Render the dropped segment` + `\n  - [ignore] Set \`export const instant = false\` to opt the dropped segment out of instant-navigation validation` + `\n\nLearn more: https://nextjs.org/docs/messages/instant-unrendered-segment`;
     }
-    return Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E1286",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(message);
 }
 function createLinkPrefetchPartialError(pathname) {
-    return Object.defineProperty(new Error(`Next.js encountered dynamic data during prefetching for "${pathname}".\n\n` + `This will lead to slower, more expensive prefetches.\n\n` + `Ways to fix this:\n` + `  - [upgrade] Opt into Partial Prefetching by exporting \`const prefetch = 'partial'\` from the page or layout, or by setting \`partialPrefetching: true\` in next.config to opt the whole app in\n` + `  - [disable] Remove \`prefetch={true}\` from the <Link> to use the default prefetch\n` + `  - [ignore] Set \`export const instant = false\` to opt the route out of instant-navigation validation\n\n` + `Learn more: https://nextjs.org/docs/messages/instant-link-prefetch-partial`), "__NEXT_ERROR_CODE", {
-        value: "E1435",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`Next.js encountered dynamic data during prefetching for "${pathname}".\n\n` + `This will lead to slower, more expensive prefetches.\n\n` + `Ways to fix this:\n` + `  - [upgrade] Opt into Partial Prefetching by exporting \`const prefetch = 'partial'\` from the page or layout, or by setting \`partialPrefetching: true\` in next.config to opt the whole app in\n` + `  - [disable] Remove \`prefetch={true}\` from the <Link> to use the default prefetch\n` + `  - [ignore] Set \`export const instant = false\` to opt the route out of instant-navigation validation\n\n` + `Learn more: https://nextjs.org/docs/messages/instant-link-prefetch-partial`);
 }
 
 //# sourceMappingURL=instant-messages.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/invariant-error.js

@@ -11,11 +11,6 @@ Object.defineProperty(exports, "InvariantError", {
 class InvariantError extends Error {
     constructor(message, options){
         super(`Invariant: ${message.endsWith('.') ? message : message + '.'} This is a bug in Next.js.`, options);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E1179",
-            enumerable: false,
-            configurable: true
-        });
         this.name = 'InvariantError';
     }
 }

package/.next/standalone/node_modules/next/dist/shared/lib/lazy-dynamic/react-browser-bailout.js

@@ -0,0 +1,45 @@
+// This module is bundled separately into user code and the precompiled App
+// Router runtime. Use the global symbol registry so both copies recognize the
+// same browser bailout reason.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createReactBrowserBailoutReason: null,
+    getReactBrowserBailoutReason: null,
+    isNextBrowserBailoutError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createReactBrowserBailoutReason: function() {
+        return createReactBrowserBailoutReason;
+    },
+    getReactBrowserBailoutReason: function() {
+        return getReactBrowserBailoutReason;
+    },
+    isNextBrowserBailoutError: function() {
+        return isNextBrowserBailoutError;
+    }
+});
+const REACT_BROWSER_BAILOUT_REASON = Symbol.for('next.browser-bailout-reason');
+function createReactBrowserBailoutReason(reason) {
+    return {
+        $$typeof: REACT_BROWSER_BAILOUT_REASON,
+        reason
+    };
+}
+function getReactBrowserBailoutReason(error) {
+    const cause = error?.cause;
+    return cause?.$$typeof === REACT_BROWSER_BAILOUT_REASON ? cause.reason : undefined;
+}
+function isNextBrowserBailoutError(error) {
+    return getReactBrowserBailoutReason(error) !== undefined;
+}
+
+//# sourceMappingURL=react-browser-bailout.js.map