@atlaspack/core 2.13.2-dev.3682 → 2.14.0

package/lib/requests/AssetGraphRequest.js

@@ -1,432 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AssetGraphBuilder = void 0;
-exports.default = createAssetGraphRequest;
-function _logger() {
-  const data = _interopRequireDefault(require("@atlaspack/logger"));
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _nullthrows() {
-  const data = _interopRequireDefault(require("nullthrows"));
-  _nullthrows = function () {
-    return data;
-  };
-  return data;
-}
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-var _types = require("../types");
-var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
-var _constants = require("../constants");
-var _EntryRequest = _interopRequireDefault(require("./EntryRequest"));
-var _TargetRequest = _interopRequireDefault(require("./TargetRequest"));
-var _AssetRequest = _interopRequireDefault(require("./AssetRequest"));
-var _PathRequest = _interopRequireDefault(require("./PathRequest"));
-var _projectPath = require("../projectPath");
-var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
-var _SymbolPropagation = require("../SymbolPropagation");
-var _RequestTracker = require("../RequestTracker");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function createAssetGraphRequest(requestInput) {
-  return {
-    type: _RequestTracker.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;
-      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 {
-  assetRequests = [];
-  constructor({
-    input,
-    api,
-    options
-  }, prevResult) {
-    let {
-      entries,
-      assetGroups,
-      optionsRef,
-      name,
-      requestedAssetIds,
-      shouldBuildLazily,
-      lazyIncludes,
-      lazyExcludes
-    } = input;
-    let assetGraph = (prevResult === null || prevResult === void 0 ? void 0 : prevResult.assetGraph) ?? new _AssetGraph.default();
-    assetGraph.safeToIncrementallyBundle = true;
-    assetGraph.setRootConnections({
-      entries,
-      assetGroups
-    });
-    assetGraph.undeferredDependencies.clear();
-    this.assetGroupsWithRemovedParents = (prevResult === null || prevResult === void 0 ? void 0 : prevResult.assetGroupsWithRemovedParents) ?? new Set();
-    this.previousSymbolPropagationErrors = (prevResult === null || prevResult === void 0 ? void 0 : prevResult.previousSymbolPropagationErrors) ?? new Map();
-    this.changedAssets = (prevResult === null || prevResult === void 0 ? void 0 : prevResult.changedAssets) ?? new Map();
-    this.changedAssetsPropagation = new Set();
-    this.prevChangedAssetsPropagation = prevResult === null || prevResult === void 0 ? void 0 : 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 ?? [];
-    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
-    this.isSingleChangeRebuild = api.getInvalidSubRequests().filter(req => req.requestType === 'asset_request').length === 1;
-    this.queue = new (_utils().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().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().default)(assetGraph.getNode(child));
-          (0, _assert().default)(childNode.type === 'asset_group' || childNode.type === 'asset');
-          childNode.usedSymbolsDownDirty = true;
-          this.assetGroupsWithRemovedParents.add(child);
-        }
-      }
-    };
-  }
-  async build() {
-    let errors = [];
-    let rootNodeId = (0, _nullthrows().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().default)(this.assetGraph.getNode(childNodeId));
-        if ((!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().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.default)(this.assetGraph, 'AssetGraph_' + this.name + '_before_prop');
-      try {
-        let errors = (0, _SymbolPropagation.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().default)({
-            diagnostic: [...errors.values()][0]
-          });
-        }
-      } catch (e) {
-        await (0, _dumpGraphToGraphViz.default)(this.assetGraph, 'AssetGraph_' + this.name + '_failed');
-        throw e;
-      }
-    }
-    await (0, _dumpGraphToGraphViz.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().default)(this.assetGraph.getNode(nodeId));
-      let childNode = (0, _nullthrows().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.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.Priority.sync);
-          if (isAsyncChild && childNode.value.priority !== _types.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().default)(this.assetGraph.getNode(nodeId));
-    return node.complete === true || !typesWithRequests.has(node.type) || node.correspondingRequest != null && this.api.canSkipSubrequest(node.correspondingRequest);
-  }
-  queueCorrespondingRequest(nodeId, errors) {
-    let promise;
-    let node = (0, _nullthrows().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.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;
-      }
-    }
-  }
-  async runTargetRequest(input) {
-    let request = (0, _TargetRequest.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.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);
-    let request = (0, _AssetRequest.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) {
-        if (this.assetGraph.safeToIncrementallyBundle) {
-          let otherAsset = this.assetGraph.getNodeByContentKey(asset.id);
-          if (otherAsset != null) {
-            (0, _assert().default)(otherAsset.type === 'asset');
-            if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
-              this.assetGraph.safeToIncrementallyBundle = false;
-            }
-          } else {
-            // adding a new entry or dependency
-            this.assetGraph.safeToIncrementallyBundle = false;
-          }
-        }
-        this.changedAssets.set(asset.id, asset);
-        this.changedAssetsPropagation.add(asset.id);
-      }
-      this.assetGraph.resolveAssetGroup(input, assets, request.id);
-    } else {
-      this.assetGraph.safeToIncrementallyBundle = false;
-    }
-    this.isSingleChangeRebuild = false;
-  }
-
-  /**
-   * Used for incremental bundling of modified assets
-   */
-  _areDependenciesEqualForAssets(asset, otherAsset) {
-    let assetDependencies = Array.from(asset === null || asset === void 0 ? void 0 : asset.dependencies.keys()).sort();
-    let otherAssetDependencies = Array.from(otherAsset === null || otherAsset === void 0 ? void 0 : otherAsset.dependencies.keys()).sort();
-    if (assetDependencies.length !== otherAssetDependencies.length) {
-      return false;
-    }
-    return assetDependencies.every((key, index) => {
-      var _asset$dependencies$g, _otherAsset$dependenc;
-      if (key !== otherAssetDependencies[index]) {
-        return false;
-      }
-      return (0, _utils().setEqual)(new Set(asset === null || asset === void 0 || (_asset$dependencies$g = asset.dependencies.get(key)) === null || _asset$dependencies$g === void 0 || (_asset$dependencies$g = _asset$dependencies$g.symbols) === null || _asset$dependencies$g === void 0 ? void 0 : _asset$dependencies$g.keys()), new Set(otherAsset === null || otherAsset === void 0 || (_otherAsset$dependenc = otherAsset.dependencies.get(key)) === null || _otherAsset$dependenc === void 0 || (_otherAsset$dependenc = _otherAsset$dependenc.symbols) === null || _otherAsset$dependenc === void 0 ? void 0 : _otherAsset$dependenc.keys()));
-    });
-  }
-}
-exports.AssetGraphBuilder = AssetGraphBuilder;

