failproofai 1.0.11-beta.1 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/server/client-component-renderer-logger.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    ClientComponentLoadTracker: null,
     getClientComponentLoaderMetrics: null,
     wrapClientComponentLoader: null
 });
@@ -13,6 +14,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    ClientComponentLoadTracker: function() {
+        return ClientComponentLoadTracker;
+    },
     getClientComponentLoaderMetrics: function() {
         return getClientComponentLoaderMetrics;
     },
@@ -20,49 +24,146 @@ _export(exports, {
         return wrapClientComponentLoader;
     }
 });
-// Combined load times for loading client components
-let clientComponentLoadStart = 0;
-let clientComponentLoadTimes = 0;
-let clientComponentLoadCount = 0;
-function wrapClientComponentLoader(ComponentMod, isTracingEnabled) {
-    if (!('performance' in globalThis) || !process.env.NEXT_OTEL_PERFORMANCE_PREFIX && !isTracingEnabled) {
+const _workasyncstorageexternal = require("./app-render/work-async-storage.external");
+class ClientComponentLoadTracker {
+    constructor(report = ()=>{}){
+        this.report = report;
+        this.clientComponentLoadStart = 0;
+        this.clientComponentLoadEnd = 0;
+        this.clientComponentLoadTimes = 0;
+        this.clientComponentLoadCount = 0;
+        this.hasLoads = false;
+        this.pending = 0;
+        this.sealed = false;
+        this.resolveCompletion = undefined;
+    }
+    isSealed() {
+        return this.sealed;
+    }
+    beginRequire(startTime) {
+        this.recordStart(startTime);
+        this.clientComponentLoadCount++;
+        this.pending++;
+    }
+    finishRequire(startTime, endTime) {
+        this.recordSettlement(startTime, endTime);
+    }
+    beginChunk(startTime) {
+        this.recordStart(startTime);
+        this.pending++;
+    }
+    finishChunk(startTime, endTime) {
+        this.recordSettlement(startTime, endTime);
+    }
+    snapshot() {
+        if (!this.hasLoads) {
+            return undefined;
+        }
+        return {
+            clientComponentLoadStart: this.clientComponentLoadStart,
+            clientComponentLoadEnd: this.clientComponentLoadEnd,
+            clientComponentLoadTimes: this.clientComponentLoadTimes,
+            clientComponentLoadCount: this.clientComponentLoadCount
+        };
+    }
+    /** Stop accepting new loads and report after any in-flight loads settle. */ finish() {
+        if (this.sealed) return;
+        this.sealed = true;
+        let completion;
+        if (this.pending === 0) {
+            completion = Promise.resolve(this.snapshot());
+        } else {
+            completion = new Promise((resolve)=>{
+                this.resolveCompletion = resolve;
+            });
+        }
+        // Telemetry is best-effort and must not keep the response open or mask a
+        // render error, including when reporting fails.
+        void completion.then(this.report).catch((error)=>{
+            console.error('Failed to report client component loading metrics:', error);
+        });
+    }
+    recordStart(startTime) {
+        if (!this.hasLoads) {
+            this.hasLoads = true;
+            this.clientComponentLoadStart = startTime;
+        }
+    }
+    recordSettlement(startTime, endTime) {
+        this.clientComponentLoadEnd = endTime;
+        this.clientComponentLoadTimes += endTime - startTime;
+        this.pending--;
+        if (this.sealed && this.pending === 0 && this.resolveCompletion) {
+            const resolve = this.resolveCompletion;
+            this.resolveCompletion = undefined;
+            resolve(this.snapshot());
+        }
+    }
+}
+function wrapClientComponentLoader(ComponentMod) {
+    if (!('performance' in globalThis)) {
         return ComponentMod.__next_app__;
     }
     return {
         require: (...args)=>{
-            const startTime = performance.now();
-            if (clientComponentLoadStart === 0) {
-                clientComponentLoadStart = startTime;
+            var _workAsyncStorage_getStore;
+            const tracker = (_workAsyncStorage_getStore = _workasyncstorageexternal.workAsyncStorage.getStore()) == null ? void 0 : _workAsyncStorage_getStore.clientComponentLoadTracker;
+            if (tracker === undefined || tracker.isSealed()) {
+                return ComponentMod.__next_app__.require(...args);
             }
+            const startTime = performance.now();
+            tracker.beginRequire(startTime);
+            let result;
             try {
-                clientComponentLoadCount += 1;
-                return ComponentMod.__next_app__.require(...args);
-            } finally{
-                clientComponentLoadTimes += performance.now() - startTime;
+                result = ComponentMod.__next_app__.require(...args);
+            } catch (error) {
+                tracker.finishRequire(startTime, performance.now());
+                throw error;
             }
+            // Webpack and Turbopack return native Promises for async modules. A
+            // synchronous module may export `then`, so do not probe arbitrary exports.
+            if (result instanceof Promise) {
+                const onSettled = ()=>{
+                    tracker.finishRequire(startTime, performance.now());
+                };
+                result.then(onSettled, onSettled);
+            } else {
+                tracker.finishRequire(startTime, performance.now());
+            }
+            return result;
         },
         loadChunk: (...args)=>{
+            var _workAsyncStorage_getStore;
+            const tracker = (_workAsyncStorage_getStore = _workasyncstorageexternal.workAsyncStorage.getStore()) == null ? void 0 : _workAsyncStorage_getStore.clientComponentLoadTracker;
+            if (tracker === undefined || tracker.isSealed()) {
+                return ComponentMod.__next_app__.loadChunk(...args);
+            }
             const startTime = performance.now();
-            const result = ComponentMod.__next_app__.loadChunk(...args);
-            // Avoid wrapping `loadChunk`'s result in an extra promise in case something like React depends on its identity.
-            // We only need to know when it's settled.
-            result.finally(()=>{
-                clientComponentLoadTimes += performance.now() - startTime;
-            });
+            tracker.beginChunk(startTime);
+            let result;
+            try {
+                result = ComponentMod.__next_app__.loadChunk(...args);
+            } catch (error) {
+                tracker.finishChunk(startTime, performance.now());
+                throw error;
+            }
+            // React can depend on the original promise identity.
+            const onSettled = ()=>{
+                tracker.finishChunk(startTime, performance.now());
+            };
+            result.then(onSettled, onSettled);
             return result;
         }
     };
 }
 function getClientComponentLoaderMetrics(options = {}) {
-    const metrics = clientComponentLoadStart === 0 ? undefined : {
-        clientComponentLoadStart,
-        clientComponentLoadTimes,
-        clientComponentLoadCount
-    };
-    if (options.reset) {
-        clientComponentLoadStart = 0;
-        clientComponentLoadTimes = 0;
-        clientComponentLoadCount = 0;
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const tracker = workStore == null ? void 0 : workStore.clientComponentLoadTracker;
+    const metrics = tracker == null ? void 0 : tracker.snapshot();
+    if (options.reset && workStore) {
+        // Pending settlements still hold their original tracker. Detaching it only
+        // affects subsequent reads and loads in this render.
+        workStore.clientComponentLoadTracker = undefined;
     }
     return metrics;
 }

package/.next/standalone/node_modules/next/dist/server/config-schema.js

@@ -36,6 +36,7 @@ const zExportMap = _zod.z.record(_zod.z.string(), _zod.z.object({
     query: _zod.z.any(),
     // private optional properties
     _fallbackRouteParams: _zod.z.array(_zod.z.any()).optional(),
+    _notFoundParams: _zod.z.array(_zod.z.string()).optional(),
     _isAppDir: _zod.z.boolean().optional(),
     _isDynamicError: _zod.z.boolean().optional(),
     _isRoutePPREnabled: _zod.z.boolean().optional(),
@@ -146,10 +147,12 @@ const zTurbopackModuleType = _zod.z.enum([
     'typescript',
     'css',
     'css-module',
+    'json',
     'wasm',
     'raw',
     'node',
-    'bytes'
+    'bytes',
+    'text'
 ]);
 const zTurbopackRuleConfigItem = _zod.z.strictObject({
     loaders: _zod.z.array(zTurbopackLoaderItem).optional(),
@@ -167,9 +170,11 @@ const zTurbopackRuleConfigCollection = _zod.z.union([
 const zTurbopackConfig = _zod.z.strictObject({
     rules: _zod.z.record(_zod.z.string(), zTurbopackRuleConfigCollection).optional(),
     resolveAlias: _zod.z.record(_zod.z.string(), _zod.z.union([
+        _zod.z.literal(false),
         _zod.z.string(),
         _zod.z.array(_zod.z.string()),
         _zod.z.record(_zod.z.string(), _zod.z.union([
+            _zod.z.literal(false),
             _zod.z.string(),
             _zod.z.array(_zod.z.string())
         ]))
@@ -194,12 +199,26 @@ const zTurbopackConfig = _zod.z.strictObject({
     })).optional()
 });
 const experimentalSchema = {
+    agentUpgrade: _zod.z.union([
+        _zod.z.enum([
+            'security',
+            'latest',
+            'experimental-future'
+        ]),
+        _zod.z.literal(false)
+    ]).optional(),
+    agentFeedback: _zod.z.boolean().optional(),
+    turbopackAdditionalRoots: _zod.z.record(_zod.z.string(), _zod.z.strictObject({
+        path: _zod.z.string(),
+        ignoreIfMissing: _zod.z.boolean().optional()
+    })).optional(),
     outputHashSalt: _zod.z.string().optional(),
     useSkewCookie: _zod.z.boolean().optional(),
     after: _zod.z.boolean().optional(),
     appNavFailHandling: _zod.z.boolean().optional(),
-    appNewScrollHandler: _zod.z.boolean().optional(),
+    parallelRouteMetadata: _zod.z.boolean().optional(),
     coldCacheBadge: _zod.z.boolean().optional(),
+    collapseAdapterRoutes: _zod.z.boolean().optional(),
     preloadEntriesOnStart: _zod.z.boolean().optional(),
     allowedRevalidateHeaderKeys: _zod.z.array(_zod.z.string()).optional(),
     staleTimes: _zod.z.object({
@@ -222,8 +241,10 @@ const experimentalSchema = {
     clientParamParsingOrigins: _zod.z.array(_zod.z.string()).optional(),
     cachedNavigations: _zod.z.boolean().optional(),
     dynamicOnHover: _zod.z.boolean().optional(),
+    reactBrowserBailout: _zod.z.boolean().optional(),
     useOffline: _zod.z.boolean().optional(),
     optimisticRouting: _zod.z.boolean().optional(),
+    concurrentRouterQueue: _zod.z.boolean().optional(),
     instrumentationClientRouterTransitionEvents: _zod.z.boolean().optional(),
     varyParams: _zod.z.boolean().optional(),
     prefetchInlining: _zod.z.union([
@@ -247,6 +268,7 @@ const experimentalSchema = {
         allowedOrigins: _zod.z.array(_zod.z.string()).optional()
     }).optional(),
     maxPostponedStateSize: zSizeLimit.optional(),
+    disableResumeDataCacheCompression: _zod.z.boolean().optional(),
     // The original type was Record<string, any>
     extensionAlias: _zod.z.record(_zod.z.string(), _zod.z.any()).optional(),
     externalDir: _zod.z.boolean().optional(),
@@ -264,6 +286,7 @@ const experimentalSchema = {
     imgOptTimeoutInSeconds: _zod.z.number().int().optional(),
     imgOptMaxInputPixels: _zod.z.number().int().optional(),
     imgOptSequentialRead: _zod.z.boolean().optional().nullable(),
+    imgOptMozjpeg: _zod.z.boolean().optional(),
     isrFlushToDisk: _zod.z.boolean().optional(),
     largePageDataBytes: _zod.z.number().optional(),
     linkNoTouchStart: _zod.z.boolean().optional(),
@@ -315,6 +338,7 @@ const experimentalSchema = {
     proxyTimeout: _zod.z.number().gte(0).optional(),
     rootParams: _zod.z.boolean().optional(),
     mcpServer: _zod.z.boolean().optional(),
+    exposeRuntimeErrorsToHMR: _zod.z.boolean().optional(),
     removeUncaughtErrorAndRejectionListeners: _zod.z.boolean().optional(),
     validateRSCRequestHeaders: _zod.z.boolean().optional(),
     scrollRestoration: _zod.z.boolean().optional(),
@@ -351,7 +375,6 @@ const experimentalSchema = {
     webVitalsAttribution: _zod.z.array(_zod.z.union([
         _zod.z.literal('CLS'),
         _zod.z.literal('FCP'),
-        _zod.z.literal('FID'),
         _zod.z.literal('INP'),
         _zod.z.literal('LCP'),
         _zod.z.literal('TTFB')
@@ -381,14 +404,30 @@ const experimentalSchema = {
         _zod.z.literal('full'),
         _zod.z.literal('auto')
     ]).optional(),
+    turbopackGc: _zod.z.union([
+        _zod.z.boolean(),
+        _zod.z.strictObject({
+            minProgressMs: _zod.z.number().min(0).finite().optional(),
+            rootTtlMs: _zod.z.number().min(0).finite().optional()
+        })
+    ]).optional(),
     turbopackPluginRuntimeStrategy: _zod.z.enum([
         'workerThreads',
-        'childProcesses'
+        'childProcesses',
+        'forceWorkerThreads'
+    ]).optional(),
+    turbopackMinify: _zod.z.union([
+        _zod.z.boolean(),
+        _zod.z.strictObject({
+            server: _zod.z.boolean().optional(),
+            client: _zod.z.boolean().optional(),
+            edge: _zod.z.boolean().optional()
+        })
     ]).optional(),
-    turbopackMinify: _zod.z.boolean().optional(),
     turbopackFileSystemCacheForDev: _zod.z.boolean().optional(),
     turbopackFileSystemCacheForBuild: _zod.z.boolean().optional(),
     turbopackSeedCacheFromWorktree: _zod.z.boolean().optional(),
+    turbopackStaleOutputMaxAge: _zod.z.number().min(0).finite().optional(),
     turbopackSourceMaps: _zod.z.boolean().optional(),
     turbopackInputSourceMaps: _zod.z.boolean().optional(),
     turbopackModuleFragments: _zod.z.boolean().optional(),
@@ -397,6 +436,7 @@ const experimentalSchema = {
     turbopackScopeHoisting: _zod.z.boolean().optional(),
     turbopackSharedRuntime: _zod.z.boolean().optional(),
     turbopackChunking: _zod.z.object({
+        clusters: _zod.z.array(_zod.z.array(_zod.z.instanceof(RegExp))).optional(),
         firstPageLoadPriority: _zod.z.number().min(0).max(1).optional(),
         priorityRoutes: _zod.z.array(_zod.z.instanceof(RegExp)).optional(),
         priorityBoost: _zod.z.number().min(1).optional(),
@@ -410,6 +450,8 @@ const experimentalSchema = {
     turbopackWorkerAssetPrefix: _zod.z.string().optional(),
     turbopackClientSideNestedAsyncChunking: _zod.z.boolean().optional(),
     turbopackServerSideNestedAsyncChunking: _zod.z.boolean().optional(),
+    turbopackLazyDynamicImports: _zod.z.boolean().optional(),
+    turbopackLazyDynamicImportsSSR: _zod.z.boolean().optional(),
     turbopackImportTypeBytes: _zod.z.boolean().optional(),
     turbopackUseBuiltinBabel: _zod.z.boolean().optional(),
     turbopackUseBuiltinSass: _zod.z.boolean().optional(),
@@ -420,6 +462,10 @@ const experimentalSchema = {
     ]).optional(),
     turbopackInferModuleSideEffects: _zod.z.boolean().optional(),
     turbopackCjsTreeShaking: _zod.z.boolean().optional(),
+    turbopackMangleExportNames: _zod.z.boolean().optional(),
+    turbopackMangleViaMaterializedNamespaceObject: _zod.z.boolean().optional(),
+    turbopackCjsScopeHoisting: _zod.z.boolean().optional(),
+    turbopackCrossModuleConstants: _zod.z.boolean().optional(),
     turbopackServerFastRefresh: _zod.z.boolean().optional(),
     optimizePackageImports: _zod.z.array(_zod.z.string()).optional(),
     optimizeServerReact: _zod.z.boolean().optional(),
@@ -456,11 +502,14 @@ const experimentalSchema = {
     authInterrupts: _zod.z.boolean().optional(),
     useCache: _zod.z.boolean().optional(),
     durableUseCacheEntries: _zod.z.boolean().optional(),
+    useCacheStaticRootParamTracking: _zod.z.boolean().optional(),
     useCacheTimeout: _zod.z.number().positive().optional(),
     slowModuleDetection: _zod.z.object({
         buildTimeThresholdMs: _zod.z.number().int()
     }).optional(),
     globalNotFound: _zod.z.boolean().optional(),
+    explicitParallelRouteChildren: _zod.z.boolean().optional(),
+    strictRouteMatching: _zod.z.boolean().optional(),
     turbopackRustReactCompiler: _zod.z.boolean().optional(),
     browserDebugInfoInTerminal: _zod.z.union([
         _zod.z.boolean(),
@@ -592,6 +641,9 @@ const configSchema = _zod.z.lazy(()=>_zod.z.strictObject({
             _zod.z.literal('anonymous'),
             _zod.z.literal('use-credentials')
         ]).optional(),
+        deprecated: _zod.z.strictObject({
+            looseRouteMatching: _zod.z.literal(true).optional()
+        }).optional(),
         deploymentId: _zod.z.string().optional(),
         supportsImmutableAssets: _zod.z.boolean().optional(),
         outputHashSalt: _zod.z.string().optional(),
@@ -737,10 +789,7 @@ const configSchema = _zod.z.lazy(()=>_zod.z.strictObject({
         outputFileTracingIncludes: _zod.z.record(_zod.z.string(), _zod.z.array(_zod.z.string())).optional(),
         pageExtensions: _zod.z.array(_zod.z.string()).min(1).optional(),
         instrumentationClientInject: _zod.z.array(_zod.z.string()).optional(),
-        partialPrefetching: _zod.z.union([
-            _zod.z.boolean(),
-            _zod.z.literal('unstable_eager')
-        ]).optional(),
+        partialPrefetching: _zod.z.boolean().optional(),
         poweredByHeader: _zod.z.boolean().optional(),
         productionBrowserSourceMaps: _zod.z.boolean().optional(),
         reactCompiler: _zod.z.union([
@@ -751,6 +800,9 @@ const configSchema = _zod.z.lazy(()=>_zod.z.strictObject({
                     'annotation',
                     'all'
                 ]).optional(),
+                environment: _zod.z.object({
+                    enablePreserveExistingMemoizationGuarantees: _zod.z.boolean().optional()
+                }).optional(),
                 panicThreshold: _zod.z.enum([
                     'none',
                     'critical_errors',

package/.next/standalone/node_modules/next/dist/server/config-shared.js

@@ -102,7 +102,6 @@ const defaultConfig = Object.freeze({
     cacheMaxMemorySize: 50 * 1024 * 1024,
     configOrigin: 'default',
     useFileSystemPublicRoutes: true,
-    generateBuildId: ()=>null,
     generateEtags: true,
     pageExtensions: [
         'tsx',
@@ -188,14 +187,18 @@ const defaultConfig = Object.freeze({
         static: process.env.NEXT_STATIC_CACHE_HANDLER_PATH
     },
     adapterPath: process.env.NEXT_ADAPTER_PATH || undefined,
+    deprecated: {},
     experimental: {
-        appNewScrollHandler: true,
+        agentUpgrade: 'security',
+        agentFeedback: false,
         coldCacheBadge: false,
+        collapseAdapterRoutes: true,
         devValidationWorker: true,
         useSkewCookie: false,
         cssChunking: true,
         multiZoneDraftMode: false,
         appNavFailHandling: false,
+        parallelRouteMetadata: false,
         prerenderEarlyExit: true,
         serverMinification: true,
         linkNoTouchStart: false,
@@ -203,9 +206,11 @@ const defaultConfig = Object.freeze({
         clientParamParsingOrigins: undefined,
         cachedNavigations: false,
         dynamicOnHover: false,
+        reactBrowserBailout: true,
         useOffline: false,
         varyParams: true,
         optimisticRouting: true,
+        concurrentRouterQueue: false,
         instrumentationClientRouterTransitionEvents: false,
         prefetchInlining: true,
         preloadEntriesOnStart: true,
@@ -224,6 +229,7 @@ const defaultConfig = Object.freeze({
         imgOptTimeoutInSeconds: 7,
         imgOptMaxInputPixels: 268402689,
         imgOptSequentialRead: null,
+        imgOptMozjpeg: true,
         isrFlushToDisk: true,
         workerThreads: false,
         proxyTimeout: undefined,
@@ -272,17 +278,28 @@ const defaultConfig = Object.freeze({
         gestureTransition: false,
         inlineCss: false,
         useCache: undefined,
+        useCacheStaticRootParamTracking: false,
         slowModuleDetection: undefined,
         globalNotFound: false,
+        explicitParallelRouteChildren: true,
+        strictRouteMatching: true,
         browserDebugInfoInTerminal: 'warn',
         lockDistDir: true,
+        disableResumeDataCacheCompression: false,
         proxyClientMaxBodySize: 10485760,
         hideLogsAfterAbort: false,
         mcpServer: true,
+        exposeRuntimeErrorsToHMR: false,
         turbopackFileSystemCacheForDev: true,
         turbopackFileSystemCacheForBuild: true,
+        turbopackStaleOutputMaxAge: 7 * 24 * 60 * 60 * 1000,
         turbopackInferModuleSideEffects: true,
-        turbopackPluginRuntimeStrategy: 'childProcesses'
+        turbopackPluginRuntimeStrategy: 'childProcesses',
+        turbopackSharedRuntime: true,
+        // Left unset so the Turbopack side picks the default from the build mode (on for production
+        // builds, off in development) — see `NextConfig::turbopack_mangle_export_names`. An explicit
+        // value always wins either way.
+        turbopackMangleExportNames: undefined
     },
     htmlLimitedBots: undefined,
     bundlePagesRouterDependencies: false
@@ -303,17 +320,20 @@ function getNextConfigRuntime(config) {
     }
     const ex = config.experimental;
     const experimental = {
-        ppr: ex.ppr,
         taint: ex.taint,
+        agentFeedback: ex.agentFeedback,
         serverActions: ex.serverActions,
         staleTimes: ex.staleTimes,
         dynamicOnHover: ex.dynamicOnHover,
         useOffline: ex.useOffline,
         optimisticRouting: ex.optimisticRouting,
+        parallelRouteMetadata: ex.parallelRouteMetadata,
         inlineCss: ex.inlineCss,
         prefetchInlining: ex.prefetchInlining,
         authInterrupts: ex.authInterrupts,
+        reactBrowserBailout: ex.reactBrowserBailout,
         useCacheTimeout: ex.useCacheTimeout,
+        durableUseCacheEntries: ex.durableUseCacheEntries,
         clientTraceMetadata: ex.clientTraceMetadata,
         clientParamParsingOrigins: ex.clientParamParsingOrigins,
         allowedRevalidateHeaderKeys: ex.allowedRevalidateHeaderKeys,
@@ -337,11 +357,13 @@ function getNextConfigRuntime(config) {
         imgOptMaxInputPixels: ex.imgOptMaxInputPixels,
         imgOptSequentialRead: ex.imgOptSequentialRead,
         imgOptTimeoutInSeconds: ex.imgOptTimeoutInSeconds,
+        imgOptMozjpeg: ex.imgOptMozjpeg,
         proxyClientMaxBodySize: ex.proxyClientMaxBodySize,
         proxyTimeout: ex.proxyTimeout,
         testProxy: ex.testProxy,
         runtimeServerDeploymentId: ex.runtimeServerDeploymentId,
         maxPostponedStateSize: ex.maxPostponedStateSize,
+        disableResumeDataCacheCompression: ex.disableResumeDataCacheCompression,
         cachedNavigations: ex.cachedNavigations,
         exposeTestingApiInProductionBuild: ex.exposeTestingApiInProductionBuild,
         instantInsights: ex.instantInsights,