failproofai 0.0.1-beta.1

package/.next/standalone/node_modules/next/dist/lib/typescript/runTypeCheck.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runTypeCheck", {
+    enumerable: true,
+    get: function() {
+        return runTypeCheck;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _diagnosticFormatter = require("./diagnosticFormatter");
+const _getTypeScriptConfiguration = require("./getTypeScriptConfiguration");
+const _writeConfigurationDefaults = require("./writeConfigurationDefaults");
+const _typepaths = require("./type-paths");
+const _compileerror = require("../compile-error");
+const _log = require("../../build/output/log");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * Check if a file path matches any of the debug build paths.
+ * Both filePath and debugPaths are resolved file paths from glob.
+ */ function fileMatchesDebugPaths(filePath, debugPaths) {
+    return debugPaths.includes(filePath);
+}
+async function runTypeCheck(typescript, baseDir, distDir, tsConfigPath, cacheDir, isAppDirEnabled, dirs, debugBuildPaths) {
+    const effectiveConfiguration = await (0, _getTypeScriptConfiguration.getTypeScriptConfiguration)(typescript, tsConfigPath);
+    // tsconfig includes both .next/types and .next/dev/types to avoid config churn
+    // between dev/build modes. During build, we filter out .next/dev/types files to
+    // prevent stale dev types from causing errors when routes have been deleted since
+    // the last dev session.
+    let fileNames = effectiveConfiguration.fileNames;
+    // Get the dev types path to filter (null if not applicable)
+    const devTypesDir = (0, _typepaths.getDevTypesPath)(baseDir, distDir);
+    if (devTypesDir) {
+        fileNames = fileNames.filter((fileName)=>!fileName.startsWith(devTypesDir));
+    }
+    // Apply debug build paths filter if specified
+    if (dirs && debugBuildPaths) {
+        const { app: appDir, pages: pagesDir } = dirs;
+        const { app: debugAppPaths, pages: debugPagePaths } = debugBuildPaths;
+        fileNames = fileNames.filter((fileName)=>{
+            // Check if file is in app directory
+            if (appDir && fileName.startsWith(appDir + _path.default.sep)) {
+                // If debugAppPaths is undefined, include all app files
+                if (debugAppPaths === undefined) {
+                    return true;
+                }
+                // If debugAppPaths is empty array, exclude all app files
+                if (debugAppPaths.length === 0) {
+                    return false;
+                }
+                // Check if file matches any of the debug paths
+                const relativeToApp = fileName.slice(appDir.length);
+                return fileMatchesDebugPaths(relativeToApp, debugAppPaths);
+            }
+            // Check if file is in pages directory
+            if (pagesDir && fileName.startsWith(pagesDir + _path.default.sep)) {
+                // If debugPagePaths is undefined, include all pages files
+                if (debugPagePaths === undefined) {
+                    return true;
+                }
+                // If debugPagePaths is empty array, exclude all pages files
+                if (debugPagePaths.length === 0) {
+                    return false;
+                }
+                // Check if file matches any of the debug paths
+                const relativeToPages = fileName.slice(pagesDir.length);
+                return fileMatchesDebugPaths(relativeToPages, debugPagePaths);
+            }
+            // Keep files outside app/pages directories (shared code, etc.)
+            return true;
+        });
+    }
+    if (fileNames.length < 1) {
+        return {
+            hasWarnings: false,
+            inputFilesCount: 0,
+            totalFilesCount: 0,
+            incremental: false
+        };
+    }
+    const requiredConfig = (0, _writeConfigurationDefaults.getRequiredConfiguration)(typescript);
+    const options = {
+        ...requiredConfig,
+        ...effectiveConfiguration.options,
+        declarationMap: false,
+        emitDeclarationOnly: false,
+        noEmit: true
+    };
+    let program;
+    let incremental = false;
+    if ((options.incremental || options.composite) && cacheDir) {
+        if (options.composite) {
+            (0, _log.warn)('TypeScript project references are not fully supported. Attempting to build in incremental mode.');
+        }
+        incremental = true;
+        program = typescript.createIncrementalProgram({
+            rootNames: fileNames,
+            options: {
+                ...options,
+                composite: false,
+                incremental: true,
+                tsBuildInfoFile: _path.default.join(cacheDir, '.tsbuildinfo')
+            }
+        });
+    } else {
+        program = typescript.createProgram(fileNames, options);
+    }
+    const result = program.emit();
+    const ignoreRegex = [
+        // matches **/__(tests|mocks)__/**
+        /[\\/]__(?:tests|mocks)__[\\/]/,
+        // matches **/*.(spec|test).*
+        /(?<=[\\/.])(?:spec|test)\.[^\\/]+$/
+    ];
+    const regexIgnoredFile = new RegExp(ignoreRegex.map((r)=>r.source).join('|'));
+    const allDiagnostics = typescript.getPreEmitDiagnostics(program).concat(result.diagnostics).filter((d)=>!(d.file && regexIgnoredFile.test(d.file.fileName)));
+    const firstError = allDiagnostics.find((d)=>d.category === typescript.DiagnosticCategory.Error && Boolean(d.file)) ?? allDiagnostics.find((d)=>d.category === typescript.DiagnosticCategory.Error);
+    // In test mode, we want to check all diagnostics, not just the first one.
+    if (process.env.__NEXT_TEST_MODE) {
+        if (firstError) {
+            const allErrors = allDiagnostics.filter((d)=>d.category === typescript.DiagnosticCategory.Error).map((d)=>'[Test Mode] ' + (0, _diagnosticFormatter.getFormattedDiagnostic)(typescript, baseDir, distDir, d, isAppDirEnabled));
+            console.error('\n\n===== TS errors =====\n\n' + allErrors.join('\n\n') + '\n\n===== TS errors =====\n\n');
+            // Make sure all stdout is flushed before we exit.
+            await new Promise((resolve)=>setTimeout(resolve, 100));
+        }
+    }
+    if (firstError) {
+        throw Object.defineProperty(new _compileerror.CompileError((0, _diagnosticFormatter.getFormattedDiagnostic)(typescript, baseDir, distDir, firstError, isAppDirEnabled)), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const warnings = allDiagnostics.filter((d)=>d.category === typescript.DiagnosticCategory.Warning).map((d)=>(0, _diagnosticFormatter.getFormattedDiagnostic)(typescript, baseDir, distDir, d, isAppDirEnabled));
+    return {
+        hasWarnings: true,
+        warnings,
+        inputFilesCount: fileNames.length,
+        totalFilesCount: program.getSourceFiles().length,
+        incremental
+    };
+}
+
+//# sourceMappingURL=runTypeCheck.js.map

package/.next/standalone/node_modules/next/dist/lib/typescript/type-paths.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getDevTypesPath: null,
+    getTypeDefinitionGlobPatterns: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getDevTypesPath: function() {
+        return getDevTypesPath;
+    },
+    getTypeDefinitionGlobPatterns: function() {
+        return getTypeDefinitionGlobPatterns;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getTypeDefinitionGlobPatterns(distDir) {
+    const distDirPosix = _path.default.win32.sep === _path.default.sep ? distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep) : distDir;
+    const typeGlobPatterns = [
+        `${distDirPosix}/types/**/*.ts`
+    ];
+    // Include both .next/types and .next/dev/types to avoid tsconfig churn when switching
+    // between dev/build modes
+    typeGlobPatterns.push(process.env.NODE_ENV === 'development' ? `${distDirPosix.replace(/\/dev$/, '')}/types/**/*.ts` : `${distDirPosix}/dev/types/**/*.ts`);
+    // Sort for consistent order
+    typeGlobPatterns.sort((a, b)=>a.length - b.length);
+    return typeGlobPatterns;
+}
+function getDevTypesPath(baseDir, distDir) {
+    const isDev = process.env.NODE_ENV === 'development';
+    if (isDev) {
+        // In dev mode, dev types are the main types, so no need to filter
+        return null;
+    }
+    // In build mode, dev types are at "{baseDir}/{distDir}/dev/types" and should be filtered
+    return _path.default.join(baseDir, distDir, 'dev', 'types');
+}
+
+//# sourceMappingURL=type-paths.js.map

package/.next/standalone/node_modules/next/dist/lib/typescript/writeAppTypeDeclarations.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "writeAppTypeDeclarations", {
+    enumerable: true,
+    get: function() {
+        return writeAppTypeDeclarations;
+    }
+});
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = require("fs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function writeAppTypeDeclarations({ baseDir, distDir, imageImportsEnabled, hasPagesDir, hasAppDir, strictRouteTypes, typedRoutes }) {
+    // Reference `next` types
+    const appTypeDeclarations = _path.default.join(baseDir, 'next-env.d.ts');
+    // Defaults EOL to system default
+    let eol = _os.default.EOL;
+    let currentContent;
+    try {
+        currentContent = await _fs.promises.readFile(appTypeDeclarations, 'utf8');
+        // If file already exists then preserve its line ending
+        const lf = currentContent.indexOf('\n', /* skip first so we can lf - 1 */ 1);
+        if (lf !== -1) {
+            if (currentContent[lf - 1] === '\r') {
+                eol = '\r\n';
+            } else {
+                eol = '\n';
+            }
+        }
+    } catch  {}
+    /**
+   * "Triple-slash directives" used to create typings files for Next.js projects
+   * using Typescript .
+   *
+   * @see https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html
+   */ const lines = [
+        // Include the core Next.js typings.
+        '/// <reference types="next" />'
+    ];
+    if (imageImportsEnabled) {
+        lines.push('/// <reference types="next/image-types/global" />');
+    }
+    if (hasAppDir && hasPagesDir) {
+        lines.push('/// <reference types="next/navigation-types/compat/navigation" />');
+    }
+    const routeTypesPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/routes.d.ts');
+    // Use ESM import instead of triple-slash reference for better ESLint compatibility
+    lines.push(`import "./${routeTypesPath}";`);
+    if (strictRouteTypes) {
+        const cacheLifePath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/cache-life.d.ts');
+        lines.push(`import "./${cacheLifePath}";`);
+        const routeValidatorPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/validator.ts');
+        lines.push(`import "./${routeValidatorPath}";`);
+        if (typedRoutes === true) {
+            const linkTypesPath = _path.default.posix.join(distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep), 'types/link.d.ts');
+            lines.push(`import "./${linkTypesPath}";`);
+        }
+    }
+    // Push the notice in.
+    lines.push('', '// NOTE: This file should not be edited', `// see https://nextjs.org/docs/${hasAppDir ? 'app' : 'pages'}/api-reference/config/typescript for more information.`);
+    const content = lines.join(eol) + eol;
+    // Avoids an un-necessary write on read-only fs
+    if (currentContent === content) {
+        return;
+    }
+    await _fs.promises.writeFile(appTypeDeclarations, content);
+}
+
+//# sourceMappingURL=writeAppTypeDeclarations.js.map

package/.next/standalone/node_modules/next/dist/lib/typescript/writeConfigurationDefaults.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getRequiredConfiguration: null,
+    writeConfigurationDefaults: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getRequiredConfiguration: function() {
+        return getRequiredConfiguration;
+    },
+    writeConfigurationDefaults: function() {
+        return writeConfigurationDefaults;
+    }
+});
+const _fs = require("fs");
+const _picocolors = require("../picocolors");
+const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("next/dist/compiled/comment-json"));
+const _semver = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/semver"));
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _typepaths = require("./type-paths");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function getDesiredCompilerOptions(typescriptVersion, userTsConfig) {
+    var _userTsConfig_compilerOptions, _userTsConfig_compilerOptions_module, _userTsConfig_compilerOptions1, _userTsConfig_compilerOptions2;
+    // ModuleKind
+    const moduleKindESNext = 'esnext';
+    const moduleKindES2020 = 'es2020';
+    const moduleKindPreserve = 'preserve';
+    const moduleKindNodeNext = 'nodenext';
+    const moduleKindNode16 = 'node16';
+    const moduleKindCommonJS = 'commonjs';
+    const moduleKindAMD = 'amd';
+    // ModuleResolutionKind
+    const moduleResolutionKindBundler = 'bundler';
+    const moduleResolutionKindNode16 = 'node16';
+    const moduleResolutionKindNodeNext = 'nodenext';
+    const moduleResolutionKindNode12 = 'node12';
+    const moduleResolutionKindNode = 'node';
+    const configuredModule = typeof (userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions.module) === 'string' ? userTsConfig.compilerOptions.module.toLowerCase() : undefined;
+    const preferBundlerResolution = _semver.default.gte(typescriptVersion, '5.0.0') && configuredModule !== moduleKindCommonJS && configuredModule !== moduleKindAMD;
+    // Jsx
+    const jsxEmitReactJSX = 'react-jsx';
+    return {
+        target: {
+            suggested: 'ES2017',
+            reason: 'For top-level `await`. Note: Next.js only polyfills for the esmodules target.'
+        },
+        // These are suggested values and will be set when not present in the
+        // tsconfig.json
+        lib: {
+            suggested: [
+                'dom',
+                'dom.iterable',
+                'esnext'
+            ]
+        },
+        allowJs: {
+            suggested: true
+        },
+        skipLibCheck: {
+            suggested: true
+        },
+        strict: {
+            suggested: false
+        },
+        noEmit: {
+            suggested: true
+        },
+        incremental: {
+            suggested: true
+        },
+        // These values are required and cannot be changed by the user
+        // Keep this in sync with the webpack config
+        // 'parsedValue' matches the output value from ts.parseJsonConfigFileContent()
+        module: {
+            parsedValue: moduleKindESNext,
+            // All of these values work:
+            parsedValues: [
+                _semver.default.gte(typescriptVersion, '5.4.0') && moduleKindPreserve,
+                moduleKindES2020,
+                moduleKindESNext,
+                moduleKindCommonJS,
+                moduleKindAMD,
+                moduleKindNodeNext,
+                moduleKindNode16
+            ],
+            value: 'esnext',
+            reason: 'for dynamic import() support'
+        },
+        // TODO: Semver check not needed once Next.js repo uses 5.4.
+        ..._semver.default.gte(typescriptVersion, '5.4.0') && (userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions1 = userTsConfig.compilerOptions) == null ? void 0 : (_userTsConfig_compilerOptions_module = _userTsConfig_compilerOptions1.module) == null ? void 0 : _userTsConfig_compilerOptions_module.toLowerCase()) === moduleKindPreserve ? {
+        } : {
+            esModuleInterop: {
+                value: true,
+                reason: 'requirement for SWC / babel'
+            },
+            moduleResolution: {
+                parsedValue: preferBundlerResolution ? moduleResolutionKindBundler : moduleResolutionKindNode,
+                // All of these values work:
+                parsedValues: preferBundlerResolution ? [
+                    moduleResolutionKindNode16,
+                    moduleResolutionKindNodeNext,
+                    moduleResolutionKindBundler
+                ] : [
+                    moduleResolutionKindNode,
+                    // only older TypeScript versions have this field
+                    moduleResolutionKindNode12,
+                    moduleResolutionKindNode16,
+                    moduleResolutionKindNodeNext
+                ],
+                value: preferBundlerResolution ? moduleResolutionKindBundler : moduleResolutionKindNode,
+                reason: preferBundlerResolution ? 'to match modern bundler resolution' : 'to match webpack resolution'
+            },
+            resolveJsonModule: {
+                value: true,
+                reason: 'to match webpack resolution'
+            }
+        },
+        ...(userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions2 = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions2.verbatimModuleSyntax) === true ? undefined : {
+            isolatedModules: {
+                value: true,
+                reason: 'requirement for SWC / Babel'
+            }
+        },
+        jsx: {
+            parsedValue: jsxEmitReactJSX,
+            value: 'react-jsx',
+            reason: 'next.js uses the React automatic runtime'
+        }
+    };
+}
+function getRequiredConfiguration(typescript) {
+    const res = {};
+    const typescriptVersion = typescript.version;
+    const desiredCompilerOptions = getDesiredCompilerOptions(typescriptVersion);
+    for (const optionKey of Object.keys(desiredCompilerOptions)){
+        const ev = desiredCompilerOptions[optionKey];
+        if (!('value' in ev)) {
+            continue;
+        }
+        const value = ev.parsedValue ?? ev.value;
+        // Convert string values back to TypeScript enum values
+        if (optionKey === 'module' && typeof value === 'string') {
+            const moduleMap = {
+                esnext: typescript.ModuleKind.ESNext,
+                es2020: typescript.ModuleKind.ES2020,
+                ...typescript.ModuleKind.Preserve !== undefined ? {
+                    preserve: typescript.ModuleKind.Preserve
+                } : {},
+                nodenext: typescript.ModuleKind.NodeNext,
+                node16: typescript.ModuleKind.Node16,
+                commonjs: typescript.ModuleKind.CommonJS,
+                amd: typescript.ModuleKind.AMD
+            };
+            res[optionKey] = moduleMap[value.toLowerCase()] ?? value;
+        } else if (optionKey === 'moduleResolution' && typeof value === 'string') {
+            const moduleResolutionMap = {
+                bundler: typescript.ModuleResolutionKind.Bundler,
+                node16: typescript.ModuleResolutionKind.Node16,
+                nodenext: typescript.ModuleResolutionKind.NodeNext,
+                node12: typescript.ModuleResolutionKind.Node12,
+                node: typescript.ModuleResolutionKind.Node10 ?? typescript.ModuleResolutionKind.NodeJs
+            };
+            res[optionKey] = moduleResolutionMap[value.toLowerCase()] ?? value;
+        } else if (optionKey === 'jsx' && typeof value === 'string') {
+            const jsxMap = {
+                'react-jsx': typescript.JsxEmit.ReactJSX
+            };
+            res[optionKey] = jsxMap[value.toLowerCase()] ?? value;
+        } else {
+            res[optionKey] = value;
+        }
+    }
+    return res;
+}
+const localDevTestFilesExcludeAction = 'NEXT_PRIVATE_LOCAL_DEV_TEST_FILES_EXCLUDE';
+async function writeConfigurationDefaults(typescriptVersion, tsConfigPath, isFirstTimeSetup, hasAppDir, distDir, hasPagesDir, strictRouteTypes) {
+    var _userTsConfig_compilerOptions;
+    if (isFirstTimeSetup) {
+        (0, _fs.writeFileSync)(tsConfigPath, '{}' + _os.default.EOL);
+    }
+    const userTsConfigContent = (0, _fs.readFileSync)(tsConfigPath, 'utf8');
+    const userTsConfig = _commentjson.parse(userTsConfigContent);
+    // Bail automatic setup when the user has extended or referenced another config
+    if ('extends' in userTsConfig || 'references' in userTsConfig) {
+        return;
+    }
+    if ((userTsConfig == null ? void 0 : userTsConfig.compilerOptions) == null) {
+        userTsConfig.compilerOptions = {};
+        isFirstTimeSetup = true;
+    }
+    const desiredCompilerOptions = getDesiredCompilerOptions(typescriptVersion, userTsConfig);
+    const suggestedActions = [];
+    const requiredActions = [];
+    for(const optionKey in desiredCompilerOptions){
+        const check = desiredCompilerOptions[optionKey];
+        if ('suggested' in check) {
+            if (!(optionKey in (userTsConfig == null ? void 0 : userTsConfig.compilerOptions))) {
+                userTsConfig.compilerOptions[optionKey] = check.suggested;
+                suggestedActions.push((0, _picocolors.cyan)(optionKey) + ' was set to ' + (0, _picocolors.bold)(check.suggested) + (check.reason ? ` (${check.reason})` : ''));
+            }
+        } else if ('value' in check) {
+            var _userTsConfig_compilerOptions1;
+            let existingValue = userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions1 = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions1[optionKey];
+            if (typeof existingValue === 'string') {
+                existingValue = existingValue.toLowerCase();
+            }
+            const shouldWriteRequiredValue = ()=>{
+                // Check if the option has multiple allowed values
+                if (check.parsedValues) {
+                    return !check.parsedValues.includes(existingValue);
+                }
+                // Check if the option has a single parsed value
+                if (check.parsedValue) {
+                    return check.parsedValue !== existingValue;
+                }
+                // Fall back to direct value comparison
+                return check.value !== existingValue;
+            };
+            if (shouldWriteRequiredValue()) {
+                if (!userTsConfig.compilerOptions) {
+                    userTsConfig.compilerOptions = {};
+                }
+                userTsConfig.compilerOptions[optionKey] = check.value;
+                requiredActions.push((0, _picocolors.cyan)(optionKey) + ' was set to ' + (0, _picocolors.bold)(check.value) + ` (${check.reason})`);
+            }
+        } else {
+            const _ = check;
+        }
+    }
+    // Get type definition glob patterns using shared utility to ensure consistency
+    // with other TypeScript infrastructure (e.g., runTypeCheck.ts)
+    const nextTypes = (0, _typepaths.getTypeDefinitionGlobPatterns)(distDir);
+    if (!('include' in userTsConfig)) {
+        const defaultInclude = hasAppDir && !strictRouteTypes ? [
+            'next-env.d.ts',
+            ...nextTypes,
+            '**/*.mts',
+            '**/*.ts',
+            '**/*.tsx'
+        ] : [
+            'next-env.d.ts',
+            '**/*.mts',
+            '**/*.ts',
+            '**/*.tsx'
+        ];
+        userTsConfig.include = defaultInclude;
+        suggestedActions.push((0, _picocolors.cyan)('include') + ' was set to [' + (0, _picocolors.bold)(defaultInclude.map((type)=>`'${type}'`).join(', ')) + ']');
+    } else if (hasAppDir && !strictRouteTypes) {
+        const missingFromResolved = [];
+        for (const type of nextTypes){
+            if (!userTsConfig.include.includes(type)) {
+                missingFromResolved.push(type);
+            }
+        }
+        if (missingFromResolved.length > 0) {
+            if (!Array.isArray(userTsConfig.include)) {
+                userTsConfig.include = [];
+            }
+            missingFromResolved.forEach((item)=>{
+                userTsConfig.include.push(item);
+                suggestedActions.push((0, _picocolors.cyan)('include') + ' was updated to add ' + (0, _picocolors.bold)(`'${item}'`));
+            });
+        }
+    }
+    // Enable the Next.js typescript plugin.
+    if (hasAppDir) {
+        var _userTsConfig_compilerOptions2;
+        // Check if the config or the resolved config has the plugin already.
+        const plugins = [
+            ...Array.isArray(userTsConfig == null ? void 0 : userTsConfig.plugins) ? userTsConfig.plugins : [],
+            ...userTsConfig.compilerOptions && Array.isArray(userTsConfig.compilerOptions.plugins) ? userTsConfig.compilerOptions.plugins : []
+        ];
+        const hasNextPlugin = plugins.some(({ name })=>name === 'next');
+        // If the TS config extends on another config, we can't add the `plugin` field
+        // because that will override the parent config's plugins.
+        // Instead we have to show a message to the user to add the plugin manually.
+        if (!userTsConfig.compilerOptions || plugins.length && !hasNextPlugin && 'extends' in userTsConfig && (!userTsConfig.compilerOptions || !userTsConfig.compilerOptions.plugins)) {
+            _log.info(`\nYour ${(0, _picocolors.bold)('tsconfig.json')} extends another configuration, which means we cannot add the Next.js TypeScript plugin automatically. To improve your development experience, we recommend adding the Next.js plugin (\`${(0, _picocolors.cyan)('"plugins": [{ "name": "next" }]')}\`) manually to your TypeScript configuration. Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#the-typescript-plugin\n`);
+        } else if (!hasNextPlugin) {
+            if (!('plugins' in userTsConfig.compilerOptions)) {
+                userTsConfig.compilerOptions.plugins = [];
+            }
+            userTsConfig.compilerOptions.plugins.push({
+                name: 'next'
+            });
+            suggestedActions.push((0, _picocolors.cyan)('plugins') + ' was updated to add ' + (0, _picocolors.bold)(`{ name: 'next' }`));
+        }
+        // If `strict` is set to `false` and `strictNullChecks` is set to `false`,
+        // then set `strictNullChecks` to `true`.
+        if (hasPagesDir && hasAppDir && !(userTsConfig == null ? void 0 : (_userTsConfig_compilerOptions2 = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions2.strict) && !('strictNullChecks' in (userTsConfig == null ? void 0 : userTsConfig.compilerOptions))) {
+            userTsConfig.compilerOptions.strictNullChecks = true;
+            suggestedActions.push((0, _picocolors.cyan)('strictNullChecks') + ' was set to ' + (0, _picocolors.bold)(`true`));
+        }
+    }
+    if (!('exclude' in userTsConfig)) {
+        userTsConfig.exclude = [
+            'node_modules'
+        ];
+        suggestedActions.push((0, _picocolors.cyan)('exclude') + ' was set to ' + (0, _picocolors.bold)(`['node_modules']`));
+    }
+    // During local development inside Next.js repo, exclude the test files coverage by the local tsconfig
+    if (process.env.NEXT_PRIVATE_LOCAL_DEV && userTsConfig.exclude) {
+        const tsGlob = '**/*.test.ts';
+        const tsxGlob = '**/*.test.tsx';
+        let hasUpdates = false;
+        if (!userTsConfig.exclude.includes(tsGlob)) {
+            userTsConfig.exclude.push(tsGlob);
+            hasUpdates = true;
+        }
+        if (!userTsConfig.exclude.includes(tsxGlob)) {
+            userTsConfig.exclude.push(tsxGlob);
+            hasUpdates = true;
+        }
+        if (hasUpdates) {
+            requiredActions.push(localDevTestFilesExcludeAction);
+        }
+    }
+    if (suggestedActions.length < 1 && requiredActions.length < 1) {
+        return;
+    }
+    (0, _fs.writeFileSync)(tsConfigPath, _commentjson.stringify(userTsConfig, null, 2) + _os.default.EOL);
+    _log.info('');
+    if (isFirstTimeSetup) {
+        _log.info(`We detected TypeScript in your project and created a ${(0, _picocolors.cyan)('tsconfig.json')} file for you.`);
+        return;
+    }
+    _log.info(`We detected TypeScript in your project and reconfigured your ${(0, _picocolors.cyan)('tsconfig.json')} file for you.${((_userTsConfig_compilerOptions = userTsConfig.compilerOptions) == null ? void 0 : _userTsConfig_compilerOptions.strict) ? '' : ` Strict-mode is set to ${(0, _picocolors.cyan)('false')} by default.`}`);
+    if (suggestedActions.length) {
+        _log.info(`The following suggested values were added to your ${(0, _picocolors.cyan)('tsconfig.json')}. These values ${(0, _picocolors.cyan)('can be changed')} to fit your project's needs:\n`);
+        suggestedActions.forEach((action)=>_log.info(`\t- ${action}`));
+        _log.info('');
+    }
+    const requiredActionsToBeLogged = process.env.NEXT_PRIVATE_LOCAL_DEV ? requiredActions.filter((action)=>action !== localDevTestFilesExcludeAction) : requiredActions;
+    if (requiredActionsToBeLogged.length) {
+        _log.info(`The following ${(0, _picocolors.white)('mandatory changes')} were made to your ${(0, _picocolors.cyan)('tsconfig.json')}:\n`);
+        requiredActionsToBeLogged.forEach((action)=>_log.info(`\t- ${action}`));
+        _log.info('');
+    }
+}
+
+//# sourceMappingURL=writeConfigurationDefaults.js.map