qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/compiled/react-is/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-is",
-  "version": "19.3.0-canary-52684925-20251110",
+  "version": "19.3.0-canary-f93b9fd4-20251217",
   "description": "Brand checking of React Elements.",
   "main": "index.js",
   "sideEffects": false,

qalita/_frontend/node_modules/next/dist/lib/build-custom-route.js

@@ -17,14 +17,14 @@ function buildCustomRoute(type, route, restrictedRedirectPaths) {
         sensitive: false,
         delimiter: '/'
     });
-    let source = compiled.source;
-    if (!route.internal) {
-        source = (0, _redirectstatus.modifyRouteRegex)(source, type === 'redirect' ? restrictedRedirectPaths : undefined);
-    }
     // If this is an internal rewrite and it already provides a regex, use it
     // otherwise, normalize the source to a regex.
     let regex;
     if (!route.internal || type !== 'rewrite' || !('regex' in route) || typeof route.regex !== 'string') {
+        let source = compiled.source;
+        if (!route.internal) {
+            source = (0, _redirectstatus.modifyRouteRegex)(source, type === 'redirect' ? restrictedRedirectPaths : undefined);
+        }
         regex = (0, _loadcustomroutes.normalizeRouteRegex)(source);
     } else {
         regex = route.regex;

qalita/_frontend/node_modules/next/dist/lib/constants.js

@@ -46,7 +46,6 @@ Object.defineProperty(exports, "__esModule", {
     RSC_CACHE_WRAPPER_ALIAS: null,
     RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS: null,
     RSC_MOD_REF_PROXY_ALIAS: null,
-    RSC_PREFETCH_SUFFIX: null,
     RSC_SEGMENTS_DIR_SUFFIX: null,
     RSC_SEGMENT_SUFFIX: null,
     RSC_SUFFIX: null,
@@ -199,9 +198,6 @@ _export(exports, {
     RSC_MOD_REF_PROXY_ALIAS: function() {
         return RSC_MOD_REF_PROXY_ALIAS;
     },
-    RSC_PREFETCH_SUFFIX: function() {
-        return RSC_PREFETCH_SUFFIX;
-    },
     RSC_SEGMENTS_DIR_SUFFIX: function() {
         return RSC_SEGMENTS_DIR_SUFFIX;
     },
@@ -256,7 +252,6 @@ const NEXT_INTERCEPTION_MARKER_PREFIX = 'nxtI';
 const MATCHED_PATH_HEADER = 'x-matched-path';
 const PRERENDER_REVALIDATE_HEADER = 'x-prerender-revalidate';
 const PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = 'x-prerender-revalidate-if-generated';
-const RSC_PREFETCH_SUFFIX = '.prefetch.rsc';
 const RSC_SEGMENTS_DIR_SUFFIX = '.segments';
 const RSC_SEGMENT_SUFFIX = '.segment.rsc';
 const RSC_SUFFIX = '.rsc';

qalita/_frontend/node_modules/next/dist/lib/default-transpiled-packages.json

@@ -0,0 +1 @@
+["geist"]

qalita/_frontend/node_modules/next/dist/lib/generate-interception-routes-rewrites.js

@@ -54,7 +54,6 @@ function generateInterceptionRoutesRewrites(appPaths, basePath = '') {
                         value: headerRegex
                     }
                 ],
-                internal: true,
                 regex: source.namedRegex
             });
         }

qalita/_frontend/node_modules/next/dist/lib/helpers/get-npx-command.js

@@ -12,15 +12,15 @@ const _child_process = require("child_process");
 const _getpkgmanager = require("./get-pkg-manager");
 function getNpxCommand(baseDir) {
     const pkgManager = (0, _getpkgmanager.getPkgManager)(baseDir);
-    let command = 'npx';
+    let command = 'npx --yes';
     if (pkgManager === 'pnpm') {
-        command = 'pnpm dlx';
+        command = 'pnpm --silent dlx';
     } else if (pkgManager === 'yarn') {
         try {
             (0, _child_process.execSync)('yarn dlx --help', {
                 stdio: 'ignore'
             });
-            command = 'yarn dlx';
+            command = 'yarn --quiet dlx';
         } catch  {}
     }
     return command;

qalita/_frontend/node_modules/next/dist/lib/inline-static-env.js

@@ -23,7 +23,7 @@ function _interop_require_default(obj) {
 const glob = (0, _util.promisify)(_glob.default);
 async function inlineStaticEnv({ distDir, config }) {
     const nextConfigEnv = (0, _staticenv.getNextConfigEnv)(config);
-    const staticEnv = (0, _staticenv.getStaticEnv)(config);
+    const staticEnv = (0, _staticenv.getStaticEnv)(config, config.deploymentId);
     const serverDir = _path.default.join(distDir, 'server');
     const serverChunks = await glob('**/*.{js,json,js.map}', {
         cwd: serverDir

qalita/_frontend/node_modules/next/dist/lib/known-edge-safe-packages.json

@@ -0,0 +1 @@
+["function-bind"]

qalita/_frontend/node_modules/next/dist/lib/metadata/metadata.js

@@ -65,8 +65,8 @@ function _interop_require_wildcard(obj, nodeInterop) {
 function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext, getDynamicParamFromSegment, errorType, workStore, serveStreamingMetadata }) {
     const searchParams = (0, _searchparams.createServerSearchParamsForMetadata)(parsedQuery, workStore);
     const pathnameForMetadata = (0, _pathname.createServerPathnameForMetadata)(pathname, workStore);
-    function Viewport() {
-        const pendingViewportTags = getResolvedViewport(tree, searchParams, getDynamicParamFromSegment, workStore, errorType).catch((viewportErr)=>{
+    async function Viewport() {
+        const tags = await getResolvedViewport(tree, searchParams, getDynamicParamFromSegment, workStore, errorType).catch((viewportErr)=>{
             // When Legacy PPR is enabled viewport can reject with a Postpone type
             // This will go away once Legacy PPR is removed and dynamic metadata will
             // stay pending until after the prerender is complete when it is dynamic
@@ -79,13 +79,16 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
             // We're going to throw the error from the metadata outlet so we just render null here instead
             return null;
         });
+        return tags;
+    }
+    Viewport.displayName = 'Next.Viewport';
+    function ViewportWrapper() {
         return /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.ViewportBoundary, {
-            children: pendingViewportTags
+            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Viewport, {})
         });
     }
-    Viewport.displayName = 'Next.Viewport';
-    function Metadata() {
-        const pendingMetadataTags = getResolvedMetadata(tree, pathnameForMetadata, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorType).catch((metadataErr)=>{
+    async function Metadata() {
+        const tags = await getResolvedMetadata(tree, pathnameForMetadata, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorType).catch((metadataErr)=>{
             // When Legacy PPR is enabled metadata can reject with a Postpone type
             // This will go away once Legacy PPR is removed and dynamic metadata will
             // stay pending until after the prerender is complete when it is dynamic
@@ -98,12 +101,16 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
             // We're going to throw the error from the metadata outlet so we just render null here instead
             return null;
         });
+        return tags;
+    }
+    Metadata.displayName = 'Next.Metadata';
+    function MetadataWrapper() {
         // TODO: We shouldn't change what we render based on whether we are streaming or not.
         // If we aren't streaming we should just block the response until we have resolved the
         // metadata.
         if (!serveStreamingMetadata) {
             return /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.MetadataBoundary, {
-                children: pendingMetadataTags
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Metadata, {})
             });
         }
         return /*#__PURE__*/ (0, _jsxruntime.jsx)("div", {
@@ -111,12 +118,11 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
             children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.MetadataBoundary, {
                 children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_react.Suspense, {
                     name: "Next.Metadata",
-                    children: pendingMetadataTags
+                    children: /*#__PURE__*/ (0, _jsxruntime.jsx)(Metadata, {})
                 })
             })
         });
     }
-    Metadata.displayName = 'Next.Metadata';
     function MetadataOutlet() {
         const pendingOutlet = Promise.all([
             getResolvedMetadata(tree, pathnameForMetadata, searchParams, getDynamicParamFromSegment, metadataContext, workStore, errorType),
@@ -139,8 +145,8 @@ function createMetadataComponents({ tree, pathname, parsedQuery, metadataContext
     }
     MetadataOutlet.displayName = 'Next.MetadataOutlet';
     return {
-        Viewport,
-        Metadata,
+        Viewport: ViewportWrapper,
+        Metadata: MetadataWrapper,
         MetadataOutlet
     };
 }

qalita/_frontend/node_modules/next/dist/lib/needs-experimental-react.js

@@ -9,8 +9,8 @@ Object.defineProperty(exports, "needsExperimentalReact", {
     }
 });
 function needsExperimentalReact(config) {
-    const { taint } = config.experimental || {};
-    return Boolean(taint);
+    const { taint, transitionIndicator } = config.experimental || {};
+    return Boolean(taint || transitionIndicator);
 }
 
 //# sourceMappingURL=needs-experimental-react.js.map

qalita/_frontend/node_modules/next/dist/lib/resolve-build-paths.js

@@ -73,41 +73,53 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 const glob = (0, _util.promisify)(_glob.default);
+/**
+ * Escapes bracket expressions that correspond to existing directories.
+ * This allows Next.js dynamic routes like [slug] to work with glob patterns.
+ *
+ * e.g., "app/blog/[slug]/** /page.tsx" → "app/blog/\[slug\]/** /page.tsx"
+ *       (if app/blog/[slug] directory exists)
+ */ function escapeExistingBrackets(pattern, projectDir) {
+    // Match bracket expressions: [name], [...name], [[...name]]
+    const bracketRegex = /\[\[?\.\.\.[^\]]+\]?\]|\[[^\]]+\]/g;
+    let lastIndex = 0;
+    let result = '';
+    let match;
+    while((match = bracketRegex.exec(pattern)) !== null){
+        const pathPrefix = pattern.slice(0, match.index + match[0].length);
+        const exists = _fs.default.existsSync(_path.default.join(projectDir, pathPrefix));
+        result += pattern.slice(lastIndex, match.index);
+        result += exists ? match[0].replace(/\[/g, '\\[').replace(/\]/g, '\\]') : match[0];
+        lastIndex = match.index + match[0].length;
+    }
+    return result + pattern.slice(lastIndex);
+}
 async function resolveBuildPaths(patterns, projectDir) {
     const appPaths = new Set();
     const pagePaths = new Set();
     for (const pattern of patterns){
         const trimmed = pattern.trim();
-        if (!trimmed) {
-            continue;
-        }
-        // Detect if pattern is glob pattern (contains glob special chars)
-        const isGlobPattern = /[*?[\]{}!]/.test(trimmed);
-        if (isGlobPattern) {
-            try {
-                // Resolve glob pattern
-                const matches = await glob(trimmed, {
-                    cwd: projectDir
-                });
-                if (matches.length === 0) {
-                    _log.warn(`Glob pattern "${trimmed}" did not match any files`);
-                }
-                for (const file of matches){
-                    // Skip directories, only process files
-                    if (!_fs.default.statSync(_path.default.join(projectDir, file)).isDirectory()) {
-                        categorizeAndAddPath(file, appPaths, pagePaths);
-                    }
+        if (!trimmed) continue;
+        try {
+            // Escape brackets that correspond to existing Next.js dynamic route directories
+            const escapedPattern = escapeExistingBrackets(trimmed, projectDir);
+            const matches = await glob(escapedPattern, {
+                cwd: projectDir
+            });
+            if (matches.length === 0) {
+                _log.warn(`Pattern "${trimmed}" did not match any files`);
+            }
+            for (const file of matches){
+                if (!_fs.default.statSync(_path.default.join(projectDir, file)).isDirectory()) {
+                    categorizeAndAddPath(file, appPaths, pagePaths);
                 }
-            } catch (error) {
-                throw Object.defineProperty(new Error(`Failed to resolve glob pattern "${trimmed}": ${(0, _iserror.default)(error) ? error.message : String(error)}`), "__NEXT_ERROR_CODE", {
-                    value: "E892",
-                    enumerable: false,
-                    configurable: true
-                });
             }
-        } else {
-            // Explicit path - categorize based on prefix
-            categorizeAndAddPath(trimmed, appPaths, pagePaths, projectDir);
+        } catch (error) {
+            throw Object.defineProperty(new Error(`Failed to resolve pattern "${trimmed}": ${(0, _iserror.default)(error) ? error.message : String(error)}`), "__NEXT_ERROR_CODE", {
+                value: "E972",
+                enumerable: false,
+                configurable: true
+            });
         }
     }
     return {
@@ -116,61 +128,17 @@ async function resolveBuildPaths(patterns, projectDir) {
     };
 }
 /**
- * Categorizes a file path to either app or pages router based on its prefix,
- * and normalizes it to the format expected by Next.js internal build system.
- *
- * The internal build system expects:
- * - App router: paths with leading slash (e.g., "/page.tsx", "/dashboard/page.tsx")
- * - Pages router: paths with leading slash (e.g., "/index.tsx", "/about.tsx")
+ * Categorizes a file path to either app or pages router based on its prefix.
  *
  * Examples:
  * - "app/page.tsx" → appPaths.add("/page.tsx")
- * - "app/dashboard/page.tsx" → appPaths.add("/dashboard/page.tsx")
  * - "pages/index.tsx" → pagePaths.add("/index.tsx")
- * - "pages/about.tsx" → pagePaths.add("/about.tsx")
- * - "/page.tsx" → appPaths.add("/page.tsx") (already in app router format)
- */ function categorizeAndAddPath(filePath, appPaths, pagePaths, projectDir) {
-    // Normalize path separators to forward slashes (Windows compatibility)
+ */ function categorizeAndAddPath(filePath, appPaths, pagePaths) {
     const normalized = filePath.replace(/\\/g, '/');
-    // Skip non-file entries (like directories without extensions)
-    if (normalized.endsWith('/')) {
-        return;
-    }
     if (normalized.startsWith('app/')) {
-        // App router path: remove 'app/' prefix and ensure leading slash
-        // "app/page.tsx" → "/page.tsx"
-        // "app/dashboard/page.tsx" → "/dashboard/page.tsx"
-        const withoutPrefix = normalized.slice(4) // Remove "app/"
-        ;
-        appPaths.add('/' + withoutPrefix);
+        appPaths.add('/' + normalized.slice(4));
     } else if (normalized.startsWith('pages/')) {
-        // Pages router path: remove 'pages/' prefix and add leading slash
-        // "pages/index.tsx" → "/index.tsx"
-        // "pages/about.tsx" → "/about.tsx"
-        const withoutPrefix = normalized.slice(6) // Remove "pages/"
-        ;
-        pagePaths.add('/' + withoutPrefix);
-    } else if (normalized.startsWith('/')) {
-        // Leading slash suggests app router format (already in correct format)
-        // "/page.tsx" → "/page.tsx" (no change needed)
-        appPaths.add(normalized);
-    } else {
-        // No obvious prefix - try to detect based on file existence
-        if (projectDir) {
-            const appPath = _path.default.join(projectDir, 'app', normalized);
-            const pagesPath = _path.default.join(projectDir, 'pages', normalized);
-            if (_fs.default.existsSync(appPath)) {
-                appPaths.add('/' + normalized);
-            } else if (_fs.default.existsSync(pagesPath)) {
-                pagePaths.add('/' + normalized);
-            } else {
-                // Default to pages router for paths without clear indicator
-                pagePaths.add('/' + normalized);
-            }
-        } else {
-            // Without projectDir context, default to pages router
-            pagePaths.add('/' + normalized);
-        }
+        pagePaths.add('/' + normalized.slice(6));
     }
 }
 function parseBuildPathsInput(input) {

qalita/_frontend/node_modules/next/dist/lib/server-external-packages.jsonc

@@ -0,0 +1,103 @@
+[
+  // alineacms.com generates this package at build time and it should not end up in a cache (much like the @prisma/client package)
+  "@alinea/generated",
+  "@appsignal/nodejs",
+  "@aws-sdk/client-s3",
+  "@aws-sdk/s3-presigned-post",
+  "@blockfrost/blockfrost-js",
+  "@highlight-run/node",
+  "@huggingface/transformers",
+  "@jpg-store/lucid-cardano",
+  "@libsql/client",
+  "@mikro-orm/core",
+  "@mikro-orm/knex",
+  "@node-rs/argon2",
+  "@node-rs/bcrypt",
+  "@prisma/client",
+  "@react-pdf/renderer",
+  // Native Node.js addons
+  "@sentry/profiling-node",
+  "@sparticuz/chromium",
+  "@sparticuz/chromium-min",
+  // Native Node.js addons
+  "@statsig/statsig-node-core",
+  // Native Node.js addons
+  "@swc/core",
+  "@xenova/transformers",
+  // Builds on top of @prisma/client so dynamically loads the version.
+  "@zenstackhq/runtime",
+  "argon2",
+  "autoprefixer",
+  "aws-crt",
+  "bcrypt",
+  "better-sqlite3",
+  "canvas",
+  "chromadb-default-embed",
+  // Contains an unconditional require to a undeclared dependency 'coffee-script'
+  "config",
+  // Native Node.js addons
+  "cpu-features",
+  "cypress",
+  "dd-trace",
+  "eslint",
+  "express",
+  "firebase-admin",
+  "htmlrewriter",
+  // Patches the module system to shim modules
+  "import-in-the-middle",
+  // Native Node.js addons
+  "isolated-vm",
+  "jest",
+  "jsdom",
+  // Used to contain a very dynamic require to load the DB backend:
+  // https://github.com/jaredwray/keyv/blob/78b247b5b7a8c9b12154fbfae4295d6fb29158cf/packages/keyv/src/index.js#L22
+  "keyv",
+  "libsql",
+  "mdx-bundler",
+  "mongodb",
+  "mongoose",
+  "newrelic",
+  "next-mdx-remote",
+  "next-seo",
+  "node-cron",
+  "node-pty",
+  "node-web-audio-api",
+  "onnxruntime-node",
+  "oslo",
+  "pg",
+  // pino@10.1.0/lib/transport.js passes `join(__dirname, 'worker.js')` to thread-stream which ends
+  // up `require`ing that filepath, leading to
+  // `Cannot find module '/ROOT/node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/worker.js'`
+  "pino",
+  // A "plugin" that is passed to pino as a string (and is then required in a worker)
+  "pino-pretty",
+  // A "plugin" that is passed to pino as a string (and is then required in a worker)
+  "pino-roll",
+  "playwright",
+  "playwright-core",
+  "postcss",
+  "prettier",
+  "prisma",
+  "puppeteer",
+  "puppeteer-core",
+  "ravendb",
+  // Patches the module system to shim modules
+  "require-in-the-middle",
+  "rimraf",
+  // Native Node.js addons
+  "sharp",
+  "shiki",
+  "sqlite3",
+  // dynamic `new Worker` call in thread-stream@3.1.0/index.js which pulls in various non-code files
+  // as well (trying to parse README and invalid test files)
+  "thread-stream",
+  // Slow to compile because it pulls in typescript
+  "ts-morph",
+  "ts-node",
+  "typescript",
+  "vscode-oniguruma",
+  "webpack",
+  "websocket",
+  // Native Node.js addons
+  "zeromq",
+]

qalita/_frontend/node_modules/next/dist/lib/static-env.js

@@ -32,8 +32,8 @@ function errorIfEnvConflicted(config, key) {
     const isPrivateKey = /^(?:NODE_.+)|^(?:__.+)$/i.test(key);
     const hasNextRuntimeKey = key === 'NEXT_RUNTIME';
     if (isPrivateKey || hasNextRuntimeKey) {
-        throw Object.defineProperty(new Error(`The key "${key}" under "env" in ${config.configFileName} is not allowed. https://nextjs.org/docs/messages/env-key-not-allowed`), "__NEXT_ERROR_CODE", {
-            value: "E170",
+        throw Object.defineProperty(new Error(`The key "${key}" under "env" in ${config.configFileName || 'config'} is not allowed. https://nextjs.org/docs/messages/env-key-not-allowed`), "__NEXT_ERROR_CODE", {
+            value: "E967",
             enumerable: false,
             configurable: true
         });
@@ -68,19 +68,19 @@ function getNextConfigEnv(config) {
     }
     return defineEnv;
 }
-function getStaticEnv(config) {
+function getStaticEnv(config, deploymentId) {
     const staticEnv = {
         ...getNextPublicEnvironmentVariables(),
         ...getNextConfigEnv(config),
-        'process.env.NEXT_DEPLOYMENT_ID': config.deploymentId || ''
+        'process.env.NEXT_DEPLOYMENT_ID': deploymentId
     };
     return staticEnv;
 }
-function populateStaticEnv(config) {
+function populateStaticEnv(config, deploymentId) {
     // since inlining comes after static generation we need
     // to ensure this value is assigned to process env so it
     // can still be accessed
-    const staticEnv = getStaticEnv(config);
+    const staticEnv = getStaticEnv(config, deploymentId);
     for(const key in staticEnv){
         const innerKey = key.split('.').pop() || '';
         if (!process.env[innerKey]) {

qalita/_frontend/node_modules/next/dist/lib/turbopack-warning.js

@@ -10,7 +10,6 @@ Object.defineProperty(exports, "validateTurboNextConfig", {
 });
 const _config = /*#__PURE__*/ _interop_require_default(require("../server/config"));
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
-const _constants = require("../shared/lib/constants");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -88,7 +87,7 @@ const unsupportedTurbopackNextConfigOptions = [
     'experimental.urlImports',
     'experimental.slowModuleDetection'
 ];
-async function validateTurboNextConfig({ dir, isDev }) {
+async function validateTurboNextConfig({ dir, configPhase }) {
     const { defaultConfig } = require('../server/config-shared');
     const { cyan, red, underline } = require('../lib/picocolors');
     const { interopDefault } = require('../lib/interop-default');
@@ -97,13 +96,12 @@ async function validateTurboNextConfig({ dir, isDev }) {
     let hasTurboConfig = false;
     const unsupportedConfig = [];
     let rawNextConfig = {};
-    const phase = isDev ? _constants.PHASE_DEVELOPMENT_SERVER : _constants.PHASE_PRODUCTION_BUILD;
     try {
-        rawNextConfig = interopDefault(await (0, _config.default)(phase, dir, {
+        rawNextConfig = interopDefault(await (0, _config.default)(configPhase, dir, {
             rawConfig: true
         }));
         if (typeof rawNextConfig === 'function') {
-            rawNextConfig = rawNextConfig(phase, {
+            rawNextConfig = rawNextConfig(configPhase, {
                 defaultConfig
             });
         }

qalita/_frontend/node_modules/next/dist/lib/typescript/runTypeCheck.js

@@ -12,16 +12,72 @@ 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");
+const _configshared = require("../../server/config-shared");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-async function runTypeCheck(typescript, baseDir, distDir, tsConfigPath, cacheDir, isAppDirEnabled) {
+/**
+ * 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, isolatedDevBuild, dirs, debugBuildPaths) {
     const effectiveConfiguration = await (0, _getTypeScriptConfiguration.getTypeScriptConfiguration)(typescript, tsConfigPath);
-    if (effectiveConfiguration.fileNames.length < 1) {
+    // When isolatedDevBuild is enabled, 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;
+    const resolvedIsolatedDevBuild = isolatedDevBuild === undefined ? _configshared.defaultConfig.experimental.isolatedDevBuild : isolatedDevBuild;
+    // Get the dev types path to filter (null if not applicable)
+    const devTypesDir = (0, _typepaths.getDevTypesPath)(baseDir, distDir, resolvedIsolatedDevBuild);
+    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,
@@ -45,7 +101,7 @@ async function runTypeCheck(typescript, baseDir, distDir, tsConfigPath, cacheDir
         }
         incremental = true;
         program = typescript.createIncrementalProgram({
-            rootNames: effectiveConfiguration.fileNames,
+            rootNames: fileNames,
             options: {
                 ...options,
                 composite: false,
@@ -54,7 +110,7 @@ async function runTypeCheck(typescript, baseDir, distDir, tsConfigPath, cacheDir
             }
         });
     } else {
-        program = typescript.createProgram(effectiveConfiguration.fileNames, options);
+        program = typescript.createProgram(fileNames, options);
     }
     const result = program.emit();
     const ignoreRegex = [
@@ -86,7 +142,7 @@ async function runTypeCheck(typescript, baseDir, distDir, tsConfigPath, cacheDir
     return {
         hasWarnings: true,
         warnings,
-        inputFilesCount: effectiveConfiguration.fileNames.length,
+        inputFilesCount: fileNames.length,
         totalFilesCount: program.getSourceFiles().length,
         incremental
     };