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

package/dist/requests/AssetGraphRequest.js

@@ -0,0 +1,429 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetGraphBuilder = void 0;
+exports.default = createAssetGraphRequest;
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const utils_1 = require("@atlaspack/utils");
+const rust_1 = require("@atlaspack/rust");
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const types_1 = require("../types");
+const AssetGraph_1 = __importDefault(require("../AssetGraph"));
+const constants_1 = require("../constants");
+const EntryRequest_1 = __importDefault(require("./EntryRequest"));
+const TargetRequest_1 = __importDefault(require("./TargetRequest"));
+const AssetRequest_1 = __importDefault(require("./AssetRequest"));
+const PathRequest_1 = __importDefault(require("./PathRequest"));
+const projectPath_1 = require("../projectPath");
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+const SymbolPropagation_1 = require("../SymbolPropagation");
+const RequestTracker_1 = require("../RequestTracker");
+function createAssetGraphRequest(requestInput) {
+    return {
+        type: RequestTracker_1.requestTypes.asset_graph_request,
+        id: requestInput.name,
+        run: async (input) => {
+            let prevResult = await input.api.getPreviousResult();
+            let builder = new AssetGraphBuilder(input, prevResult);
+            let assetGraphRequest = await await builder.build();
+            // early break for incremental bundling if production or flag is off;
+            assetGraphRequest.assetGraph.setDisableIncrementalBundling(!input.options.shouldBundleIncrementally ||
+                input.options.mode === 'production');
+            if (!input.options.shouldBundleIncrementally ||
+                input.options.mode === 'production') {
+                assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
+            }
+            return assetGraphRequest;
+        },
+        input: requestInput,
+    };
+}
+const typesWithRequests = new Set([
+    'entry_specifier',
+    'entry_file',
+    'dependency',
+    'asset_group',
+]);
+class AssetGraphBuilder {
+    constructor({ input, api, options }, prevResult) {
+        this.assetRequests = [];
+        let { entries, assetGroups, optionsRef, name, requestedAssetIds, shouldBuildLazily, lazyIncludes, lazyExcludes, } = input;
+        let assetGraph = prevResult?.assetGraph ?? new AssetGraph_1.default();
+        assetGraph.safeToIncrementallyBundle = true;
+        assetGraph.setRootConnections({
+            entries,
+            assetGroups,
+        });
+        assetGraph.undeferredDependencies.clear();
+        this.assetGroupsWithRemovedParents =
+            prevResult?.assetGroupsWithRemovedParents ?? new Set();
+        this.previousSymbolPropagationErrors =
+            prevResult?.previousSymbolPropagationErrors ?? new Map();
+        this.changedAssets = prevResult?.changedAssets ?? new Map();
+        this.changedAssetsPropagation = new Set();
+        this.prevChangedAssetsPropagation = prevResult?.changedAssetsPropagation;
+        this.assetGraph = assetGraph;
+        this.optionsRef = optionsRef;
+        this.options = options;
+        this.api = api;
+        this.name = name;
+        this.requestedAssetIds = requestedAssetIds ?? new Set();
+        this.shouldBuildLazily = shouldBuildLazily ?? false;
+        this.lazyIncludes = lazyIncludes ?? [];
+        this.lazyExcludes = lazyExcludes ?? [];
+        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
+            const key = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
+            this.cacheKey = `AssetGraph/${constants_1.ATLASPACK_VERSION}/${options.mode}/${key}`;
+        }
+        else {
+            this.cacheKey =
+                (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
+        }
+        this.isSingleChangeRebuild =
+            api
+                .getInvalidSubRequests()
+                // @ts-expect-error TS2367
+                .filter((req) => req.requestType === 'asset_request').length === 1;
+        this.queue = new utils_1.PromiseQueue();
+        assetGraph.onNodeRemoved = (nodeId) => {
+            this.assetGroupsWithRemovedParents.delete(nodeId);
+            // This needs to mark all connected nodes that doesn't become orphaned
+            // due to replaceNodesConnectedTo to make sure that the symbols of
+            // nodes from which at least one parent was removed are updated.
+            let node = (0, nullthrows_1.default)(assetGraph.getNode(nodeId));
+            if (assetGraph.isOrphanedNode(nodeId) && node.type === 'dependency') {
+                let children = assetGraph.getNodeIdsConnectedFrom(nodeId);
+                for (let child of children) {
+                    let childNode = (0, nullthrows_1.default)(assetGraph.getNode(child));
+                    (0, assert_1.default)(childNode.type === 'asset_group' || childNode.type === 'asset');
+                    childNode.usedSymbolsDownDirty = true;
+                    this.assetGroupsWithRemovedParents.add(child);
+                }
+            }
+        };
+    }
+    async build() {
+        let errors = [];
+        let rootNodeId = (0, nullthrows_1.default)(this.assetGraph.rootNodeId, 'A root node is required to traverse');
+        let visitedAssetGroups = new Set();
+        let visited = new Set([rootNodeId]);
+        const visit = (nodeId) => {
+            if (errors.length > 0) {
+                return;
+            }
+            if (this.shouldSkipRequest(nodeId)) {
+                visitChildren(nodeId);
+            }
+            else {
+                // ? do we need to visit children inside of the promise that is queued?
+                this.queueCorrespondingRequest(nodeId, errors).then(() => visitChildren(nodeId));
+            }
+        };
+        const visitChildren = (nodeId) => {
+            for (let childNodeId of this.assetGraph.getNodeIdsConnectedFrom(nodeId)) {
+                let child = (0, nullthrows_1.default)(this.assetGraph.getNode(childNodeId));
+                if (
+                // @ts-expect-error TS2339
+                (!visited.has(childNodeId) || child.hasDeferred) &&
+                    this.shouldVisitChild(nodeId, childNodeId)) {
+                    if (child.type === 'asset_group') {
+                        visitedAssetGroups.add(childNodeId);
+                    }
+                    visited.add(childNodeId);
+                    visit(childNodeId);
+                }
+            }
+        };
+        visit(rootNodeId);
+        await this.queue.run();
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: 'Asset graph walked',
+            meta: {
+                visitedAssetGroupsCount: visitedAssetGroups.size,
+            },
+        });
+        if (this.prevChangedAssetsPropagation) {
+            // Add any previously seen Assets that have not been propagated yet to
+            // 'this.changedAssetsPropagation', but only if they still remain in the graph
+            // as they could have been removed since the last build
+            for (let assetId of this.prevChangedAssetsPropagation) {
+                if (this.assetGraph.hasContentKey(assetId)) {
+                    this.changedAssetsPropagation.add(assetId);
+                }
+            }
+        }
+        if (errors.length) {
+            this.api.storeResult({
+                assetGraph: this.assetGraph,
+                changedAssets: this.changedAssets,
+                changedAssetsPropagation: this.changedAssetsPropagation,
+                assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
+                previousSymbolPropagationErrors: undefined,
+                assetRequests: [],
+            }, this.cacheKey);
+            // TODO: eventually support multiple errors since requests could reject in parallel
+            throw errors[0];
+        }
+        if (this.assetGraph.nodes.length > 1) {
+            await (0, dumpGraphToGraphViz_1.default)(this.assetGraph, 'AssetGraph_' + this.name + '_before_prop');
+            try {
+                let errors = (0, SymbolPropagation_1.propagateSymbols)({
+                    options: this.options,
+                    assetGraph: this.assetGraph,
+                    changedAssetsPropagation: this.changedAssetsPropagation,
+                    assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
+                    previousErrors: this.previousSymbolPropagationErrors,
+                });
+                this.changedAssetsPropagation.clear();
+                if (errors.size > 0) {
+                    this.api.storeResult({
+                        assetGraph: this.assetGraph,
+                        changedAssets: this.changedAssets,
+                        changedAssetsPropagation: this.changedAssetsPropagation,
+                        assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
+                        previousSymbolPropagationErrors: errors,
+                        assetRequests: [],
+                    }, this.cacheKey);
+                    // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+                    // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+                    throw new diagnostic_1.default({
+                        diagnostic: [...errors.values()][0],
+                    });
+                }
+            }
+            catch (e) {
+                await (0, dumpGraphToGraphViz_1.default)(this.assetGraph, 'AssetGraph_' + this.name + '_failed');
+                throw e;
+            }
+        }
+        await (0, dumpGraphToGraphViz_1.default)(this.assetGraph, 'AssetGraph_' + this.name);
+        this.api.storeResult({
+            assetGraph: this.assetGraph,
+            changedAssets: new Map(),
+            changedAssetsPropagation: this.changedAssetsPropagation,
+            assetGroupsWithRemovedParents: undefined,
+            previousSymbolPropagationErrors: undefined,
+            assetRequests: [],
+        }, this.cacheKey);
+        return {
+            assetGraph: this.assetGraph,
+            changedAssets: this.changedAssets,
+            changedAssetsPropagation: this.changedAssetsPropagation,
+            assetGroupsWithRemovedParents: undefined,
+            previousSymbolPropagationErrors: undefined,
+            assetRequests: this.assetRequests,
+        };
+    }
+    shouldVisitChild(nodeId, childNodeId) {
+        if (this.shouldBuildLazily) {
+            let node = (0, nullthrows_1.default)(this.assetGraph.getNode(nodeId));
+            let childNode = (0, nullthrows_1.default)(this.assetGraph.getNode(childNodeId));
+            if (node.type === 'asset' && childNode.type === 'dependency') {
+                // This logic will set `node.requested` to `true` if the node is in the list of requested asset ids
+                // (i.e. this is an entry of a (probably) placeholder bundle that wasn't previously requested)
+                //
+                // Otherwise, if this node either is explicitly not requested, or has had it's requested attribute deleted,
+                // it will determine whether this node is an "async child" - that is, is it a (probably)
+                // dynamic import(). If so, it will explicitly have it's `node.requested` set to `false`
+                //
+                // If it's not requested, but it's not an async child then it's `node.requested` is deleted (undefined)
+                // by default with lazy compilation all nodes are lazy
+                let isNodeLazy = true;
+                // For conditional lazy building - if this node matches the `lazyInclude` globs that means we want
+                // only those nodes to be treated as lazy - that means if this node does _NOT_ match that glob, then we
+                // also consider it not lazy (so it gets marked as requested).
+                const relativePath = (0, projectPath_1.fromProjectPathRelative)(node.value.filePath);
+                if (this.lazyIncludes.length > 0) {
+                    isNodeLazy = this.lazyIncludes.some((lazyIncludeRegex) => relativePath.match(lazyIncludeRegex));
+                }
+                // Excludes override includes, so a node is _not_ lazy if it is included in the exclude list.
+                if (this.lazyExcludes.length > 0 && isNodeLazy) {
+                    isNodeLazy = !this.lazyExcludes.some((lazyExcludeRegex) => relativePath.match(lazyExcludeRegex));
+                }
+                if (this.requestedAssetIds.has(node.value.id) || !isNodeLazy) {
+                    node.requested = true;
+                }
+                else if (!node.requested) {
+                    let isAsyncChild = this.assetGraph
+                        .getIncomingDependencies(node.value)
+                        .every((dep) => dep.isEntry || dep.priority !== types_1.Priority.sync);
+                    if (isAsyncChild &&
+                        childNode.value.priority !== types_1.Priority.conditional) {
+                        // Skip if we're on a conditional import
+                        node.requested = !isNodeLazy;
+                    }
+                    else {
+                        delete node.requested;
+                    }
+                }
+                let previouslyDeferred = childNode.deferred;
+                childNode.deferred = node.requested === false;
+                // The child dependency node we're now evaluating should not be deferred if it's parent
+                // is explicitly not requested (requested = false, but not requested = undefined)
+                //
+                // if we weren't previously deferred but we are now, then this dependency node's parents should also
+                // be marked as deferred
+                //
+                // if we were previously deferred but we not longer are, then then all parents should no longer be
+                // deferred either
+                if (!previouslyDeferred && childNode.deferred) {
+                    this.assetGraph.markParentsWithHasDeferred(childNodeId);
+                }
+                else if (previouslyDeferred && !childNode.deferred) {
+                    // Mark Asset and Dependency as dirty for symbol propagation as it was
+                    // previously deferred and it's used symbols may have changed
+                    this.changedAssetsPropagation.add(node.id);
+                    node.usedSymbolsDownDirty = true;
+                    this.changedAssetsPropagation.add(childNode.id);
+                    childNode.usedSymbolsDownDirty = true;
+                    this.assetGraph.unmarkParentsWithHasDeferred(childNodeId);
+                }
+                // We `shouldVisitChild` if the childNode is not deferred
+                return !childNode.deferred;
+            }
+        }
+        return this.assetGraph.shouldVisitChild(nodeId, childNodeId);
+    }
+    shouldSkipRequest(nodeId) {
+        let node = (0, nullthrows_1.default)(this.assetGraph.getNode(nodeId));
+        return (
+        // @ts-expect-error TS2339
+        node.complete === true ||
+            !typesWithRequests.has(node.type) ||
+            // @ts-expect-error TS2339
+            (node.correspondingRequest != null &&
+                // @ts-expect-error TS2339
+                this.api.canSkipSubrequest(node.correspondingRequest)));
+    }
+    queueCorrespondingRequest(nodeId, errors) {
+        let promise;
+        let node = (0, nullthrows_1.default)(this.assetGraph.getNode(nodeId));
+        switch (node.type) {
+            case 'entry_specifier':
+                promise = this.runEntryRequest(node.value);
+                break;
+            case 'entry_file':
+                promise = this.runTargetRequest(node.value);
+                break;
+            case 'dependency':
+                promise = this.runPathRequest(node.value);
+                break;
+            case 'asset_group':
+                promise = this.runAssetRequest(node.value);
+                break;
+            default:
+                throw new Error(`Can not queue corresponding request of node with type ${node.type}`);
+        }
+        return new Promise((resolve) => {
+            this.queue.add(() => promise.then(() => {
+                resolve(null);
+            }, (error) => errors.push(error)));
+        });
+    }
+    async runEntryRequest(input) {
+        let prevEntries = this.assetGraph.safeToIncrementallyBundle
+            ? this.assetGraph
+                .getEntryAssets()
+                .map((asset) => asset.id)
+                .sort()
+            : [];
+        let request = (0, EntryRequest_1.default)(input);
+        let result = await this.api.runRequest(request, {
+            force: true,
+        });
+        this.assetGraph.resolveEntry(request.input, result.entries, request.id);
+        if (this.assetGraph.safeToIncrementallyBundle) {
+            let currentEntries = this.assetGraph
+                .getEntryAssets()
+                .map((asset) => asset.id)
+                .sort();
+            let didEntriesChange = prevEntries.length !== currentEntries.length ||
+                prevEntries.every((entryId, index) => entryId === currentEntries[index]);
+            if (didEntriesChange) {
+                this.assetGraph.safeToIncrementallyBundle = false;
+                this.assetGraph.setNeedsBundling();
+            }
+        }
+    }
+    async runTargetRequest(input) {
+        let request = (0, TargetRequest_1.default)(input);
+        let targets = await this.api.runRequest(request, {
+            force: true,
+        });
+        this.assetGraph.resolveTargets(request.input, targets, request.id);
+    }
+    async runPathRequest(input) {
+        let request = (0, PathRequest_1.default)({ dependency: input, name: this.name });
+        let result = await this.api.runRequest(request, { force: true });
+        this.assetGraph.resolveDependency(input, result, request.id);
+    }
+    async runAssetRequest(input) {
+        this.assetRequests.push(input);
+        // @ts-expect-error TS2345
+        let request = (0, AssetRequest_1.default)({
+            ...input,
+            name: this.name,
+            optionsRef: this.optionsRef,
+            isSingleChangeRebuild: this.isSingleChangeRebuild,
+        });
+        let assets = await this.api.runRequest(request, { force: true });
+        if (assets != null) {
+            for (let asset of assets) {
+                // Pass the runtimeAssetRequiringExecutionOnLoad flag from the asset
+                // group down to the asset itself, for reading in the packager.
+                if (input.runtimeAssetRequiringExecutionOnLoad) {
+                    asset.meta = {
+                        ...(asset.meta ?? {}),
+                        runtimeAssetRequiringExecutionOnLoad: input.runtimeAssetRequiringExecutionOnLoad,
+                    };
+                }
+                if (this.assetGraph.safeToIncrementallyBundle) {
+                    let otherAsset = this.assetGraph.getNodeByContentKey(asset.id);
+                    if (otherAsset != null) {
+                        (0, assert_1.default)(otherAsset.type === 'asset');
+                        if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
+                            this.assetGraph.safeToIncrementallyBundle = false;
+                            this.assetGraph.setNeedsBundling();
+                        }
+                    }
+                    else {
+                        // adding a new entry or dependency
+                        this.assetGraph.safeToIncrementallyBundle = false;
+                        this.assetGraph.setNeedsBundling();
+                    }
+                }
+                this.changedAssets.set(asset.id, asset);
+                this.changedAssetsPropagation.add(asset.id);
+            }
+            this.assetGraph.resolveAssetGroup(input, assets, request.id);
+        }
+        else {
+            this.assetGraph.safeToIncrementallyBundle = false;
+            this.assetGraph.setNeedsBundling();
+        }
+        this.isSingleChangeRebuild = false;
+    }
+    /**
+     * Used for incremental bundling of modified assets
+     */
+    _areDependenciesEqualForAssets(asset, otherAsset) {
+        let assetDependencies = Array.from(asset?.dependencies.keys()).sort();
+        let otherAssetDependencies = Array.from(otherAsset?.dependencies.keys()).sort();
+        if (assetDependencies.length !== otherAssetDependencies.length) {
+            return false;
+        }
+        return assetDependencies.every((key, index) => {
+            if (key !== otherAssetDependencies[index]) {
+                return false;
+            }
+            return (0, utils_1.setEqual)(new Set(asset?.dependencies.get(key)?.symbols?.keys()), new Set(otherAsset?.dependencies.get(key)?.symbols?.keys()));
+        });
+    }
+}
+exports.AssetGraphBuilder = AssetGraphBuilder;

