@atlaspack/core 2.12.1-dev.3401 → 2.12.1-dev.3443

package/lib/atlaspack-v3/worker/compat.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssetCompat = void 0;
+var _Environment = _interopRequireDefault(require("../../public/Environment"));
+var _types = require("../../types");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class AssetCompat {
+  // TODO: Type properly
+
+  constructor(_inner, options) {
+    this._inner = _inner;
+    // $FlowFixMe This isn't correct to flow but is enough to satisfy the runtime checks
+    this.env = new _Environment.default(_inner.env, options);
+    this._dependencies = [];
+  }
+  get id() {
+    return this._inner.id;
+  }
+  get filePath() {
+    return this._inner.filePath;
+  }
+  get type() {
+    return this._inner.type;
+  }
+  set type(value) {
+    this._inner.type = value;
+  }
+  get bundleBehavior() {
+    let bundleBehavior = this._inner.bundleBehavior;
+    return bundleBehavior == null ? null : _types.BundleBehaviorNames[bundleBehavior];
+  }
+  set bundleBehavior(bundleBehavior) {
+    this._inner.bundleBehavior = bundleBehavior ? _types.BundleBehavior[bundleBehavior] : null;
+  }
+  getCode() {
+    return Buffer.from(this._inner.code).toString();
+  }
+  setCode(code) {
+    this._inner.code = Array.from(new TextEncoder().encode(code));
+  }
+  getAST() {
+    return this._ast;
+  }
+  setAST(ast) {
+    this._ast = ast;
+  }
+  addDependency() {
+    throw new Error('[V3] Unimplemented: Asset.addDependency not yet implemented');
+  }
+  addURLDependency() {
+    throw new Error('[V3] Unimplemented: Asset.addURLDependency not yet implemented');
+  }
+}
+exports.AssetCompat = AssetCompat;

package/lib/atlaspack-v3/worker/worker.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AtlaspackWorker = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
 function napi() {
   const data = _interopRequireWildcard(require("@atlaspack/rust"));
   napi = function () {
@@ -18,13 +25,161 @@ function _worker_threads() {
   };
   return data;
 }
+function _module() {
+  const data = _interopRequireWildcard(require("module"));
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+var _compat = require("./compat");
+var _jsCallable = require("../jsCallable");
 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 }; }
