@atlaspack/core 2.12.1-canary.3426 → 2.12.1-canary.3428

package/lib/AssetGraph.js

@@ -189,8 +189,7 @@ class AssetGraph extends _graph().ContentGraph {
       // The passed project path is ignored in this case, because there is no `loc`
       (0, _Dependency.createDependency)('', {
         specifier: (0, _projectPath.fromProjectPathRelative)(entry.filePath),
-        specifierType: 'esm',
-        // ???
+        specifierType: 'url',
         pipeline: target.pipeline,
         target: target,
         env: target.env,

package/lib/Atlaspack.js

@@ -192,11 +192,11 @@ class Atlaspack {
         }
       });
     }
+    (0, _featureFlags().setFeatureFlags)(resolvedOptions.featureFlags);
     let {
       config
     } = await (0, _AtlaspackConfigRequest.loadAtlaspackConfig)(resolvedOptions);
     this.#config = new _AtlaspackConfig.default(config, resolvedOptions);
-    (0, _featureFlags().setFeatureFlags)(resolvedOptions.featureFlags);
     if (this.#initialOptions.workerFarm) {
       if (this.#initialOptions.workerFarm.ending) {
         throw new Error('Supplied WorkerFarm is ending');

package/lib/Dependency.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createDependency = createDependency;
+exports.createDependencyId = createDependencyId;
 exports.mergeDependencies = mergeDependencies;
 function _rust() {
   const data = require("@atlaspack/rust");
@@ -15,8 +16,52 @@ function _rust() {
 var _types = require("./types");
 var _utils = require("./utils");
 var _projectPath = require("./projectPath");
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function createDependencyId({
+  sourceAssetId,
+  specifier,
+  env,
+  target,
+  pipeline,
+  specifierType,
+  bundleBehavior,
+  priority,
+  packageConditions
+}) {
+  (0, _assert().default)(typeof specifierType === 'string');
+  (0, _assert().default)(typeof priority === 'string' || priority == null);
+  const params = {
+    sourceAssetId,
+    specifier,
+    env,
+    target,
+    pipeline,
+    specifierType: _types.SpecifierType[specifierType],
+    bundleBehavior,
+    priority: priority ? _types.Priority[priority] : _types.Priority.sync,
+    packageConditions
+  };
+  return (0, _rust().createDependencyId)(params);
+}
 function createDependency(projectRoot, opts) {
-  let id = opts.id || (0, _rust().hashString)((opts.sourceAssetId ?? '') + opts.specifier + opts.env.id + (opts.target ? JSON.stringify(opts.target) : '') + (opts.pipeline ?? '') + opts.specifierType + (opts.bundleBehavior ?? '') + (opts.priority ?? 'sync') + (opts.packageConditions ? JSON.stringify(opts.packageConditions) : ''));
+  let id = opts.id || createDependencyId({
+    bundleBehavior: opts.bundleBehavior,
+    env: opts.env,
+    packageConditions: opts.packageConditions,
+    pipeline: opts.pipeline,
+    priority: opts.priority,
+    sourceAssetId: opts.sourceAssetId,
+    specifier: opts.specifier,
+    specifierType: opts.specifierType,
+    target: opts.target
+  });
   let dep = {
     id,
     specifier: opts.specifier,

package/lib/Environment.js

@@ -105,7 +105,7 @@ function createEnvironment({
     loc
   };
   res.id = getEnvironmentHash(res);
-  return res;
+  return Object.freeze(res);
 }
 function mergeEnvironments(projectRoot, a, b) {
   // If merging the same object, avoid copying.
@@ -124,5 +124,15 @@ function mergeEnvironments(projectRoot, a, b) {
   });
 }
 function getEnvironmentHash(env) {
-  return (0, _rust().hashString)(JSON.stringify([env.context, env.engines, env.includeNodeModules, env.outputFormat, env.sourceType, env.isLibrary, env.shouldOptimize, env.shouldScopeHoist, env.sourceMap]));
+  return (0, _rust().createEnvironmentId)({
+    context: env.context,
+    engines: env.engines,
+    includeNodeModules: env.includeNodeModules,
+    outputFormat: env.outputFormat,
+    sourceType: env.sourceType,
+    isLibrary: env.isLibrary,
+    shouldOptimize: env.shouldOptimize,
+    shouldScopeHoist: env.shouldScopeHoist,
+    sourceMap: env.sourceMap
+  });
 }

package/lib/Transformation.js

@@ -46,13 +46,6 @@ function _utils() {
   };
   return data;
 }
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
 var _Dependency = require("./Dependency");
 var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
 var _PathRequest = require("./requests/PathRequest");
@@ -181,16 +174,9 @@ class Transformation {
 
     // Prefer `isSource` originating from the AssetRequest.
 
-    // If the transformer request passed code, use a hash in addition
-    // to the filename as the base for the id to ensure it is unique.
-    let idBase = (0, _projectPath.fromProjectPathRelative)(filePath);
-    if (code != null) {
-      idBase += (0, _rust().hashString)(code);
-    }
     return new _UncommittedAsset.default({
-      idBase,
       value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
-        idBase,
+        code,
         filePath,
         isSource: isSourceOverride ?? summarizedIsSource,
         type: _path().default.extname((0, _projectPath.fromProjectPathRelative)(filePath)).slice(1),

package/lib/UncommittedAsset.js

@@ -56,7 +56,7 @@ class UncommittedAsset {
     mapBuffer,
     ast,
     isASTDirty,
-    idBase,
+    code,
     invalidations
   }) {
     this.value = value;
@@ -65,7 +65,7 @@ class UncommittedAsset {
     this.mapBuffer = mapBuffer;
     this.ast = ast;
     this.isASTDirty = isASTDirty || false;
-    this.idBase = idBase;
+    this.code = code;
     this.invalidations = invalidations || (0, _utils2.createInvalidations)();
   }
 
@@ -289,7 +289,7 @@ class UncommittedAsset {
     let content = result.content ?? null;
     let asset = new UncommittedAsset({
       value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
-        idBase: this.idBase,
+        code: this.code,
         filePath: this.value.filePath,
         type: result.type,
         bundleBehavior: result.bundleBehavior ?? (this.value.bundleBehavior == null ? null : _types.BundleBehaviorNames[this.value.bundleBehavior]),
@@ -323,7 +323,7 @@ class UncommittedAsset {
       ast: result.ast,
       isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
       mapBuffer: result.map ? result.map.toBuffer() : null,
-      idBase: this.idBase,
+      code: this.code,
       invalidations: this.invalidations
     });
     let dependencies = result.dependencies;

package/lib/Validation.js

@@ -46,13 +46,6 @@ function _profiler() {
   };
   return data;
 }
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
 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 }; }
@@ -188,14 +181,9 @@ class Validation {
     } = await (0, _summarizeRequest.default)(this.options.inputFS, {
       filePath: (0, _projectPath.fromProjectPath)(this.options.projectRoot, request.filePath)
     });
-
-    // If the transformer request passed code rather than a filename,
-    // use a hash as the base for the id to ensure it is unique.
-    let idBase = code != null ? (0, _rust().hashString)(code) : (0, _projectPath.fromProjectPathRelative)(filePath);
     return new _UncommittedAsset.default({
-      idBase,
       value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
-        idBase,
+        code,
         filePath: filePath,
         isSource,
         type: _path().default.extname((0, _projectPath.fromProjectPathRelative)(filePath)).slice(1),

package/lib/assetUtils.js

@@ -61,9 +61,15 @@ function _profiler() {
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetIdFromOptions(options) {
-  let uniqueKey = options.uniqueKey ?? '';
-  let idBase = options.idBase != null ? options.idBase : (0, _projectPath.fromProjectPathRelative)(options.filePath);
-  return (0, _rust().hashString)(idBase + options.type + options.env.id + uniqueKey + ':' + (options.pipeline ?? '') + ':' + (options.query ?? ''));
+  return (0, _rust().createAssetId)({
+    env: options.env,
+    filePath: options.filePath,
+    code: options.code,
+    pipeline: options.pipeline,
+    query: options.query,
+    uniqueKey: options.uniqueKey,
+    fileType: options.type
+  });
 }
 function createAsset(projectRoot, options) {
   return {

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

@@ -33,11 +33,82 @@ function _module() {
   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);
+    switch (kind) {
+      case 'resolver':
+        this.#resolvers.set(specifier, resolvedModule.default[CONFIG]);
+        break;
+    }
+  });
+  runResolverResolve = (0, _jsCallable.jsCallable)(async ({
+    key,
+    dependency,
+    specifier
+  }) => {
+    const resolver = this.#resolvers.get(key);
+    if (!resolver) {
+      throw new Error('Resolver not found');
+    }
+    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');
   }
@@ -47,24 +118,24 @@ class AtlaspackWorker {
     options,
     asset
   }) {
-    let customRequire = _module().createRequire(resolveFrom);
-    let resolvedPath = customRequire.resolve(specifier);
+    const customRequire = _module().createRequire(resolveFrom);
+    const resolvedPath = customRequire.resolve(specifier);
     // $FlowFixMe
-    let transformerModule = await import(resolvedPath);
-    let transformer = transformerModule.default.default[CONFIG];
+    const transformerModule = await import(resolvedPath);
+    const transformer = transformerModule.default.default[CONFIG];
     let assetCompat = new _compat.AssetCompat(asset, options);
     try {
       if (transformer.parse) {
         // $FlowFixMe
-        let ast = await transformer.parse({
+        const ast = await transformer.parse({
           asset: assetCompat
-        });
+        }); // missing "config"
         // $FlowFixMe
         assetCompat.setAST(ast);
       }
 
       // $FlowFixMe
-      let result = await transformer.transform({
+      const result = await transformer.transform({
         // $FlowFixMe
         asset: assetCompat,
         options,
@@ -97,4 +168,9 @@ class AtlaspackWorker {
   }
 }
 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
+};

package/lib/requests/AssetGraphRequestRust.js

@@ -86,13 +86,11 @@ function getAssetGraph(serializedGraph, options) {
     ...symbol
   }) {
     let jsSymbol = {
-      local: symbol.local,
-      loc: symbol.loc
+      local: symbol.local ?? undefined,
+      loc: symbol.loc ?? undefined,
+      meta: undefined,
+      isWeak: symbol.isWeak
     };
-    if (symbol.isWeak) {
-      // $FlowFixMe
-      jsSymbol.isWeak = symbol.isWeak;
-    }
     if (symbol.exported) {
       // $FlowFixMe
       jsSymbol.exported = symbol.exported;
@@ -105,11 +103,8 @@ function getAssetGraph(serializedGraph, options) {
     }
     return [exported, jsSymbol];
   }
+
   // See crates/atlaspack_core/src/types/environment.rs
-  let sourceTypeLookup = {
-    '0': 'module',
-    '1': 'script'
-  };
   let cachedAssets = new Map();
   let changedAssets = new Map();
   let entry = 0;
@@ -144,10 +139,23 @@ function getAssetGraph(serializedGraph, options) {
       asset.meta.id = id;
       asset = {
         ...asset,
+        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: sourceTypeLookup[asset.env.sourceType]
+          sourceType: asset.env.sourceType
         },
         bundleBehavior: asset.bundleBehavior === 255 ? null : asset.bundleBehavior,
         committed: true,
@@ -175,15 +183,20 @@ function getAssetGraph(serializedGraph, options) {
         env: {
           ...dependency.env,
           id: getEnvId(dependency.env),
-          sourceType: sourceTypeLookup[dependency.env.sourceType]
+          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,
         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) : null,
+        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

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/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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3426+9ec24d923",
+  "version": "2.12.1-canary.3428+a36723bdd",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/diagnostic": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/events": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/feature-flags": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/fs": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/graph": "3.2.1-canary.3426+9ec24d923",
-    "@atlaspack/logger": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/package-manager": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/plugin": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/profiler": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/rust": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/types": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/utils": "2.12.1-canary.3426+9ec24d923",
-    "@atlaspack/workers": "2.12.1-canary.3426+9ec24d923",
+    "@atlaspack/cache": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/diagnostic": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/events": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/feature-flags": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/fs": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/graph": "3.2.1-canary.3428+a36723bdd",
+    "@atlaspack/logger": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/package-manager": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/plugin": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/profiler": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/rust": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/types": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/utils": "2.12.1-canary.3428+a36723bdd",
+    "@atlaspack/workers": "2.12.1-canary.3428+a36723bdd",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -50,10 +50,12 @@
     "@atlaspack/babel-register": "2.12.0",
     "@types/node": ">= 18",
     "graphviz": "^0.0.9",
+    "jest-diff": "*",
+    "rfdc": "1",
     "tempy": "^0.2.1"
   },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "9ec24d923e4361f97bcc64c967c066fbebb7f4b4"
+  "gitHead": "a36723bdd944adb8243fa61102923c6811a63001"
 }

package/src/AssetGraph.js

@@ -227,7 +227,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         // The passed project path is ignored in this case, because there is no `loc`
         createDependency('', {
           specifier: fromProjectPathRelative(entry.filePath),
-          specifierType: 'esm', // ???
+          specifierType: 'url',
           pipeline: target.pipeline,
           target: target,
           env: target.env,

package/src/Atlaspack.js

@@ -152,11 +152,11 @@ export default class Atlaspack {
       });
     }
 
+    setFeatureFlags(resolvedOptions.featureFlags);
+
     let {config} = await loadAtlaspackConfig(resolvedOptions);
     this.#config = new AtlaspackConfig(config, resolvedOptions);
 
-    setFeatureFlags(resolvedOptions.featureFlags);
-
     if (this.#initialOptions.workerFarm) {
       if (this.#initialOptions.workerFarm.ending) {
         throw new Error('Supplied WorkerFarm is ending');