@atlaspack/transformer-js 3.2.3-canary.49 → 3.2.3-canary.490

package/src/{JSTransformer.js → JSTransformer.ts}

@@ -1,17 +1,24 @@
-// @flow
 import type {
   JSONObject,
   EnvMap,
   SourceLocation,
   FilePath,
   FileCreateInvalidation,
-  ConditionMeta,
+  Config,
+  PluginOptions,
 } from '@atlaspack/types';
+import {createBuildCache} from '@atlaspack/build-cache';
 import type {SchemaEntity} from '@atlaspack/utils';
 import type {Diagnostic} from '@atlaspack/diagnostic';
-import SourceMap from '@parcel/source-map';
+import SourceMap from '@atlaspack/source-map';
 import {Transformer} from '@atlaspack/plugin';
-import {transform, transformAsync} from '@atlaspack/rust';
+import {
+  transform,
+  transformAsync,
+  determineJsxConfiguration,
+} from '@atlaspack/rust';
+import {type CompiledCssInJsConfigPlugin} from '@atlaspack/rust';
+import invariant from 'assert';
 import browserslist from 'browserslist';
 import semver from 'semver';
 import nullthrows from 'nullthrows';
@@ -22,11 +29,12 @@ import ThrowableDiagnostic, {
 import {validateSchema, remapSourceLocation, globMatch} from '@atlaspack/utils';
 import pkg from '../package.json';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import path, {join} from 'path';
 
 const JSX_EXTENSIONS = {
   jsx: true,
   tsx: true,
-};
+} as const;
 
 const JSX_PRAGMA = {
   react: {
@@ -49,7 +57,7 @@ const JSX_PRAGMA = {
     pragmaFrag: undefined,
     automatic: undefined,
   },
-};
+} as const;
 
 const BROWSER_MAPPING = {
   and_chr: 'chrome',
@@ -63,7 +71,7 @@ const BROWSER_MAPPING = {
   bb: null,
   kaios: null,
   op_mini: null,
-};
+} as const;
 
 // List of browsers to exclude when the esmodule target is specified.
 // Based on https://caniuse.com/#feat=es6-module
@@ -108,16 +116,35 @@ const CONFIG_SCHEMA: SchemaEntity = {
         },
       ],
     },
+    addReactDisplayName: {
+      type: 'boolean',
+    },
     magicComments: {
       type: 'boolean',
     },
     unstable_inlineConstants: {
       type: 'boolean',
     },
+    jsx: {
+      type: 'object',
+    },
   },
   additionalProperties: false,
 };
 
+// Mirrors the CONFIG_SCHEMA
+interface JsTransformerConfig {
+  inlineFS?: boolean;
+  inlineEnvironment?: boolean | string[];
+  addReactDisplayName?: boolean;
+  magicComments?: boolean;
+  unstable_inlineConstants?: boolean;
+  // This is exclusively used in Rust so not worth typing
+  jsx: any;
+}
+
+const configCache = createBuildCache();
+
 const SCRIPT_ERRORS = {
   browser: {
     message: 'Browser scripts cannot have imports or exports.',
@@ -133,143 +160,306 @@ const SCRIPT_ERRORS = {
       'Service workers cannot have imports or exports without the `type: "module"` option.',
     hint: "Add {type: 'module'} as a second argument to the navigator.serviceWorker.register() call.",
   },
-};
+} as const;
 
 type TSConfig = {
   compilerOptions?: {
     // https://www.typescriptlang.org/tsconfig#jsx
-    jsx?: 'react' | 'react-jsx' | 'react-jsxdev' | 'preserve' | 'react-native',
+    jsx?: 'react' | 'react-jsx' | 'react-jsxdev' | 'preserve' | 'react-native';
     // https://www.typescriptlang.org/tsconfig#jsxFactory
-    jsxFactory?: string,
+    jsxFactory?: string;
     // https://www.typescriptlang.org/tsconfig#jsxFragmentFactory
-    jsxFragmentFactory?: string,
+    jsxFragmentFactory?: string;
     // https://www.typescriptlang.org/tsconfig#jsxImportSource
-    jsxImportSource?: string,
+    jsxImportSource?: string;
     // https://www.typescriptlang.org/tsconfig#experimentalDecorators
-    experimentalDecorators?: boolean,
+    experimentalDecorators?: boolean;
     // https://www.typescriptlang.org/tsconfig#useDefineForClassFields
-    useDefineForClassFields?: boolean,
+    useDefineForClassFields?: boolean;
     // https://www.typescriptlang.org/tsconfig#target
-    target?: string, // 'es3' | 'es5' | 'es6' | 'es2015' | ...  |'es2022' | ... | 'esnext'
-    ...
-  },
-  ...
+    target?: string; // 'es3' | 'es5' | 'es6' | 'es2015' | ...  |'es2022' | ... | 'esnext';
+  };
 };
 
-type MacroAsset = {|
-  type: string,
-  content: string,
-|};
+type MacroAsset = {
+  type: string;
+  content: string;
+};
 
 // NOTE: Make sure this is in sync with the TypeScript definition in the @atlaspack/macros package.