+const CONFIG = Symbol.for('parcel-plugin-config');
 class AtlaspackWorker {
   #resolvers;
+  constructor() {
+    this.#resolvers = new Map();
+  }
+  loadPlugin = (0, _jsCallable.jsCallable)(async ({
+    kind,
+    specifier,
+    resolveFrom
+  }) => {
+    let customRequire = _module().createRequire(resolveFrom);
+    let resolvedPath = customRequire.resolve(specifier);
+    // $FlowFixMe
+    let resolvedModule = await import(resolvedPath);
+    let instance = undefined;
+    if (resolvedModule.default && resolvedModule.default[CONFIG]) {
+      instance = resolvedModule.default[CONFIG];
+    } else if (resolvedModule.default && resolvedModule.default.default[CONFIG]) {
+      instance = resolvedModule.default.default[CONFIG];
+    } else {
+      throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
+    }
+    switch (kind) {
+      case 'resolver':
+        this.#resolvers.set(specifier, instance);
+        break;
+    }
+  });
+  runResolverResolve = (0, _jsCallable.jsCallable)(async ({
+    key,
+    dependency,
+    specifier
+  }) => {
+    const resolver = this.#resolvers.get(key);
+    if (!resolver) {
+      throw new Error(`Resolver not found: ${key}`);
+    }
+    const result = await resolver.resolve({
+      specifier,
+      dependency,
+      get options() {
+        throw new Error('TODO: Resolver.resolve.options');
+      },
+      get logger() {
+        throw new Error('TODO: Resolver.resolve.logger');
+      },
+      get tracer() {
+        throw new Error('TODO: Resolver.resolve.tracer');
+      },
+      get pipeline() {
+        throw new Error('TODO: Resolver.resolve.pipeline');
+      },
+      get config() {
+        throw new Error('TODO: Resolver.resolve.config');
+      }
+    });
+    if (!result) {
+      return {
+        invalidations: [],
+        resolution: {
+          type: 'unresolved'
+        }
+      };
+    }
+    return {
+      invalidations: [],
+      resolution: {
+        type: 'resolved',
+        filePath: result.filePath || '',
+        canDefer: result.canDefer || false,
+        sideEffects: result.sideEffects || false,
+        code: result.code || undefined,
+        meta: result.meta || undefined,
+        pipeline: result.pipeline || undefined,
+        priority: result.priority && PriorityMap[result.priority],
+        query: result.query && result.query.toString()
+      }
+    };
+  });
   ping() {
     // console.log('Hi');
   }
+  async runTransformer({
+    resolveFrom,
+    specifier,
+    options,
+    asset
+  }) {
+    const customRequire = _module().createRequire(resolveFrom);
+    const resolvedPath = customRequire.resolve(specifier);
+    // $FlowFixMe
+    const transformerModule = await import(resolvedPath);
+    const transformer = transformerModule.default.default[CONFIG];
+    let assetCompat = new _compat.AssetCompat(asset, options);
+    try {
+      if (transformer.parse) {
+        // $FlowFixMe
+        const ast = await transformer.parse({
+          asset: assetCompat
+        }); // missing "config"
+        // $FlowFixMe
+        assetCompat.setAST(ast);
+      }
+
+      // $FlowFixMe
+      const result = await transformer.transform({
+        // $FlowFixMe
+        asset: assetCompat,
+        options,
+        config: null
+      });
+      if (transformer.generate) {
+        // $FlowFixMe
+        let output = await transformer.generate({
+          // $FlowFixMe
+          asset: assetCompat,
+          // $FlowFixMe
+          ast: assetCompat.getAST()
+        });
+        // $FlowFixMe
+        assetCompat.setCode(output.content);
+      }
+      (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+      (0, _assert().default)(result[0] === assetCompat, '[V3] Unimplemented: New asset returned from Node transformer');
+      return {
+        asset,
+        dependencies: assetCompat._dependencies
+      };
+    } catch (e) {
+      // TODO: Improve error logging from JS plugins. Without this you currently
+      // only see the error message, no stack trace.
+      // eslint-disable-next-line no-console
+      console.error(e);
+      throw e;
+    }
+  }
 }
 exports.AtlaspackWorker = AtlaspackWorker;
-napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());
+napi().registerWorker(_worker_threads().workerData.tx_worker, new AtlaspackWorker());
+const PriorityMap = {
+  sync: 0,
+  parallel: 1,
+  lazy: 2,
+  conditional: 3
+};

package/lib/public/BundleGraph.js

@@ -189,5 +189,73 @@ class BundleGraph {
   getEntryRoot(target) {
     return this.#graph.getEntryRoot(this.#options.projectRoot, (0, _Target.targetToInternalTarget)(target));
   }
+
+  // Given a set of dependencies, return any conditions where those dependencies are either
+  // the true or false dependency for those conditions. This is currently used to work out which
+  // conditions belong to a bundle in packaging.
+  getConditionsForDependencies(deps) {
+    const conditions = new Set();
+    const depIds = deps.map(dep => dep.id);
+    for (const condition of this.#graph._conditions.values()) {
+      if (depIds.includes(condition.ifTrueDependency.id) || depIds.includes(condition.ifFalseDependency.id)) {
+        const [trueAsset, falseAsset] = [condition.ifTrueDependency, condition.ifFalseDependency].map(dep => {
+          const resolved = (0, _nullthrows().default)(this.#graph.resolveAsyncDependency(dep));
+          if (resolved.type === 'asset') {
+            return resolved.value;
+          } else {
+            return this.#graph.getAssetById(resolved.value.entryAssetId);
+          }
+        });
+        conditions.add({
+          publicId: condition.publicId,
+          key: condition.key,
+          ifTrueDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifTrueDependency.id), 'ifTrueDependency was null'),
+          ifFalseDependency: (0, _nullthrows().default)(deps.find(dep => dep.id === condition.ifFalseDependency.id), 'ifFalseDependency was null'),
+          ifTrueAssetId: this.#graph.getAssetPublicId(trueAsset),
+          ifFalseAssetId: this.#graph.getAssetPublicId(falseAsset)
+        });
+      }
+    }
+    return conditions;
+  }
+
+  // This is used to generate information for building a manifest that can
+  // be used by a webserver to understand which conditions are used by which bundles,
+  // and which bundles those conditions require depending on what they evaluate to.
+  getConditionalBundleMapping() {
+    let bundleConditions = new Map();
+
+    // Convert the internal references in conditions to public API references
+    for (const cond of this.#graph._conditions.values()) {
+      let assets = Array.from(cond.assets).map(asset => (0, _nullthrows().default)(this.getAssetById(asset.id)));
+      let bundles = new Set();
+      let ifTrueBundles = [];
+      let ifFalseBundles = [];
+      for (const asset of assets) {
+        const bundlesWithAsset = this.getBundlesWithAsset(asset);
+        for (const bundle of bundlesWithAsset) {
+          bundles.add(bundle);
+        }
+        const assetDeps = this.getDependencies(asset);
+        const depToBundles = dep => {
+          const publicDep = (0, _nullthrows().default)(assetDeps.find(assetDep => dep.id === assetDep.id));
+          const resolved = (0, _nullthrows().default)(this.resolveAsyncDependency(publicDep));
+          (0, _assert().default)(resolved.type === 'bundle_group');
+          return this.getBundlesInBundleGroup(resolved.value);
+        };
+        ifTrueBundles.push(...depToBundles(cond.ifTrueDependency));
+        ifFalseBundles.push(...depToBundles(cond.ifFalseDependency));
+      }
+      for (let bundle of bundles) {
+        const conditions = bundleConditions.get(bundle) ?? new Map();
+        conditions.set(cond.key, {
+          ifTrueBundles,
+          ifFalseBundles
+        });
+        bundleConditions.set(bundle, conditions);
+      }
+    }
+    return bundleConditions;
+  }
 }
 exports.default = BundleGraph;