package/dist/requests/AssetGraphRequestRust.js

@@ -0,0 +1,246 @@
+"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.createAssetGraphRequestRust = createAssetGraphRequestRust;
+exports.getAssetGraph = getAssetGraph;
+const assert_1 = __importDefault(require("assert"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const logger_1 = require("@atlaspack/logger");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const AssetGraph_1 = __importStar(require("../AssetGraph"));
+const RequestTracker_1 = require("../RequestTracker");
+const SymbolPropagation_1 = require("../SymbolPropagation");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const Environment_1 = require("../Environment");
+function createAssetGraphRequestRust(rustAtlaspack) {
+    return (input) => ({
+        type: RequestTracker_1.requestTypes.asset_graph_request,
+        id: input.name,
+        run: async (input) => {
+            let options = input.options;
+            let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
+            // @ts-expect-error TS7006
+            serializedAssetGraph.nodes = serializedAssetGraph.nodes.map((node) => JSON.parse(node));
+            let { assetGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph));
+            let changedAssetsPropagation = new Set(changedAssets.keys());
+            let errors = (0, SymbolPropagation_1.propagateSymbols)({
+                options,
+                assetGraph,
+                changedAssetsPropagation,
+                assetGroupsWithRemovedParents: new Set(),
+                previousErrors: new Map(), //this.previousSymbolPropagationErrors,
+            });
+            if (errors.size > 0) {
+                // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+                // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+                throw new diagnostic_1.default({
+                    diagnostic: [...errors.values()][0],
+                });
+            }
+            return {
+                assetGraph,
+                assetRequests: [],
+                assetGroupsWithRemovedParents: new Set(),
+                changedAssets,
+                changedAssetsPropagation,
+                previousSymbolPropagationErrors: undefined,
+            };
+        },
+        input,
+    });
+}
+function getAssetGraph(serializedGraph) {
+    let graph = new AssetGraph_1.default({
+        _contentKeyToNodeId: new Map(),
+        _nodeIdToContentKey: new Map(),
+        initialCapacity: serializedGraph.edges.length,
+    });
+    graph.safeToIncrementallyBundle = false;
+    // @ts-expect-error TS7031
+    function mapSymbols({ exported, ...symbol }) {
+        let jsSymbol = {
+            local: symbol.local ?? undefined,
+            loc: symbol.loc ?? undefined,
+            isWeak: symbol.isWeak,
+            meta: {
+                isEsm: symbol.isEsmExport,
+                isStaticBindingSafe: symbol.isStaticBindingSafe,
+            },
+        };
+        if (symbol.exported) {
+            // @ts-expect-error TS2339
+            jsSymbol.exported = symbol.exported;
+        }
+        return [exported, jsSymbol];
+    }
+    // See crates/atlaspack_core/src/types/environment.rs
+    let changedAssets = new Map();
+    let entry = 0;
+    let envs = new Map();
+    let getEnvId = (env) => {
+        let envKey = [
+            env.context,
+            env.engines.atlaspack,
+            env.engines.browsers,
+            env.engines.electron,
+            env.engines.node,
+            env.includeNodeModules,
+            env.isLibrary,
+            env.outputFormat,
+            env.shouldScopeHoist,
+            env.shouldOptimize,
+            env.sourceType,
+        ].join(':');
+        let envId = envs.get(envKey);
+        if (envId == null) {
+            envId = `${envs.size}`;
+            envs.set(envKey, envId);
+        }
+        return envId;
+    };
+    for (let node of serializedGraph.nodes) {
+        if (node.type === 'root') {
+            let index = graph.addNodeByContentKey('@@root', {
+                id: '@@root',
+                type: 'root',
+                value: null,
+            });
+            graph.setRootNodeId(index);
+        }
+        else if (node.type === 'entry') {
+            let id = 'entry:' + ++entry;
+            graph.addNodeByContentKey(id, {
+                id: id,
+                type: 'root',
+                value: null,
+            });
+        }
+        else if (node.type === 'asset') {
+            let asset = node.value;
+            let id = asset.id;
+            asset.committed = true;
+            asset.contentKey = id;
+            asset.env.id = (0, feature_flags_1.getFeatureFlag)('environmentDeduplication')
+                ? // TODO: Rust can do this and avoid copying a significant amount of data over
+                    (0, Environment_1.getEnvironmentHash)(asset.env)
+                : getEnvId(asset.env);
+            asset.mapKey = `map:${asset.id}`;
+            asset.env = (0, EnvironmentManager_1.toEnvironmentRef)(asset.env);
+            // This is populated later when we map the edges between assets and dependencies
+            asset.dependencies = new Map();
+            // We need to add this property for source map handling, as some assets like runtimes
+            // are processed after the Rust transformation and take the v2 code path
+            asset.meta.isV3 = true;
+            if (asset.symbols != null) {
+                asset.symbols = new Map(asset.symbols.map(mapSymbols));
+            }
+            changedAssets.set(id, asset);
+            graph.addNodeByContentKey(id, {
+                id,
+                type: 'asset',
+                usedSymbols: new Set(),
+                usedSymbolsDownDirty: true,
+                usedSymbolsUpDirty: true,
+                value: asset,
+            });
+        }
+        else if (node.type === 'dependency') {
+            let id = node.value.id;
+            let dependency = node.value.dependency;
+            dependency.id = id;
+            dependency.env.id = (0, feature_flags_1.getFeatureFlag)('environmentDeduplication')
+                ? // TODO: Rust can do this and avoid copying a significant amount of data over
+                    (0, Environment_1.getEnvironmentHash)(dependency.env)
+                : getEnvId(dependency.env);
+            dependency.env = (0, EnvironmentManager_1.toEnvironmentRef)(dependency.env);
+            if (dependency.symbols != null) {
+                dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));
+            }
+            let usedSymbolsDown = new Set();
+            let usedSymbolsUp = new Map();
+            if (dependency.isEntry && dependency.isLibrary) {
+                usedSymbolsDown.add('*');
+                usedSymbolsUp.set('*', undefined);
+            }
+            graph.addNodeByContentKey(id, {
+                id,
+                type: 'dependency',
+                deferred: false,
+                excluded: false,
+                hasDeferred: node.has_deferred,
+                // @ts-expect-error TS2322
+                usedSymbolsDown,
+                usedSymbolsDownDirty: true,
+                usedSymbolsUp,
+                usedSymbolsUpDirtyDown: true,
+                usedSymbolsUpDirtyUp: true,
+                value: dependency,
+            });
+        }
+    }
+    for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+        let from = serializedGraph.edges[i];
+        let to = serializedGraph.edges[i + 1];
+        let fromNode = graph.getNode(from);
+        let toNode = graph.getNode(to);
+        if (fromNode?.type === 'dependency') {
+            (0, assert_1.default)(toNode?.type === 'asset');
+            // For backwards compatibility, create asset group node if needed.
+            let assetGroupNode = (0, AssetGraph_1.nodeFromAssetGroup)({
+                filePath: toNode.value.filePath,
+                env: fromNode.value.env,
+                pipeline: toNode.value.pipeline,
+                sideEffects: Boolean(toNode.value.sideEffects),
+            });
+            let index = graph.addNodeByContentKeyIfNeeded(assetGroupNode.id, assetGroupNode);
+            graph.addEdge(from, index);
+            graph.addEdge(index, to);
+        }
+        else if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+            fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+            graph.addEdge(from, to);
+        }
+        else {
+            graph.addEdge(from, to);
+        }
+    }
+    return {
+        assetGraph: graph,
+        changedAssets,
+    };
+}