@taskmark/ui 0.2.1 → 0.2.2

package/dist/standalone/node_modules/next/dist/server/dev/on-demand-entry-handler.js

@@ -1,773 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    ADDED: null,
-    BUILDING: null,
-    BUILT: null,
-    EntryTypes: null,
-    findPagePathData: null,
-    getEntries: null,
-    getEntryKey: null,
-    getInvalidator: null,
-    onDemandEntryHandler: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    ADDED: function() {
-        return ADDED;
-    },
-    BUILDING: function() {
-        return BUILDING;
-    },
-    BUILT: function() {
-        return BUILT;
-    },
-    EntryTypes: function() {
-        return EntryTypes;
-    },
-    findPagePathData: function() {
-        return findPagePathData;
-    },
-    getEntries: function() {
-        return getEntries;
-    },
-    getEntryKey: function() {
-        return getEntryKey;
-    },
-    getInvalidator: function() {
-        return getInvalidator;
-    },
-    onDemandEntryHandler: function() {
-        return onDemandEntryHandler;
-    }
-});
-const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
-const _events = require("events");
-const _findpagefile = require("../lib/find-page-file");
-const _entries = require("../../build/entries");
-const _getstaticinfoincludinglayouts = require("../../build/get-static-info-including-layouts");
-const _path = require("path");
-const _normalizepathsep = require("../../shared/lib/page-path/normalize-path-sep");
-const _normalizepagepath = require("../../shared/lib/page-path/normalize-page-path");
-const _ensureleadingslash = require("../../shared/lib/page-path/ensure-leading-slash");
-const _removepagepathtail = require("../../shared/lib/page-path/remove-page-path-tail");
-const _output = require("../../build/output");
-const _getroutefromentrypoint = /*#__PURE__*/ _interop_require_default(require("../get-route-from-entrypoint"));
-const _utils = require("../../build/utils");
-const _utils1 = require("../../shared/lib/utils");
-const _constants = require("../../shared/lib/constants");
-const _segment = require("../../shared/lib/segment");
-const _hotreloadertypes = require("./hot-reloader-types");
-const _apppageroutedefinition = require("../route-definitions/app-page-route-definition");
-const _scheduler = require("../../lib/scheduler");
-const _batcher = require("../../lib/batcher");
-const _apppaths = require("../../shared/lib/router/utils/app-paths");
-const _pagetypes = require("../../lib/page-types");
-const _flightdatahelpers = require("../../client/flight-data-helpers");
-const _geterrors = require("../mcp/tools/get-errors");
-const _getpagemetadata = require("../mcp/tools/get-page-metadata");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const debug = (0, _debug.default)('next:on-demand-entry-handler');
-/**
- * Returns object keys with type inferred from the object key
- */ const keys = Object.keys;
-const COMPILER_KEYS = keys(_constants.COMPILER_INDEXES);
-function treePathToEntrypoint(segmentPath, parentPath) {
-    const [parallelRouteKey, segment] = segmentPath;
-    // TODO-APP: modify this path to cover parallelRouteKey convention
-    const path = (parentPath ? parentPath + '/' : '') + (parallelRouteKey !== 'children' && !segment.startsWith('@') ? `@${parallelRouteKey}/` : '') + (segment === '' ? 'page' : segment);
-    // Last segment
-    if (segmentPath.length === 2) {
-        return path;
-    }
-    const childSegmentPath = (0, _flightdatahelpers.getNextFlightSegmentPath)(segmentPath);
-    return treePathToEntrypoint(childSegmentPath, path);
-}
-function convertDynamicParamTypeToSyntax(dynamicParamTypeShort, param) {
-    switch(dynamicParamTypeShort){
-        case 'c':
-        case 'ci(..)(..)':
-        case 'ci(.)':
-        case 'ci(..)':
-        case 'ci(...)':
-            return `[...${param}]`;
-        case 'oc':
-            return `[[...${param}]]`;
-        case 'd':
-        case 'di(..)(..)':
-        case 'di(.)':
-        case 'di(..)':
-        case 'di(...)':
-            return `[${param}]`;
-        default:
-            throw Object.defineProperty(new Error('Unknown dynamic param type'), "__NEXT_ERROR_CODE", {
-                value: "E378",
-                enumerable: false,
-                configurable: true
-            });
-    }
-}
-function getEntryKey(compilerType, pageBundleType, page) {
-    // TODO: handle the /children slot better
-    // this is a quick hack to handle when children is provided as children/page instead of /page
-    const pageKey = page.replace(/(@[^/]+)\/children/g, '$1');
-    return `${compilerType}@${pageBundleType}@${pageKey}`;
-}
-function getPageBundleType(pageBundlePath) {
-    // Handle special case for /_error
-    if (pageBundlePath === '/_error') return _pagetypes.PAGE_TYPES.PAGES;
-    if ((0, _utils.isMiddlewareFilename)(pageBundlePath)) return _pagetypes.PAGE_TYPES.ROOT;
-    return pageBundlePath.startsWith('pages/') ? _pagetypes.PAGE_TYPES.PAGES : pageBundlePath.startsWith('app/') ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.ROOT;
-}
-function getEntrypointsFromTree(tree, isFirst, parentPath = []) {
-    const [segment, parallelRoutes] = tree;
-    const currentSegment = Array.isArray(segment) ? convertDynamicParamTypeToSyntax(segment[2], segment[0]) : segment;
-    const isPageSegment = currentSegment.startsWith(_segment.PAGE_SEGMENT_KEY);
-    const currentPath = [
-        ...parentPath,
-        isPageSegment ? '' : currentSegment
-    ];
-    if (!isFirst && isPageSegment) {
-        // TODO get rid of '' at the start of tree
-        return [
-            treePathToEntrypoint(currentPath.slice(1))
-        ];
-    }
-    return Object.keys(parallelRoutes).reduce((paths, key)=>{
-        const childTree = parallelRoutes[key];
-        const childPages = getEntrypointsFromTree(childTree, false, [
-            ...currentPath,
-            key
-        ]);
-        return [
-            ...paths,
-            ...childPages
-        ];
-    }, []);
-}
-const ADDED = Symbol('added');
-const BUILDING = Symbol('building');
-const BUILT = Symbol('built');
-var EntryTypes = /*#__PURE__*/ function(EntryTypes) {
-    EntryTypes[EntryTypes["ENTRY"] = 0] = "ENTRY";
-    EntryTypes[EntryTypes["CHILD_ENTRY"] = 1] = "CHILD_ENTRY";
-    return EntryTypes;
-}({});
-const entriesMap = new Map();
-// remove /server from end of output for server compiler
-const normalizeOutputPath = (dir)=>dir.replace(/[/\\]server$/, '');
-const getEntries = (dir)=>{
-    dir = normalizeOutputPath(dir);
-    const entries = entriesMap.get(dir) || {};
-    entriesMap.set(dir, entries);
-    return entries;
-};
-const invalidators = new Map();
-const getInvalidator = (dir)=>{
-    dir = normalizeOutputPath(dir);
-    return invalidators.get(dir);
-};
-const doneCallbacks = new _events.EventEmitter();
-const lastClientAccessPages = [
-    ''
-];
-const lastServerAccessPagesForAppDir = [
-    ''
-];
-// Make sure only one invalidation happens at a time
-// Otherwise, webpack hash gets changed and it'll force the client to reload.
-class Invalidator {
-    constructor(multiCompiler){
-        this.building = new Set();
-        this.rebuildAgain = new Set();
-        this.multiCompiler = multiCompiler;
-    }
-    shouldRebuildAll() {
-        return this.rebuildAgain.size > 0;
-    }
-    invalidate(compilerKeys = COMPILER_KEYS) {
-        for (const key of compilerKeys){
-            var _this_multiCompiler_compilers_COMPILER_INDEXES_key_watching;
-            // If there's a current build is processing, we won't abort it by invalidating.
-            // (If aborted, it'll cause a client side hard reload)
-            // But let it to invalidate just after the completion.
-            // So, it can re-build the queued pages at once.
-            if (this.building.has(key)) {
-                this.rebuildAgain.add(key);
-                continue;
-            }
-            this.building.add(key);
-            (_this_multiCompiler_compilers_COMPILER_INDEXES_key_watching = this.multiCompiler.compilers[_constants.COMPILER_INDEXES[key]].watching) == null ? void 0 : _this_multiCompiler_compilers_COMPILER_INDEXES_key_watching.invalidate();
-        }
-    }
-    startBuilding(compilerKey) {
-        this.building.add(compilerKey);
-    }
-    doneBuilding(compilerKeys = []) {
-        const rebuild = [];
-        for (const key of compilerKeys){
-            this.building.delete(key);
-            if (this.rebuildAgain.has(key)) {
-                rebuild.push(key);
-                this.rebuildAgain.delete(key);
-            }
-        }
-        if (rebuild.length > 0) {
-            this.invalidate(rebuild);
-        }
-    }
-    willRebuild(compilerKey) {
-        return this.rebuildAgain.has(compilerKey);
-    }
-}
-function disposeInactiveEntries(entries, maxInactiveAge) {
-    Object.keys(entries).forEach((entryKey)=>{
-        const entryData = entries[entryKey];
-        const { lastActiveTime, status, dispose, bundlePath } = entryData;
-        // TODO-APP: implement disposing of CHILD_ENTRY
-        if (entryData.type === 1) {
-            return;
-        }
-        // For the root middleware and the instrumentation hook files,
-        // we don't dispose them periodically as it's needed for every request.
-        if ((0, _utils.isMiddlewareFilename)(bundlePath) || (0, _utils.isInstrumentationHookFilename)(bundlePath)) {
-            return;
-        }
-        if (dispose) // Skip pages already scheduled for disposing
-        return;
-        // This means this entry is currently building or just added
-        // We don't need to dispose those entries.
-        if (status !== BUILT) return;
-        // We should not build the last accessed page even we didn't get any pings
-        // Sometimes, it's possible our XHR ping to wait before completing other requests.
-        // In that case, we should not dispose the current viewing page
-        if (lastClientAccessPages.includes(entryKey) || lastServerAccessPagesForAppDir.includes(entryKey)) return;
-        if (lastActiveTime && Date.now() - lastActiveTime > maxInactiveAge) {
-            entries[entryKey].dispose = true;
-        }
-    });
-}
-// Normalize both app paths and page paths
-function tryToNormalizePagePath(page) {
-    try {
-        return (0, _normalizepagepath.normalizePagePath)(page);
-    } catch (err) {
-        console.error(err);
-        throw new _utils1.PageNotFoundError(page);
-    }
-}
-async function findPagePathData(rootDir, page, extensions, pagesDir, appDir, isGlobalNotFoundEnabled) {
-    const normalizedPagePath = tryToNormalizePagePath(page);
-    let pagePath = null;
-    const isInstrumentation = (0, _utils.isInstrumentationHookFile)(normalizedPagePath);
-    if ((0, _utils.isMiddlewareFile)(normalizedPagePath) || isInstrumentation) {
-        pagePath = await (0, _findpagefile.findPageFile)(rootDir, normalizedPagePath, extensions, false);
-        if (!pagePath) {
-            throw new _utils1.PageNotFoundError(normalizedPagePath);
-        }
-        const pageUrl = (0, _ensureleadingslash.ensureLeadingSlash)((0, _removepagepathtail.removePagePathTail)((0, _normalizepathsep.normalizePathSep)(pagePath), {
-            extensions
-        }));
-        let bundlePath = normalizedPagePath;
-        let pageKey = _path.posix.normalize(pageUrl);
-        if (isInstrumentation || (0, _utils.isMiddlewareFile)(normalizedPagePath)) {
-            bundlePath = bundlePath.replace('/src', '');
-            pageKey = page.replace('/src', '');
-        }
-        return {
-            filename: (0, _path.join)(rootDir, pagePath),
-            bundlePath: bundlePath.slice(1),
-            page: pageKey
-        };
-    }
-    // Check appDir first falling back to pagesDir
-    if (appDir) {
-        if (page === _constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY) {
-            // Load `global-not-found` when global-not-found is enabled.
-            // Prefer to load it when both `global-not-found` and root `not-found` present.
-            if (isGlobalNotFoundEnabled) {
-                const globalNotFoundPath = await (0, _findpagefile.findPageFile)(appDir, 'global-not-found', extensions, true);
-                if (globalNotFoundPath) {
-                    return {
-                        filename: (0, _path.join)(appDir, globalNotFoundPath),
-                        bundlePath: `app${_constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY}`,
-                        page: _constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY
-                    };
-                }
-            } else {
-                // Then if global-not-found.js doesn't exist then load not-found.js
-                const notFoundPath = await (0, _findpagefile.findPageFile)(appDir, 'not-found', extensions, true);
-                if (notFoundPath) {
-                    return {
-                        filename: (0, _path.join)(appDir, notFoundPath),
-                        bundlePath: `app${_constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY}`,
-                        page: _constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY
-                    };
-                }
-            }
-            // If they're not presented, then fallback to global-not-found
-            return {
-                filename: require.resolve('next/dist/client/components/builtin/global-not-found'),
-                bundlePath: `app${_constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY}`,
-                page: _constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY
-            };
-        }
-        pagePath = await (0, _findpagefile.findPageFile)(appDir, normalizedPagePath, extensions, true);
-        if (pagePath) {
-            const pageUrl = (0, _ensureleadingslash.ensureLeadingSlash)((0, _removepagepathtail.removePagePathTail)((0, _normalizepathsep.normalizePathSep)(pagePath), {
-                keepIndex: true,
-                extensions
-            }));
-            return {
-                filename: (0, _path.join)(appDir, pagePath),
-                bundlePath: _path.posix.join('app', pageUrl),
-                page: _path.posix.normalize(pageUrl)
-            };
-        }
-    }
-    if (!pagePath && pagesDir) {
-        pagePath = await (0, _findpagefile.findPageFile)(pagesDir, normalizedPagePath, extensions, false);
-    }
-    if (pagePath !== null && pagesDir) {
-        const pageUrl = (0, _ensureleadingslash.ensureLeadingSlash)((0, _removepagepathtail.removePagePathTail)((0, _normalizepathsep.normalizePathSep)(pagePath), {
-            extensions
-        }));
-        return {
-            filename: (0, _path.join)(pagesDir, pagePath),
-            bundlePath: _path.posix.join('pages', (0, _normalizepagepath.normalizePagePath)(pageUrl)),
-            page: _path.posix.normalize(pageUrl)
-        };
-    }
-    if (page === '/_error') {
-        return {
-            filename: require.resolve('next/dist/pages/_error'),
-            bundlePath: page,
-            page: (0, _normalizepathsep.normalizePathSep)(page)
-        };
-    } else {
-        throw new _utils1.PageNotFoundError(normalizedPagePath);
-    }
-}
-function onDemandEntryHandler({ hotReloader, maxInactiveAge, multiCompiler, nextConfig, pagesBufferLength, pagesDir, rootDir, appDir }) {
-    const hasAppDir = !!appDir;
-    let curInvalidator = getInvalidator(multiCompiler.outputPath);
-    const curEntries = getEntries(multiCompiler.outputPath);
-    if (!curInvalidator) {
-        curInvalidator = new Invalidator(multiCompiler);
-        invalidators.set(multiCompiler.outputPath, curInvalidator);
-    }
-    // Deferred entries state management
-    const deferredEntriesConfig = nextConfig.experimental.deferredEntries;
-    const hasDeferredEntriesConfig = deferredEntriesConfig && deferredEntriesConfig.length > 0;
-    let onBeforeDeferredEntriesCalled = false;
-    let onBeforeDeferredEntriesPromise = null;
-    // Function to wait for all non-deferred entries to be built
-    async function waitForNonDeferredEntries() {
-        return new Promise((resolve)=>{
-            const checkEntries = ()=>{
-                // Check if there are any non-deferred entries that are still building or added
-                const hasNonDeferredEntriesBuilding = Object.entries(curEntries).some(([, entry])=>{
-                    const entryData = entry;
-                    if (entryData.type !== 0) return false;
-                    const isDeferred = (0, _entries.isDeferredEntry)(entryData.absolutePagePath.replace(appDir || '', '').replace(pagesDir || '', '').replace(rootDir, ''), deferredEntriesConfig);
-                    return !isDeferred && (entryData.status === ADDED || entryData.status === BUILDING);
-                });
-                if (!hasNonDeferredEntriesBuilding) {
-                    resolve();
-                } else {
-                    // Check again after a short delay
-                    setTimeout(checkEntries, 100);
-                }
-            };
-            checkEntries();
-        });
-    }
-    // Function to handle deferred entry processing
-    async function processDeferredEntry() {
-        if (!hasDeferredEntriesConfig) return;
-        // Wait for all non-deferred entries to be built
-        await waitForNonDeferredEntries();
-        // Call the onBeforeDeferredEntries callback once
-        if (!onBeforeDeferredEntriesCalled) {
-            onBeforeDeferredEntriesCalled = true;
-            if (nextConfig.experimental.onBeforeDeferredEntries) {
-                debug('calling onBeforeDeferredEntries callback');
-                if (!onBeforeDeferredEntriesPromise) {
-                    onBeforeDeferredEntriesPromise = nextConfig.experimental.onBeforeDeferredEntries();
-                }
-                await onBeforeDeferredEntriesPromise;
-                debug('onBeforeDeferredEntries callback completed');
-            }
-        } else if (onBeforeDeferredEntriesPromise) {
-            // Wait for any in-progress callback
-            await onBeforeDeferredEntriesPromise;
-        }
-    }
-    const startBuilding = (compilation)=>{
-        const compilationName = compilation.name;
-        curInvalidator.startBuilding(compilationName);
-        // Reset deferred entries state for this compilation cycle
-        // This ensures onBeforeDeferredEntries will be called again during HMR
-        onBeforeDeferredEntriesCalled = false;
-        onBeforeDeferredEntriesPromise = null;
-    };
-    for (const compiler of multiCompiler.compilers){
-        compiler.hooks.make.tap('NextJsOnDemandEntries', startBuilding);
-    }
-    function getPagePathsFromEntrypoints(type, entrypoints) {
-        const pagePaths = [];
-        for (const entrypoint of entrypoints.values()){
-            const page = (0, _getroutefromentrypoint.default)(entrypoint.name, hasAppDir);
-            if (page) {
-                var _entrypoint_name;
-                const pageBundleType = ((_entrypoint_name = entrypoint.name) == null ? void 0 : _entrypoint_name.startsWith('app/')) ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES;
-                pagePaths.push(getEntryKey(type, pageBundleType, page));
-            } else if ((0, _utils.isMiddlewareFilename)(entrypoint.name) || (0, _utils.isInstrumentationHookFilename)(entrypoint.name)) {
-                pagePaths.push(getEntryKey(type, _pagetypes.PAGE_TYPES.ROOT, `/${entrypoint.name}`));
-            }
-        }
-        return pagePaths;
-    }
-    for (const compiler of multiCompiler.compilers){
-        compiler.hooks.done.tap('NextJsOnDemandEntries', ()=>{
-            var _getInvalidator;
-            return (_getInvalidator = getInvalidator(compiler.outputPath)) == null ? void 0 : _getInvalidator.doneBuilding([
-                compiler.name
-            ]);
-        });
-    }
-    multiCompiler.hooks.done.tap('NextJsOnDemandEntries', (multiStats)=>{
-        var _getInvalidator;
-        const [clientStats, serverStats, edgeServerStats] = multiStats.stats;
-        const entryNames = [
-            ...getPagePathsFromEntrypoints(_constants.COMPILER_NAMES.client, clientStats.compilation.entrypoints),
-            ...getPagePathsFromEntrypoints(_constants.COMPILER_NAMES.server, serverStats.compilation.entrypoints),
-            ...edgeServerStats ? getPagePathsFromEntrypoints(_constants.COMPILER_NAMES.edgeServer, edgeServerStats.compilation.entrypoints) : []
-        ];
-        for (const name of entryNames){
-            const entry = curEntries[name];
-            if (!entry) {
-                continue;
-            }
-            if (entry.status !== BUILDING) {
-                continue;
-            }
-            entry.status = BUILT;
-            doneCallbacks.emit(name);
-        }
-        (_getInvalidator = getInvalidator(multiCompiler.outputPath)) == null ? void 0 : _getInvalidator.doneBuilding([
-            ...COMPILER_KEYS
-        ]);
-        // Call onBeforeDeferredEntries after compilation completes during HMR
-        // This ensures the callback is invoked even when non-deferred entries change
-        if (hasDeferredEntriesConfig && !onBeforeDeferredEntriesCalled) {
-            onBeforeDeferredEntriesCalled = true;
-            if (nextConfig.experimental.onBeforeDeferredEntries) {
-                debug('calling onBeforeDeferredEntries callback after HMR');
-                onBeforeDeferredEntriesPromise = nextConfig.experimental.onBeforeDeferredEntries();
-            }
-        }
-    });
-    const pingIntervalTime = Math.max(1000, Math.min(5000, maxInactiveAge));
-    setInterval(function() {
-        disposeInactiveEntries(curEntries, maxInactiveAge);
-    }, pingIntervalTime + 1000).unref();
-    function handleAppDirPing(tree) {
-        const pages = getEntrypointsFromTree(tree, true);
-        for (const page of pages){
-            for (const compilerType of [
-                _constants.COMPILER_NAMES.client,
-                _constants.COMPILER_NAMES.server,
-                _constants.COMPILER_NAMES.edgeServer
-            ]){
-                const entryKey = getEntryKey(compilerType, _pagetypes.PAGE_TYPES.APP, `/${page}`);
-                const entryInfo = curEntries[entryKey];
-                // If there's no entry, it may have been invalidated and needs to be re-built.
-                if (!entryInfo) {
-                    continue;
-                }
-                // We don't need to maintain active state of anything other than BUILT entries
-                if (entryInfo.status !== BUILT) continue;
-                // If there's an entryInfo
-                if (!lastServerAccessPagesForAppDir.includes(entryKey)) {
-                    lastServerAccessPagesForAppDir.unshift(entryKey);
-                    // Maintain the buffer max length
-                    // TODO: verify that the current pageKey is not at the end of the array as multiple entrypoints can exist
-                    if (lastServerAccessPagesForAppDir.length > pagesBufferLength) {
-                        lastServerAccessPagesForAppDir.pop();
-                    }
-                }
-                entryInfo.lastActiveTime = Date.now();
-                entryInfo.dispose = false;
-            }
-        }
-    }
-    function handlePing(pg) {
-        const page = (0, _normalizepathsep.normalizePathSep)(pg);
-        for (const compilerType of [
-            _constants.COMPILER_NAMES.client,
-            _constants.COMPILER_NAMES.server,
-            _constants.COMPILER_NAMES.edgeServer
-        ]){
-            const entryKey = getEntryKey(compilerType, _pagetypes.PAGE_TYPES.PAGES, page);
-            const entryInfo = curEntries[entryKey];
-            // If there's no entry, it may have been invalidated and needs to be re-built.
-            if (!entryInfo) {
-                // if (page !== lastEntry) client pings, but there's no entry for page
-                if (compilerType === _constants.COMPILER_NAMES.client) {
-                    return;
-                }
-                continue;
-            }
-            // We don't need to maintain active state of anything other than BUILT entries
-            if (entryInfo.status !== BUILT) continue;
-            // If there's an entryInfo
-            if (!lastClientAccessPages.includes(entryKey)) {
-                lastClientAccessPages.unshift(entryKey);
-                // Maintain the buffer max length
-                if (lastClientAccessPages.length > pagesBufferLength) {
-                    lastClientAccessPages.pop();
-                }
-            }
-            entryInfo.lastActiveTime = Date.now();
-            entryInfo.dispose = false;
-        }
-        return;
-    }
-    async function ensurePageImpl({ page, appPaths, definition, isApp, url }) {
-        const stalledTime = 60;
-        const stalledEnsureTimeout = setTimeout(()=>{
-            debug(`Ensuring ${page} has taken longer than ${stalledTime}s, if this continues to stall this may be a bug`);
-        }, stalledTime * 1000);
-        try {
-            let route;
-            if (definition) {
-                route = definition;
-            } else {
-                route = await findPagePathData(rootDir, page, nextConfig.pageExtensions, pagesDir, appDir, !!nextConfig.experimental.globalNotFound);
-            }
-            const isInsideAppDir = !!appDir && route.filename.startsWith(appDir);
-            // Check if this is a deferred entry and wait for non-deferred entries first
-            if (hasDeferredEntriesConfig) {
-                const isDeferred = (0, _entries.isDeferredEntry)(route.page, deferredEntriesConfig);
-                if (isDeferred) {
-                    debug(`Page ${page} is a deferred entry, waiting for other entries`);
-                    await processDeferredEntry();
-                    debug(`Deferred entry ${page} can now be processed`);
-                }
-            }
-            if (typeof isApp === 'boolean' && isApp !== isInsideAppDir) {
-                Error.stackTraceLimit = 15;
-                throw Object.defineProperty(new Error(`Ensure bailed, found path "${route.page}" does not match ensure type (${isApp ? 'app' : 'pages'})`), "__NEXT_ERROR_CODE", {
-                    value: "E419",
-                    enumerable: false,
-                    configurable: true
-                });
-            }
-            const pageBundleType = getPageBundleType(route.bundlePath);
-            const addEntry = (compilerType)=>{
-                const entryKey = getEntryKey(compilerType, pageBundleType, route.page);
-                if (curEntries[entryKey] && // there can be an overlap in the entryKey for the instrumentation hook file and a page named the same
-                // this is a quick fix to support this scenario by overwriting the instrumentation hook entry, since we only use it one time
-                // any changes to the instrumentation hook file will require a restart of the dev server anyway
-                !(0, _utils.isInstrumentationHookFilename)(curEntries[entryKey].bundlePath)) {
-                    curEntries[entryKey].dispose = false;
-                    curEntries[entryKey].lastActiveTime = Date.now();
-                    if (curEntries[entryKey].status === BUILT) {
-                        return {
-                            entryKey,
-                            newEntry: false,
-                            shouldInvalidate: false
-                        };
-                    }
-                    return {
-                        entryKey,
-                        newEntry: false,
-                        shouldInvalidate: true
-                    };
-                }
-                curEntries[entryKey] = {
-                    type: 0,
-                    appPaths,
-                    absolutePagePath: route.filename,
-                    request: route.filename,
-                    bundlePath: route.bundlePath,
-                    dispose: false,
-                    lastActiveTime: Date.now(),
-                    status: ADDED
-                };
-                return {
-                    entryKey: entryKey,
-                    newEntry: true,
-                    shouldInvalidate: true
-                };
-            };
-            const staticInfo = await (0, _getstaticinfoincludinglayouts.getStaticInfoIncludingLayouts)({
-                page,
-                pageFilePath: route.filename,
-                isInsideAppDir,
-                pageExtensions: nextConfig.pageExtensions,
-                isDev: true,
-                config: nextConfig,
-                appDir
-            });
-            const added = new Map();
-            const isServerComponent = isInsideAppDir && staticInfo.rsc !== _constants.RSC_MODULE_TYPES.client;
-            let pageRuntime = staticInfo.runtime;
-            (0, _entries.runDependingOnPageType)({
-                page: route.page,
-                pageRuntime,
-                pageType: pageBundleType,
-                onClient: ()=>{
-                    // Skip adding the client entry for app / Server Components.
-                    if (isServerComponent || isInsideAppDir) {
-                        return;
-                    }
-                    added.set(_constants.COMPILER_NAMES.client, addEntry(_constants.COMPILER_NAMES.client));
-                },
-                onServer: ()=>{
-                    added.set(_constants.COMPILER_NAMES.server, addEntry(_constants.COMPILER_NAMES.server));
-                    const edgeServerEntry = getEntryKey(_constants.COMPILER_NAMES.edgeServer, pageBundleType, route.page);
-                    if (curEntries[edgeServerEntry] && !(0, _utils.isInstrumentationHookFile)(route.page)) {
-                        // Runtime switched from edge to server
-                        delete curEntries[edgeServerEntry];
-                    }
-                },
-                onEdgeServer: ()=>{
-                    added.set(_constants.COMPILER_NAMES.edgeServer, addEntry(_constants.COMPILER_NAMES.edgeServer));
-                    const serverEntry = getEntryKey(_constants.COMPILER_NAMES.server, pageBundleType, route.page);
-                    if (curEntries[serverEntry] && !(0, _utils.isInstrumentationHookFile)(route.page)) {
-                        // Runtime switched from server to edge
-                        delete curEntries[serverEntry];
-                    }
-                }
-            });
-            const addedValues = [
-                ...added.values()
-            ];
-            const entriesThatShouldBeInvalidated = [
-                ...added.entries()
-            ].filter(([, entry])=>entry.shouldInvalidate);
-            const hasNewEntry = addedValues.some((entry)=>entry.newEntry);
-            if (hasNewEntry) {
-                const routePage = isApp ? route.page : (0, _apppaths.normalizeAppPath)(route.page);
-                // If proxy file, remove the leading slash from "/proxy" to "proxy".
-                (0, _output.reportTrigger)((0, _utils.isMiddlewareFile)(routePage) ? routePage.slice(1) : routePage, url);
-            }
-            if (entriesThatShouldBeInvalidated.length > 0) {
-                const invalidatePromise = Promise.all(entriesThatShouldBeInvalidated.map(([compilerKey, { entryKey }])=>{
-                    return new Promise((resolve, reject)=>{
-                        doneCallbacks.once(entryKey, (err)=>{
-                            if (err) {
-                                return reject(err);
-                            }
-                            // If the invalidation also triggers a rebuild, we need to
-                            // wait for that additional build to prevent race conditions.
-                            const needsRebuild = curInvalidator.willRebuild(compilerKey);
-                            if (needsRebuild) {
-                                doneCallbacks.once(entryKey, (rebuildErr)=>{
-                                    if (rebuildErr) {
-                                        return reject(rebuildErr);
-                                    }
-                                    resolve();
-                                });
-                            } else {
-                                resolve();
-                            }
-                        });
-                    });
-                }));
-                curInvalidator.invalidate([
-                    ...added.keys()
-                ]);
-                await invalidatePromise;
-            }
-        } finally{
-            clearTimeout(stalledEnsureTimeout);
-        }
-    }
-    // Make sure that we won't have multiple invalidations ongoing concurrently.
-    const batcher = _batcher.Batcher.create({
-        // The cache key here is composed of the elements that affect the
-        // compilation, namely, the page, whether it's client only, and whether
-        // it's an app page. This ensures that we don't have multiple compilations
-        // for the same page happening concurrently.
-        //
-        // We don't include the whole match because it contains match specific
-        // parameters (like route params) that would just bust this cache. Any
-        // details that would possibly bust the cache should be listed here.
-        cacheKeyFn: (options)=>JSON.stringify(options),
-        // Schedule the invocation of the ensurePageImpl function on the next tick.
-        schedulerFn: _scheduler.scheduleOnNextTick
-    });
-    return {
-        async ensurePage ({ page, appPaths = null, definition, isApp, url }) {
-            // If the route is actually an app page route, then we should have access
-            // to the app route definition, and therefore, the appPaths from it.
-            if (!appPaths && definition && (0, _apppageroutedefinition.isAppPageRouteDefinition)(definition)) {
-                appPaths = definition.appPaths;
-            }
-            // Wrap the invocation of the ensurePageImpl function in the pending
-            // wrapper, which will ensure that we don't have multiple compilations
-            // for the same page happening concurrently.
-            return batcher.batch({
-                page,
-                appPaths,
-                definition,
-                isApp
-            }, async ()=>{
-                await ensurePageImpl({
-                    page,
-                    appPaths,
-                    definition,
-                    isApp,
-                    url
-                });
-            });
-        },
-        onHMR (client, getHmrServerError) {
-            let bufferedHmrServerError = null;
-            client.addEventListener('close', ()=>{
-                bufferedHmrServerError = null;
-            });
-            client.addEventListener('message', ({ data })=>{
-                try {
-                    const error = getHmrServerError();
-                    // New error occurred: buffered error is flushed and new error occurred
-                    if (!bufferedHmrServerError && error) {
-                        hotReloader.send({
-                            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_ERROR,
-                            errorJSON: (0, _utils1.stringifyError)(error)
-                        });
-                        bufferedHmrServerError = null;
-                    }
-                    const parsedData = JSON.parse(typeof data !== 'string' ? data.toString() : data);
-                    if (parsedData.event === _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.PING) {
-                        if (parsedData.appDirRoute) {
-                            handleAppDirPing(parsedData.tree);
-                        } else {
-                            handlePing(parsedData.page);
-                        }
-                    } else if (parsedData.event === _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.MCP_ERROR_STATE_RESPONSE) {
-                        (0, _geterrors.handleErrorStateResponse)(parsedData.requestId, parsedData.errorState, parsedData.url);
-                    } else if (parsedData.event === _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.MCP_PAGE_METADATA_RESPONSE) {
-                        (0, _getpagemetadata.handlePageMetadataResponse)(parsedData.requestId, parsedData.segmentTrieData, parsedData.url);
-                    }
-                } catch  {}
-            });
-        }
-    };
-}
-
-//# sourceMappingURL=on-demand-entry-handler.js.map