@atlaspack/core 2.24.0 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/RequestTracker.js

@@ -0,0 +1,1368 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestGraph = exports.requestTypes = exports.requestGraphEdgeTypes = void 0;
+exports.getWatcherOptions = getWatcherOptions;
+exports.readAndDeserializeRequestGraph = readAndDeserializeRequestGraph;
+exports.invalidateRequestGraph = invalidateRequestGraph;
+exports.invalidateRequestGraphFSEvents = invalidateRequestGraphFSEvents;
+exports.runInvalidation = runInvalidation;
+exports.cleanUpOrphans = cleanUpOrphans;
+exports.getBiggestFSEventsInvalidations = getBiggestFSEventsInvalidations;
+const assert_1 = __importStar(require("assert"));
+const path_1 = __importDefault(require("path"));
+const build_cache_1 = require("@atlaspack/build-cache");
+const cache_1 = require("@atlaspack/cache");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const graph_1 = require("@atlaspack/graph");
+const logger_1 = __importStar(require("@atlaspack/logger"));
+const rust_1 = require("@atlaspack/rust");
+const utils_1 = require("@atlaspack/utils");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const constants_1 = require("./constants");
+const projectPath_1 = require("./projectPath");
+const ReporterRunner_1 = require("./ReporterRunner");
+const ConfigRequest_1 = require("./requests/ConfigRequest");
+const utils_2 = require("./utils");
+const perf_hooks_1 = require("perf_hooks");
+const EnvironmentManager_1 = require("./EnvironmentManager");
+exports.requestGraphEdgeTypes = {
+    subrequest: 2,
+    invalidated_by_update: 3,
+    invalidated_by_delete: 4,
+    invalidated_by_create: 5,
+    invalidated_by_create_above: 6,
+    dirname: 7,
+};
+class FSBailoutError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'FSBailoutError';
+    }
+}
+const FILE = 0;
+const REQUEST = 1;
+const FILE_NAME = 2;
+const ENV = 3;
+const OPTION = 4;
+const GLOB = 5;
+const CONFIG_KEY = 6;
+exports.requestTypes = {
+    atlaspack_build_request: 1,
+    bundle_graph_request: 2,
+    asset_graph_request: 3,
+    entry_request: 4,
+    target_request: 5,
+    atlaspack_config_request: 6,
+    path_request: 7,
+    dev_dep_request: 8,
+    asset_request: 9,
+    config_request: 10,
+    write_bundles_request: 11,
+    package_request: 12,
+    write_bundle_request: 13,
+    validation_request: 14,
+};
+const nodeFromFilePath = (filePath) => ({
+    id: (0, projectPath_1.fromProjectPathRelative)(filePath),
+    type: FILE,
+});
+const nodeFromGlob = (glob) => ({
+    id: (0, projectPath_1.fromProjectPathRelative)(glob),
+    type: GLOB,
+    value: glob,
+});
+const nodeFromFileName = (fileName) => ({
+    id: 'file_name:' + fileName,
+    type: FILE_NAME,
+});
+const nodeFromRequest = (request) => ({
+    id: request.id,
+    type: REQUEST,
+    requestType: request.requestType,
+    invalidateReason: constants_1.INITIAL_BUILD,
+});
+const nodeFromEnv = (env, value) => ({
+    id: 'env:' + env,
+    type: ENV,
+    value,
+});
+const nodeFromOption = (option, value) => ({
+    id: 'option:' + option,
+    type: OPTION,
+    hash: (0, utils_2.hashFromOption)(value),
+});
+const nodeFromConfigKey = (fileName, configKey, contentHash) => ({
+    id: `config_key:${(0, projectPath_1.fromProjectPathRelative)(fileName)}:${JSON.stringify(configKey)}`,
+    type: CONFIG_KEY,
+    configKey,
+    contentHash,
+});
+const keyFromEnvContentKey = (contentKey) => contentKey.slice('env:'.length);
+const keyFromOptionContentKey = (contentKey) => contentKey.slice('option:'.length);
+// This constant is chosen by local profiling the time to serialise n nodes and tuning until an average time of ~50 ms per blob.
+// The goal is to free up the event loop periodically to allow interruption by the user.
+const NODES_PER_BLOB = 2 ** 14;
+// @ts-expect-error TS2417
+class RequestGraph extends graph_1.ContentGraph {
+    constructor() {
+        super(...arguments);
+        this.invalidNodeIds = new Set();
+        this.incompleteNodeIds = new Set();
+        this.incompleteNodePromises = new Map();
+        this.globNodeIds = new Set();
+        this.envNodeIds = new Set();
+        this.optionNodeIds = new Set();
+        // Unpredictable nodes are requests that cannot be predicted whether they should rerun based on
+        // filesystem changes alone. They should rerun on each startup of Atlaspack.
+        this.unpredicatableNodeIds = new Set();
+        this.invalidateOnBuildNodeIds = new Set();
+        this.cachedRequestChunks = new Set();
+        this.configKeyNodes = new Map();
+        this.nodesPerBlob = NODES_PER_BLOB;
+    }
+    static deserialize(opts) {
+        let deserialized = new RequestGraph(opts);
+        deserialized.invalidNodeIds = opts.invalidNodeIds;
+        deserialized.incompleteNodeIds = opts.incompleteNodeIds;
+        deserialized.globNodeIds = opts.globNodeIds;
+        deserialized.envNodeIds = opts.envNodeIds;
+        deserialized.optionNodeIds = opts.optionNodeIds;
+        deserialized.unpredicatableNodeIds = opts.unpredicatableNodeIds;
+        deserialized.invalidateOnBuildNodeIds = opts.invalidateOnBuildNodeIds;
+        deserialized.cachedRequestChunks = opts.cachedRequestChunks;
+        deserialized.configKeyNodes = opts.configKeyNodes;
+        return deserialized;
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            invalidNodeIds: this.invalidNodeIds,
+            incompleteNodeIds: this.incompleteNodeIds,
+            globNodeIds: this.globNodeIds,
+            envNodeIds: this.envNodeIds,
+            optionNodeIds: this.optionNodeIds,
+            unpredicatableNodeIds: this.unpredicatableNodeIds,
+            invalidateOnBuildNodeIds: this.invalidateOnBuildNodeIds,
+            cachedRequestChunks: this.cachedRequestChunks,
+            configKeyNodes: this.configKeyNodes,
+        };
+    }
+    // addNode for RequestGraph should not override the value if added multiple times
+    addNode(node) {
+        let nodeId = this._contentKeyToNodeId.get(node.id);
+        if (nodeId != null) {
+            return nodeId;
+        }
+        nodeId = super.addNodeByContentKey(node.id, node);
+        if (node.type === GLOB) {
+            this.globNodeIds.add(nodeId);
+        }
+        else if (node.type === ENV) {
+            this.envNodeIds.add(nodeId);
+        }
+        else if (node.type === OPTION) {
+            this.optionNodeIds.add(nodeId);
+        }
+        this.removeCachedRequestChunkForNode(nodeId);
+        return nodeId;
+    }
+    removeNode(nodeId, removeOrphans = true) {
+        this.invalidNodeIds.delete(nodeId);
+        this.incompleteNodeIds.delete(nodeId);
+        this.incompleteNodePromises.delete(nodeId);
+        this.unpredicatableNodeIds.delete(nodeId);
+        this.invalidateOnBuildNodeIds.delete(nodeId);
+        let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+        if (node.type === GLOB) {
+            this.globNodeIds.delete(nodeId);
+        }
+        else if (node.type === ENV) {
+            this.envNodeIds.delete(nodeId);
+        }
+        else if (node.type === OPTION) {
+            this.optionNodeIds.delete(nodeId);
+        }
+        else if (node.type === CONFIG_KEY) {
+            for (let configKeyNodes of this.configKeyNodes.values()) {
+                configKeyNodes.delete(nodeId);
+            }
+        }
+        return super.removeNode(nodeId, removeOrphans);
+    }
+    getRequestNode(nodeId) {
+        let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+        if (node.type === REQUEST) {
+            return node;
+        }
+        throw new assert_1.AssertionError({
+            message: `Expected a request node: ${node.type} (${typeof node.type}) does not equal ${REQUEST} (${typeof REQUEST}).`,
+            expected: REQUEST,
+            actual: node.type,
+        });
+    }
+    replaceSubrequests(requestNodeId, subrequestContentKeys) {
+        let subrequestNodeIds = [];
+        for (let key of subrequestContentKeys) {
+            if (this.hasContentKey(key)) {
+                subrequestNodeIds.push(this.getNodeIdByContentKey(key));
+            }
+        }
+        this.replaceNodeIdsConnectedTo(requestNodeId, subrequestNodeIds, null, exports.requestGraphEdgeTypes.subrequest);
+    }
+    invalidateNode(nodeId, reason) {
+        let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+        (0, assert_1.default)(node.type === REQUEST);
+        node.invalidateReason |= reason;
+        this.invalidNodeIds.add(nodeId);
+        let parentNodes = this.getNodeIdsConnectedTo(nodeId, exports.requestGraphEdgeTypes.subrequest);
+        for (let parentNode of parentNodes) {
+            this.invalidateNode(parentNode, reason);
+        }
+        // If the node is invalidated, the cached request chunk on disk needs to be re-written
+        this.removeCachedRequestChunkForNode(nodeId);
+    }
+    /**
+     * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+     * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+     * system.
+     */
+    invalidateUnpredictableNodes() {
+        for (let nodeId of this.unpredicatableNodeIds) {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            (0, assert_1.default)(node.type !== FILE && node.type !== GLOB);
+            this.invalidateNode(nodeId, constants_1.STARTUP);
+        }
+    }
+    /**
+     * Effectively uncacheable nodes.
+     */
+    invalidateOnBuildNodes() {
+        for (let nodeId of this.invalidateOnBuildNodeIds) {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            (0, assert_1.default)(node.type !== FILE && node.type !== GLOB);
+            this.invalidateNode(nodeId, constants_1.STARTUP);
+        }
+    }
+    /**
+     * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+     */
+    invalidateEnvNodes(env) {
+        const invalidatedKeys = [];
+        for (let nodeId of this.envNodeIds) {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            (0, assert_1.default)(node.type === ENV);
+            const key = keyFromEnvContentKey(node.id);
+            if (env[key] !== node.value) {
+                invalidatedKeys.push(key);
+                let parentNodes = this.getNodeIdsConnectedTo(nodeId, exports.requestGraphEdgeTypes.invalidated_by_update);
+                for (let parentNode of parentNodes) {
+                    this.invalidateNode(parentNode, constants_1.ENV_CHANGE);
+                }
+            }
+        }
+        return invalidatedKeys;
+    }
+    /**
+     * Nodes invalidated by option changes.
+     */
+    invalidateOptionNodes(options) {
+        const invalidatedKeys = [];
+        for (let nodeId of this.optionNodeIds) {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            (0, assert_1.default)(node.type === OPTION);
+            const key = keyFromOptionContentKey(node.id);
+            // @ts-expect-error TS7053
+            if ((0, utils_2.hashFromOption)(options[key]) !== node.hash) {
+                invalidatedKeys.push(key);
+                let parentNodes = this.getNodeIdsConnectedTo(nodeId, exports.requestGraphEdgeTypes.invalidated_by_update);
+                for (let parentNode of parentNodes) {
+                    this.invalidateNode(parentNode, constants_1.OPTION_CHANGE);
+                }
+            }
+        }
+        return invalidatedKeys;
+    }
+    invalidateOnConfigKeyChange(requestNodeId, filePath, configKey, contentHash) {
+        let configKeyNodeId = this.addNode(nodeFromConfigKey(filePath, configKey, contentHash));
+        let nodes = this.configKeyNodes.get(filePath);
+        if (!nodes) {
+            nodes = new Set();
+            this.configKeyNodes.set(filePath, nodes);
+        }
+        nodes.add(configKeyNodeId);
+        if (!this.hasEdge(requestNodeId, configKeyNodeId, exports.requestGraphEdgeTypes.invalidated_by_update)) {
+            this.addEdge(requestNodeId, configKeyNodeId, 
+            // Store as an update edge, but file deletes are handled too
+            exports.requestGraphEdgeTypes.invalidated_by_update);
+        }
+    }
+    invalidateOnFileUpdate(requestNodeId, filePath) {
+        let fileNodeId = this.addNode(nodeFromFilePath(filePath));
+        if (!this.hasEdge(requestNodeId, fileNodeId, exports.requestGraphEdgeTypes.invalidated_by_update)) {
+            this.addEdge(requestNodeId, fileNodeId, exports.requestGraphEdgeTypes.invalidated_by_update);
+        }
+    }
+    invalidateOnFileDelete(requestNodeId, filePath) {
+        let fileNodeId = this.addNode(nodeFromFilePath(filePath));
+        if (!this.hasEdge(requestNodeId, fileNodeId, exports.requestGraphEdgeTypes.invalidated_by_delete)) {
+            this.addEdge(requestNodeId, fileNodeId, exports.requestGraphEdgeTypes.invalidated_by_delete);
+        }
+    }
+    invalidateOnFileCreate(requestNodeId, input) {
+        let node;
+        // @ts-expect-error TS2339
+        if (input.glob != null) {
+            // @ts-expect-error TS2339
+            node = nodeFromGlob(input.glob);
+            // @ts-expect-error TS2339
+        }
+        else if (input.fileName != null && input.aboveFilePath != null) {
+            // @ts-expect-error TS2339
+            let aboveFilePath = input.aboveFilePath;
+            // Create nodes and edges for each part of the filename pattern.
+            // For example, 'node_modules/foo' would create two nodes and one edge.
+            // This creates a sort of trie structure within the graph that can be
+            // quickly matched by following the edges. This is also memory efficient
+            // since common sub-paths (e.g. 'node_modules') are deduplicated.
+            // @ts-expect-error TS2339
+            let parts = input.fileName.split('/').reverse();
+            let lastNodeId;
+            for (let part of parts) {
+                let fileNameNode = nodeFromFileName(part);
+                let fileNameNodeId = this.addNode(fileNameNode);
+                if (lastNodeId != null &&
+                    !this.hasEdge(lastNodeId, fileNameNodeId, exports.requestGraphEdgeTypes.dirname)) {
+                    this.addEdge(lastNodeId, fileNameNodeId, exports.requestGraphEdgeTypes.dirname);
+                }
+                lastNodeId = fileNameNodeId;
+            }
+            // The `aboveFilePath` condition asserts that requests are only invalidated
+            // if the file being created is "above" it in the filesystem (e.g. the file
+            // is created in a parent directory). There is likely to already be a node
+            // for this file in the graph (e.g. the source file) that we can reuse for this.
+            node = nodeFromFilePath(aboveFilePath);
+            let nodeId = this.addNode(node);
+            // Now create an edge from the `aboveFilePath` node to the first file_name node
+            // in the chain created above, and an edge from the last node in the chain back to
+            // the `aboveFilePath` node. When matching, we will start from the first node in
+            // the chain, and continue following it to parent directories until there is an
+            // edge pointing an `aboveFilePath` node that also points to the start of the chain.
+            // This indicates a complete match, and any requests attached to the `aboveFilePath`
+            // node will be invalidated.
+            let firstId = 'file_name:' + parts[0];
+            let firstNodeId = this.getNodeIdByContentKey(firstId);
+            if (!this.hasEdge(nodeId, firstNodeId, exports.requestGraphEdgeTypes.invalidated_by_create_above)) {
+                this.addEdge(nodeId, firstNodeId, exports.requestGraphEdgeTypes.invalidated_by_create_above);
+            }
+            (0, assert_1.default)(lastNodeId != null);
+            if (!this.hasEdge(lastNodeId, nodeId, exports.requestGraphEdgeTypes.invalidated_by_create_above)) {
+                this.addEdge(lastNodeId, nodeId, exports.requestGraphEdgeTypes.invalidated_by_create_above);
+            }
+            // @ts-expect-error TS2339
+        }
+        else if (input.filePath != null) {
+            // @ts-expect-error TS2339
+            node = nodeFromFilePath(input.filePath);
+        }
+        else {
+            throw new Error('Invalid invalidation');
+        }
+        let nodeId = this.addNode(node);
+        if (!this.hasEdge(requestNodeId, nodeId, exports.requestGraphEdgeTypes.invalidated_by_create)) {
+            this.addEdge(requestNodeId, nodeId, exports.requestGraphEdgeTypes.invalidated_by_create);
+        }
+    }
+    invalidateOnStartup(requestNodeId) {
+        this.getRequestNode(requestNodeId);
+        this.unpredicatableNodeIds.add(requestNodeId);
+    }
+    invalidateOnBuild(requestNodeId) {
+        this.getRequestNode(requestNodeId);
+        this.invalidateOnBuildNodeIds.add(requestNodeId);
+    }
+    invalidateOnEnvChange(requestNodeId, env, value) {
+        const envNode = nodeFromEnv(env, value);
+        const envNodeId = this.addNode(envNode);
+        if (!this.hasEdge(requestNodeId, envNodeId, exports.requestGraphEdgeTypes.invalidated_by_update)) {
+            this.addEdge(requestNodeId, envNodeId, exports.requestGraphEdgeTypes.invalidated_by_update);
+        }
+    }
+    invalidateOnOptionChange(requestNodeId, option, value) {
+        let optionNode = nodeFromOption(option, value);
+        let optionNodeId = this.addNode(optionNode);
+        if (!this.hasEdge(requestNodeId, optionNodeId, exports.requestGraphEdgeTypes.invalidated_by_update)) {
+            this.addEdge(requestNodeId, optionNodeId, exports.requestGraphEdgeTypes.invalidated_by_update);
+        }
+    }
+    clearInvalidations(nodeId) {
+        this.unpredicatableNodeIds.delete(nodeId);
+        this.invalidateOnBuildNodeIds.delete(nodeId);
+        this.replaceNodeIdsConnectedTo(nodeId, [], null, exports.requestGraphEdgeTypes.invalidated_by_update);
+        this.replaceNodeIdsConnectedTo(nodeId, [], null, exports.requestGraphEdgeTypes.invalidated_by_delete);
+        this.replaceNodeIdsConnectedTo(nodeId, [], null, exports.requestGraphEdgeTypes.invalidated_by_create);
+    }
+    getInvalidations(requestNodeId) {
+        if (!this.hasNode(requestNodeId)) {
+            return [];
+        }
+        // For now just handling updates. Could add creates/deletes later if needed.
+        let invalidations = this.getNodeIdsConnectedFrom(requestNodeId, exports.requestGraphEdgeTypes.invalidated_by_update);
+        // @ts-expect-error TS2322
+        return invalidations
+            .map((nodeId) => {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            switch (node.type) {
+                case FILE:
+                    return { type: 'file', filePath: (0, projectPath_1.toProjectPathUnsafe)(node.id) };
+                case ENV:
+                    return { type: 'env', key: keyFromEnvContentKey(node.id) };
+                case OPTION:
+                    return {
+                        type: 'option',
+                        key: keyFromOptionContentKey(node.id),
+                    };
+            }
+        })
+            .filter(Boolean);
+    }
+    getSubRequests(requestNodeId) {
+        if (!this.hasNode(requestNodeId)) {
+            return [];
+        }
+        let subRequests = this.getNodeIdsConnectedFrom(requestNodeId, exports.requestGraphEdgeTypes.subrequest);
+        return subRequests.map((nodeId) => {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            (0, assert_1.default)(node.type === REQUEST);
+            return node;
+        });
+    }
+    getInvalidSubRequests(requestNodeId) {
+        if (!this.hasNode(requestNodeId)) {
+            return [];
+        }
+        let subRequests = this.getNodeIdsConnectedFrom(requestNodeId, exports.requestGraphEdgeTypes.subrequest);
+        return subRequests
+            .filter((id) => this.invalidNodeIds.has(id))
+            .map((nodeId) => {
+            let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+            (0, assert_1.default)(node.type === REQUEST);
+            return node;
+        });
+    }
+    invalidateFileNameNode(node, filePath, matchNodes, invalidateNode) {
+        // If there is an edge between this file_name node and one of the original file nodes pointed to
+        // by the original file_name node, and the matched node is inside the current directory, invalidate
+        // all connected requests pointed to by the file node.
+        let nodeId = this.getNodeIdByContentKey(node.id);
+        let dirname = path_1.default.dirname((0, projectPath_1.fromProjectPathRelative)(filePath));
+        if ((0, feature_flags_1.getFeatureFlag)('fixQuadraticCacheInvalidation')) {
+            while (dirname !== '/') {
+                if (!this.hasContentKey(dirname))
+                    break;
+                const matchNodeId = this.getNodeIdByContentKey(dirname);
+                if (!this.hasEdge(nodeId, matchNodeId, exports.requestGraphEdgeTypes.invalidated_by_create_above))
+                    break;
+                const connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, exports.requestGraphEdgeTypes.invalidated_by_create);
+                for (let connectedNode of connectedNodes) {
+                    invalidateNode(connectedNode, constants_1.FILE_CREATE);
+                }
+                dirname = path_1.default.dirname(dirname);
+            }
+        }
+        else {
+            for (let matchNode of matchNodes) {
+                let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
+                if (this.hasEdge(nodeId, matchNodeId, exports.requestGraphEdgeTypes.invalidated_by_create_above) &&
+                    (0, utils_1.isDirectoryInside)((0, projectPath_1.fromProjectPathRelative)((0, projectPath_1.toProjectPathUnsafe)(matchNode.id)), dirname)) {
+                    let connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, exports.requestGraphEdgeTypes.invalidated_by_create);
+                    for (let connectedNode of connectedNodes) {
+                        this.invalidateNode(connectedNode, constants_1.FILE_CREATE);
+                    }
+                }
+            }
+        }
+        // Find the `file_name` node for the parent directory and
+        // recursively invalidate connected requests as described above.
+        let basename = path_1.default.basename(dirname);
+        let contentKey = 'file_name:' + basename;
+        if (this.hasContentKey(contentKey)) {
+            if (this.hasEdge(nodeId, this.getNodeIdByContentKey(contentKey), exports.requestGraphEdgeTypes.dirname)) {
+                let parent = (0, nullthrows_1.default)(this.getNodeByContentKey(contentKey));
+                (0, assert_1.default)(parent.type === FILE_NAME);
+                this.invalidateFileNameNode(parent, (0, projectPath_1.toProjectPathUnsafe)(dirname), matchNodes, invalidateNode);
+            }
+        }
+    }
+    async respondToFSEvents(events, options, threshold, 
+    /**
+     * True if this is the start-up (loading phase) invalidation.
+     */
+    isInitialBuild = false) {
+        let didInvalidate = false;
+        let count = 0;
+        let predictedTime = 0;
+        let startTime = Date.now();
+        const enableOptimization = (0, feature_flags_1.getFeatureFlag)('fixQuadraticCacheInvalidation');
+        const removeOrphans = !enableOptimization;
+        const invalidatedNodes = new Set();
+        const invalidateNode = (nodeId, reason) => {
+            if (enableOptimization && invalidatedNodes.has(nodeId)) {
+                return;
+            }
+            invalidatedNodes.add(nodeId);
+            this.invalidateNode(nodeId, reason);
+        };
+        const aboveCache = new Map();
+        const getAbove = (fileNameNodeId) => {
+            const cachedResult = aboveCache.get(fileNameNodeId);
+            if (enableOptimization && cachedResult) {
+                return cachedResult;
+            }
+            let above = [];
+            const children = this.getNodeIdsConnectedTo(fileNameNodeId, exports.requestGraphEdgeTypes.invalidated_by_create_above);
+            for (const nodeId of children) {
+                let node = (0, nullthrows_1.default)(this.getNode(nodeId));
+                if (node.type === FILE) {
+                    above.push(node);
+                }
+            }
+            aboveCache.set(fileNameNodeId, above);
+            return above;
+        };
+        const invalidationsByPath = new Map();
+        for (let { path: _path, type } of events) {
+            const invalidationsBefore = this.getInvalidNodeCount();
+            if (!enableOptimization &&
+                process.env.ATLASPACK_DISABLE_CACHE_TIMEOUT !== 'true' &&
+                ++count === 256) {
+                let duration = Date.now() - startTime;
+                predictedTime = duration * (events.length >> 8);
+                if (predictedTime > threshold) {
+                    logger_1.default.warn({
+                        origin: '@atlaspack/core',
+                        message: 'Building with clean cache. Cache invalidation took too long.',
+                        meta: {
+                            trackableEvent: 'cache_invalidation_timeout',
+                            watcherEventCount: events.length,
+                            predictedTime,
+                        },
+                    });
+                    throw new FSBailoutError('Responding to file system events exceeded threshold, start with empty cache.');
+                }
+            }
+            let _filePath = (0, projectPath_1.toProjectPath)(options.projectRoot, _path);
+            let filePath = (0, projectPath_1.fromProjectPathRelative)(_filePath);
+            let hasFileRequest = this.hasContentKey(filePath);
+            // If we see a 'create' event for the project root itself,
+            // this means the project root was moved and we need to
+            // re-run all requests.
+            if (type === 'create' && filePath === '') {
+                logger_1.default.verbose({
+                    origin: '@atlaspack/core',
+                    message: 'Watcher reported project root create event. Invalidate all nodes.',
+                    meta: {
+                        trackableEvent: 'project_root_create',
+                    },
+                });
+                for (let [id, node] of this.nodes.entries()) {
+                    if (node?.type === REQUEST) {
+                        this.invalidNodeIds.add(id);
+                    }
+                }
+                return {
+                    didInvalidate: true,
+                    invalidationsByPath: new Map(),
+                };
+            }
+            // sometimes mac os reports update events as create events.
+            // if it was a create event, but the file already exists in the graph,
+            // then also invalidate nodes connected by invalidated_by_update edges.
+            if (hasFileRequest && (type === 'create' || type === 'update')) {
+                let nodeId = this.getNodeIdByContentKey(filePath);
+                let nodes = this.getNodeIdsConnectedTo(nodeId, exports.requestGraphEdgeTypes.invalidated_by_update);
+                for (let connectedNode of nodes) {
+                    didInvalidate = true;
+                    invalidateNode(connectedNode, constants_1.FILE_UPDATE);
+                }
+                if (type === 'create') {
+                    let nodes = this.getNodeIdsConnectedTo(nodeId, exports.requestGraphEdgeTypes.invalidated_by_create);
+                    for (let connectedNode of nodes) {
+                        didInvalidate = true;
+                        invalidateNode(connectedNode, constants_1.FILE_CREATE);
+                    }
+                }
+            }
+            else if (type === 'create') {
+                let basename = path_1.default.basename(filePath);
+                let fileNameNode = this.getNodeByContentKey('file_name:' + basename);
+                if (fileNameNode != null && fileNameNode.type === FILE_NAME) {
+                    let fileNameNodeId = this.getNodeIdByContentKey('file_name:' + basename);
+                    // Find potential file nodes to be invalidated if this file name pattern matches
+                    let above = getAbove(fileNameNodeId);
+                    if (above.length > 0) {
+                        didInvalidate = true;
+                        this.invalidateFileNameNode(fileNameNode, _filePath, above, invalidateNode);
+                    }
+                }
+                for (let globeNodeId of this.globNodeIds) {
+                    let globNode = this.getNode(globeNodeId);
+                    (0, assert_1.default)(globNode && globNode.type === GLOB);
+                    if ((0, utils_1.isGlobMatch)(filePath, (0, projectPath_1.fromProjectPathRelative)(globNode.value))) {
+                        let connectedNodes = this.getNodeIdsConnectedTo(globeNodeId, exports.requestGraphEdgeTypes.invalidated_by_create);
+                        for (let connectedNode of connectedNodes) {
+                            didInvalidate = true;
+                            invalidateNode(connectedNode, constants_1.FILE_CREATE);
+                        }
+                    }
+                }
+            }
+            else if (hasFileRequest && type === 'delete') {
+                let nodeId = this.getNodeIdByContentKey(filePath);
+                for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, exports.requestGraphEdgeTypes.invalidated_by_delete)) {
+                    didInvalidate = true;
+                    invalidateNode(connectedNode, constants_1.FILE_DELETE);
+                }
+                // Delete the file node since it doesn't exist anymore.
+                // This ensures that files that don't exist aren't sent
+                // to requests as invalidations for future requests.
+                this.removeNode(nodeId, removeOrphans);
+            }
+            let configKeyNodes = this.configKeyNodes.get(_filePath);
+            // With granular invalidations we will always run this block,
+            // so even if we get a create event (for whatever reason), we will still
+            // try to limit invalidations from config key changes through hashing.
+            //
+            // Currently create events can invalidate a large number of nodes due to
+            // "create above" invalidations.
+            if (configKeyNodes) {
+                for (let nodeId of configKeyNodes) {
+                    let isInvalid = type === 'delete';
+                    if (type !== 'delete') {
+                        let node = this.getNode(nodeId);
+                        (0, assert_1.default)(node && node.type === CONFIG_KEY);
+                        let contentHash = await (0, ConfigRequest_1.getConfigKeyContentHash)(_filePath, node.configKey, options);
+                        isInvalid = node.contentHash !== contentHash;
+                    }
+                    if (isInvalid) {
+                        for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, exports.requestGraphEdgeTypes.invalidated_by_update)) {
+                            invalidateNode(connectedNode, type === 'delete' ? constants_1.FILE_DELETE : constants_1.FILE_UPDATE);
+                        }
+                        didInvalidate = true;
+                        this.removeNode(nodeId, removeOrphans);
+                    }
+                }
+            }
+            const invalidationsAfter = this.getInvalidNodeCount();
+            const invalidationsForEvent = invalidationsAfter - invalidationsBefore;
+            invalidationsByPath.set(_path, (invalidationsByPath.get(_path) ?? 0) + invalidationsForEvent);
+        }
+        if ((0, feature_flags_1.getFeatureFlag)('fixQuadraticCacheInvalidation')) {
+            cleanUpOrphans(this);
+        }
+        let duration = Date.now() - startTime;
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: `RequestGraph.respondToFSEvents duration: ${duration}`,
+            meta: {
+                trackableEvent: 'fsevent_response_time',
+                duration,
+                predictedTime,
+                isInitialBuild,
+                numberOfEvents: events.length,
+                numberOfInvalidatedNodes: invalidatedNodes.size,
+            },
+        });
+        return {
+            didInvalidate,
+            invalidationsByPath,
+        };
+    }
+    hasCachedRequestChunk(index) {
+        return this.cachedRequestChunks.has(index);
+    }
+    setCachedRequestChunk(index) {
+        this.cachedRequestChunks.add(index);
+    }
+    removeCachedRequestChunkForNode(nodeId) {
+        this.cachedRequestChunks.delete(Math.floor(nodeId / this.nodesPerBlob));
+    }
+    /**
+     * Returns the number of invalidated nodes in the graph.
+     */
+    getInvalidNodeCount() {
+        return this.invalidNodeIds.size;
+    }
+}
+exports.RequestGraph = RequestGraph;
+class RequestTracker {
+    constructor({ graph, farm, options, rustAtlaspack, }) {
+        this.stats = new Map();
+        this.graph = graph || new RequestGraph();
+        this.farm = farm;
+        this.options = options;
+        this.rustAtlaspack = rustAtlaspack;
+    }
+    startRequest(request) {
+        let didPreviouslyExist = this.graph.hasContentKey(request.id);
+        let requestNodeId;
+        if (didPreviouslyExist) {
+            requestNodeId = this.graph.getNodeIdByContentKey(request.id);
+            // Clear existing invalidations for the request so that the new
+            // invalidations created during the request replace the existing ones.
+            this.graph.clearInvalidations(requestNodeId);
+        }
+        else {
+            requestNodeId = this.graph.addNode(nodeFromRequest(request));
+        }
+        this.graph.incompleteNodeIds.add(requestNodeId);
+        this.graph.invalidNodeIds.delete(requestNodeId);
+        let { promise, deferred } = (0, utils_1.makeDeferredWithPromise)();
+        // @ts-expect-error TS2345
+        this.graph.incompleteNodePromises.set(requestNodeId, promise);
+        return { requestNodeId, deferred };
+    }
+    // If a cache key is provided, the result will be removed from the node and stored in a separate cache entry
+    storeResult(nodeId, result, cacheKey) {
+        let node = this.graph.getNode(nodeId);
+        if (node && node.type === REQUEST) {
+            node.result = result;
+            node.resultCacheKey = cacheKey;
+        }
+    }
+    hasValidResult(nodeId) {
+        return (this.graph.hasNode(nodeId) &&
+            !this.graph.invalidNodeIds.has(nodeId) &&
+            !this.graph.incompleteNodeIds.has(nodeId));
+    }
+    async getRequestResult(contentKey, ifMatch) {
+        let node = (0, nullthrows_1.default)(this.graph.getNodeByContentKey(contentKey));
+        (0, assert_1.default)(node.type === REQUEST);
+        if (ifMatch != null && node.resultCacheKey !== ifMatch) {
+            return null;
+        }
+        if (node.result != undefined) {
+            let result = node.result;
+            return result;
+        }
+        else if (node.resultCacheKey != null && ifMatch == null) {
+            let key = node.resultCacheKey;
+            if (!(0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+                (0, assert_1.default)(this.options.cache.hasLargeBlob(key));
+            }
+            let cachedResult = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+                ? (0, nullthrows_1.default)(await this.options.cache.get(key))
+                : (0, build_cache_1.deserialize)(await this.options.cache.getLargeBlob(key));
+            node.result = cachedResult;
+            return cachedResult;
+        }
+    }
+    completeRequest(nodeId) {
+        this.graph.invalidNodeIds.delete(nodeId);
+        this.graph.incompleteNodeIds.delete(nodeId);
+        this.graph.incompleteNodePromises.delete(nodeId);
+        let node = this.graph.getNode(nodeId);
+        if (node && node.type === REQUEST) {
+            node.invalidateReason = constants_1.VALID;
+        }
+        this.graph.removeCachedRequestChunkForNode(nodeId);
+    }
+    rejectRequest(nodeId) {
+        this.graph.incompleteNodeIds.delete(nodeId);
+        this.graph.incompleteNodePromises.delete(nodeId);
+        let node = this.graph.getNode(nodeId);
+        if (node?.type === REQUEST) {
+            this.graph.invalidateNode(nodeId, constants_1.ERROR);
+        }
+    }
+    respondToFSEvents(events, threshold) {
+        return this.graph.respondToFSEvents(events, this.options, threshold);
+    }
+    hasInvalidRequests() {
+        return this.graph.invalidNodeIds.size > 0;
+    }
+    getInvalidRequests() {
+        let invalidRequests = [];
+        for (let id of this.graph.invalidNodeIds) {
+            let node = (0, nullthrows_1.default)(this.graph.getNode(id));
+            (0, assert_1.default)(node.type === REQUEST);
+            invalidRequests.push(node);
+        }
+        return invalidRequests;
+    }
+    replaceSubrequests(requestNodeId, subrequestContextKeys) {
+        this.graph.replaceSubrequests(requestNodeId, subrequestContextKeys);
+    }
+    async runRequest(request, opts) {
+        let hasKey = this.graph.hasContentKey(request.id);
+        let requestId = hasKey
+            ? this.graph.getNodeIdByContentKey(request.id)
+            : undefined;
+        let hasValidResult = requestId != null && this.hasValidResult(requestId);
+        if (!opts?.force && hasValidResult) {
+            // @ts-expect-error TS2322
+            return this.getRequestResult(request.id);
+        }
+        if (requestId != null) {
+            let incompletePromise = this.graph.incompleteNodePromises.get(requestId);
+            if (incompletePromise != null) {
+                // There is a another instance of this request already running, wait for its completion and reuse its result
+                try {
+                    if (await incompletePromise) {
+                        // @ts-expect-error TS2322
+                        return this.getRequestResult(request.id);
+                    }
+                }
+                catch (e) {
+                    // Rerun this request
+                }
+            }
+        }
+        let previousInvalidations = requestId != null ? this.graph.getInvalidations(requestId) : [];
+        let { requestNodeId, deferred } = this.startRequest({
+            id: request.id,
+            type: REQUEST,
+            requestType: request.type,
+            invalidateReason: constants_1.INITIAL_BUILD,
+        });
+        let { api, subRequestContentKeys } = this.createAPI(requestNodeId, previousInvalidations);
+        try {
+            let node = this.graph.getRequestNode(requestNodeId);
+            this.stats.set(request.type, (this.stats.get(request.type) ?? 0) + 1);
+            let result = await request.run({
+                input: request.input,
+                api,
+                farm: this.farm,
+                invalidateReason: node.invalidateReason,
+                options: this.options,
+                rustAtlaspack: this.rustAtlaspack,
+            });
+            this.completeRequest(requestNodeId);
+            deferred.resolve(true);
+            return result;
+        }
+        catch (err) {
+            if (!(err instanceof utils_2.BuildAbortError) &&
+                request.type === exports.requestTypes.dev_dep_request) {
+                logger_1.default.verbose({
+                    origin: '@atlaspack/core',
+                    message: `Failed DevDepRequest`,
+                    meta: {
+                        trackableEvent: 'failed_dev_dep_request',
+                        hasKey,
+                        hasValidResult,
+                    },
+                });
+            }
+            this.rejectRequest(requestNodeId);
+            deferred.resolve(false);
+            throw err;
+        }
+        finally {
+            this.graph.replaceSubrequests(requestNodeId, [...subRequestContentKeys]);
+        }
+    }
+    flushStats() {
+        let requestTypeEntries = {};
+        for (let key of Object.keys(exports.requestTypes)) {
+            requestTypeEntries[exports.requestTypes[key]] = key;
+        }
+        let formattedStats = {};
+        for (let [requestType, count] of this.stats.entries()) {
+            let requestTypeName = requestTypeEntries[requestType];
+            formattedStats[requestTypeName] = count;
+        }
+        this.stats = new Map();
+        return formattedStats;
+    }
+    createAPI(requestId, previousInvalidations) {
+        let subRequestContentKeys = new Set();
+        let api = {
+            invalidateOnFileCreate: (input) => this.graph.invalidateOnFileCreate(requestId, input),
+            invalidateOnConfigKeyChange: (filePath, configKey, contentHash) => this.graph.invalidateOnConfigKeyChange(requestId, filePath, configKey, contentHash),
+            invalidateOnFileDelete: (filePath) => this.graph.invalidateOnFileDelete(requestId, filePath),
+            invalidateOnFileUpdate: (filePath) => this.graph.invalidateOnFileUpdate(requestId, filePath),
+            invalidateOnStartup: () => this.graph.invalidateOnStartup(requestId),
+            invalidateOnBuild: () => this.graph.invalidateOnBuild(requestId),
+            invalidateOnEnvChange: (env) => this.graph.invalidateOnEnvChange(requestId, env, this.options.env[env]),
+            invalidateOnOptionChange: (option) => this.graph.invalidateOnOptionChange(requestId, option, 
+            // @ts-expect-error TS7053
+            this.options[option]),
+            getInvalidations: () => previousInvalidations,
+            storeResult: (result, cacheKey) => {
+                this.storeResult(requestId, result, cacheKey);
+            },
+            getSubRequests: () => this.graph.getSubRequests(requestId),
+            getInvalidSubRequests: () => this.graph.getInvalidSubRequests(requestId),
+            getPreviousResult: (ifMatch) => {
+                let contentKey = (0, nullthrows_1.default)(this.graph.getNode(requestId)?.id);
+                return this.getRequestResult(contentKey, ifMatch);
+            },
+            getRequestResult: (
+            // @ts-expect-error TS7006
+            id) => this.getRequestResult(id),
+            canSkipSubrequest: (contentKey) => {
+                if (this.graph.hasContentKey(contentKey) &&
+                    this.hasValidResult(this.graph.getNodeIdByContentKey(contentKey))) {
+                    subRequestContentKeys.add(contentKey);
+                    return true;
+                }
+                return false;
+            },
+            runRequest: (subRequest, opts) => {
+                subRequestContentKeys.add(subRequest.id);
+                return this.runRequest(subRequest, opts);
+            },
+        };
+        return { api, subRequestContentKeys };
+    }
+    async writeToCache(signal) {
+        const options = this.options;
+        async function runCacheImprovements(newPath, oldPath) {
+            if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+                (0, assert_1.default)(options.cache instanceof cache_1.LMDBLiteCache);
+                const result = await newPath(options.cache);
+                return result;
+            }
+            else {
+                const result = await oldPath();
+                return result;
+            }
+        }
+        let cacheKey = getCacheKey(this.options);
+        let requestGraphKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+            ? `${cacheKey}/RequestGraph`
+            : `requestGraph-${cacheKey}`;
+        let snapshotKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+            ? `${cacheKey}/snapshot`
+            : `snapshot-${cacheKey}`;
+        if (this.options.shouldDisableCache) {
+            return;
+        }
+        let total = 0;
+        await runCacheImprovements(async (cache) => {
+            await cache.getNativeRef().startWriteTransaction();
+        }, () => Promise.resolve());
+        try {
+            (0, ReporterRunner_1.report)({
+                type: 'cache',
+                phase: 'start',
+                total,
+                size: this.graph.nodes.length,
+            });
+            if ((0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
+                await (0, EnvironmentManager_1.writeEnvironmentsToCache)(options.cache);
+            }
+            let serialisedGraph = this.graph.serialize();
+            // Delete an existing request graph cache, to prevent invalid states
+            await this.options.cache.deleteLargeBlob(requestGraphKey);
+            const serialiseAndSet = async (key, contents) => {
+                if (signal?.aborted) {
+                    throw new Error('Serialization was aborted');
+                }
+                await runCacheImprovements((cache) => {
+                    (0, logger_1.instrument)(`RequestTracker::writeToCache::cache.put(${key})`, () => {
+                        cache.getNativeRef().putNoConfirm(key, (0, build_cache_1.serialize)(contents));
+                    });
+                    return Promise.resolve();
+                }, async () => {
+                    await this.options.cache.setLargeBlob(key, (0, build_cache_1.serialize)(contents), signal
+                        ? {
+                            signal: signal,
+                        }
+                        : undefined);
+                });
+                total += 1;
+                (0, ReporterRunner_1.report)({
+                    type: 'cache',
+                    phase: 'write',
+                    total,
+                    size: this.graph.nodes.length,
+                });
+            };
+            let queue = new utils_1.PromiseQueue({
+                maxConcurrent: 32,
+            });
+            // Preallocating a sparse array is faster than pushing when N is high enough
+            let cacheableNodes = new Array(serialisedGraph.nodes.length);
+            for (let i = 0; i < serialisedGraph.nodes.length; i += 1) {
+                let node = serialisedGraph.nodes[i];
+                // @ts-expect-error TS2339
+                let resultCacheKey = node?.resultCacheKey;
+                if (node?.type === REQUEST &&
+                    resultCacheKey != null &&
+                    node?.result != null) {
+                    queue.add(() => serialiseAndSet(resultCacheKey, node.result));
+                    // eslint-disable-next-line no-unused-vars
+                    let { result: _, ...newNode } = node;
+                    cacheableNodes[i] = newNode;
+                }
+                else {
+                    cacheableNodes[i] = node;
+                }
+            }
+            let nodeCountsPerBlob = [];
+            for (let i = 0; i * this.graph.nodesPerBlob < cacheableNodes.length; i += 1) {
+                let nodesStartIndex = i * this.graph.nodesPerBlob;
+                let nodesEndIndex = Math.min((i + 1) * this.graph.nodesPerBlob, cacheableNodes.length);
+                nodeCountsPerBlob.push(nodesEndIndex - nodesStartIndex);
+                if (!this.graph.hasCachedRequestChunk(i)) {
+                    // We assume the request graph nodes are immutable and won't change
+                    let nodesToCache = cacheableNodes.slice(nodesStartIndex, nodesEndIndex);
+                    queue.add(() => serialiseAndSet(getRequestGraphNodeKey(i, cacheKey), nodesToCache).then(() => {
+                        // Succeeded in writing to disk, save that we have completed this chunk
+                        this.graph.setCachedRequestChunk(i);
+                    }));
+                }
+            }
+            await queue.run();
+            // Set the request graph after the queue is flushed to avoid writing an invalid state
+            await serialiseAndSet(requestGraphKey, {
+                ...serialisedGraph,
+                nodeCountsPerBlob,
+                nodes: undefined,
+            });
+            await runCacheImprovements(() => serialiseAndSet(`${cacheKey}/cache_metadata`, {
+                version: constants_1.ATLASPACK_VERSION,
+                entries: this.options.entries,
+                mode: this.options.mode,
+                shouldBuildLazily: this.options.shouldBuildLazily,
+                watchBackend: this.options.watchBackend,
+            }), () => Promise.resolve());
+            let opts = getWatcherOptions(this.options);
+            let snapshotPath = path_1.default.join(this.options.cacheDir, snapshotKey + '.txt');
+            await this.options.outputFS.writeSnapshot(this.options.watchDir, snapshotPath, opts);
+        }
+        catch (err) {
+            // If we have aborted, ignore the error and continue
+            if (!signal?.aborted)
+                throw err;
+        }
+        finally {
+            await runCacheImprovements(async (cache) => {
+                await cache.getNativeRef().commitWriteTransaction();
+            }, () => Promise.resolve());
+        }
+        (0, ReporterRunner_1.report)({ type: 'cache', phase: 'end', total, size: this.graph.nodes.length });
+    }
+    static async init({ farm, options, rustAtlaspack, }) {
+        let graph = await loadRequestGraph(options);
+        return new RequestTracker({ farm, graph, options, rustAtlaspack });
+    }
+}
+exports.default = RequestTracker;
+function getWatcherOptions({ watchIgnore = [], cacheDir, watchDir, watchBackend, }) {
+    const vcsDirs = ['.git', '.hg'];
+    const uniqueDirs = [...new Set([...watchIgnore, ...vcsDirs, cacheDir])];
+    const ignore = uniqueDirs.map((dir) => path_1.default.resolve(watchDir, dir));
+    return { ignore, backend: watchBackend };
+}
+function getCacheKey(options) {
+    if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+        const hash = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
+        return `RequestTracker/${constants_1.ATLASPACK_VERSION}/${hash}`;
+    }
+    return (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
+}
+function getRequestGraphNodeKey(index, cacheKey) {
+    if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+        return `${cacheKey}/RequestGraph/nodes/${index}`;
+    }
+    return `requestGraph-nodes-${index}-${cacheKey}`;
+}
+async function readAndDeserializeRequestGraph(cache, requestGraphKey, cacheKey) {
+    let bufferLength = 0;
+    const getAndDeserialize = async (key) => {
+        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+            const buffer = await cache.getBlob(key);
+            bufferLength += Buffer.byteLength(buffer);
+            return (0, build_cache_1.deserialize)(buffer);
+        }
+        else {
+            const buffer = await cache.getLargeBlob(key);
+            bufferLength += Buffer.byteLength(buffer);
+            return (0, build_cache_1.deserialize)(buffer);
+        }
+    };
+    let serializedRequestGraph = await getAndDeserialize(requestGraphKey);
+    let nodePromises = serializedRequestGraph.nodeCountsPerBlob.map(
+    // @ts-expect-error TS7006
+    async (nodesCount, i) => {
+        let nodes = await getAndDeserialize(getRequestGraphNodeKey(i, cacheKey));
+        assert_1.default.equal(nodes.length, nodesCount, 'RequestTracker node chunk: invalid node count');
+        return nodes;
+    });
+    return {
+        requestGraph: RequestGraph.deserialize({
+            ...serializedRequestGraph,
+            nodes: (await Promise.all(nodePromises)).flat(),
+        }),
+        // This is used inside atlaspack query for `.inspectCache`
+        bufferLength,
+    };
+}
+async function loadRequestGraph(options) {
+    if (options.shouldDisableCache) {
+        return new RequestGraph();
+    }
+    let cacheKey = getCacheKey(options);
+    let requestGraphKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+        ? `${cacheKey}/RequestGraph`
+        : `requestGraph-${cacheKey}`;
+    let timeout;
+    const snapshotKey = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+        ? `${cacheKey}/snapshot`
+        : `snapshot-${cacheKey}`;
+    const snapshotPath = path_1.default.join(options.cacheDir, snapshotKey + '.txt');
+    const commonMeta = {
+        cacheKey,
+        snapshotKey,
+        cacheKeyOptions: {
+            version: constants_1.ATLASPACK_VERSION,
+            entries: options.entries,
+            mode: options.mode,
+            shouldBuildLazily: options.shouldBuildLazily,
+            watchBackend: options.watchBackend,
+        },
+    };
+    logger_1.default.verbose({
+        origin: '@atlaspack/core',
+        message: 'Loading request graph',
+        meta: {
+            ...commonMeta,
+        },
+    });
+    if ((0, feature_flags_1.getFeatureFlag)('environmentDeduplication')) {
+        await (0, EnvironmentManager_1.loadEnvironmentsFromCache)(options.cache);
+    }
+    const hasRequestGraphInCache = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+        ? await options.cache.has(requestGraphKey)
+        : await options.cache.hasLargeBlob(requestGraphKey);
+    if (hasRequestGraphInCache) {
+        try {
+            let { requestGraph } = await readAndDeserializeRequestGraph(options.cache, requestGraphKey, cacheKey);
+            let opts = getWatcherOptions(options);
+            timeout = setTimeout(() => {
+                logger_1.default.warn({
+                    origin: '@atlaspack/core',
+                    message: `Retrieving file system events since last build...\nThis can take upto a minute after branch changes or npm/yarn installs.`,
+                });
+            }, 5000);
+            let startTime = Date.now();
+            let events = process.env.ATLASPACK_BYPASS_CACHE_INVALIDATION === 'true'
+                ? []
+                : await options.inputFS.getEventsSince(options.watchDir, snapshotPath, opts);
+            clearTimeout(timeout);
+            logger_1.default.verbose({
+                origin: '@atlaspack/core',
+                message: `File system event count: ${events.length}`,
+                meta: {
+                    ...commonMeta,
+                    trackableEvent: 'watcher_events_count',
+                    watcherEventCount: events.length,
+                    duration: Date.now() - startTime,
+                },
+            });
+            if ((0, feature_flags_1.getFeatureFlag)('verboseRequestInvalidationStats')) {
+                const invalidationStats = await invalidateRequestGraph(requestGraph, options, events);
+                logger_1.default.verbose({
+                    origin: '@atlaspack/core',
+                    message: 'Request track loaded from cache',
+                    meta: {
+                        ...commonMeta,
+                        trackableEvent: 'request_tracker_cache_key_hit',
+                        invalidationStats,
+                    },
+                });
+            }
+            else {
+                requestGraph.invalidateUnpredictableNodes();
+                requestGraph.invalidateOnBuildNodes();
+                requestGraph.invalidateEnvNodes(options.env);
+                requestGraph.invalidateOptionNodes(options);
+            }
+            return requestGraph;
+        }
+        catch (e) {
+            // Prevent logging fs events took too long warning
+            clearTimeout(timeout);
+            logErrorOnBailout(options, snapshotPath, e);
+            // This error means respondToFSEvents timed out handling the invalidation events
+            // In this case we'll return a fresh RequestGraph
+            return new RequestGraph();
+        }
+    }
+    logger_1.default.verbose({
+        origin: '@atlaspack/core',
+        message: 'Cache entry for request tracker was not found, initializing a clean cache.',
+        meta: {
+            ...commonMeta,
+            trackableEvent: 'request_tracker_cache_key_miss',
+        },
+    });
+    return new RequestGraph();
+}
+/**
+ * Respond to unpredictable, build, environment changes, option changes and file-system events
+ * invalidating RequestGraph nodes.
+ *
+ * Returns the count of nodes invalidated by each invalidation type.
+ */
+async function invalidateRequestGraph(requestGraph, options, events) {
+    const invalidationFns = [
+        {
+            key: 'unpredictable',
+            // @ts-expect-error TS2322
+            fn: () => requestGraph.invalidateUnpredictableNodes(),
+        },
+        {
+            key: 'onBuild',
+            // @ts-expect-error TS2322
+            fn: () => requestGraph.invalidateOnBuildNodes(),
+        },
+        {
+            key: 'env',
+            fn: () => requestGraph.invalidateEnvNodes(options.env),
+        },
+        {
+            key: 'option',
+            fn: () => requestGraph.invalidateOptionNodes(options),
+        },
+        {
+            key: 'fsEvents',
+            fn: () => invalidateRequestGraphFSEvents(requestGraph, options, events),
+        },
+    ];
+    const invalidations = [];
+    for (const invalidation of invalidationFns) {
+        invalidations.push(await runInvalidation(requestGraph, invalidation));
+    }
+    const invalidatedCount = invalidations.reduce((acc, invalidation) => acc + invalidation.count, 0);
+    const requestCount = requestGraph.nodes.reduce((acc, node) => acc + (node?.type === REQUEST ? 1 : 0), 0);
+    const nodeCount = requestGraph.nodes.length;
+    const nodeInvalidationRatio = invalidatedCount / nodeCount;
+    const requestInvalidationRatio = invalidatedCount / requestCount;
+    return {
+        invalidations,
+        nodeCount,
+        requestCount,
+        invalidatedCount,
+        nodeInvalidationRatio,
+        requestInvalidationRatio,
+    };
+}
+/**
+ * Invalidate the request graph based on file-system events.
+ *
+ * Returns statistics about the invalidations.
+ */
+async function invalidateRequestGraphFSEvents(requestGraph, options, events) {
+    const { invalidationsByPath } = await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
+    const biggestInvalidations = getBiggestFSEventsInvalidations(invalidationsByPath);
+    return {
+        biggestInvalidations,
+    };
+}
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(requestGraph, invalidationFn) {
+    const start = perf_hooks_1.performance.now();
+    const startInvalidationCount = requestGraph.getInvalidNodeCount();
+    const result = await invalidationFn.fn();
+    const count = requestGraph.getInvalidNodeCount() - startInvalidationCount;
+    const duration = perf_hooks_1.performance.now() - start;
+    return {
+        key: invalidationFn.key,
+        count,
+        detail: result ?? null,
+        duration,
+    };
+}
+function logErrorOnBailout(options, snapshotPath, e) {
+    if (e.message && e.message.includes('invalid clockspec')) {
+        const snapshotContents = options.inputFS.readFileSync(snapshotPath, 'utf-8');
+        logger_1.default.warn({
+            origin: '@atlaspack/core',
+            message: `Error reading clockspec from snapshot, building with clean cache.`,
+            meta: {
+                snapshotContents: snapshotContents,
+                trackableEvent: 'invalid_clockspec_error',
+            },
+        });
+    }
+    else {
+        logger_1.default.warn({
+            origin: '@atlaspack/core',
+            message: `Unexpected error loading cache from disk, building with clean cache.`,
+            meta: {
+                errorMessage: e.message,
+                errorStack: e.stack,
+                trackableEvent: 'cache_load_error',
+            },
+        });
+    }
+}
+function cleanUpOrphans(graph) {
+    if (graph.rootNodeId == null) {
+        return [];
+    }
+    const reachableNodes = new Set();
+    graph.traverse((nodeId) => {
+        reachableNodes.add(nodeId);
+    });
+    const removedNodeIds = [];
+    graph.nodes.forEach((_node, nodeId) => {
+        if (!reachableNodes.has(nodeId)) {
+            removedNodeIds.push(nodeId);
+            graph.removeNode(nodeId);
+        }
+    });
+    return removedNodeIds;
+}
+/**
+ * Returns paths that invalidated the most nodes
+ */
+function getBiggestFSEventsInvalidations(invalidationsByPath, limit = 10) {
+    const invalidations = [];
+    for (const [path, count] of invalidationsByPath) {
+        invalidations.push({ path, count });
+    }
+    invalidations.sort((a, b) => b.count - a.count);
+    return invalidations.slice(0, limit);
+}