package/lib/requests/AssetGraphRequestRust.js

@@ -81,9 +81,43 @@ function getAssetGraph(serializedGraph, options) {
     _nodeIdToContentKey: new Map()
   });
   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 cachedAssets = new Map();
   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', {
@@ -100,18 +134,34 @@ function getAssetGraph(serializedGraph, options) {
         value: null
       });
     } else if (node.type === 'asset') {
-      let id = node.value.id;
-      let asset = node.value.asset;
+      let asset = node.value;
+      let id = asset.id;
+      asset.meta.id = id;
       asset = {
         ...asset,
-        id,
+        uniqueKey: asset.uniqueKey ?? undefined,
+        pipeline: asset.pipeline ?? undefined,
+        range: asset.range ?? undefined,
+        resolveFrom: asset.resolveFrom ?? undefined,
+        target: asset.target ?? undefined,
+        plugin: asset.plugin ?? undefined,
+        query: asset.query ?? undefined,
+        configPath: asset.configPath ?? undefined,
+        configKeyPath: asset.configKeyPath ?? undefined,
+        isLargeBlob: asset.isLargeBlob ?? false,
+        isSource: asset.isSource ?? false,
+        sourcePath: asset.sourcePath ?? undefined,
+        env: {
+          ...asset.env,
+          loc: asset.env.loc ?? undefined,
+          id: getEnvId(asset.env),
+          sourceType: asset.env.sourceType
+        },
+        bundleBehavior: asset.bundleBehavior === 255 ? null : asset.bundleBehavior,
         committed: true,
         contentKey: id,
         filePath: (0, _projectPath.toProjectPath)(options.projectRoot, asset.filePath),
-        symbols: asset.hasSymbols ? new Map(asset.symbols.map(({
-          exported,
-          ...symbol
-        }) => [exported, symbol])) : null
+        symbols: asset.symbols != null ? new Map(asset.symbols.map(mapSymbols)) : null
       };
       cachedAssets.set(id, asset.code);
       changedAssets.set(id, asset);
@@ -124,17 +174,34 @@ function getAssetGraph(serializedGraph, options) {
         value: asset
       });
     } else if (node.type === 'dependency') {
+      var _dependency$symbols;
       let id = node.value.id;
       let dependency = node.value.dependency;
       dependency = {
         ...dependency,
         id,
+        env: {
+          ...dependency.env,
+          id: getEnvId(dependency.env),
+          sourceType: dependency.env.sourceType,
+          loc: dependency.env.loc ?? undefined
+        },
+        pipeline: dependency.pipeline ?? undefined,
+        range: dependency.range ?? undefined,
+        resolveFrom: dependency.resolveFrom ?? undefined,
+        target: dependency.target ?? undefined,
+        bundleBehavior: dependency.bundleBehavior === 255 ? null : dependency.bundleBehavior,
         contentKey: id,
-        sourcePath: dependency.sourcePath ? (0, _projectPath.toProjectPath)(options.projectRoot, dependency.sourcePath) : null,
-        symbols: dependency.hasSymbols ? new Map(dependency.symbols.map(({
-          exported,
-          ...symbol
-        }) => [exported, symbol])) : null
+        loc: dependency.loc ? {
+          ...dependency.loc,
+          filePath: (0, _projectPath.toProjectPath)(options.projectRoot, dependency.loc.filePath)
+        } : undefined,
+        sourcePath: dependency.sourcePath ? (0, _projectPath.toProjectPath)(options.projectRoot, dependency.sourcePath) : undefined,
+        symbols:
+        // Dependency.symbols are always set to an empty map when scope hoisting
+        // is enabled. Some tests will fail if this is not the case. We should
+        // make this consistant when we re-visit packaging.
+        dependency.symbols != null || dependency.env.shouldScopeHoist ? new Map((_dependency$symbols = dependency.symbols) === null || _dependency$symbols === void 0 ? void 0 : _dependency$symbols.map(mapSymbols)) : undefined
       };
       let usedSymbolsDown = new Set();
       let usedSymbolsUp = new Map();

package/lib/requests/BundleGraphRequest.js

@@ -109,6 +109,25 @@ function createBundleGraphRequest(input) {
       } = await api.runRequest(request, {
         force: options.shouldBuildLazily && requestedAssetIds.size > 0
       });
+
+      // if (input.rustAtlaspack && process.env.NATIVE_COMPARE === 'true') {
+      //   let {assetGraph: jsAssetGraph} = await api.runRequest(
+      //     createAssetGraphRequestJS({
+      //       name: 'Main',
+      //       entries: options.entries,
+      //       optionsRef,
+      //       shouldBuildLazily: options.shouldBuildLazily,
+      //       lazyIncludes: options.lazyIncludes,
+      //       lazyExcludes: options.lazyExcludes,
+      //       requestedAssetIds,
+      //     }),
+      //     {
+      //       force: true,
+      //     },
+      //   );
+      //   require('./asset-graph-diff.js')(jsAssetGraph, assetGraph);
+      // }
+
       measurement && measurement.end();
       (0, _utils2.assertSignalNotAborted)(signal);
 

package/lib/requests/WriteBundleRequest.js

@@ -4,6 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = createWriteBundleRequest;
+exports.replaceStream = replaceStream;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
 var _constants = require("../constants");
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
@@ -127,16 +135,8 @@ async function run({
   let writeOptions = publicBundle.env.isBrowser() || !mainEntry ? undefined : {
     mode: (await inputFS.stat(mainEntry.filePath)).mode
   };
-  let contentStream;
-  if (info.isLargeBlob) {
-    contentStream = options.cache.getStream(cacheKeys.content);
-  } else {
-    contentStream = (0, _utils().blobToStream)(await options.cache.getBlob(cacheKeys.content));
-  }
-  let size = 0;
-  contentStream = contentStream.pipe(new (_utils().TapStream)(buf => {
-    size += buf.length;
-  }));
+  const contents = await options.cache.getBlob(cacheKeys.content);
+  const size = contents.byteLength;
   let configResult = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
   let config = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, options);
   let {
@@ -144,9 +144,9 @@ async function run({
     invalidDevDeps
   } = await (0, _DevDepRequest.getDevDepRequests)(api);
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
-  await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
+  await writeFiles(contents, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
   if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline && (await options.cache.has(mapKey))) {
-    await writeFiles((0, _utils().blobToStream)(await options.cache.getBlob(mapKey)), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+    await writeFiles(await options.cache.getBlob(mapKey), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
   }
   let res = {
     filePath,
@@ -159,13 +159,13 @@ async function run({
   api.storeResult(res);
   return res;
 }
-async function writeFiles(inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
+async function writeFiles(contents, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
   let compressors = await config.getCompressors((0, _projectPath.fromProjectPathRelative)(filePath));
   let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
-  let stream = info.hashReferences.length ? inputStream.pipe(replaceStream(hashRefToNameHash)) : inputStream;
+  const stream = info.hashReferences.length ? (0, _rust().replaceHashReferences)(contents, Object.fromEntries(hashRefToNameHash.entries())) : contents;
   let promises = [];
   for (let compressor of compressors) {
-    promises.push(runCompressor(compressor, cloneStream(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
+    promises.push(runCompressor(compressor, (0, _utils().blobToStream)(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
   }
   await Promise.all(promises);
 }

package/lib/requests/asset-graph-diff.js

@@ -0,0 +1,128 @@
+"use strict";
+
+function _default() {
+  const data = _interopRequireDefault(require("rfdc/default"));
+  _default = function () {
+    return data;
+  };
+  return data;
+}
+function _jestDiff() {
+  const data = require("jest-diff");
+  _jestDiff = function () {
+    return data;
+  };
+  return data;
+}
+var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
+var _projectPath = require("../projectPath");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-console */ // $FlowFixMe
+// $FlowFixMe
+function filterNode(node) {
+  let clone = (0, _default().default)(node);
+
+  // Clean up anything you don't want to see in the diff
+  // delete clone.id;
+  delete clone.value.id;
+  delete clone.value.meta.id;
+  delete clone.value.sourceAssetId;
+  delete clone.value.env.id;
+  delete clone.value.isEsm;
+  delete clone.value.shouldWrap;
+  delete clone.value.contentKey;
+  delete clone.value.placeholder;
+  delete clone.value.code;
+  delete clone.value.hasCjsExports;
+  delete clone.value.staticExports;
+  delete clone.value.isConstantModule;
+  delete clone.value.hasNodeReplacements;
+  delete clone.value.stats;
+  delete clone.value.astKey;
+  delete clone.value.astGenerator;
+  delete clone.value.dependencies;
+  return clone;
+}
+function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
+  if (obj instanceof Map) {
+    const copy = {};
+    Array.from(obj.entries()).forEach(([k, v]) => {
+      if (v != null) {
+        copy[k] = compactDeep(v, ignoredPatterns, `${currentPath}.${k}`);
+      }
+    });
+    return copy;
+  } else if (Array.isArray(obj)) {
+    return obj.map(v => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
+  } else if (typeof obj === 'object') {
+    const copy = {};
+    Object.entries(obj ?? {}).forEach(([key, value]) => {
+      const path = `${currentPath}.${key}`;
+      if (ignoredPatterns.some(pattern => path.includes(pattern))) {
+        return;
+      }
+      // Equivalent false == null
+      if (key === 'isWeak' && value === false) {
+        return;
+      }
+      if (value != null) {
+        copy[key] = compactDeep(value, ignoredPatterns, path);
+      }
+    });
+    return copy;
+  } else if (obj != null) {
+    return obj;
+  }
+}
+function assetGraphDiff(jsAssetGraph, rustAssetGraph) {
+  const getNodes = graph => {
+    let nodes = {};
+    graph.traverse(nodeId => {
+      let node = graph.getNode(nodeId) ?? null;
+      if (!node) return;
+      if (node.type === 'dependency') {
+        let sourcePath = node.value.sourcePath ?? (0, _projectPath.toProjectPath)('', 'entry');
+        nodes[`dep:${(0, _projectPath.fromProjectPathRelative)(sourcePath)}:${node.value.specifier}`] = filterNode(node);
+      } else if (node.type === 'asset') {
+        nodes[`asset:${(0, _projectPath.fromProjectPathRelative)(node.value.filePath)}`] = filterNode(node);
+      }
+    });
+    return nodes;
+  };
+  const jsNodes = getNodes(jsAssetGraph);
+  const rustNodes = getNodes(rustAssetGraph);
+  const all = new Set([...Object.keys(jsNodes), ...Object.keys(rustNodes)]);
+  const missing = [];
+  const extra = [];
+  for (const key of all.keys()) {
+    if (process.env.NATIVE_COMPARE !== 'true') {
+      continue;
+    }
+    let jsNode = jsNodes[key];
+    let rustNode = rustNodes[key];
+    if (!rustNode) {
+      missing.push(key);
+      continue;
+    }
+    if (!jsNode) {
+      extra.push(key);
+      continue;
+    }
+    console.log(key);
+    const ignoredPatterns = [
+    // ignored because we don't copy the environment ID back from rust
+    // in the target value
+    '$.value.target.env.id',
+    // ignore asset.mapKey because we don't do persistence on rust yet
+    '$.value.mapKey',
+    // ignore this because it's just the output hash. We don't need to compute
+    // this yet
+    '$.value.outputHash',
+    // ignore correspondingRequest from all nodes
+    '$.correspondingRequest'];
+    console.log((0, _jestDiff().diff)(compactDeep(rustNode, ignoredPatterns), compactDeep(jsNode, ignoredPatterns)));
+  }
+  console.log('Missing', missing);
+  console.log('Extra', extra);
+}
+module.exports = assetGraphDiff;