@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/src/requests/{TargetRequest.js → TargetRequest.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Diagnostic} from '@atlaspack/diagnostic';
 import type {FileSystem} from '@atlaspack/fs';
 import type {
@@ -34,7 +32,6 @@ import {createEnvironment} from '../Environment';
 import createAtlaspackConfigRequest, {
   getCachedAtlaspackConfig,
 } from './AtlaspackConfigRequest';
-// $FlowFixMe
 import browserslist from 'browserslist';
 import {parse} from '@mischnic/json-sourcemap';
 import invariant from 'assert';
@@ -49,11 +46,12 @@ import {BROWSER_ENVS} from '../public/Environment';
 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,
-  ...StaticRunOpts<TResult>,
-|};
+type RunOpts<TResult> = {
+  input: Entry;
+} & StaticRunOpts<TResult>;
 
 const DEFAULT_DIST_DIRNAME = 'dist';
 const JS_RE = /\.[mc]?js$/;
@@ -76,7 +74,7 @@ const COMMON_TARGETS = {
     match: /\.d\.ts$/,
     extensions: ['.d.ts'],
   },
-};
+} as const;
 
 const DEFAULT_ENGINES = {
   node: 'current',
@@ -86,14 +84,14 @@ const DEFAULT_ENGINES = {
     'last 1 Firefox version',
     'last 1 Edge version',
   ],
-};
+} as const;
 
-export type TargetRequest = {|
-  id: string,
-  +type: typeof requestTypes.target_request,
-  run: (RunOpts<TargetRequestResult>) => Async<TargetRequestResult>,
-  input: Entry,
-|};
+export type TargetRequest = {
+  id: string;
+  readonly type: typeof requestTypes.target_request;
+  run: (arg1: RunOpts<TargetRequestResult>) => Async<TargetRequestResult>;
+  input: Entry;
+};
 
 export type TargetRequestResult = Target[];
 
@@ -122,7 +120,7 @@ export function skipTarget(
     : targetName !== exclusiveTarget;
 }
 
