@atlaspack/core 2.23.4 → 2.23.6-dev-export-func-opt-67f87c28a.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaspack/core
 
+## 2.23.5
+
+### Patch Changes
+
+- Updated dependencies [[`830261d`](https://github.com/atlassian-labs/atlaspack/commit/830261dcf4a40293090b61cab52fd75d5683c73f), [`58ddd5d`](https://github.com/atlassian-labs/atlaspack/commit/58ddd5d79adde2ac5dc4c60ca575e4705a91e592), [`53dd47b`](https://github.com/atlassian-labs/atlaspack/commit/53dd47bd6d23cd47f87297347f03a609ab38a03d)]:
+  - @atlaspack/feature-flags@2.24.1
+  - @atlaspack/package-manager@2.14.29
+  - @atlaspack/rust@3.7.0
+  - @atlaspack/cache@3.2.24
+  - @atlaspack/fs@2.15.24
+  - @atlaspack/graph@3.5.18
+  - @atlaspack/utils@2.19.1
+  - @atlaspack/logger@2.14.21
+  - @atlaspack/plugin@2.14.29
+  - @atlaspack/profiler@2.14.26
+  - @atlaspack/types@2.15.19
+  - @atlaspack/workers@2.14.29
+
 ## 2.23.4
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2024 Atlassian US., Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/lib/Environment.js

@@ -34,7 +34,8 @@ function createEnvironment({
   shouldScopeHoist = false,
   sourceMap,
   unstableSingleFileOutput = false,
-  loc
+  loc,
+  customEnv
 } = {
   /*::...null*/
 }) {
@@ -111,7 +112,8 @@ function createEnvironment({
     shouldScopeHoist,
     sourceMap,
     unstableSingleFileOutput,
-    loc
+    loc,
+    customEnv
   };
   res.id = getEnvironmentHash(res);
   return (0, _EnvironmentManager.toEnvironmentRef)(Object.freeze(res));
@@ -140,7 +142,8 @@ function getEnvironmentHash(env) {
     isLibrary: env.isLibrary,
     shouldOptimize: env.shouldOptimize,
     shouldScopeHoist: env.shouldScopeHoist,
-    sourceMap: env.sourceMap
+    sourceMap: env.sourceMap,
+    customEnv: env.customEnv
   };
   const id = (0, _rust().createEnvironmentId)(data);
   _IdentifierRegistry.identifierRegistry.addIdentifier('environment', id, data);

package/lib/TargetDescriptor.schema.js

@@ -98,6 +98,12 @@ const PACKAGE_DESCRIPTOR_SCHEMA = exports.PACKAGE_DESCRIPTOR_SCHEMA = {
     },
     __unstable_singleFileOutput: {
       type: 'boolean'
+    },
+    env: {
+      type: 'object',
+      additionalProperties: {
+        type: 'string'
+      }
     }
   },
   additionalProperties: false

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

@@ -21,6 +21,7 @@ class Environment {
     this.sourceMap = inner.sourceMap;
     this.loc = inner.loc;
     this.unstableSingleFileOutput = false;
+    this.customEnv = inner.customEnv;
   }
   isBrowser() {
     return this.context === 'browser' || this.isWorker() || this.isTesseract() || this.isWorklet() || this.context === 'electron-renderer';

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

@@ -269,6 +269,13 @@ class AtlaspackWorker {
     }
     (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
     (0, _assert().default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
+    let assetBuffer = await mutableAsset.getBuffer();
+
+    // If the asset has no code, we set the buffer to null, which we can
+    // detect in Rust, to avoid passing back an empty buffer, which we can't.
+    if (assetBuffer.length === 0) {
+      assetBuffer = null;
+    }
     return [{
       id: mutableAsset.id,
       bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
@@ -284,7 +291,7 @@ class AtlaspackWorker {
       symbols: mutableAsset.symbols.intoNapi(),
       type: mutableAsset.type,
       uniqueKey: mutableAsset.uniqueKey
-    }, await mutableAsset.getBuffer(),
+    }, assetBuffer,
     // Only send back the map if it has changed
     mutableAsset.isMapDirty ?
     // @ts-expect-error TS2533

package/lib/public/Environment.js

@@ -178,6 +178,9 @@ class Environment {
   get unstableSingleFileOutput() {
     return this.#environment.unstableSingleFileOutput;
   }
+  get customEnv() {
+    return this.#environment.customEnv;
+  }
   [inspect]() {
     return `Env(${this.#environment.context})`;
   }

package/lib/requests/AssetGraphRequestRust.js

@@ -99,19 +99,16 @@ function getAssetGraph(serializedGraph) {
     let jsSymbol = {
       local: symbol.local ?? undefined,
       loc: symbol.loc ?? undefined,
-      meta: undefined,
-      isWeak: symbol.isWeak
+      isWeak: symbol.isWeak,
+      meta: {
+        isEsm: symbol.isEsmExport,
+        isStaticBindingSafe: symbol.isStaticBindingSafe
+      }
     };
     if (symbol.exported) {
       // @ts-expect-error TS2339
       jsSymbol.exported = symbol.exported;
     }
-    if (symbol.isEsmExport) {
-      // @ts-expect-error TS2322
-      jsSymbol.meta = {
-        isEsm: true
-      };
-    }
     return [exported, jsSymbol];
   }
 

package/lib/requests/TargetRequest.js

@@ -70,6 +70,13 @@ var _utils2 = require("../utils");
 var _projectPath = require("../projectPath");
 var _RequestTracker = require("../RequestTracker");
 var _EnvironmentManager = require("../EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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; }
@@ -115,8 +122,6 @@ function skipTarget(targetName, exclusiveTarget, descriptorSource) {
 
   return exclusiveTarget == null ? descriptorSource != null : targetName !== exclusiveTarget;
 }
-
-// @ts-expect-error TS7031
 async function run({
   input,
   api,
@@ -124,10 +129,35 @@ async function run({
 }) {
   let targetResolver = new TargetResolver(api, (0, _utils2.optionsProxy)(options, api.invalidateOnOptionChange));
   let targets = await targetResolver.resolve((0, _projectPath.fromProjectPath)(options.projectRoot, input.packagePath), input.target);
+
+  // Filter targets based on allowExplicitTargetEntries feature flag
+  if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && options.targets &&
+  // Only explicit targets are allowed (i.e. an object of targets)
+  !Array.isArray(options.targets)) {
+    // Check if ALL targets have sources - only apply new behavior if they do
+    const allTargetsHaveSources = targets.every(t => t.source);
+    if (allTargetsHaveSources) {
+      // Get the current entry file path relative to project root
+      const currentEntryPath = input.filePath;
+
+      // Filter targets to only include those whose source matches the current entry
+      targets = targets.filter(target => {
+        // Handle both string and array sources
+        const sources = Array.isArray(target.source) ? target.source : [target.source];
+
+        // Check if current entry matches any of the target sources
+        return sources.some(source => {
+          const targetSourcePath = (0, _projectPath.toProjectPath)(options.projectRoot, _path().default.resolve((0, _projectPath.fromProjectPath)(options.projectRoot, input.packagePath), (0, _nullthrows().default)(source, 'Source must be not be undefined when specified')));
+          return targetSourcePath === currentEntryPath;
+        });
+      });
+    } else {
+      // If not all targets have sources, fall back to old behavior (skip targets with sources)
+      targets = targets.filter(target => !target.source);
+    }
+  }
   assertTargetsAreNotEntries(targets, input, options);
-  let configResult = (0, _nullthrows().default)(
-  // @ts-expect-error TS2347
-  await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let configResult = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
   let atlaspackConfig = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, options);
 
   // Find named pipelines for each target.
@@ -226,7 +256,8 @@ class TargetResolver {
               shouldOptimize: this.options.defaultTargetOptions.shouldOptimize && descriptor.optimize !== false,
               shouldScopeHoist: this.options.defaultTargetOptions.shouldScopeHoist && descriptor.scopeHoist !== false,
               sourceMap: normalizeSourceMap(this.options, descriptor.sourceMap),
-              unstableSingleFileOutput: descriptor.__unstable_singleFileOutput
+              unstableSingleFileOutput: descriptor.__unstable_singleFileOutput,
+              customEnv: descriptor.env
             })
           };
           if (descriptor.distEntry != null) {
@@ -236,7 +267,17 @@ class TargetResolver {
             target.source = descriptor.source;
           }
           return target;
-        }).filter(target => !skipTarget(target.name, exclusiveTarget, target.source));
+        }).filter(target => (0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && this.options.entries.length !== 0 || !skipTarget(target.name, exclusiveTarget, target.source));
+
+        // Apply allowExplicitTargetEntries filtering logic
+        if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries')) {
+          // Check if ALL targets have sources - only apply new behavior if they do
+          const allTargetsHaveSources = targets.every(t => t.source);
+          if (!allTargetsHaveSources) {
+            // If not all targets have sources, fall back to old behavior (skip targets with sources)
+            targets = targets.filter(target => !target.source);
+          }
+        }
       }
       let serve = this.options.serveOptions;
       if (serve && targets.length > 0) {

package/lib/requests/WriteBundlesRequest.js

@@ -12,6 +12,7 @@ function _featureFlags() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+var _types = require("../types");
 var _ReporterRunner = require("../ReporterRunner");
 var _constants = require("../constants");
 var _projectPath = require("../projectPath");
@@ -55,8 +56,6 @@ function createWriteBundlesRequest(input) {
     input
   };
 }
-
-// @ts-expect-error TS7031
 async function run({
   input,
   api,
@@ -82,11 +81,7 @@ async function run({
   const allBundles = bundleGraph.getBundles({
     includeInline: (0, _featureFlags().getFeatureFlag)('inlineBundlesSourceMapFixes')
   });
-  const bundles = allBundles.filter(
-  // @ts-expect-error TS7006
-  bundle => bundle.bundleBehavior !== 'inline' && bundle.bundleBehavior !== 'inline-isolated')
-  // @ts-expect-error TS7006
-  .filter(bundle => {
+  const bundles = allBundles.filter(bundle => bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated).filter(bundle => {
     // Do not package and write placeholder bundles to disk. We just
     // need to update the name so other bundles can reference it.
     if (bundle.isPlaceholder) {
@@ -107,9 +102,7 @@ async function run({
     }
     return true;
   });
-  let cachedBundles = new Set(
-  // @ts-expect-error TS7006
-  bundles.filter(b => api.canSkipSubrequest(bundleGraph.getHash(b))));
+  let cachedBundles = new Set(bundles.filter(b => api.canSkipSubrequest(bundleGraph.getHash(b))));
 
   // Package on the main thread if there is only one bundle to package.
   // This avoids the cost of serializing the bundle graph for single file change builds.
@@ -117,9 +110,7 @@ async function run({
   try {
     let completeBundles = cachedBundles.size;
     reportPackagingProgress(completeBundles, bundles.length);
-    await Promise.all(
-    // @ts-expect-error TS7006
-    bundles.map(async bundle => {
+    await Promise.all(bundles.map(async bundle => {
       let request = (0, _PackageRequest.createPackageRequest)({
         bundle,
         bundleGraph,
@@ -159,17 +150,13 @@ async function run({
       }
     }));
     assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
-    await Promise.all(
-    // @ts-expect-error TS7006
-    bundles.map(bundle => {
+    await Promise.all(bundles.map(bundle => {
       let promise = writeEarlyPromises[bundle.id] ?? api.runRequest((0, _WriteBundleRequest.default)({
         bundle,
         info: bundleInfoMap[bundle.id],
         hashRefToNameHash,
         bundleGraph
       }));
-
-      // @ts-expect-error TS7006
       return promise.then(r => res.set(bundle.id, r));
     }));
     api.storeResult(res);
@@ -178,18 +165,12 @@ async function run({
     await dispose();
   }
 }
-function assignComplexNameHashes(hashRefToNameHash,
-// @ts-expect-error TS2304
-bundles, bundleInfoMap,
-// @ts-expect-error TS2304
-options) {
+function assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options) {
   for (let bundle of bundles) {
     if (hashRefToNameHash.get(bundle.hashReference) != null) {
       continue;
     }
-    hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-    // @ts-expect-error TS2538
-    .map(bundleId => bundleInfoMap[bundleId].hash).join(':')).slice(-8) : bundle.id.slice(-8));
+    hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash ? (0, _rust().hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)].map(bundleId => bundleInfoMap[bundleId].hash).join(':')).slice(-8) : bundle.id.slice(-8));
   }
 }
 function getBundlesIncludedInHash(bundleId, bundleInfoMap, included = new Set()) {

package/lib/resolveOptions.js

@@ -106,6 +106,21 @@ async function resolveOptions(initialOptions) {
   } else {
     entries = [_path().default.resolve(inputCwd, initialOptions.entries)];
   }
+
+  // When allowExplicitTargetEntries is enabled and no entries are provided,
+  // automatically derive entries from target sources
+  if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && initialOptions.targets && !Array.isArray(initialOptions.targets) && entries.length === 0) {
+    const targetSources = new Set();
+    for (const [, target] of Object.entries(initialOptions.targets)) {
+      if (target.source) {
+        const sources = Array.isArray(target.source) ? target.source : [target.source];
+        for (const source of sources) {
+          targetSources.add(source);
+        }
+      }
+    }
+    entries = Array.from(targetSources);
+  }
   let shouldMakeEntryReferFolder = false;
   if (entries.length === 1 && !(0, _utils().isGlob)(entries[0])) {
     let [entry] = entries;

package/lib/types/Environment.d.ts

@@ -1,10 +1,11 @@
-import type { EnvironmentOptions, Environment as IEnvironment, FilePath } from '@atlaspack/types';
+import type { EnvironmentOptions, Environment as IEnvironment, FilePath, EnvMap } from '@atlaspack/types';
 import type { Environment, InternalSourceLocation } from './types';
 import type { EnvironmentRef } from './EnvironmentManager';
 type EnvironmentOpts = EnvironmentOptions & {
     loc?: InternalSourceLocation | null | undefined;
+    customEnv?: EnvMap | null | undefined;
 };
-export declare function createEnvironment({ context, engines, includeNodeModules, outputFormat, sourceType, shouldOptimize, isLibrary, shouldScopeHoist, sourceMap, unstableSingleFileOutput, loc, }?: EnvironmentOpts): EnvironmentRef;
+export declare function createEnvironment({ context, engines, includeNodeModules, outputFormat, sourceType, shouldOptimize, isLibrary, shouldScopeHoist, sourceMap, unstableSingleFileOutput, loc, customEnv, }?: EnvironmentOpts): EnvironmentRef;
 export declare function mergeEnvironments(projectRoot: FilePath, a: Environment, b?: EnvironmentOptions | IEnvironment | null): EnvironmentRef;
 export declare function getEnvironmentHash(env: Environment): string;
 export {};

package/lib/types/atlaspack-v3/worker/compat/environment.d.ts

@@ -1,5 +1,5 @@
 import type { Environment as NapiEnvironment } from '@atlaspack/rust';
-import type { Environment as IEnvironment, EnvironmentContext, Engines, PackageName, OutputFormat, SourceType, TargetSourceMapOptions, SourceLocation, VersionMap, EnvironmentFeature } from '@atlaspack/types';
+import type { Environment as IEnvironment, EnvironmentContext, Engines, PackageName, OutputFormat, SourceType, TargetSourceMapOptions, SourceLocation, VersionMap, EnvironmentFeature, EnvMap } from '@atlaspack/types';
 export declare class Environment implements IEnvironment {
     id: string;
     includeNodeModules: boolean | Array<PackageName> | Partial<Record<PackageName, boolean>>;
@@ -13,6 +13,7 @@ export declare class Environment implements IEnvironment {
     sourceMap: TargetSourceMapOptions | null | undefined;
     loc: SourceLocation | null | undefined;
     unstableSingleFileOutput: boolean;
+    customEnv: EnvMap | null | undefined;
     constructor(inner: NapiEnvironment);
     isBrowser(): boolean;
     isNode(): boolean;

package/lib/types/public/Environment.d.ts

@@ -1,4 +1,4 @@
-import type { Environment as IEnvironment, EnvironmentContext, EnvironmentFeature, Engines, OutputFormat, PackageName, VersionMap, SourceLocation, SourceType, TargetSourceMapOptions } from '@atlaspack/types';
+import type { Environment as IEnvironment, EnvironmentContext, EnvironmentFeature, Engines, OutputFormat, PackageName, VersionMap, SourceLocation, SourceType, TargetSourceMapOptions, EnvMap } from '@atlaspack/types';
 import type { Environment as InternalEnvironment, AtlaspackOptions } from '../types';
 declare const inspect: unique symbol;
 export declare const BROWSER_ENVS: Set<string>;
@@ -19,6 +19,7 @@ export default class Environment implements IEnvironment {
     get sourceMap(): TargetSourceMapOptions | null | undefined;
     get loc(): SourceLocation | null | undefined;
     get unstableSingleFileOutput(): boolean;
+    get customEnv(): EnvMap | null | undefined;
     [inspect](): string;
     isBrowser(): boolean;
     isNode(): boolean;

package/lib/types/requests/WriteBundlesRequest.d.ts

@@ -3,7 +3,7 @@ import type { Async } from '@atlaspack/types';
 import type { SharedReference } from '@atlaspack/workers';
 import type { StaticRunOpts } from '../RequestTracker';
 import { requestTypes } from '../RequestTracker';
-import type { PackagedBundleInfo } from '../types';
+import { type PackagedBundleInfo } from '../types';
 import type BundleGraph from '../BundleGraph';
 type WriteBundlesRequestInput = {
     bundleGraph: BundleGraph;

package/lib/types/types.d.ts

@@ -46,6 +46,7 @@ export type Environment = {
     sourceMap: TargetSourceMapOptions | null | undefined;
     loc: InternalSourceLocation | null | undefined;
     unstableSingleFileOutput: boolean;
+    customEnv: EnvMap | null | undefined;
 };
 export type InternalSourceLocation = {
     readonly filePath: ProjectPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.23.4",
+  "version": "2.23.6-dev-export-func-opt-67f87c28a.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -11,7 +11,7 @@
   },
   "main": "./lib/index.js",
   "source": "./src/index.ts",
-  "types": "./lib/types/index.d.ts",
+  "types": "./lib/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
@@ -23,22 +23,22 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
+    "@atlaspack/build-cache": "2.13.6-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/cache": "3.2.25-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/diagnostic": "2.14.4-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/events": "2.14.4-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/feature-flags": "2.24.2-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/fs": "2.15.25-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/graph": "3.5.19-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/logger": "2.14.22-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/package-manager": "2.14.30-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/plugin": "2.14.30-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/profiler": "2.14.27-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/rust": "3.7.1-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/types": "2.15.20-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/utils": "2.19.2-dev-export-func-opt-67f87c28a.0",
+    "@atlaspack/workers": "2.14.30-dev-export-func-opt-67f87c28a.0",
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.5",
-    "@atlaspack/cache": "3.2.23",
-    "@atlaspack/diagnostic": "2.14.3",
-    "@atlaspack/events": "2.14.3",
-    "@atlaspack/feature-flags": "2.24.0",
-    "@atlaspack/fs": "2.15.23",
-    "@atlaspack/graph": "3.5.17",
-    "@atlaspack/logger": "2.14.20",
-    "@atlaspack/package-manager": "2.14.28",
-    "@atlaspack/plugin": "2.14.28",
-    "@atlaspack/profiler": "2.14.25",
-    "@atlaspack/rust": "3.6.2",
-    "@atlaspack/types": "2.15.18",
-    "@atlaspack/utils": "2.19.0",
-    "@atlaspack/workers": "2.14.28",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
@@ -51,15 +51,16 @@
     "semver": "^7.5.2"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.3",
+    "@atlaspack/babel-register": "2.14.4-dev-export-func-opt-67f87c28a.0",
     "@types/node": ">= 18",
-    "rfdc": "1",
-    "jest-diff": "*",
     "graphviz": "^0.0.9",
+    "jest-diff": "*",
+    "rfdc": "1",
     "tempy": "^0.2.1"
   },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "type": "commonjs"
-}
+  "type": "commonjs",
+  "gitHead": "67f87c28a23fcf285d88a1c969de4e35956cb500"
+}

package/src/Environment.ts

@@ -2,6 +2,7 @@ import type {
   EnvironmentOptions,
   Environment as IEnvironment,
   FilePath,
+  EnvMap,
 } from '@atlaspack/types';
 import type {Environment, InternalSourceLocation} from './types';
 import {createEnvironmentId} from '@atlaspack/rust';
@@ -19,6 +20,7 @@ const DEFAULT_ENGINES = {
 
 type EnvironmentOpts = EnvironmentOptions & {
   loc?: InternalSourceLocation | null | undefined;
+  customEnv?: EnvMap | null | undefined;
 };
 
 export function createEnvironment({
@@ -33,6 +35,7 @@ export function createEnvironment({
   sourceMap,
   unstableSingleFileOutput = false,
   loc,
+  customEnv,
 }: EnvironmentOpts = {
   /*::...null*/
 }): EnvironmentRef {
@@ -113,6 +116,7 @@ export function createEnvironment({
     sourceMap,
     unstableSingleFileOutput,
     loc,
+    customEnv,
   };
 
   res.id = getEnvironmentHash(res);
@@ -152,6 +156,7 @@ export function getEnvironmentHash(env: Environment): string {
     shouldOptimize: env.shouldOptimize,
     shouldScopeHoist: env.shouldScopeHoist,
     sourceMap: env.sourceMap,
+    customEnv: env.customEnv,
   } as const;
   const id = createEnvironmentId(data);
   identifierRegistry.addIdentifier('environment', id, data);

package/src/TargetDescriptor.schema.ts

@@ -115,6 +115,12 @@ export const PACKAGE_DESCRIPTOR_SCHEMA: SchemaObject = {
     __unstable_singleFileOutput: {
       type: 'boolean',
     },
+    env: {
+      type: 'object',
+      additionalProperties: {
+        type: 'string',
+      },
+    },
   },
   additionalProperties: false,
 };

package/src/Transformation.ts

@@ -46,6 +46,7 @@ import UncommittedAsset from './UncommittedAsset';
 import {createAsset} from './assetUtils';
 import summarizeRequest from './summarizeRequest';
 import PluginOptions from './public/PluginOptions';
+import {fromEnvironmentId} from './EnvironmentManager';
 import {optionsProxy} from './utils';
 import {createConfig} from './InternalConfig';
 import {

package/src/atlaspack-v3/worker/compat/environment.ts

@@ -11,6 +11,7 @@ import type {
   SourceLocation,
   VersionMap,
   EnvironmentFeature,
+  EnvMap,
 } from '@atlaspack/types';
 
 export class Environment implements IEnvironment {
@@ -29,6 +30,7 @@ export class Environment implements IEnvironment {
   sourceMap: TargetSourceMapOptions | null | undefined;
   loc: SourceLocation | null | undefined;
   unstableSingleFileOutput: boolean;
+  customEnv: EnvMap | null | undefined;
 
   constructor(inner: NapiEnvironment) {
     // TODO
@@ -44,6 +46,7 @@ export class Environment implements IEnvironment {
     this.sourceMap = inner.sourceMap;
     this.loc = inner.loc;
     this.unstableSingleFileOutput = false;
+    this.customEnv = inner.customEnv;
   }
 
   isBrowser(): boolean {

package/src/atlaspack-v3/worker/worker.ts

@@ -282,6 +282,14 @@ export class AtlaspackWorker {
         '[V3] Unimplemented: New asset returned from Node transformer',
       );
 
+      let assetBuffer: Buffer | null = await mutableAsset.getBuffer();
+
+      // If the asset has no code, we set the buffer to null, which we can
+      // detect in Rust, to avoid passing back an empty buffer, which we can't.
+      if (assetBuffer.length === 0) {
+        assetBuffer = null;
+      }
+
       return [
         {
           id: mutableAsset.id,
@@ -301,7 +309,7 @@ export class AtlaspackWorker {
           type: mutableAsset.type,
           uniqueKey: mutableAsset.uniqueKey,
         },
-        await mutableAsset.getBuffer(),
+        assetBuffer,
         // Only send back the map if it has changed
         mutableAsset.isMapDirty
           ? // @ts-expect-error TS2533

package/src/public/Environment.ts

@@ -9,6 +9,7 @@ import type {
   SourceLocation,
   SourceType,
   TargetSourceMapOptions,
+  EnvMap,
 } from '@atlaspack/types';
 import type {
   Environment as InternalEnvironment,
@@ -232,6 +233,10 @@ export default class Environment implements IEnvironment {
     return this.#environment.unstableSingleFileOutput;
   }
 
+  get customEnv(): EnvMap | null | undefined {
+    return this.#environment.customEnv;
+  }
+
   [inspect](): string {
     return `Env(${this.#environment.context})`;
   }

package/src/requests/AssetGraphRequestRust.ts

@@ -96,8 +96,11 @@ export function getAssetGraph(serializedGraph: any): {
     let jsSymbol = {
       local: symbol.local ?? undefined,
       loc: symbol.loc ?? undefined,
-      meta: undefined,
       isWeak: symbol.isWeak,
+      meta: {
+        isEsm: symbol.isEsmExport,
+        isStaticBindingSafe: symbol.isStaticBindingSafe,
+      },
     };
 
     if (symbol.exported) {
@@ -105,13 +108,6 @@ export function getAssetGraph(serializedGraph: any): {
       jsSymbol.exported = symbol.exported;
     }
 
-    if (symbol.isEsmExport) {
-      // @ts-expect-error TS2322
-      jsSymbol.meta = {
-        isEsm: true,
-      };
-    }
-
     return [exported, jsSymbol];
   }
 

package/src/requests/TargetRequest.ts

@@ -47,6 +47,7 @@ import {optionsProxy, toInternalSourceLocation} from '../utils';
 import {fromProjectPath, toProjectPath, joinProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
 import {fromEnvironmentId} from '../EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type RunOpts<TResult> = {
   input: Entry;
@@ -119,8 +120,7 @@ export function skipTarget(
     : targetName !== exclusiveTarget;
 }
 
-// @ts-expect-error TS7031
-async function run({input, api, options}) {
+async function run({input, api, options}: RunOpts<TargetRequestResult>) {
   let targetResolver = new TargetResolver(
     api,
     optionsProxy(options, api.invalidateOnOptionChange),
@@ -130,10 +130,50 @@ async function run({input, api, options}) {
     input.target,
   );
 
+  // Filter targets based on allowExplicitTargetEntries feature flag
+  if (
+    getFeatureFlag('allowExplicitTargetEntries') &&
+    options.targets &&
+    // Only explicit targets are allowed (i.e. an object of targets)
+    !Array.isArray(options.targets)
+  ) {
+    // Check if ALL targets have sources - only apply new behavior if they do
+    const allTargetsHaveSources = targets.every((t) => t.source);
+    if (allTargetsHaveSources) {
+      // Get the current entry file path relative to project root
+      const currentEntryPath = input.filePath;
+
+      // Filter targets to only include those whose source matches the current entry
+      targets = targets.filter((target) => {
+        // Handle both string and array sources
+        const sources = Array.isArray(target.source)
+          ? target.source
+          : [target.source];
+
+        // Check if current entry matches any of the target sources
+        return sources.some((source) => {
+          const targetSourcePath = toProjectPath(
+            options.projectRoot,
+            path.resolve(
+              fromProjectPath(options.projectRoot, input.packagePath),
+              nullthrows(
+                source,
+                'Source must be not be undefined when specified',
+              ),
+            ),
+          );
+          return targetSourcePath === currentEntryPath;
+        });
+      });
+    } else {
+      // If not all targets have sources, fall back to old behavior (skip targets with sources)
+      targets = targets.filter((target) => !target.source);
+    }
+  }
+
   assertTargetsAreNotEntries(targets, input, options);
 
   let configResult = nullthrows(
-    // @ts-expect-error TS2347
     await api.runRequest<null, ConfigAndCachePath>(
       createAtlaspackConfigRequest(),
     ),
@@ -314,6 +354,7 @@ export class TargetResolver {
                 ),
                 unstableSingleFileOutput:
                   descriptor.__unstable_singleFileOutput,
+                customEnv: descriptor.env,
               }),
             };
 
@@ -329,8 +370,21 @@ export class TargetResolver {
           })
           .filter(
             (target) =>
+              (getFeatureFlag('allowExplicitTargetEntries') &&
+                this.options.entries.length !== 0) ||
               !skipTarget(target.name, exclusiveTarget, target.source),
           );
+
+        // Apply allowExplicitTargetEntries filtering logic
+        if (getFeatureFlag('allowExplicitTargetEntries')) {
+          // Check if ALL targets have sources - only apply new behavior if they do
+          const allTargetsHaveSources = targets.every((t) => t.source);
+
+          if (!allTargetsHaveSources) {
+            // If not all targets have sources, fall back to old behavior (skip targets with sources)
+            targets = targets.filter((target) => !target.source);
+          }
+        }
       }
 
       let serve = this.options.serveOptions;

package/src/requests/WriteBundlesRequest.ts

@@ -4,7 +4,12 @@ import {getFeatureFlag} from '@atlaspack/feature-flags';
 import type {SharedReference} from '@atlaspack/workers';
 import type {StaticRunOpts} from '../RequestTracker';
 import {requestTypes} from '../RequestTracker';
-import type {PackagedBundleInfo} from '../types';
+import {
+  BundleBehavior,
+  type PackagedBundleInfo,
+  type Bundle,
+  type AtlaspackOptions,
+} from '../types';
 import type BundleGraph from '../BundleGraph';
 import type {BundleInfo} from '../PackagerRunner';
 import {report} from '../ReporterRunner';
@@ -66,8 +71,12 @@ export default function createWriteBundlesRequest(
   };
 }
 
-// @ts-expect-error TS7031
-async function run({input, api, farm, options}) {
+async function run({
+  input,
+  api,
+  farm,
+  options,
+}: RunInput<WriteBundlesRequestResult>) {
   let {bundleGraph, optionsRef} = input;
   let {ref, dispose} = await farm.createSharedReference(bundleGraph);
 
@@ -77,7 +86,7 @@ async function run({input, api, farm, options}) {
   let bundleInfoMap: {
     [key: string]: BundleInfo;
   } = {};
-  let writeEarlyPromises: Record<string, any> = {};
+  let writeEarlyPromises: Record<string, Promise<PackagedBundleInfo>> = {};
   let hashRefToNameHash = new Map();
 
   // Include inline bundles so that non-inline bundles referenced from inline bundles are written to
@@ -87,12 +96,10 @@ async function run({input, api, farm, options}) {
   });
   const bundles = allBundles
     .filter(
-      // @ts-expect-error TS7006
       (bundle) =>
-        bundle.bundleBehavior !== 'inline' &&
-        bundle.bundleBehavior !== 'inline-isolated',
+        bundle.bundleBehavior !== BundleBehavior.inline &&
+        bundle.bundleBehavior !== BundleBehavior.inlineIsolated,
     )
-    // @ts-expect-error TS7006
     .filter((bundle) => {
       // Do not package and write placeholder bundles to disk. We just
       // need to update the name so other bundles can reference it.
@@ -119,7 +126,6 @@ async function run({input, api, farm, options}) {
     });
 
   let cachedBundles = new Set(
-    // @ts-expect-error TS7006
     bundles.filter((b) => api.canSkipSubrequest(bundleGraph.getHash(b))),
   );
 
@@ -133,7 +139,6 @@ async function run({input, api, farm, options}) {
     reportPackagingProgress(completeBundles, bundles.length);
 
     await Promise.all(
-      // @ts-expect-error TS7006
       bundles.map(async (bundle) => {
         let request = createPackageRequest({
           bundle,
@@ -185,7 +190,6 @@ async function run({input, api, farm, options}) {
     );
     assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
     await Promise.all(
-      // @ts-expect-error TS7006
       bundles.map((bundle) => {
         let promise =
           writeEarlyPromises[bundle.id] ??
@@ -198,7 +202,6 @@ async function run({input, api, farm, options}) {
             }),
           );
 
-        // @ts-expect-error TS7006
         return promise.then((r) => res.set(bundle.id, r));
       }),
     );
@@ -212,12 +215,10 @@ async function run({input, api, farm, options}) {
 
 function assignComplexNameHashes(
   hashRefToNameHash: Map<string, string>,
-  // @ts-expect-error TS2304
   bundles: Array<Bundle>,
   bundleInfoMap: {
     [key: string]: BundleInfo;
   },
-  // @ts-expect-error TS2304
   options: AtlaspackOptions,
 ) {
   for (let bundle of bundles) {
@@ -229,7 +230,6 @@ function assignComplexNameHashes(
       options.shouldContentHash
         ? hashString(
             [...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
-              // @ts-expect-error TS2538
               .map((bundleId) => bundleInfoMap[bundleId].hash)
               .join(':'),
           ).slice(-8)
@@ -243,7 +243,7 @@ function getBundlesIncludedInHash(
   bundleInfoMap: {
     [key: string]: BundleInfo;
   },
-  included = new Set(),
+  included = new Set<string>(),
 ) {
   included.add(bundleId);
   for (let hashRef of bundleInfoMap[bundleId]?.hashReferences ?? []) {

package/src/resolveOptions.ts

@@ -91,6 +91,29 @@ export default async function resolveOptions(
     entries = [path.resolve(inputCwd, initialOptions.entries)];
   }
 
+  // When allowExplicitTargetEntries is enabled and no entries are provided,
+  // automatically derive entries from target sources
+  if (
+    getFeatureFlag('allowExplicitTargetEntries') &&
+    initialOptions.targets &&
+    !Array.isArray(initialOptions.targets) &&
+    entries.length === 0
+  ) {
+    const targetSources = new Set<string>();
+
+    for (const [, target] of Object.entries(initialOptions.targets)) {
+      if (target.source) {
+        const sources = Array.isArray(target.source)
+          ? target.source
+          : [target.source];
+        for (const source of sources) {
+          targetSources.add(source);
+        }
+      }
+    }
+    entries = Array.from(targetSources);
+  }
+
   let shouldMakeEntryReferFolder = false;
   if (entries.length === 1 && !isGlob(entries[0])) {
     let [entry] = entries;

package/src/types.ts

@@ -84,6 +84,7 @@ export type Environment = {
   sourceMap: TargetSourceMapOptions | null | undefined;
   loc: InternalSourceLocation | null | undefined;
   unstableSingleFileOutput: boolean;
+  customEnv: EnvMap | null | undefined;
 };
 
 export type InternalSourceLocation = {

package/test/Environment.test.ts

@@ -9,6 +9,7 @@ describe('Environment', () => {
     assert.deepEqual(fromEnvironmentId(createEnvironment()), {
       id: 'd821e85f6b50315e',
       context: 'browser',
+      customEnv: undefined,
       engines: {
         browsers: ['> 0.25%'],
       },
@@ -17,8 +18,8 @@ describe('Environment', () => {
       isLibrary: false,
       shouldOptimize: false,
       shouldScopeHoist: false,
-      sourceMap: null,
-      loc: null,
+      sourceMap: undefined,
+      loc: undefined,
       sourceType: 'module',
       unstableSingleFileOutput: false,
     });
@@ -30,6 +31,7 @@ describe('Environment', () => {
       {
         id: '2320af923a717577',
         context: 'node',
+        customEnv: undefined,
         engines: {
           node: '>= 10.0.0',
         },
@@ -54,6 +56,7 @@ describe('Environment', () => {
       {
         id: '75603271034eff15',
         context: 'browser',
+        customEnv: undefined,
         engines: {
           browsers: ['last 1 version'],
         },
@@ -62,8 +65,8 @@ describe('Environment', () => {
         isLibrary: false,
         shouldOptimize: false,
         shouldScopeHoist: false,
-        sourceMap: null,
-        loc: null,
+        sourceMap: undefined,
+        loc: undefined,
         sourceType: 'module',
         unstableSingleFileOutput: false,
       },
@@ -74,6 +77,7 @@ describe('Environment', () => {
     assert.deepEqual(fromEnvironmentId(createEnvironment({context: 'node'})), {
       id: 'e45cc12216f7857d',
       context: 'node',
+      customEnv: undefined,
       engines: {
         node: '>= 8.0.0',
       },
@@ -95,6 +99,7 @@ describe('Environment', () => {
       {
         id: 'd821e85f6b50315e',
         context: 'browser',
+        customEnv: undefined,
         engines: {
           browsers: ['> 0.25%'],
         },
@@ -103,8 +108,8 @@ describe('Environment', () => {
         isLibrary: false,
         shouldOptimize: false,
         shouldScopeHoist: false,
-        sourceMap: null,
-        loc: null,
+        sourceMap: undefined,
+        loc: undefined,
         sourceType: 'module',
         unstableSingleFileOutput: false,
       },
@@ -117,6 +122,7 @@ describe('Environment', () => {
       {
         id: '9917be65326c5de9',
         context: 'tesseract',
+        customEnv: undefined,
         engines: {
           browsers: ['> 0.25%'],
         },
@@ -125,8 +131,8 @@ describe('Environment', () => {
         isLibrary: false,
         shouldOptimize: false,
         shouldScopeHoist: false,
-        sourceMap: null,
-        loc: null,
+        sourceMap: undefined,
+        loc: undefined,
         sourceType: 'module',
         unstableSingleFileOutput: false,
       },