@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.3

package/assets/standalone/node_modules/next/dist/build/segment-config/app/app-segment-config.js

@@ -24,15 +24,13 @@ const _zod = require("next/dist/compiled/zod");
 const _zod1 = require("../../../shared/lib/zod");
 const CookieSchema = _zod.z.object({
     name: _zod.z.string(),
-    value: _zod.z.string(),
-    httpOnly: _zod.z.boolean().optional(),
-    path: _zod.z.string().optional()
+    value: _zod.z.string().or(_zod.z.null())
 }).strict();
 const RuntimeSampleSchema = _zod.z.object({
     cookies: _zod.z.array(CookieSchema).optional(),
     headers: _zod.z.array(_zod.z.tuple([
         _zod.z.string(),
-        _zod.z.string()
+        _zod.z.string().or(_zod.z.null())
     ])).optional(),
     params: _zod.z.record(_zod.z.union([
         _zod.z.string(),
@@ -41,23 +39,31 @@ const RuntimeSampleSchema = _zod.z.object({
     searchParams: _zod.z.record(_zod.z.union([
         _zod.z.string(),
         _zod.z.array(_zod.z.string()),
-        _zod.z.undefined()
+        _zod.z.null()
     ])).optional()
 }).strict();
-const StaticPrefetchSchema = _zod.z.object({
-    mode: _zod.z.literal('static'),
+const InstantConfigStaticSchema = _zod.z.object({
+    prefetch: _zod.z.literal('static'),
+    samples: _zod.z.array(RuntimeSampleSchema).min(1).optional(),
     from: _zod.z.array(_zod.z.string()).optional(),
-    expectUnableToVerify: _zod.z.boolean().optional()
+    unstable_disableValidation: _zod.z.literal(true).optional(),
+    unstable_disableDevValidation: _zod.z.literal(true).optional(),
+    unstable_disableBuildValidation: _zod.z.literal(true).optional()
 }).strict();
-const RuntimePrefetchSchema = _zod.z.object({
-    mode: _zod.z.literal('runtime'),
+const InstantConfigRuntimeSchema = _zod.z.object({
+    prefetch: _zod.z.literal('runtime'),
     samples: _zod.z.array(RuntimeSampleSchema).min(1),
     from: _zod.z.array(_zod.z.string()).optional(),
-    expectUnableToVerify: _zod.z.boolean().optional()
+    unstable_disableValidation: _zod.z.literal(true).optional(),
+    unstable_disableDevValidation: _zod.z.literal(true).optional(),
+    unstable_disableBuildValidation: _zod.z.literal(true).optional()
 }).strict();
-const PrefetchSchema = _zod.z.discriminatedUnion('mode', [
-    StaticPrefetchSchema,
-    RuntimePrefetchSchema
+const InstantConfigSchema = _zod.z.union([
+    _zod.z.discriminatedUnion('prefetch', [
+        InstantConfigStaticSchema,
+        InstantConfigRuntimeSchema
+    ]),
+    _zod.z.literal(false)
 ]);
 /**
  * The schema for configuration for a page.
@@ -92,7 +98,12 @@ const PrefetchSchema = _zod.z.discriminatedUnion('mode', [
     ]).optional(),
     /**
    * How this segment should be prefetched.
-   */ unstable_prefetch: PrefetchSchema.optional(),
+   */ unstable_instant: InstantConfigSchema.optional(),
+    /**
+   * The stale time for dynamic responses in seconds.
+   * Controls how long the client-side router cache retains dynamic page data.
+   * Pages only — not allowed in layouts.
+   */ unstable_dynamicStaleTime: _zod.z.number().int().nonnegative().optional(),
     /**
    * The preferred region for the page.
    */ preferredRegion: _zod.z.union([
@@ -120,11 +131,17 @@ function parseAppSegmentConfig(data, route) {
                                 message: `Invalid revalidate value ${JSON.stringify(ctx.data)} on "${route}", must be a non-negative number or false`
                             };
                         }
-                    case 'unstable_prefetch':
+                    case 'unstable_instant':
                         {
                             return {
                                 // @TODO replace this link with a link to the docs when they are written
-                                message: `Invalid unstable_prefetch value ${JSON.stringify(ctx.data)} on "${route}", must be an object with a mode of "static" or "runtime". Read more at https://nextjs.org/docs/messages/invalid-prefetch-configuration`
+                                message: `Invalid unstable_instant value ${JSON.stringify(ctx.data)} on "${route}", must be an object with \`prefetch: "static"\` or \`prefetch: "runtime"\`, or \`false\`. Read more at https://nextjs.org/docs/messages/invalid-instant-configuration`
+                            };
+                        }
+                    case 'unstable_dynamicStaleTime':
+                        {
+                            return {
+                                message: `Invalid unstable_dynamicStaleTime value ${JSON.stringify(ctx.data)} on "${route}", must be a non-negative number`
                             };
                         }
                     default:

package/assets/standalone/node_modules/next/dist/build/static-paths/app.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    assignErrorIfEmpty: null,
+    assignStaticShellMetadata: null,
     buildAppStaticPaths: null,
     calculateFallbackMode: null,
     filterUniqueParams: null,
@@ -17,8 +17,8 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    assignErrorIfEmpty: function() {
-        return assignErrorIfEmpty;
+    assignStaticShellMetadata: function() {
+        return assignStaticShellMetadata;
     },
     buildAppStaticPaths: function() {
         return buildAppStaticPaths;
@@ -46,6 +46,7 @@ const _createincrementalcache = require("../../export/helpers/create-incremental
 const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
 const _emptygeneratestaticparamserror = require("../../shared/lib/errors/empty-generate-static-params-error");
 const _interceptionprefixfromparamtype = require("../../shared/lib/router/utils/interception-prefix-from-param-type");
+const _implicittags = require("../../server/lib/implicit-tags");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -280,7 +281,7 @@ function calculateFallbackMode(dynamicParams, fallbackRootParams, baseFallbackMo
     }
     return valid;
 }
-function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
+function assignStaticShellMetadata(prerenderedRoutes, pathnameSegments, computeRemainingPrerenderableParams) {
     // If there are no routes to process, exit early.
     if (prerenderedRoutes.length === 0) {
         return;
@@ -391,6 +392,31 @@ function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
                     route.throwOnEmptyStaticShell = true // Should throw on empty static shell.
                     ;
                 }
+                if (computeRemainingPrerenderableParams && route.fallbackRouteParams && route.fallbackRouteParams.length > 0) {
+                    const fallbackRouteParamsByName = new Map(route.fallbackRouteParams.map((param)=>[
+                            param.paramName,
+                            param
+                        ]));
+                    const remainingPrerenderableParams = [];
+                    // Only unresolved pathname params that can still be filled by
+                    // generateStaticParams belong here. Once we hit an unresolved param
+                    // that is purely dynamic, the rest of the shell also stays dynamic
+                    // and cannot be completed into a more specific prerendered shell.
+                    for (const segment of pathnameSegments){
+                        if (route.params.hasOwnProperty(segment.paramName)) {
+                            continue;
+                        }
+                        if (!segment.hasGenerateStaticParams) {
+                            break;
+                        }
+                        const fallbackRouteParam = fallbackRouteParamsByName.get(segment.paramName);
+                        if (!fallbackRouteParam) {
+                            break;
+                        }
+                        remainingPrerenderableParams.push(fallbackRouteParam);
+                    }
+                    route.remainingPrerenderableParams = remainingPrerenderableParams.length > 0 ? remainingPrerenderableParams : undefined;
+                }
             }
         }
         // Add all children of the current node to the stack. This ensures that
@@ -400,9 +426,30 @@ function assignErrorIfEmpty(prerenderedRoutes, pathnameSegments) {
         }
     }
 }
-async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
+/**
+ * Calls a single generateStaticParams function within a WorkUnitStore context,
+ * making root param getters available during static param generation.
+ */ async function callGenerateStaticParams(generateStaticParams, workUnitAsyncStorage, parentParams, rootParamKeys, implicitTags) {
+    const rootParams = {};
+    for (const key of rootParamKeys){
+        if (key in parentParams) {
+            rootParams[key] = parentParams[key];
+        }
+    }
+    const workUnitStore = {
+        type: 'generate-static-params',
+        phase: 'render',
+        implicitTags,
+        rootParams
+    };
+    return workUnitAsyncStorage.run(workUnitStore, generateStaticParams, {
+        params: parentParams
+    });
+}
+async function generateRouteStaticParams(segments, store, workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys) {
     // Early return if no segments to process
     if (segments.length === 0) return [];
+    const implicitTags = await (0, _implicittags.getImplicitTags)(store.page, store.page, null);
     const queue = [
         {
             segmentIndex: 0,
@@ -436,9 +483,7 @@ async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
         if (params.length > 0) {
             // Process each parent parameter combination
             for (const parentParams of params){
-                const result = await current.generateStaticParams({
-                    params: parentParams
-                });
+                const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, parentParams, rootParamKeys, implicitTags);
                 if (result.length > 0) {
                     // Merge parent params with each result item
                     for (const item of result){
@@ -456,9 +501,7 @@ async function generateRouteStaticParams(segments, store, isRoutePPREnabled) {
             }
         } else {
             // No parent params, call generateStaticParams with empty object
-            const result = await current.generateStaticParams({
-                params: {}
-            });
+            const result = await callGenerateStaticParams(current.generateStaticParams, workUnitAsyncStorage, {}, rootParamKeys, implicitTags);
             if (result.length === 0 && isRoutePPREnabled) {
                 (0, _emptygeneratestaticparamserror.throwEmptyGenerateStaticParamsError)();
             }
@@ -488,7 +531,7 @@ function createReplacements(segment, paramValue) {
         encodeURIComponent)
     };
 }
-async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, buildId, rootParamKeys }) {
+async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents, authInterrupts, segments, isrFlushToDisk, cacheHandler, cacheLifeProfiles, requestHeaders, cacheHandlers, cacheMaxMemorySize, fetchCacheKeyPrefix, nextConfigOutput, ComponentMod, isRoutePPREnabled = false, partialFallbacksEnabled = false, buildId, rootParamKeys }) {
     if (segments.some((generate)=>{
         var _generate_config;
         return ((_generate_config = generate.config) == null ? void 0 : _generate_config.dynamicParams) === true;
@@ -533,7 +576,17 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         buildId,
         previouslyRevalidatedTags: []
     });
-    const routeParams = await ComponentMod.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, isRoutePPREnabled);
+    const routeParams = await ComponentMod.workAsyncStorage.run(store, generateRouteStaticParams, segments, store, ComponentMod.workUnitAsyncStorage, isRoutePPREnabled, rootParamKeys);
+    const generatedParamNames = new Set();
+    for (const params of routeParams){
+        for (const paramName of Object.keys(params)){
+            generatedParamNames.add(paramName);
+        }
+    }
+    const prerenderablePathSegments = pathnameRouteParamSegments.map((segment)=>({
+            paramName: segment.paramName,
+            hasGenerateStaticParams: generatedParamNames.has(segment.paramName)
+        }));
     await afterRunner.executeAfter();
     let lastDynamicSegmentHadGenerateStaticParams = false;
     for (const segment of segments){
@@ -572,7 +625,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
         var _segment_config;
         return ((_segment_config = segment.config) == null ? void 0 : _segment_config.dynamicParams) !== false;
     });
-    const supportsRoutePreGeneration = hadAllParamsGenerated || process.env.NODE_ENV === 'production';
+    const supportsRoutePreGeneration = hadAllParamsGenerated || !process.env.__NEXT_DEV_SERVER;
     const fallbackMode = dynamicParams ? supportsRoutePreGeneration ? isRoutePPREnabled ? _fallback.FallbackMode.PRERENDER : _fallback.FallbackMode.BLOCKING_STATIC_RENDER : undefined : _fallback.FallbackMode.NOT_FOUND;
     const prerenderedRoutesByPathname = new Map();
     // Convert rootParamKeys to Set for O(1) lookup.
@@ -671,7 +724,7 @@ async function buildAppStaticPaths({ dir, page, route, distDir, cacheComponents,
     ] : undefined;
     // Now we have to set the throwOnEmptyStaticShell for each of the routes.
     if (prerenderedRoutes && cacheComponents) {
-        assignErrorIfEmpty(prerenderedRoutes, pathnameRouteParamSegments);
+        assignStaticShellMetadata(prerenderedRoutes, prerenderablePathSegments, partialFallbacksEnabled);
     }
     return {
         fallbackMode,

package/assets/standalone/node_modules/next/dist/build/static-paths/pages.js

@@ -38,7 +38,7 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
     const expectedReturnVal = `Expected: { paths: [], fallback: boolean }\n` + `See here for more info: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`;
     if (!staticPathsResult || typeof staticPathsResult !== 'object' || Array.isArray(staticPathsResult)) {
         throw Object.defineProperty(new Error(`Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E241",
+            value: "E1004",
             enumerable: false,
             configurable: true
         });
@@ -46,14 +46,14 @@ async function buildPagesStaticPaths({ page, getStaticPaths, configFileName, loc
     const invalidStaticPathKeys = Object.keys(staticPathsResult).filter((key)=>!(key === 'paths' || key === 'fallback'));
     if (invalidStaticPathKeys.length > 0) {
         throw Object.defineProperty(new Error(`Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(', ')}) ${expectedReturnVal}`), "__NEXT_ERROR_CODE", {
-            value: "E38",
+            value: "E1047",
             enumerable: false,
             configurable: true
         });
     }
     if (!(typeof staticPathsResult.fallback === 'boolean' || staticPathsResult.fallback === 'blocking')) {
         throw Object.defineProperty(new Error(`The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` + expectedReturnVal), "__NEXT_ERROR_CODE", {
-            value: "E243",
+            value: "E1034",
             enumerable: false,
             configurable: true
         });