package/lib/requests/AssetGraphRequestRust.js

@@ -1,220 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createAssetGraphRequestRust = createAssetGraphRequestRust;
-exports.getAssetGraph = getAssetGraph;
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-  _assert = function () {
-    return data;
-  };
-  return data;
-}
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
-  _diagnostic = function () {
-    return data;
-  };
-  return data;
-}
-function _logger() {
-  const data = require("@atlaspack/logger");
-  _logger = function () {
-    return data;
-  };
-  return data;
-}
-var _AssetGraph = _interopRequireWildcard(require("../AssetGraph"));
-var _RequestTracker = require("../RequestTracker");
-var _SymbolPropagation = require("../SymbolPropagation");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function createAssetGraphRequestRust(rustAtlaspack) {
-  return input => ({
-    type: _RequestTracker.requestTypes.asset_graph_request,
-    id: input.name,
-    run: async input => {
-      let options = input.options;
-      let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
-      serializedAssetGraph.nodes = serializedAssetGraph.nodes.map(node => JSON.parse(node));
-      let {
-        assetGraph,
-        changedAssets
-      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph));
-      let changedAssetsPropagation = new Set(changedAssets.keys());
-      let errors = (0, _SymbolPropagation.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().default)({
-          diagnostic: [...errors.values()][0]
-        });
-      }
-      return {
-        assetGraph,
-        assetRequests: [],
-        assetGroupsWithRemovedParents: new Set(),
-        changedAssets,
-        changedAssetsPropagation,
-        previousSymbolPropagationErrors: undefined
-      };
-    },
-    input
-  });
-}
-
-// $FlowFixMe
-function getAssetGraph(serializedGraph) {
-  let graph = new _AssetGraph.default({
-    _contentKeyToNodeId: new Map(),
-    _nodeIdToContentKey: new Map(),
-    initialCapacity: serializedGraph.edges.length
-  });
-  graph.safeToIncrementallyBundle = false;
-  function mapSymbols({
-    exported,
-    ...symbol
-  }) {
-    let jsSymbol = {
-      local: symbol.local ?? undefined,
-      loc: symbol.loc ?? undefined,
-      meta: undefined,
-      isWeak: symbol.isWeak
-    };
-    if (symbol.exported) {
-      // $FlowFixMe
-      jsSymbol.exported = symbol.exported;
-    }
-    if (symbol.isEsmExport) {
-      // $FlowFixMe
-      jsSymbol.meta = {
-        isEsm: true
-      };
-    }
-    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 = getEnvId(asset.env);
-      asset.mapKey = `map:${asset.id}`;
-
-      // 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 = getEnvId(dependency.env);
-      if (dependency.symbols != null) {
-        var _dependency$symbols;
-        dependency.symbols = new Map((_dependency$symbols = dependency.symbols) === null || _dependency$symbols === void 0 ? void 0 : _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,
-        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 === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
-      (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
-
-      // For backwards compatibility, create asset group node if needed.
-      let assetGroupNode = (0, _AssetGraph.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 === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : 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
-  };
-}