-async function run({input, api, options}) {
+async function run({input, api, options}: RunOpts<TargetRequestResult>) {
   let targetResolver = new TargetResolver(
     api,
     optionsProxy(options, api.invalidateOnOptionChange),
@@ -132,6 +130,47 @@ 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(
@@ -161,30 +200,30 @@ async function run({input, api, options}) {
   return targets;
 }
 
-type TargetInfo = {|
-  output: TargetKeyInfo,
-  engines: TargetKeyInfo,
-  context: TargetKeyInfo,
-  includeNodeModules: TargetKeyInfo,
-  outputFormat: TargetKeyInfo,
-  isLibrary: TargetKeyInfo,
-  shouldOptimize: TargetKeyInfo,
-  shouldScopeHoist: TargetKeyInfo,
-|};
+type TargetInfo = {
+  output: TargetKeyInfo;
+  engines: TargetKeyInfo;
+  context: TargetKeyInfo;
+  includeNodeModules: TargetKeyInfo;
+  outputFormat: TargetKeyInfo;
+  isLibrary: TargetKeyInfo;
+  shouldOptimize: TargetKeyInfo;
+  shouldScopeHoist: TargetKeyInfo;
+};
 
 type TargetKeyInfo =
-  | {|
-      path: string,
-      type?: 'key' | 'value',
-    |}
-  | {|
-      inferred: string,
-      type?: 'key' | 'value',
-      message: string,
-    |}
-  | {|
-      message: string,
-    |};
+  | {
+      path: string;
+      type?: 'key' | 'value';
+    }
+  | {
+      inferred: string;
+      type?: 'key' | 'value';
+      message: string;
+    }
+  | {
+      message: string;
+    };
 
 export class TargetResolver {
   fs: FileSystem;
@@ -231,6 +270,7 @@ export class TargetResolver {
 
         // If an array of strings is passed, it's a filter on the resolved package
         // targets. Load them, and find the matching targets.
+        // @ts-expect-error TS2322
         targets = optionTargets
           .map((target) => {
             // null means skipped.
@@ -249,7 +289,7 @@ export class TargetResolver {
         // Otherwise, it's an object map of target descriptors (similar to those
         // in package.json). Adapt them to native targets.
         targets = Object.entries(optionTargets)
-          .map(([name, _descriptor]) => {
+          .map(([name, _descriptor]: [any, any]) => {
             let {distDir, ...descriptor} = parseDescriptor(
               name,
               _descriptor,
@@ -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;
@@ -345,7 +399,7 @@ export class TargetResolver {
             },
           });
         }
-        if (!BROWSER_ENVS.has(targets[0].env.context)) {
+        if (!BROWSER_ENVS.has(fromEnvironmentId(targets[0].env).context)) {
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: `Only browser targets are supported in serve mode`,
@@ -375,6 +429,7 @@ export class TargetResolver {
             env: createEnvironment({
               context: 'browser',
               engines: {
+                // @ts-expect-error TS2322
                 browsers: DEFAULT_ENGINES.browsers,
               },
               shouldOptimize: this.options.defaultTargetOptions.shouldOptimize,
@@ -388,6 +443,7 @@ export class TargetResolver {
           },
         ];
       } else {
+        // @ts-expect-error TS2322
         targets = Array.from(packageTargets.values())
           .filter(Boolean)
           .filter((descriptor) => {
@@ -424,11 +480,11 @@ export class TargetResolver {
 
     let pkg;
     let pkgContents;
-    let pkgFilePath: ?FilePath;
+    let pkgFilePath: FilePath | null | undefined;
     let pkgDir: FilePath;
     let pkgMap;
     if (conf) {
-      pkg = (conf.config: PackageJSON);
+      pkg = conf.config as PackageJSON;
       let pkgFile = conf.files[0];
       if (pkgFile == null) {
         throw new ThrowableDiagnostic({
@@ -512,6 +568,7 @@ export class TargetResolver {
             };
 
             browsersLoc = {
+              // @ts-expect-error TS2353
               message: `(defined in ${path.relative(
                 process.cwd(),
                 browserslistConfig,
@@ -533,25 +590,28 @@ export class TargetResolver {
     let browsers = pkgEngines.browsers;
 
     let defaultEngines = this.options.defaultTargetOptions.engines;
-    let context = browsers ?? node == null ? 'browser' : 'node';
+    let context = (browsers ?? node == null) ? 'browser' : 'node';
     if (context === 'browser' && pkgEngines.browsers == null) {
       pkgEngines = {
         ...pkgEngines,
+        // @ts-expect-error TS2322
         browsers: defaultEngines?.browsers ?? DEFAULT_ENGINES.browsers,
       };
+      // @ts-expect-error TS2353
       browsersLoc = {message: '(default)'};
     } else if (context === 'node' && pkgEngines.node == null) {
       pkgEngines = {
         ...pkgEngines,
         node: defaultEngines?.node ?? DEFAULT_ENGINES.node,
       };
+      // @ts-expect-error TS2353
       nodeLoc = {message: '(default)'};
     }
 
     // If there is a separate `browser` target, or an `engines.node` field but no browser targets, then
     // the `main` and `module` targets refer to node, otherwise browser.
     let mainContext =
-      pkg.browser ?? pkgTargets.browser ?? (node != null && browsers == null)
+      (pkg.browser ?? pkgTargets.browser ?? (node != null && browsers == null))
         ? 'node'
         : 'browser';
     let mainContextLoc: TargetKeyInfo =
@@ -562,22 +622,22 @@ export class TargetResolver {
             type: 'key',
           }
         : pkgTargets.browser
-        ? {
-            inferred: '/targets/browser',
-            message: '(because a browser target also exists)',
-            type: 'key',
-          }
-        : node != null && browsers == null
-        ? nodeLoc.path
           ? {
-              inferred: nodeLoc.path,
-              message: '(because node engines were defined)',
+              inferred: '/targets/browser',
+              message: '(because a browser target also exists)',
               type: 'key',
             }
-          : nodeLoc
-        : {message: '(default)'};
+          : node != null && browsers == null
+            ? nodeLoc.path
+              ? {
+                  inferred: nodeLoc.path,
+                  message: '(because node engines were defined)',
+                  type: 'key',
+                }
+              : nodeLoc
+            : {message: '(default)'};
     let moduleContext =
-      pkg.browser ?? pkgTargets.browser ? 'browser' : mainContext;
+      (pkg.browser ?? pkgTargets.browser) ? 'browser' : mainContext;
     let moduleContextLoc: TargetKeyInfo =
       pkg.browser != null
         ? {
@@ -586,14 +646,17 @@ export class TargetResolver {
             type: 'key',
           }
         : pkgTargets.browser
-        ? {
-            inferred: '/targets/browser',
-            message: '(becausea browser target also exists)',
-            type: 'key',
-          }
-        : mainContextLoc;
+          ? {
+              inferred: '/targets/browser',
+              message: '(becausea browser target also exists)',
+              type: 'key',
+            }
+          : mainContextLoc;
 
-    let getEnginesLoc = (targetName, descriptor): TargetKeyInfo => {
+    let getEnginesLoc = (
+      targetName: string,
+      descriptor: PackageTargetDescriptor,
+    ): TargetKeyInfo => {
       let enginesLoc = `/targets/${targetName}/engines`;
       switch (context) {
         case 'browser':
@@ -639,6 +702,7 @@ export class TargetResolver {
         _targetDist = pkg[targetName][pkg.name];
         pointer = `/${targetName}/${encodeJSONKeyComponent(pkg.name)}`;
       } else {
+        // @ts-expect-error TS7053
         _targetDist = pkg[targetName];
         pointer = `/${targetName}`;
       }
@@ -652,7 +716,7 @@ export class TargetResolver {
 
         invariant(pkgMap != null);
 
-        let _descriptor: mixed = pkgTargets[targetName] ?? {};
+        let _descriptor: unknown = pkgTargets[targetName] ?? {};
         if (typeof targetDist === 'string') {
           distDir = toProjectPath(
             this.options.projectRoot,
@@ -690,16 +754,16 @@ export class TargetResolver {
 
         if (
           distEntry != null &&
+          // @ts-expect-error TS7053
           !COMMON_TARGETS[targetName].match.test(distEntry)
         ) {
           let contents: string =
             typeof pkgContents === 'string'
               ? pkgContents
-              : // $FlowFixMe
-                JSON.stringify(pkgContents, null, '\t');
-          // $FlowFixMe
+              : JSON.stringify(pkgContents, null, '\t');
           let listFormat = new Intl.ListFormat('en-US', {type: 'disjunction'});
           let extensions = listFormat.format(
+            // @ts-expect-error TS7053
             COMMON_TARGETS[targetName].extensions,
           );
           let ext = path.extname(distEntry);
@@ -734,8 +798,7 @@ export class TargetResolver {
           let contents: string =
             typeof pkgContents === 'string'
               ? pkgContents
-              : // $FlowFixMe
-                JSON.stringify(pkgContents, null, '\t');
+              : JSON.stringify(pkgContents, null, '\t');
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: md`The "global" output format is not supported in the "${targetName}" target.`,
@@ -767,6 +830,7 @@ export class TargetResolver {
             distEntry,
             descriptor,
             targetName,
+            // @ts-expect-error TS2345
             pkg,
             pkgFilePath,
             pkgContents,
@@ -787,8 +851,7 @@ export class TargetResolver {
           let contents: string =
             typeof pkgContents === 'string'
               ? pkgContents
-              : // $FlowFixMe
-                JSON.stringify(pkgContents, null, '\t');
+              : JSON.stringify(pkgContents, null, '\t');
           throw new ThrowableDiagnostic({
             diagnostic: {
               // prettier-ignore
@@ -826,8 +889,7 @@ export class TargetResolver {
           let contents: string =
             typeof pkgContents === 'string'
               ? pkgContents
-              : // $FlowFixMe
-                JSON.stringify(pkgContents, null, '\t');
+              : JSON.stringify(pkgContents, null, '\t');
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: 'Scope hoisting cannot be disabled for library targets.',
@@ -859,8 +921,8 @@ export class TargetResolver {
           (targetName === 'browser'
             ? 'browser'
             : isModule
-            ? moduleContext
-            : mainContext);
+              ? moduleContext
+              : mainContext);
 
         targets.set(targetName, {
           name: targetName,
@@ -870,6 +932,7 @@ export class TargetResolver {
             descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
           env: createEnvironment({
             engines: descriptor.engines ?? pkgEngines,
+            // @ts-expect-error TS2322
             context,
             includeNodeModules: descriptor.includeNodeModules ?? false,
             outputFormat,
@@ -889,30 +952,30 @@ export class TargetResolver {
           context: descriptor.context
             ? {path: `/targets/${targetName}/context`}
             : targetName === 'browser'
-            ? {
-                message: '(inferred from target name)',
-                inferred: pointer,
-                type: 'key',
-              }
-            : isModule
-            ? moduleContextLoc
-            : mainContextLoc,
+              ? {
+                  message: '(inferred from target name)',
+                  inferred: pointer,
+                  type: 'key',
+                }
+              : isModule
+                ? moduleContextLoc
+                : mainContextLoc,
           includeNodeModules: descriptor.includeNodeModules
             ? {path: `/targets/${targetName}/includeNodeModules`, type: 'key'}
             : {message: '(default)'},
           outputFormat: descriptor.outputFormat
             ? {path: `/targets/${targetName}/outputFormat`}
             : inferredOutputFormatField === '/type'
-            ? {
-                message: `(inferred from package.json#type)`,
-                inferred: inferredOutputFormatField,
-              }
-            : inferredOutputFormatField != null
-            ? {
-                message: `(inferred from file extension)`,
-                inferred: inferredOutputFormatField,
-              }
-            : {message: '(default)'},
+              ? {
+                  message: `(inferred from package.json#type)`,
+                  inferred: inferredOutputFormatField,
+                }
+              : inferredOutputFormatField != null
+                ? {
+                    message: `(inferred from file extension)`,
+                    inferred: inferredOutputFormatField,
+                  }
+                : {message: '(default)'},
           isLibrary: {message: '(default)'},
           shouldOptimize: descriptor.optimize
             ? {path: `/targets/${targetName}/optimize`}
@@ -922,13 +985,15 @@ export class TargetResolver {
       }
     }
 
-    let customTargets = (Object.keys(pkgTargets): Array<string>).filter(
+    let customTargets = (Object.keys(pkgTargets) as Array<string>).filter(
+      // @ts-expect-error TS7053
       (targetName) => !COMMON_TARGETS[targetName],
     );
 
     // Custom targets
     for (let targetName of customTargets) {
-      let distPath: mixed = pkg[targetName];
+      // @ts-expect-error TS7053
+      let distPath: unknown = pkg[targetName];
       let distDir;
       let distEntry;
       let loc;
@@ -956,8 +1021,7 @@ export class TargetResolver {
           let contents: string =
             typeof pkgContents === 'string'
               ? pkgContents
-              : // $FlowFixMe
-                JSON.stringify(pkgContents, null, '\t');
+              : JSON.stringify(pkgContents, null, '\t');
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: md`Invalid distPath for target "${targetName}"`,
@@ -1009,6 +1073,7 @@ export class TargetResolver {
             distEntry,
             descriptor,
             targetName,
+            // @ts-expect-error TS2345
             pkg,
             pkgFilePath,
             pkgContents,
@@ -1018,8 +1083,7 @@ export class TargetResolver {
           let contents: string =
             typeof pkgContents === 'string'
               ? pkgContents
-              : // $FlowFixMe
-                JSON.stringify(pkgContents, null, '\t');
+              : JSON.stringify(pkgContents, null, '\t');
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: 'Scope hoisting cannot be disabled for library targets.',
@@ -1087,6 +1151,7 @@ export class TargetResolver {
             shouldScopeHoist:
               shouldScopeHoist && descriptor.scopeHoist !== false,
             sourceMap: normalizeSourceMap(this.options, descriptor.sourceMap),
+            customEnv: descriptor.env,
           }),
           loc: toInternalSourceLocation(this.options.projectRoot, loc),
         });
@@ -1103,16 +1168,16 @@ export class TargetResolver {
           outputFormat: descriptor.outputFormat
             ? {path: `/targets/${targetName}/outputFormat`}
             : inferredOutputFormatField === '/type'
-            ? {
-                message: `(inferred from package.json#type)`,
-                inferred: inferredOutputFormatField,
-              }
-            : inferredOutputFormatField != null
-            ? {
-                message: `(inferred from file extension)`,
-                inferred: inferredOutputFormatField,
-              }
-            : {message: '(default)'},
+              ? {
+                  message: `(inferred from package.json#type)`,
+                  inferred: inferredOutputFormatField,
+                }
+              : inferredOutputFormatField != null
+                ? {
+                    message: `(inferred from file extension)`,
+                    inferred: inferredOutputFormatField,
+                  }
+                : {message: '(default)'},
           isLibrary:
             descriptor.isLibrary != null
               ? {path: `/targets/${targetName}/isLibrary`}
@@ -1142,6 +1207,7 @@ export class TargetResolver {
         publicUrl: this.options.defaultTargetOptions.publicUrl,
         env: createEnvironment({
           engines: pkgEngines,
+          // @ts-expect-error TS2322
           context,
           outputFormat: this.options.defaultTargetOptions.outputFormat,
           isLibrary: this.options.defaultTargetOptions.isLibrary,
@@ -1163,13 +1229,13 @@ export class TargetResolver {
   }
 
   inferOutputFormat(
-    distEntry: ?FilePath,
+    distEntry: FilePath | null | undefined,
     descriptor: PackageTargetDescriptor,
     targetName: string,
     pkg: PackageJSON,
-    pkgFilePath: ?FilePath,
-    pkgContents: ?string,
-  ): [?OutputFormat, ?string] {
+    pkgFilePath?: FilePath | null,
+    pkgContents?: string | null,
+  ): [OutputFormat | null | undefined, string | null | undefined] {
     // Infer the outputFormat based on package.json properties.
     // If the extension is .mjs it's always a module.
     // If the extension is .cjs, it's always commonjs.
@@ -1201,8 +1267,7 @@ export class TargetResolver {
       let contents: string =
         typeof pkgContents === 'string'
           ? pkgContents
-          : // $FlowFixMe
-            JSON.stringify(pkgContents, null, '\t');
+          : JSON.stringify(pkgContents, null, '\t');
       let expectedExtensions;
       switch (descriptor.outputFormat) {
         case 'esmodule':
@@ -1215,7 +1280,6 @@ export class TargetResolver {
           expectedExtensions = ['.js'];
           break;
       }
-      // $FlowFixMe
       let listFormat = new Intl.ListFormat('en-US', {type: 'disjunction'});
       throw new ThrowableDiagnostic({
         diagnostic: {
@@ -1253,14 +1317,15 @@ export class TargetResolver {
       });
     }
 
+    // @ts-expect-error TS2322
     return [inferredOutputFormat, inferredOutputFormatField];
   }
 }
 
 function parseEngines(
-  engines: mixed,
-  pkgPath: ?FilePath,
-  pkgContents: ?string,
+  engines: unknown,
+  pkgPath: FilePath | null | undefined,
+  pkgContents: string | null | undefined,
   prependKey: string,
   message: string,
 ): Engines | typeof undefined {
@@ -1273,16 +1338,16 @@ function parseEngines(
       '@atlaspack/core',
       message,
     );
-    // $FlowFixMe we just verified this
+    // @ts-expect-error TS2322
     return engines;
   }
 }
 
 function parseDescriptor(
   targetName: string,
-  descriptor: mixed,
-  pkgPath: ?FilePath,
-  pkgContents: ?string,
+  descriptor: unknown,
+  pkgPath?: FilePath | null,
+  pkgContents?: string | null,
 ): TargetDescriptor {
   validateSchema.diagnostic(
     DESCRIPTOR_SCHEMA,
@@ -1296,15 +1361,15 @@ function parseDescriptor(
     `Invalid target descriptor for target "${targetName}"`,
   );
 
-  // $FlowFixMe we just verified this
+  // @ts-expect-error TS2322
   return descriptor;
 }
 
 function parsePackageDescriptor(
   targetName: string,
-  descriptor: mixed,
-  pkgPath: ?FilePath,
-  pkgContents: ?string,
+  descriptor: unknown,
+  pkgPath?: FilePath | null,
+  pkgContents?: string | null,
 ): PackageTargetDescriptor {
   validateSchema.diagnostic(
     PACKAGE_DESCRIPTOR_SCHEMA,
@@ -1317,15 +1382,15 @@ function parsePackageDescriptor(
     '@atlaspack/core',
     `Invalid target descriptor for target "${targetName}"`,
   );
-  // $FlowFixMe we just verified this
+  // @ts-expect-error TS2322
   return descriptor;
 }
 
 function parseCommonTargetDescriptor(
   targetName: string,
-  descriptor: mixed,
-  pkgPath: ?FilePath,
-  pkgContents: ?string,
+  descriptor: unknown,
+  pkgPath?: FilePath | null,
+  pkgContents?: string | null,
 ): PackageTargetDescriptor {
   validateSchema.diagnostic(
     COMMON_TARGET_DESCRIPTOR_SCHEMA,
@@ -1339,11 +1404,16 @@ function parseCommonTargetDescriptor(
     `Invalid target descriptor for target "${targetName}"`,
   );
 
-  // $FlowFixMe we just verified this
+  // @ts-expect-error TS2322
   return descriptor;
 }
 
-function assertNoDuplicateTargets(options, targets, pkgFilePath, pkgContents) {
+function assertNoDuplicateTargets(
+  options: AtlaspackOptions,
+  targets: Map<string, Target | null>,
+  pkgFilePath: FilePath | null | undefined,
+  pkgContents: undefined | string,
+) {
   // Detect duplicate targets by destination path and provide a nice error.
   // Without this, an assertion is thrown much later after naming the bundles and finding duplicates.
   let targetsByPath: Map<string, Array<string>> = new Map();
@@ -1404,7 +1474,11 @@ function assertNoDuplicateTargets(options, targets, pkgFilePath, pkgContents) {
   }
 }
 
-function normalizeSourceMap(options: AtlaspackOptions, sourceMap) {
+function normalizeSourceMap(
+  options: AtlaspackOptions,
+  // @ts-expect-error TS2304
+  sourceMap: undefined | TargetSourceMapOptions | boolean,
+) {
   if (options.defaultTargetOptions.sourceMaps) {
     if (typeof sourceMap === 'boolean') {
       return sourceMap ? {} : undefined;
@@ -1431,7 +1505,8 @@ function assertTargetsAreNotEntries(
         process.cwd(),
         fromProjectPath(options.projectRoot, input.filePath),
       );
-      let codeFrames = [];
+      // @ts-expect-error TS2304
+      let codeFrames: Array<DiagnosticCodeFrame> = [];
       if (loc) {
         codeFrames.push({
           filePath: fromProjectPath(options.projectRoot, loc.filePath),
@@ -1464,6 +1539,7 @@ function assertTargetsAreNotEntries(
           message: `Target "${target.name}" is configured to overwrite entry "${relativeEntry}".`,
           codeFrames,
           hints: [
+            // @ts-expect-error TS7053
             (COMMON_TARGETS[target.name]
               ? `The "${target.name}" field is an _output_ file path so that your build can be consumed by other tools. `
               : '') +
@@ -1476,7 +1552,12 @@ function assertTargetsAreNotEntries(
   }
 }
 
-async function debugResolvedTargets(input, targets, targetInfo, options) {
+async function debugResolvedTargets(
+  input: Entry,
+  targets: TargetRequestResult,
+  targetInfo: Map<string, TargetInfo>,
+  options: AtlaspackOptions,
+) {
   for (let target of targets) {
     let info = targetInfo.get(target.name);
     let loc = target.loc;
@@ -1491,25 +1572,27 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Resolve relevant engines for context.
     let engines;
-    switch (target.env.context) {
+    const env = fromEnvironmentId(target.env);
+    switch (env.context) {
       case 'browser':
       case 'web-worker':
       case 'service-worker':
       case 'worklet': {
-        let browsers = target.env.engines.browsers;
+        let browsers = env.engines.browsers;
         engines = Array.isArray(browsers) ? browsers.join(', ') : browsers;
         break;
       }
       case 'node':
-        engines = target.env.engines.node;
+        engines = env.engines.node;
         break;
       case 'electron-main':
       case 'electron-renderer':
-        engines = target.env.engines.electron;
+        engines = env.engines.electron;
         break;
     }
 
-    let highlights = [];
+    // @ts-expect-error TS2304
+    let highlights: Array<DiagnosticCodeHighlight> = [];
     if (input.loc) {
       highlights.push(
         convertSourceLocationToHighlight(input.loc, 'entry defined here'),
@@ -1523,6 +1606,7 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
     // Builds up map of code highlights for each defined/inferred path in the package.json.
     let jsonHighlights = new Map();
     for (let key in info) {
+      // @ts-expect-error TS7053
       let keyInfo = info[key];
       let path = keyInfo.path || keyInfo.inferred;
       if (!path) {
@@ -1547,29 +1631,29 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
       }
 
       if (keyInfo.inferred) {
-        highlight.inferred.push(
-          md`${key} to be ${JSON.stringify(target.env[key])}`,
-        );
+        // @ts-expect-error TS2345
+        highlight.inferred.push(md`${key} to be ${JSON.stringify(env[key])}`);
       }
     }
 
-    // $FlowFixMe
     let listFormat = new Intl.ListFormat('en-US');
 
     // Generate human friendly messages for each field.
-    let highlightsWithMessages = [...jsonHighlights].map(([k, v]) => {
-      let message = v.defined;
-      if (v.inferred.length > 0) {
-        message += (message ? ', ' : '') + 'caused ';
-        message += listFormat.format(v.inferred);
-      }
+    let highlightsWithMessages = [...jsonHighlights].map(
+      ([k, v]: [any, any]) => {
+        let message = v.defined;
+        if (v.inferred.length > 0) {
+          message += (message ? ', ' : '') + 'caused ';
+          message += listFormat.format(v.inferred);
+        }
 
-      return {
-        key: k,
-        type: v.type,
-        message,
-      };
-    });
+        return {
+          key: k,
+          type: v.type,
+          message,
+        };
+      },
+    );
 
     // Get code highlights from JSON paths.
     highlights.push(
@@ -1578,28 +1662,29 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Format includeNodeModules to be human readable.
     let includeNodeModules;
-    if (typeof target.env.includeNodeModules === 'boolean') {
-      includeNodeModules = String(target.env.includeNodeModules);
-    } else if (Array.isArray(target.env.includeNodeModules)) {
+    if (typeof env.includeNodeModules === 'boolean') {
+      includeNodeModules = String(env.includeNodeModules);
+    } else if (Array.isArray(env.includeNodeModules)) {
       includeNodeModules =
         'only ' +
-        listFormat.format(
-          target.env.includeNodeModules.map((m) => JSON.stringify(m)),
-        );
+        listFormat.format(env.includeNodeModules.map((m) => JSON.stringify(m)));
     } else if (
-      target.env.includeNodeModules &&
-      typeof target.env.includeNodeModules === 'object'
+      env.includeNodeModules &&
+      typeof env.includeNodeModules === 'object'
     ) {
       includeNodeModules =
         'all except ' +
         listFormat.format(
-          Object.entries(target.env.includeNodeModules)
-            .filter(([, v]) => v === false)
-            .map(([k]) => JSON.stringify(k)),
+          Object.entries(env.includeNodeModules)
+            .filter(([, v]: [any, any]) => v === false)
+            // @ts-expect-error TS2345
+            .map(([k]: [any]) => JSON.stringify(k)),
         );
     }
 
-    let format = (v) => (v.message != null ? md.italic(v.message) : '');
+    let format = (v: TargetKeyInfo) =>
+      // @ts-expect-error TS2339
+      v.message != null ? md.italic(v.message) : '';
     logger.verbose({
       origin: '@atlaspack/core',
       message: md`**Target** "${target.name}"
@@ -1609,20 +1694,16 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
                  fromProjectPath(options.projectRoot, input.filePath),
                )}
               **Output**: ${path.relative(process.cwd(), output)}
-              **Format**: ${target.env.outputFormat} ${format(
-        info.outputFormat,
-      )}
-             **Context**: ${target.env.context} ${format(info.context)}
+              **Format**: ${env.outputFormat} ${format(info.outputFormat)}
+             **Context**: ${env.context} ${format(info.context)}
              **Engines**: ${engines || ''} ${format(info.engines)}
-        **Library Mode**: ${String(target.env.isLibrary)} ${format(
-        info.isLibrary,
-      )}
+        **Library Mode**: ${String(env.isLibrary)} ${format(info.isLibrary)}
 **Include Node Modules**: ${includeNodeModules} ${format(
         info.includeNodeModules,
       )}
-            **Optimize**: ${String(target.env.shouldOptimize)} ${format(
-        info.shouldOptimize,
-      )}`,
+            **Optimize**: ${String(env.shouldOptimize)} ${format(
+              info.shouldOptimize,
+            )}`,
       codeFrames: target.loc
         ? [
             {