-type MacroContext = {|
-  addAsset(asset: MacroAsset): void,
-  invalidateOnFileChange(FilePath): void,
-  invalidateOnFileCreate(FileCreateInvalidation): void,
-  invalidateOnEnvChange(string): void,
-  invalidateOnStartup(): void,
-  invalidateOnBuild(): void,
-|};
-
-export default (new Transformer({
-  async loadConfig({config, options}) {
-    let pkg = await config.getPackage();
-    let isJSX,
-      pragma,
-      pragmaFrag,
-      jsxImportSource,
-      automaticJSXRuntime,
-      reactRefresh,
-      decorators,
-      useDefineForClassFields;
-    if (config.isSource) {
-      let reactLib;
-      if (pkg?.alias && pkg.alias['react']) {
-        // e.g.: `{ alias: { "react": "preact/compat" } }`
-        reactLib = 'react';
-      } else {
-        // Find a dependency that we can map to a JSX pragma
-        reactLib = Object.keys(JSX_PRAGMA).find(
-          (libName) =>
-            pkg?.dependencies?.[libName] ||
-            pkg?.devDependencies?.[libName] ||
-            pkg?.peerDependencies?.[libName],
-        );
-      }
+type MacroContext = {
+  addAsset(asset: MacroAsset): void;
+  invalidateOnFileChange(arg1: FilePath): void;
+  invalidateOnFileCreate(arg1: FileCreateInvalidation): void;
+  invalidateOnEnvChange(arg1: string): void;
+  invalidateOnStartup(): void;
+  invalidateOnBuild(): void;
+};
 
-      reactRefresh =
-        options.hmrOptions &&
-        options.mode === 'development' &&
-        Boolean(
-          pkg?.dependencies?.react ||
-            pkg?.devDependencies?.react ||
-            pkg?.peerDependencies?.react,
-        );
+type AtlaskitTokensConfigPartial = {
+  shouldUseAutoFallback?: boolean;
+  shouldForceAutoFallback?: boolean;
+  forceAutoFallbackExemptions?: Array<string>;
+  defaultTheme?: 'light' | 'legacy-light';
+  tokenDataPath: string;
+};
 
-      const compilerOptions: TSConfig['compilerOptions'] = getFeatureFlag(
-        'granularTsConfigInvalidation',
-      )
-        ? (
-            await config.getConfigFrom<TSConfig['compilerOptions']>(
-              options.projectRoot + '/index',
-              ['tsconfig.json', 'jsconfig.json'],
-              {configKey: 'compilerOptions'},
-            )
-          )?.contents
-        : (
-            await config.getConfigFrom<TSConfig>(
-              options.projectRoot + '/index',
-              ['tsconfig.json', 'jsconfig.json'],
-            )
-          )?.contents?.compilerOptions;
-
-      // Use explicitly defined JSX options in tsconfig.json over inferred values from dependencies.
-      pragma =
-        compilerOptions?.jsxFactory ||
-        (reactLib ? JSX_PRAGMA[reactLib].pragma : undefined);
-      pragmaFrag =
-        compilerOptions?.jsxFragmentFactory ||
-        (reactLib ? JSX_PRAGMA[reactLib].pragmaFrag : undefined);
+type AtlaskitTokensConfig = Required<AtlaskitTokensConfigPartial>;
 
-      if (
-        compilerOptions?.jsx === 'react-jsx' ||
-        compilerOptions?.jsx === 'react-jsxdev' ||
-        compilerOptions?.jsxImportSource
-      ) {
-        jsxImportSource = compilerOptions?.jsxImportSource;
-        automaticJSXRuntime = true;
-      } else if (reactLib) {
-        let effectiveReactLib =
-          pkg?.alias && pkg.alias['react'] === 'preact/compat'
-            ? 'preact'
-            : reactLib;
-        let automaticVersion = JSX_PRAGMA[effectiveReactLib]?.automatic;
-        let reactLibVersion =
-          pkg?.dependencies?.[effectiveReactLib] ||
-          pkg?.devDependencies?.[effectiveReactLib] ||
-          pkg?.peerDependencies?.[effectiveReactLib];
-        reactLibVersion = reactLibVersion
-          ? semver.validRange(reactLibVersion)
+const TOKENS_CONFIG_SCHEMA = {
+  type: 'object',
+  properties: {
+    shouldUseAutoFallback: {type: 'boolean'},
+    shouldForceAutoFallback: {type: 'boolean'},
+    forceAutoFallbackExemptions: {
+      type: 'array',
+      items: {type: 'string'},
+    },
+    defaultTheme: {type: 'string', enum: ['light', 'legacy-light']},
+    tokenDataPath: {type: 'string'},
+  },
+  additionalProperties: false,
+} as const;
+
+interface JsxConfig {
+  isJSX: boolean | undefined;
+  jsxPragma: string | undefined;
+  jsxPragmaFrag: string | undefined;
+  jsxImportSource: string | undefined;
+  automaticJSXRuntime: boolean | undefined;
+  reactRefresh: boolean | null | undefined;
+}
+
+async function legacyDetemineJsxConfig(
+  config: Config,
+  options: PluginOptions,
+): Promise<JsxConfig> {
+  let packageJson = await config.getPackage();
+  let isJSX,
+    jsxPragma,
+    jsxPragmaFrag,
+    jsxImportSource,
+    automaticJSXRuntime,
+    reactRefresh;
+
+  if (config.isSource) {
+    let reactLib;
+    if (packageJson?.alias && packageJson.alias['react']) {
+      // e.g.: `{ alias: { "react": "preact/compat" } }`
+      reactLib = 'react';
+    } else {
+      // Find a dependency that we can map to a JSX pragma
+      reactLib = Object.keys(JSX_PRAGMA).find(
+        (libName) =>
+          packageJson?.dependencies?.[libName] ||
+          packageJson?.devDependencies?.[libName] ||
+          packageJson?.peerDependencies?.[libName],
+      );
+    }
+
+    reactRefresh = Boolean(
+      packageJson?.dependencies?.react ||
+        packageJson?.devDependencies?.react ||
+        packageJson?.peerDependencies?.react,
+    );
+
+    const compilerOptions: TSConfig['compilerOptions'] = (
+      await config.getConfigFrom<TSConfig>(
+        options.projectRoot + '/index',
+        ['tsconfig.json', 'jsconfig.json'],
+        {
+          readTracking: true,
+        },
+      )
+    )?.contents?.compilerOptions;
+
+    // Use explicitly defined JSX options in tsconfig.json over inferred values from dependencies.
+    jsxPragma =
+      compilerOptions?.jsxFactory ||
+      // @ts-expect-error TS7053
+      (reactLib ? JSX_PRAGMA[reactLib].pragma : undefined);
+    jsxPragmaFrag =
+      compilerOptions?.jsxFragmentFactory ||
+      // @ts-expect-error TS7053
+      (reactLib ? JSX_PRAGMA[reactLib].pragmaFrag : undefined);
+
+    if (
+      compilerOptions?.jsx === 'react-jsx' ||
+      compilerOptions?.jsx === 'react-jsxdev' ||
+      compilerOptions?.jsxImportSource
+    ) {
+      jsxImportSource = compilerOptions?.jsxImportSource;
+      automaticJSXRuntime = true;
+    } else if (reactLib) {
+      let effectiveReactLib =
+        packageJson?.alias && packageJson.alias['react'] === 'preact/compat'
+          ? 'preact'
+          : reactLib;
+      // @ts-expect-error TS7053
+      let automaticVersion = JSX_PRAGMA[effectiveReactLib]?.automatic;
+      let reactLibVersion =
+        packageJson?.dependencies?.[effectiveReactLib] ||
+        packageJson?.devDependencies?.[effectiveReactLib] ||
+        packageJson?.peerDependencies?.[effectiveReactLib];
+      // @ts-expect-error TS2322
+      reactLibVersion = reactLibVersion
+        ? semver.validRange(reactLibVersion)
+        : null;
+      let minReactLibVersion =
+        reactLibVersion !== null && reactLibVersion !== '*'
+          ? // @ts-expect-error TS2345
+            semver.minVersion(reactLibVersion)?.toString()
           : null;
-        let minReactLibVersion =
-          reactLibVersion !== null && reactLibVersion !== '*'
-            ? semver.minVersion(reactLibVersion)?.toString()
-            : null;
-
-        automaticJSXRuntime =
-          automaticVersion &&
-          !compilerOptions?.jsxFactory &&
-          minReactLibVersion != null &&
-          semver.satisfies(minReactLibVersion, automaticVersion, {
-            includePrerelease: true,
-          });
 
-        if (automaticJSXRuntime) {
-          jsxImportSource = reactLib;
-        }
+      automaticJSXRuntime =
+        automaticVersion &&
+        !compilerOptions?.jsxFactory &&
+        minReactLibVersion != null &&
+        semver.satisfies(minReactLibVersion, automaticVersion, {
+          includePrerelease: true,
+        });
+
+      if (automaticJSXRuntime) {
+        jsxImportSource = reactLib;
       }
+    }
+
+    isJSX = Boolean(compilerOptions?.jsx || jsxPragma);
+  }
+
+  return {
+    isJSX,
+    jsxPragma,
+    jsxPragmaFrag,
+    jsxImportSource,
+    automaticJSXRuntime,
+    reactRefresh,
+  };
+}
+
+export async function loadTokensConfig(config: Config, options: PluginOptions) {
+  const conf = await config.getConfigFrom(options.projectRoot + '/index', [], {
+    packageKey: '@atlaspack/transformer-tokens',
+  });
+
+  if (conf && conf.contents) {
+    validateSchema.diagnostic(
+      TOKENS_CONFIG_SCHEMA,
+      {
+        data: conf.contents,
+        source: () => options.inputFS.readFileSync(conf.filePath, 'utf8'),
+        filePath: conf.filePath,
+        prependKey: `/${encodeJSONKeyComponent('@atlaspack/transformer-tokens')}`,
+      },
+      '@atlaspack/transformer-tokens',
+      'Invalid config for @atlaspack/transformer-tokens',
+    );
+
+    // @ts-expect-error TS2339
+    const tokensConfig: AtlaskitTokensConfigPartial = conf.contents;
+
+    let resolvedConfig: AtlaskitTokensConfig = {
+      shouldUseAutoFallback: tokensConfig.shouldUseAutoFallback ?? true,
+      shouldForceAutoFallback: tokensConfig.shouldForceAutoFallback ?? true,
+      forceAutoFallbackExemptions:
+        tokensConfig.forceAutoFallbackExemptions ?? [],
+      defaultTheme: tokensConfig.defaultTheme ?? 'light',
+      tokenDataPath: path.join(options.projectRoot, tokensConfig.tokenDataPath),
+    };
+    return resolvedConfig;
+  }
+}
+
+export async function loadCompiledCssInJsConfig(
+  config: Config,
+  options: PluginOptions,
+): Promise<CompiledCssInJsConfigPlugin> {
+  const DEFAULT_IMPORT_SOURCES = ['@compiled/react', '@atlaskit/css'];
+
+  const conf = await config.getConfigFrom<CompiledCssInJsConfigPlugin>(
+    join(options.projectRoot, 'index'),
+    ['.compiledcssrc', '.compiledcssrc.json'],
+    {
+      packageKey: '@atlaspack/transformer-compiled-css-in-js',
+    },
+  );
+
+  const resolvedBrowserslistEnv =
+    conf?.contents.browserslistEnv ??
+    process.env.BROWSERSLIST_ENV ??
+    process.env.NODE_ENV ??
+    'production';
+
+  const contents: CompiledCssInJsConfigPlugin = {
+    ...conf?.contents,
+    importSources: [
+      ...DEFAULT_IMPORT_SOURCES,
+      ...(conf?.contents.importSources ?? []),
+    ],
+    extract: conf?.contents.extract && options.mode !== 'development',
+    // Use explicit env or process env (BROWSERSLIST_ENV/NODE_ENV). Default to "production"
+    // to match browserslist/caniuse defaults and the legacy Babel plugin behavior.
+    browserslistEnv: resolvedBrowserslistEnv,
+  };
+
+  return contents;
+}
+
+export default new Transformer({
+  async loadConfig({config, options}) {
+    let conf = await config.getConfigFrom<JsTransformerConfig>(
+      options.projectRoot + '/index',
+      [],
+      {
+        packageKey: '@atlaspack/transformer-js',
+      },
+    );
+
+    if (conf && conf.contents) {
+      validateSchema.diagnostic(
+        CONFIG_SCHEMA,
+        {
+          data: conf.contents,
+          source: () => options.inputFS.readFileSync(conf.filePath, 'utf8'),
+          filePath: conf.filePath,
+          prependKey: `/${encodeJSONKeyComponent('@atlaspack/transformer-js')}`,
+        },
+        // FIXME
+        '@atlaspack/transformer-js',
+        'Invalid config for @atlaspack/transformer-js',
+      );
+    }
+
+    let packageJson = await config.getPackage();
+    let decorators, useDefineForClassFields;
+
+    let {
+      isJSX,
+      jsxPragma,
+      jsxPragmaFrag,
+      jsxImportSource,
+      automaticJSXRuntime,
+      reactRefresh,
+    } = options.featureFlags.newJsxConfig
+      ? (determineJsxConfiguration(
+          config.searchPath,
+          config.isSource,
+          conf?.contents?.jsx,
+          options.projectRoot,
+        ) as JsxConfig)
+      : await legacyDetemineJsxConfig(config, options);
+
+    if (config.isSource) {
+      const compilerOptions: TSConfig['compilerOptions'] = (
+        await config.getConfigFrom<TSConfig>(
+          options.projectRoot + '/index',
+          ['tsconfig.json', 'jsconfig.json'],
+          {
+            readTracking: true,
+          },
+        )
+      )?.contents?.compilerOptions;
 
-      isJSX = Boolean(compilerOptions?.jsx || pragma);
       decorators = compilerOptions?.experimentalDecorators;
       useDefineForClassFields = compilerOptions?.useDefineForClassFields;
       if (
@@ -289,36 +479,99 @@ export default (new Transformer({
     // Check if we should ignore fs calls
     // See https://github.com/defunctzombie/node-browser-resolve#skip
     let ignoreFS =
-      pkg &&
-      pkg.browser &&
-      typeof pkg.browser === 'object' &&
-      pkg.browser.fs === false;
-
-    let conf = await config.getConfigFrom(options.projectRoot + '/index', [], {
-      packageKey: '@atlaspack/transformer-js',
-    });
+      packageJson &&
+      packageJson.browser &&
+      typeof packageJson.browser === 'object' &&
+      packageJson.browser.fs === false;
 
     let inlineEnvironment = config.isSource;
     let inlineFS = !ignoreFS;
     let inlineConstants = false;
     let magicComments = false;
+    let addReactDisplayName = false;
+
+    let enableSsrTypeofReplacement =
+      options.env.NATIVE_SSR_TYPEOF_REPLACEMENT === 'true';
+    let globalAliasingConfig =
+      options.env.NATIVE_GLOBAL_ALIASING &&
+      JSON.parse(options.env.NATIVE_GLOBAL_ALIASING);
+    let enableLazyLoading = options.env.NATIVE_LAZY_LOADING === 'true';
+    let enableReactHooksRemoval =
+      options.env.NATIVE_REACT_HOOKS_REMOVAL === 'true';
+    let enableReactAsyncImportLift =
+      options.env.NATIVE_REACT_ASYNC_IMPORT_LIFT === 'true';
+    let reactAsyncLiftByDefault =
+      options.env.REACT_ASYNC_IMPORT_LIFTING_BY_DEFAULT === 'true';
+    let reactAsyncLiftReportLevel =
+      options.env.REACT_ASYNC_LIFT_REPORT_LEVEL || 'none';
+    let enableStaticPrevaluation = options.env.NATIVE_PREVALUATION === 'true';
+    let enableDeadReturnsRemoval =
+      options.env.NATIVE_DEAD_RETURNS_REMOVAL === 'true';
+    let enableUnusedBindingsRemoval =
+      options.env.NATIVE_UNUSED_BINDINGS_REMOVAL === 'true';
+    let syncDynamicImportConfig:
+      | {
+          entrypoint_filepath_suffix: string;
+          actual_require_paths: string[];
+          activate_reject_on_unresolved_imports?: boolean;
+        }
+      | undefined;
+
+    if (config.env.isTesseract() && options.env.SYNC_DYNAMIC_IMPORT_CONFIG) {
+      try {
+        let config = configCache.get(
+          'SYNC_DYNAMIC_IMPORT_CONFIG',
+        ) as typeof syncDynamicImportConfig;
+
+        if (!config) {
+          config = JSON.parse(options.env.SYNC_DYNAMIC_IMPORT_CONFIG);
+
+          invariant(typeof config?.entrypoint_filepath_suffix === 'string');
+          invariant(Array.isArray(config.actual_require_paths));
+          invariant(
+            typeof (config.activate_reject_on_unresolved_imports ?? false) ===
+              'boolean',
+          );
 
-    if (conf && conf.contents) {
-      validateSchema.diagnostic(
-        CONFIG_SCHEMA,
-        {
-          data: conf.contents,
-          // FIXME
-          source: await options.inputFS.readFile(conf.filePath, 'utf8'),
-          filePath: conf.filePath,
-          prependKey: `/${encodeJSONKeyComponent('@atlaspack/transformer-js')}`,
-        },
-        // FIXME
-        '@atlaspack/transformer-js',
-        'Invalid config for @atlaspack/transformer-js',
-      );
+          configCache.set('SYNC_DYNAMIC_IMPORT_CONFIG', config);
+        }
+
+        syncDynamicImportConfig = config;
+      } catch {
+        // eslint-disable-next-line no-console
+        console.warn(
+          'Failed to parse SYNC_DYNAMIC_IMPORT_CONFIG to JSON or config shape did not match. Config will not be applied.',
+        );
+
+        const fallback = {
+          entrypoint_filepath_suffix: '__NO_MATCH__',
+          actual_require_paths: [],
+          activate_reject_on_unresolved_imports: false,
+        };
+
+        // Set cache to fallback so we don't keep trying to parse.
+        configCache.set('SYNC_DYNAMIC_IMPORT_CONFIG', fallback);
+        syncDynamicImportConfig = fallback;
+      }
+    }
+
+    config.invalidateOnEnvChange('SYNC_DYNAMIC_IMPORT_CONFIG');
+
+    const tokensConfig = getFeatureFlag('coreTokensAndCompiledCssInJsTransform')
+      ? await loadTokensConfig(config, options)
+      : undefined;
 
+    const compiledCssInJsConfig = getFeatureFlag(
+      'coreTokensAndCompiledCssInJsTransform',
+    )
+      ? await loadCompiledCssInJsConfig(config, options)
+      : undefined;
+
+    if (conf && conf.contents) {
+      addReactDisplayName =
+        conf.contents?.addReactDisplayName ?? addReactDisplayName;
       magicComments = conf.contents?.magicComments ?? magicComments;
+      // @ts-expect-error TS2322
       inlineEnvironment = conf.contents?.inlineEnvironment ?? inlineEnvironment;
       inlineFS = conf.contents?.inlineFS ?? inlineFS;
       inlineConstants =
@@ -329,15 +582,29 @@ export default (new Transformer({
       isJSX,
       automaticJSXRuntime,
       jsxImportSource,
-      pragma,
-      pragmaFrag,
+      pragma: jsxPragma,
+      pragmaFrag: jsxPragmaFrag,
       inlineEnvironment,
       inlineFS,
       inlineConstants,
+      addReactDisplayName,
       reactRefresh,
       decorators,
       useDefineForClassFields,
       magicComments,
+      globalAliasingConfig,
+      enableSsrTypeofReplacement,
+      enableLazyLoading,
+      enableDeadReturnsRemoval,
+      enableUnusedBindingsRemoval,
+      enableStaticPrevaluation,
+      enableReactHooksRemoval,
+      syncDynamicImportConfig,
+      enableReactAsyncImportLift,
+      reactAsyncLiftByDefault,
+      reactAsyncLiftReportLevel,
+      tokensConfig,
+      compiledCssInJsConfig,
     };
   },
   async transform({asset, config, options, logger}) {
@@ -368,6 +635,7 @@ export default (new Transformer({
       for (let browser of browsers) {
         let [name, version] = browser.split(' ');
         if (BROWSER_MAPPING.hasOwnProperty(name)) {
+          // @ts-expect-error TS7053
           name = BROWSER_MAPPING[name];
           if (!name) {
             continue;
@@ -377,12 +645,15 @@ export default (new Transformer({
         let [major, minor = '0', patch = '0'] = version
           .split('-')[0]
           .split('.');
+        // @ts-expect-error TS2345
         if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
           continue;
         }
         let semverVersion = `${major}.${minor}.${patch}`;
 
+        // @ts-expect-error TS2345
         if (targets[name] == null || semver.gt(targets[name], semverVersion)) {
+          // @ts-expect-error TS7053
           targets[name] = semverVersion;
         }
       }
@@ -422,24 +693,49 @@ export default (new Transformer({
       if (asset.type === 'ts') {
         isJSX = false;
       } else if (!isJSX) {
+        // @ts-expect-error TS7053
         isJSX = Boolean(JSX_EXTENSIONS[asset.type]);
       }
     }
 
-    let macroAssets = [];
+    let macroAssets: Array<{
+      content: string;
+      // @ts-expect-error TS2552
+      map: undefined | NodeSourceMap;
+      type: string;
+      uniqueKey: string;
+    }> = [];
     let {
+      // @ts-expect-error TS2339
       dependencies,
+      // @ts-expect-error TS2339
       code: compiledCode,
+      // @ts-expect-error TS2339
       map,
+      // @ts-expect-error TS2339
       shebang,
+      // @ts-expect-error TS2339
       hoist_result,
+      // @ts-expect-error TS2339
       symbol_result,
+      // @ts-expect-error TS2339
+      is_empty_or_empty_export,
+      // @ts-expect-error TS2339
       needs_esm_helpers,
+      // @ts-expect-error TS2339
       diagnostics,
+      // @ts-expect-error TS2339
       used_env,
+      // @ts-expect-error TS2339
       has_node_replacements,
+      // @ts-expect-error TS2339
       is_constant_module,
+      // @ts-expect-error TS2339
       conditions,
+      // @ts-expect-error TS2339
+      magic_comments,
+      // @ts-expect-error TS2339
+      style_rules,
     } = await (transformAsync || transform)({
       filename: asset.filePath,
       code,
@@ -451,7 +747,7 @@ export default (new Transformer({
         !asset.env.isNode() && asset.env.sourceType !== 'script',
       node_replacer: asset.env.isNode(),
       is_browser: asset.env.isBrowser(),
-      is_worker: asset.env.isWorker(),
+      is_worker: asset.env.isWorker() || asset.env.isTesseract(),
       env,
       is_type_script: asset.type === 'ts' || asset.type === 'tsx',
       is_jsx: isJSX,
@@ -460,12 +756,16 @@ export default (new Transformer({
       automatic_jsx_runtime: Boolean(config?.automaticJSXRuntime),
       jsx_import_source: config?.jsxImportSource,
       is_development: options.mode === 'development',
-      react_refresh:
+      react_refresh: Boolean(
         asset.env.isBrowser() &&
-        !asset.env.isLibrary &&
-        !asset.env.isWorker() &&
-        !asset.env.isWorklet() &&
-        Boolean(config?.reactRefresh),
+          !asset.env.isLibrary &&
+          !asset.env.isWorker() &&
+          !asset.env.isTesseract() &&
+          !asset.env.isWorklet() &&
+          config?.reactRefresh &&
+          options.hmrOptions &&
+          options.mode === 'development',
+      ),
       decorators: Boolean(config?.decorators),
       use_define_for_class_fields: Boolean(config?.useDefineForClassFields),
       targets,
@@ -481,9 +781,37 @@ export default (new Transformer({
       standalone: asset.query.has('standalone'),
       inline_constants: config.inlineConstants,
       conditional_bundling: options.featureFlags.conditionalBundlingApi,
-      magic_comments: Boolean(config?.magicComments),
+      hmr_improvements: options.featureFlags.hmrImprovements,
+      add_display_name: Boolean(config.addReactDisplayName),
+      exports_rebinding_optimisation:
+        options.featureFlags.exportsRebindingOptimisation,
+      magic_comments:
+        Boolean(config?.magicComments) ||
+        getFeatureFlag('supportWebpackChunkName'),
+      is_source: asset.isSource,
+      nested_promise_import_fix: options.featureFlags.nestedPromiseImportFix,
+      global_aliasing_config: config.globalAliasingConfig,
+      enable_ssr_typeof_replacement: Boolean(config.enableSsrTypeofReplacement),
+      enable_lazy_loading: Boolean(config.enableLazyLoading),
+      enable_dead_returns_removal: Boolean(config.enableDeadReturnsRemoval),
+      enable_unused_bindings_removal: Boolean(
+        config.enableUnusedBindingsRemoval,
+      ),
+      enable_static_prevaluation: Boolean(config.enableStaticPrevaluation),
+      enable_react_hooks_removal: Boolean(config.enableReactHooksRemoval),
+      enable_react_async_import_lift: Boolean(
+        config.enableReactAsyncImportLift,
+      ),
+      react_async_lift_by_default: Boolean(config.reactAsyncLiftByDefault),
+      react_async_lift_report_level: String(config.reactAsyncLiftReportLevel),
+      sync_dynamic_import_config: config.syncDynamicImportConfig,
+      enable_tokens_and_compiled_css_in_js_transform: getFeatureFlag(
+        'coreTokensAndCompiledCssInJsTransform',
+      ),
+      tokens_config: config.tokensConfig,
+      compiled_css_in_js_config: config.compiledCssInJsConfig,
       callMacro: asset.isSource
-        ? async (err, src, exportName, args, loc) => {
+        ? async (err: any, src: any, exportName: any, args: any, loc: any) => {
             let mod;
             try {
               mod = await options.packageManager.require(src, asset.filePath);
@@ -492,7 +820,6 @@ export default (new Transformer({
               if (
                 exportName === 'default' &&
                 !mod.__esModule &&
-                // $FlowFixMe
                 Object.prototype.toString.call(config) !== '[object Module]'
               ) {
                 mod = {default: mod};
@@ -501,7 +828,7 @@ export default (new Transformer({
               if (!Object.hasOwnProperty.call(mod, exportName)) {
                 throw new Error(`"${src}" does not export "${exportName}".`);
               }
-            } catch (err) {
+            } catch (err: any) {
               throw {
                 kind: 1,
                 message: err.message,
@@ -518,7 +845,8 @@ export default (new Transformer({
                     if (asset.env.sourceMap) {
                       // Generate a source map that maps each line of the asset to the original macro call.
                       map = new SourceMap(options.projectRoot);
-                      let mappings = [];
+                      // @ts-expect-error TS2304
+                      let mappings: Array<IndexedMapping<string>> = [];
                       let line = 1;
                       for (let i = 0; i <= a.content.length; i++) {
                         if (i === a.content.length || a.content[i] === '\n') {
@@ -541,7 +869,9 @@ export default (new Transformer({
                       if (originalMap) {
                         map.extends(originalMap);
                       } else {
-                        map.setSourceContent(asset.filePath, code.toString());
+                        if (!getFeatureFlag('omitSourcesContentInMemory')) {
+                          map.setSourceContent(asset.filePath, code.toString());
+                        }
                       }
                     }
 
@@ -557,13 +887,13 @@ export default (new Transformer({
                       specifierType: 'esm',
                     });
                   },
-                  invalidateOnFileChange(filePath) {
+                  invalidateOnFileChange(filePath: FilePath) {
                     asset.invalidateOnFileChange(filePath);
                   },
-                  invalidateOnFileCreate(invalidation) {
+                  invalidateOnFileCreate(invalidation: FileCreateInvalidation) {
                     asset.invalidateOnFileCreate(invalidation);
                   },
-                  invalidateOnEnvChange(env) {
+                  invalidateOnEnvChange(env: string) {
                     asset.invalidateOnEnvChange(env);
                   },
                   invalidateOnStartup() {
@@ -580,7 +910,7 @@ export default (new Transformer({
                   `"${exportName}" in "${src}" is not a function.`,
                 );
               }
-            } catch (err) {
+            } catch (err: any) {
               // Remove atlaspack core from stack and build string so Rust can process errors more easily.
               let stack = (err.stack || '').split('\n').slice(1);
               let message = err.message;
@@ -600,18 +930,18 @@ export default (new Transformer({
     });
 
     if (getFeatureFlag('conditionalBundlingApi')) {
-      asset.meta.conditions = conditions.map((c): ConditionMeta => ({
-        key: c.key,
-        ifTruePlaceholder: c.if_true_placeholder,
-        ifFalsePlaceholder: c.if_false_placeholder,
-      }));
+      asset.meta.conditions = conditions;
+    }
+
+    if (style_rules) {
+      asset.meta.styleRules = style_rules;
     }
 
     if (is_constant_module) {
       asset.meta.isConstantModule = true;
     }
 
-    let convertLoc = (loc): SourceLocation => {
+    let convertLoc = (loc: any): SourceLocation => {
       let location = {
         filePath: asset.filePath,
         start: {
@@ -626,7 +956,11 @@ export default (new Transformer({
 
       // If there is an original source map, use it to remap to the original source location.
       if (originalMap) {
-        location = remapSourceLocation(location, originalMap);
+        location = remapSourceLocation(
+          location,
+          originalMap,
+          options.projectRoot,
+        );
       }
 
       return location;
@@ -634,19 +968,22 @@ export default (new Transformer({
 
     if (diagnostics) {
       let errors = diagnostics.filter(
+        // @ts-expect-error TS7006
         (d) =>
           d.severity === 'Error' ||
           (d.severity === 'SourceError' && asset.isSource),
       );
       let warnings = diagnostics.filter(
+        // @ts-expect-error TS7006
         (d) =>
           d.severity === 'Warning' ||
           (d.severity === 'SourceError' && !asset.isSource),
       );
-      let convertDiagnostic = (diagnostic) => {
+      let convertDiagnostic = (diagnostic: any) => {
         let message = diagnostic.message;
         if (message === 'SCRIPT_ERROR') {
-          let err = SCRIPT_ERRORS[(asset.env.context: string)];
+          // @ts-expect-error TS7053
+          let err = SCRIPT_ERRORS[asset.env.context as string];
           message = err?.message || SCRIPT_ERRORS.browser.message;
         }
 
@@ -655,17 +992,21 @@ export default (new Transformer({
           codeFrames: [
             {
               filePath: asset.filePath,
-              codeHighlights: diagnostic.code_highlights?.map((highlight) =>
-                convertSourceLocationToHighlight(
-                  convertLoc(highlight.loc),
-                  highlight.message ?? undefined,
-                ),
+              codeHighlights: diagnostic.code_highlights?.map(
+                (highlight: any) =>
+                  convertSourceLocationToHighlight(
+                    convertLoc(highlight.loc),
+                    highlight.message ?? undefined,
+                  ),
               ),
             },
           ],
           hints: diagnostic.hints,
         };
 
+        if (diagnostic.name) {
+          res.name = diagnostic.name;
+        }
         if (diagnostic.documentation_url) {
           res.documentationURL = diagnostic.documentation_url;
         }
@@ -683,7 +1024,8 @@ export default (new Transformer({
             });
           }
 
-          let err = SCRIPT_ERRORS[(asset.env.context: string)];
+          // @ts-expect-error TS7053
+          let err = SCRIPT_ERRORS[asset.env.context as string];
           if (err) {
             if (!res.hints) {
               res.hints = [err.hint];
@@ -740,6 +1082,7 @@ export default (new Transformer({
           env: {
             context: 'web-worker',
             sourceType: dep.source_type === 'Module' ? 'module' : 'script',
+            // @ts-expect-error TS2322
             outputFormat,
             loc,
           },
@@ -787,6 +1130,13 @@ export default (new Transformer({
         });
       } else if (dep.kind === 'File') {
         asset.invalidateOnFileChange(dep.specifier);
+      } else if (dep.kind === 'Id') {
+        // Record parcelRequire calls so that the dev packager can add them as dependencies.
+        // This allows the HMR runtime to collect parents across async boundaries (through runtimes).
+        // TODO: ideally this would result as an actual dep in the graph rather than asset.meta.
+        asset.meta.hmrDeps ??= [];
+        invariant(Array.isArray(asset.meta.hmrDeps));
+        asset.meta.hmrDeps.push(dep.specifier);
       } else {
         let meta: JSONObject = {kind: dep.kind};
         if (dep.attributes) {
@@ -850,6 +1200,13 @@ export default (new Transformer({
             outputFormat,
             loc: convertLoc(dep.loc),
           };
+
+          if (getFeatureFlag('supportWebpackChunkName')) {
+            let chunkName = magic_comments[dep.specifier];
+            if (chunkName) {
+              meta.chunkName = chunkName;
+            }
+          }
         }
 
         // Always bundle helpers, even with includeNodeModules: false, except if this is a library.
@@ -874,6 +1231,7 @@ export default (new Transformer({
             idx = dep.specifier.indexOf('/', idx + 1);
           }
           let module = idx >= 0 ? dep.specifier.slice(0, idx) : dep.specifier;
+          // @ts-expect-error TS7053
           range = pkg.dependencies[module];
         }
 
@@ -885,12 +1243,13 @@ export default (new Transformer({
             dep.kind === 'DynamicImport'
               ? 'lazy'
               : dep.kind === 'ConditionalImport'
-              ? 'conditional'
-              : 'sync',
+                ? 'conditional'
+                : 'sync',
           isOptional: dep.is_optional,
           meta,
           resolveFrom: isHelper ? __filename : undefined,
           range,
+          // @ts-expect-error TS2322
           env,
         });
       }
@@ -904,8 +1263,12 @@ export default (new Transformer({
         local,
         loc,
         is_esm,
+        is_static_binding_safe,
       } of hoist_result.exported_symbols) {
-        asset.symbols.set(exported, local, convertLoc(loc), {isEsm: is_esm});
+        asset.symbols.set(exported, local, convertLoc(loc), {
+          isEsm: is_esm,
+          isStaticBindingSafe: is_static_binding_safe,
+        });
       }
 
       // deps is a map of dependencies that are keyed by placeholder or specifier
@@ -937,7 +1300,24 @@ export default (new Transformer({
         let dep = deps.get(source);
         if (!dep) continue;
         if (local === '*' && imported === '*') {
-          dep.symbols.set('*', '*', convertLoc(loc), true);
+          // When a module has both `import * as ns from 'x'` and
+          // `export * from 'x'`, they share a single dep (merged by the
+          // core). The namespace import binding ('*' → local, isWeak:false)
+          // set by imported_symbols is strictly more inclusive than the
+          // wildcard re-export ('*' → '*', isWeak:true) for symbol
+          // propagation, so don't overwrite it. Instead, flag the dep so
+          // that symbol propagation still treats it as a wildcard
+          // re-exporter.
+          let existingStar = dep.symbols.get('*');
+          if (
+            getFeatureFlag('fixExportStarNamespaceOverwrite') &&
+            existingStar &&
+            existingStar.local !== '*'
+          ) {
+            dep.meta.hasExportStar = true;
+          } else {
+            dep.symbols.set('*', '*', convertLoc(loc), true);
+          }
         } else {
           let reExportName =
             dep.symbols.get(imported)?.local ??
@@ -1002,6 +1382,9 @@ export default (new Transformer({
           Object.keys(hoist_result.exported_symbols).length === 0) ||
         (hoist_result.should_wrap && !asset.symbols.hasExportSymbol('*'))
       ) {
+        if (is_empty_or_empty_export) {
+          asset.meta.emptyFileStarReexport = true;
+        }
         asset.symbols.set('*', `$${asset.id}$exports`);
       }
 
@@ -1046,7 +1429,20 @@ export default (new Transformer({
           let dep = deps.get(source);
           if (!dep) continue;
           dep.symbols.ensure();
-          dep.symbols.set('*', '*', convertLoc(loc), true);
+          // When a module has both `import * as ns from 'x'` and
+          // `export * from 'x'`, they share a single dep. Don't overwrite
+          // the namespace import binding — flag the dep instead so symbol
+          // propagation still treats it as a wildcard re-exporter.
+          let existingStar = dep.symbols.get('*');
+          if (
+            getFeatureFlag('fixExportStarNamespaceOverwrite') &&
+            existingStar &&
+            existingStar.local !== '*'
+          ) {
+            dep.meta.hasExportStar = true;
+          } else {
+            dep.symbols.set('*', '*', convertLoc(loc), true);
+          }
         }
 
         // Add * symbol if there are CJS exports, no imports/exports at all, or the asset is wrapped.
@@ -1104,4 +1500,4 @@ export default (new Transformer({
 
     return [asset, ...macroAssets];
   },
-}): Transformer);
+}) as Transformer<unknown>;