@atlaspack/runtime-js 2.14.5-canary.45 → 2.14.5-canary.450

package/lib/JSRuntime.js

@@ -76,8 +76,10 @@ const LOADERS = {
   }
 };
 function getLoaders(ctx) {
-  if (ctx.isWorker()) return LOADERS.worker;
+  // @ts-expect-error TS2322
+  if (ctx.isWorker() || ctx.isTesseract()) return LOADERS.worker;
   if (ctx.isBrowser()) return LOADERS.browser;
+  // @ts-expect-error TS2322
   if (ctx.isNode()) return LOADERS.node;
   return null;
 }
@@ -162,12 +164,22 @@ var _default = exports.default = new (_plugin().Runtime)({
           // If this bundle already has the asset this dependency references,
           // return a simple runtime of `Promise.resolve(internalRequire(assetId))`.
           // The linker handles this for scope-hoisting.
+
+          const requireName = (0, _featureFlags().getFeatureFlag)('hmrImprovements') ? 'parcelRequire' : 'module.bundle.root';
           assets.push({
             filePath: __filename,
-            code: `module.exports = Promise.resolve(module.bundle.root(${JSON.stringify(bundleGraph.getAssetPublicId(resolved.value))}))`,
+            code: `module.exports = Promise.resolve(${requireName}(${JSON.stringify(bundleGraph.getAssetPublicId(resolved.value))}))`,
             dependency,
             env: {
               sourceType: 'module'
+            },
+            // Pre-computed symbols: exports Promise, no external dependencies (uses global)
+            symbolData: {
+              symbols: new Map([['default', {
+                local: 'module.exports',
+                loc: null
+              }]]),
+              dependencies: []
             }
           });
         }
@@ -175,13 +187,21 @@ var _default = exports.default = new (_plugin().Runtime)({
         // Resolve the dependency to a bundle. If inline, export the dependency id,
         // which will be replaced with the contents of that bundle later.
         let referencedBundle = bundleGraph.getReferencedBundle(dependency, bundle);
-        if ((referencedBundle === null || referencedBundle === void 0 ? void 0 : referencedBundle.bundleBehavior) === 'inline') {
+        if ((referencedBundle === null || referencedBundle === void 0 ? void 0 : referencedBundle.bundleBehavior) === 'inline' || (referencedBundle === null || referencedBundle === void 0 ? void 0 : referencedBundle.bundleBehavior) === 'inlineIsolated') {
           assets.push({
             filePath: _path().default.join(__dirname, `/bundles/${referencedBundle.id}.js`),
             code: `module.exports = Promise.resolve(${JSON.stringify(dependency.id)});`,
             dependency,
             env: {
               sourceType: 'module'
+            },
+            // Pre-computed symbols: exports Promise, no external dependencies
+            symbolData: {
+              symbols: new Map([['default', {
+                local: 'module.exports',
+                loc: null
+              }]]),
+              dependencies: []
             }
           });
           continue;
@@ -205,10 +225,28 @@ var _default = exports.default = new (_plugin().Runtime)({
       // replaced with a reference to this asset to implement the selection.
       const conditions = bundleGraph.getConditionsForDependencies(conditionalDependencies, bundle);
       for (const cond of conditions) {
-        const requireName = bundle.env.shouldScopeHoist ? 'parcelRequire' : '__parcel__require__';
-        const assetCode = `module.exports = require('../helpers/conditional-loader${options.mode === 'development' ? '-dev' : ''}')('${cond.key}', function (){return ${requireName}('${cond.ifTrueAssetId}')}, function (){return ${requireName}('${cond.ifFalseAssetId}')})`;
+        const requireName = (0, _featureFlags().getFeatureFlag)('hmrImprovements') || bundle.env.shouldScopeHoist ? 'parcelRequire' : '__parcel__require__';
+
+        // We have fallback behaviour that can be used in development mode, so we need to handle both types of packagers
+        const getFallbackArgs = cond => {
+          const fallbackUrls = () => {
+            return `urls: [${[...cond.ifTrueBundles, ...cond.ifFalseBundles].map(target => {
+              let relativePathExpr = getRelativePathExpr(bundle, target, options);
+              return getAbsoluteUrlExpr(relativePathExpr, bundle, config.domainSharding);
+            }).join(',')}]`;
+          };
+          const fallbackBundleIds = () => {
+            return `i: [${[...cond.ifTrueBundles, ...cond.ifFalseBundles].map(target => `"${target.publicId}"`).join(',')}]`;
+          };
+          return `, {l: require('./helpers/browser/sync-js-loader'), ${options.mode === 'development' ? fallbackUrls() : fallbackBundleIds()}}`;
+        };
+        const shouldUseFallback = options.mode === 'development' ? (0, _featureFlags().getFeatureFlag)('condbDevFallbackDev') : (0, _featureFlags().getFeatureFlag)('condbDevFallbackProd');
+        const loaderPath = `./helpers/conditional-loader${options.mode === 'development' ? '-dev' : ''}`;
+        const ifTrue = `function (){return ${requireName}('${cond.ifTrueAssetId}')}`;
+        const ifFalse = `function (){return ${requireName}('${cond.ifFalseAssetId}')}`;
+        const assetCode = `module.exports = require('${loaderPath}')('${cond.key}', ${ifTrue}, ${ifFalse}${shouldUseFallback ? getFallbackArgs(cond) : ''})`;
         assets.push({
-          filePath: _path().default.join(__dirname, `/conditions/${cond.publicId}.js`),
+          filePath: _path().default.join(__dirname, `/conditions-${cond.publicId}.js`),
           code: assetCode,
           // This dependency is important, as it's the last symbol handled in scope hoisting.
           // That means that scope hoisting will use the module id for this asset to replace the symbol
@@ -216,6 +254,30 @@ var _default = exports.default = new (_plugin().Runtime)({
           dependency: cond.ifFalseDependency,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: conditional loader with potential sync-js-loader fallback
+          symbolData: {
+            symbols: new Map([['default', {
+              local: 'module.exports',
+              loc: null
+            }]]),
+            dependencies: [{
+              specifier: loaderPath,
+              symbols: new Map([['default', {
+                local: 'default',
+                loc: null,
+                isWeak: false
+              }]]),
+              usedSymbols: new Set(['default'])
+            }, ...(shouldUseFallback ? [{
+              specifier: './helpers/browser/sync-js-loader',
+              symbols: new Map([['default', {
+                local: 'l',
+                loc: null,
+                isWeak: false
+              }]]),
+              usedSymbols: new Set(['default'])
+            }] : [])]
           }
         });
       }
@@ -224,13 +286,21 @@ var _default = exports.default = new (_plugin().Runtime)({
       // Resolve the dependency to a bundle. If inline, export the dependency id,
       // which will be replaced with the contents of that bundle later.
       let referencedBundle = bundleGraph.getReferencedBundle(dependency, bundle);
-      if ((referencedBundle === null || referencedBundle === void 0 ? void 0 : referencedBundle.bundleBehavior) === 'inline') {
+      if ((referencedBundle === null || referencedBundle === void 0 ? void 0 : referencedBundle.bundleBehavior) === 'inline' || (referencedBundle === null || referencedBundle === void 0 ? void 0 : referencedBundle.bundleBehavior) === 'inlineIsolated') {
         assets.push({
           filePath: _path().default.join(__dirname, `/bundles/${referencedBundle.id}.js`),
           code: `module.exports = ${JSON.stringify(dependency.id)};`,
           dependency,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: simple export with no dependencies
+          symbolData: {
+            symbols: new Map([['default', {
+              local: 'module.exports',
+              loc: null
+            }]]),
+            dependencies: []
           }
         });
         continue;
@@ -248,6 +318,14 @@ var _default = exports.default = new (_plugin().Runtime)({
           dependency,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: simple export with no dependencies
+          symbolData: {
+            symbols: new Map([['default', {
+              local: 'module.exports',
+              loc: null
+            }]]),
+            dependencies: []
           }
         });
         continue;
@@ -263,7 +341,7 @@ var _default = exports.default = new (_plugin().Runtime)({
 
       // Skip URL runtimes for library builds. This is handled in packaging so that
       // the url is inlined and statically analyzable.
-      if (bundle.env.isLibrary && mainBundle.bundleBehavior !== 'isolated') {
+      if (bundle.env.isLibrary && mainBundle.bundleBehavior !== 'isolated' && mainBundle.bundleBehavior !== 'inlineIsolated') {
         continue;
       }
 
@@ -293,11 +371,25 @@ var _default = exports.default = new (_plugin().Runtime)({
           isEntry: true,
           env: {
             sourceType: 'module'
+          },
+          // Pre-computed symbols: lazy bundle loader, requires specific loader helper
+          symbolData: {
+            symbols: new Map(),
+            // No exports, just side effects
+            dependencies: [{
+              specifier: loader,
+              symbols: new Map([['default', {
+                local: 'default',
+                loc: null,
+                isWeak: false
+              }]]),
+              usedSymbols: new Set(['default'])
+            }]
           }
         });
       }
     }
-    if (shouldUseRuntimeManifest(bundle, options) && bundleGraph.getChildBundles(bundle).some(b => b.bundleBehavior !== 'inline') && isNewContext(bundle, bundleGraph)) {
+    if (shouldUseRuntimeManifest(bundle, options) && bundleGraph.getChildBundles(bundle).some(b => b.bundleBehavior !== 'inline' && b.bundleBehavior !== 'inlineIsolated') && isNewContext(bundle, bundleGraph)) {
       assets.push({
         filePath: __filename,
         code: getRegisterCode(bundle, bundleGraph),
@@ -305,7 +397,22 @@ var _default = exports.default = new (_plugin().Runtime)({
         env: {
           sourceType: 'module'
         },
-        priority: getManifestBundlePriority(bundleGraph, bundle, config.splitManifestThreshold)
+        runtimeAssetRequiringExecutionOnLoad: true,
+        priority: getManifestBundlePriority(bundleGraph, bundle, config.splitManifestThreshold),
+        // Pre-computed symbols: requires bundle-manifest helper
+        symbolData: {
+          symbols: new Map(),
+          // No exports, just executes
+          dependencies: [{
+            specifier: './helpers/bundle-manifest',
+            symbols: new Map([['register', {
+              local: 'register',
+              loc: null,
+              isWeak: false
+            }]]),
+            usedSymbols: new Set(['register'])
+          }]
+        }
       });
     }
     return assets;
@@ -357,10 +464,16 @@ function getLoaderRuntime({
     return;
   }
   let externalBundles = bundleGraph.getBundlesInBundleGroup(bundleGroup);
-  let mainBundle = (0, _nullthrows().default)(externalBundles.find(bundle => {
-    var _bundle$getMainEntry;
-    return ((_bundle$getMainEntry = bundle.getMainEntry()) === null || _bundle$getMainEntry === void 0 ? void 0 : _bundle$getMainEntry.id) === bundleGroup.entryAssetId;
-  }));
+  let potentialMainBundle;
+  if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+    potentialMainBundle = externalBundles.find(bundle => bundle.getEntryAssets().some(asset => asset.id === bundleGroup.entryAssetId));
+  } else {
+    potentialMainBundle = externalBundles.find(bundle => {
+      var _bundle$getMainEntry;
+      return ((_bundle$getMainEntry = bundle.getMainEntry()) === null || _bundle$getMainEntry === void 0 ? void 0 : _bundle$getMainEntry.id) === bundleGroup.entryAssetId;
+    });
+  }
+  let mainBundle = (0, _nullthrows().default)(potentialMainBundle);
 
   // CommonJS is a synchronous module system, so there is no need to load bundles in parallel.
   // Importing of the other bundles will be handled by the bundle group entry.
@@ -385,6 +498,7 @@ function getLoaderRuntime({
   let needsEsmLoadPrelude = false;
   let loaderModules = [];
   function getLoaderForBundle(bundle, to, shardingConfig) {
+    // @ts-expect-error TS18049
     let loader = loaders[to.type];
     if (!loader) {
       return;
@@ -400,7 +514,11 @@ function getLoaderRuntime({
       if (!needsDynamicImportPolyfill) {
         return `__parcel__import__("./" + ${relativePathExpr})`;
       }
-      loader = (0, _nullthrows().default)(loaders.IMPORT_POLYFILL, `No import() polyfill available for context '${bundle.env.context}'`);
+
+      // @ts-expect-error TS2322
+      loader = (0, _nullthrows().default)(
+      // @ts-expect-error TS18049
+      loaders.IMPORT_POLYFILL, `No import() polyfill available for context '${bundle.env.context}'`);
     } else if (to.type === 'js' && to.env.outputFormat === 'commonjs') {
       return `Promise.resolve(__parcel__require__("./" + ${relativePathExpr}))`;
     }
@@ -434,8 +552,16 @@ function getLoaderRuntime({
     const loaders = [];
     for (const cond of conditions) {
       // This bundle has a conditional dependency, we need to load the bundle group
-      const ifTrueLoaders = cond.ifTrueBundles.flatMap(targetBundle => getConditionalLoadersForCondition(getDependencies(targetBundle).conditionalDependencies, targetBundle)).concat(cond.ifTrueBundles.map(targetBundle => getLoaderForBundle(sourceBundle, targetBundle)));
-      const ifFalseLoaders = cond.ifFalseBundles.flatMap(targetBundle => getConditionalLoadersForCondition(getDependencies(targetBundle).conditionalDependencies, targetBundle)).concat(cond.ifFalseBundles.map(targetBundle => getLoaderForBundle(sourceBundle, targetBundle)));
+      const ifTrueLoaders = cond.ifTrueBundles.flatMap(targetBundle => getConditionalLoadersForCondition(getDependencies(targetBundle).conditionalDependencies, targetBundle)).concat(
+      // @ts-expect-error TS2769
+      cond.ifTrueBundles.map(targetBundle =>
+      // @ts-expect-error TS2554
+      getLoaderForBundle(sourceBundle, targetBundle)));
+      const ifFalseLoaders = cond.ifFalseBundles.flatMap(targetBundle => getConditionalLoadersForCondition(getDependencies(targetBundle).conditionalDependencies, targetBundle)).concat(
+      // @ts-expect-error TS2769
+      cond.ifFalseBundles.map(targetBundle =>
+      // @ts-expect-error TS2554
+      getLoaderForBundle(sourceBundle, targetBundle)));
       if (ifTrueLoaders.length > 0 || ifFalseLoaders.length > 0) {
         // Load conditional bundles with helper (and a dev mode with additional hints)
         loaders.push(`require('./helpers/conditional-loader${options.mode === 'development' ? '-dev' : ''}')('${cond.key}', function (){return Promise.all([${ifTrueLoaders.join(',')}]);}, function (){return Promise.all([${ifFalseLoaders.join(',')}]);})`);
@@ -444,21 +570,8 @@ function getLoaderRuntime({
     return loaders;
   }
   if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi')) {
-    if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingNestedRuntime')) {
-      let conditionalDependencies = externalBundles.flatMap(to => getDependencies(to).conditionalDependencies);
-      loaderModules.push(...getConditionalLoadersForCondition(conditionalDependencies, bundle));
-    } else {
-      let conditionalDependencies = externalBundles.flatMap(to => getDependencies(to).conditionalDependencies);
-      for (const cond of bundleGraph.getConditionsForDependencies(conditionalDependencies, bundle)) {
-        // This bundle has a conditional dependency, we need to load the bundle group
-        const ifTrueLoaders = cond.ifTrueBundles.map(targetBundle => getLoaderForBundle(bundle, targetBundle));
-        const ifFalseLoaders = cond.ifFalseBundles.map(targetBundle => getLoaderForBundle(bundle, targetBundle));
-        if (ifTrueLoaders.length > 0 || ifFalseLoaders.length > 0) {
-          // Load conditional bundles with helper (and a dev mode with additional hints)
-          loaderModules.push(`require('./helpers/conditional-loader${options.mode === 'development' ? '-dev' : ''}')('${cond.key}', function (){return Promise.all([${ifTrueLoaders.join(',')}]);}, function (){return Promise.all([${ifFalseLoaders.join(',')}]);})`);
-        }
-      }
-    }
+    let conditionalDependencies = externalBundles.flatMap(to => getDependencies(to).conditionalDependencies);
+    loaderModules.push(...getConditionalLoadersForCondition(conditionalDependencies, bundle));
   }
   for (let to of externalBundles) {
     let loaderModule = getLoaderForBundle(bundle, to, shardingConfig);
@@ -488,7 +601,7 @@ function getLoaderRuntime({
     loaderCode = `(${loaderCode})`;
   }
   if (mainBundle.type === 'js') {
-    let parcelRequire = bundle.env.shouldScopeHoist ? 'parcelRequire' : 'module.bundle.root';
+    let parcelRequire = (0, _featureFlags().getFeatureFlag)('hmrImprovements') || bundle.env.shouldScopeHoist ? 'parcelRequire' : 'module.bundle.root';
     loaderCode += `.then(() => ${parcelRequire}('${bundleGraph.getAssetPublicId(bundleGraph.getAssetById(bundleGroup.entryAssetId))}'))`;
   }
   if (needsEsmLoadPrelude && options.featureFlags.importRetry) {
@@ -506,6 +619,22 @@ function getLoaderRuntime({
       dependency,
       env: {
         sourceType: 'module'
+      },
+      // Pre-computed symbols: ESM loader with retry, requires esm-js-loader-retry helper
+      symbolData: {
+        symbols: new Map([['default', {
+          local: 'module.exports',
+          loc: null
+        }]]),
+        dependencies: [{
+          specifier: './helpers/browser/esm-js-loader-retry',
+          symbols: new Map([['default', {
+            local: 'default',
+            loc: null,
+            isWeak: false
+          }]]),
+          usedSymbols: new Set(['default'])
+        }]
       }
     };
   }
@@ -515,12 +644,165 @@ function getLoaderRuntime({
     code.push(preludeLoad);
   }
   code.push(`module.exports = ${loaderCode};`);
+
+  // Collect all potential helper dependencies used in loader runtime
+  let helperDependencies = [];
+
+  // Always potential dependencies based on the code patterns
+  if (needsEsmLoadPrelude) {
+    if (shardingConfig) {
+      helperDependencies.push({
+        specifier: './helpers/browser/esm-js-loader-shards',
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    } else {
+      helperDependencies.push({
+        specifier: './helpers/browser/esm-js-loader',
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    }
+  }
+
+  // Bundle manifest dependency if using runtime manifest
+  if (shouldUseRuntimeManifest(bundle, options)) {
+    helperDependencies.push({
+      specifier: './helpers/bundle-manifest',
+      symbols: new Map([['resolve', {
+        local: 'resolve',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['resolve'])
+    });
+  }
+
+  // Domain sharding dependency if configured
+  if (shardingConfig) {
+    helperDependencies.push({
+      specifier: '@atlaspack/domain-sharding',
+      symbols: new Map([['shardUrl', {
+        local: 'shardUrl',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['shardUrl'])
+    });
+  }
+
+  // Various loader dependencies based on bundle types in externalBundles
+  for (let to of externalBundles) {
+    let loader = loaders[to.type];
+    if (loader && typeof loader === 'string') {
+      helperDependencies.push({
+        specifier: loader,
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    }
+  }
+
+  // Import polyfill if needed
+  if (needsDynamicImportPolyfill && loaders !== null && loaders !== void 0 && loaders.IMPORT_POLYFILL) {
+    helperDependencies.push({
+      specifier: loaders.IMPORT_POLYFILL,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+  }
+
+  // Conditional loaders if using conditional bundling
+  if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi')) {
+    const loaderPath = `./helpers/conditional-loader${options.mode === 'development' ? '-dev' : ''}`;
+    helperDependencies.push({
+      specifier: loaderPath,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+
+    // Sync loader for fallback
+    if (options.mode === 'development') {
+      helperDependencies.push({
+        specifier: './helpers/browser/sync-js-loader',
+        symbols: new Map([['default', {
+          local: 'default',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['default'])
+      });
+    }
+  }
+
+  // Preload/prefetch loaders for browser context
+  if (bundle.env.context === 'browser') {
+    helperDependencies.push({
+      specifier: BROWSER_PRELOAD_LOADER,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+    helperDependencies.push({
+      specifier: BROWSER_PREFETCH_LOADER,
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+  }
+
+  // ESM loader retry if using import retry feature
+  if (needsEsmLoadPrelude && options.featureFlags.importRetry) {
+    helperDependencies.push({
+      specifier: './helpers/browser/esm-js-loader-retry',
+      symbols: new Map([['default', {
+        local: 'default',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+  }
   return {
     filePath: __filename,
     code: code.join('\n'),
     dependency,
     env: {
       sourceType: 'module'
+    },
+    // Pre-computed symbols: loader runtime with comprehensive helper dependencies
+    symbolData: {
+      symbols: new Map([['default', {
+        local: 'module.exports',
+        loc: null
+      }]]),
+      dependencies: helperDependencies
     }
   };
 }
@@ -534,14 +816,16 @@ function getHintedBundleGroups(bundleGraph, bundle) {
     var _dependency$meta;
     let attributes = (_dependency$meta = dependency.meta) === null || _dependency$meta === void 0 ? void 0 : _dependency$meta.importAttributes;
     if (typeof attributes === 'object' && attributes != null && (
-    // $FlowFixMe
+    // @ts-expect-error TS2339
     attributes.preload || attributes.prefetch)) {
       let resolved = bundleGraph.resolveAsyncDependency(dependency, bundle);
       if ((resolved === null || resolved === void 0 ? void 0 : resolved.type) === 'bundle_group') {
         // === true for flow
+        // @ts-expect-error TS2339
         if (attributes.preload === true) {
           preload.push(resolved.value);
         }
+        // @ts-expect-error TS2339
         if (attributes.prefetch === true) {
           prefetch.push(resolved.value);
         }
@@ -559,8 +843,11 @@ function getHintLoaders(bundleGraph, from, bundleGroups, loader, options) {
     let bundlesToPreload = bundleGraph.getBundlesInBundleGroup(bundleGroupToPreload);
     for (let bundleToPreload of bundlesToPreload) {
       let relativePathExpr = getRelativePathExpr(from, bundleToPreload, options);
+      // @ts-expect-error TS7053
       let priority = TYPE_TO_RESOURCE_PRIORITY[bundleToPreload.type];
-      hintLoaders.push(`require(${JSON.stringify(loader)})(${getAbsoluteUrlExpr(relativePathExpr, from)}, ${priority ? JSON.stringify(priority) : 'null'}, ${JSON.stringify(bundleToPreload.target.env.outputFormat === 'esmodule')})`);
+      hintLoaders.push(
+      // @ts-expect-error TS2554
+      `require(${JSON.stringify(loader)})(${getAbsoluteUrlExpr(relativePathExpr, from)}, ${priority ? JSON.stringify(priority) : 'null'}, ${JSON.stringify(bundleToPreload.target.env.outputFormat === 'esmodule')})`);
     }
   }
   return hintLoaders;
@@ -571,7 +858,12 @@ function isNewContext(bundle, bundleGraph) {
   return isInEntryBundleGroup || parents.length === 0 || parents.some(parent => parent.env.context !== bundle.env.context || parent.type !== 'js');
 }
 function getURLRuntime(dependency, from, to, options, shardingConfig) {
-  let relativePathExpr = getRelativePathExpr(from, to, options);
+  let relativePathExpr;
+  if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+    relativePathExpr = getRelativePathExpr(from, to, options, true);
+  } else {
+    relativePathExpr = getRelativePathExpr(from, to, options);
+  }
   let code;
   if (dependency.meta.webworker === true && !from.env.isLibrary) {
     code = `let workerURL = require('./helpers/get-worker-url');\n`;
@@ -589,19 +881,96 @@ function getURLRuntime(dependency, from, to, options, shardingConfig) {
   } else {
     code = `module.exports = ${getAbsoluteUrlExpr(relativePathExpr, from, shardingConfig)};`;
   }
+
+  // Collect dependencies based on the URL runtime code patterns
+  let urlRuntimeDependencies = [];
+  if (dependency.meta.webworker === true && !from.env.isLibrary) {
+    // Web worker runtime requires get-worker-url helper
+    urlRuntimeDependencies.push({
+      specifier: './helpers/get-worker-url',
+      symbols: new Map([['default', {
+        local: 'workerURL',
+        loc: null,
+        isWeak: false
+      }]]),
+      usedSymbols: new Set(['default'])
+    });
+    if (!(from.env.outputFormat === 'esmodule' && from.env.supports('import-meta-url'))) {
+      // Also requires bundle-url helper in non-ESM environments
+      urlRuntimeDependencies.push({
+        specifier: './helpers/bundle-url',
+        symbols: new Map([['getBundleURL', {
+          local: 'getBundleURL',
+          loc: null,
+          isWeak: false
+        }], ['getOrigin', {
+          local: 'getOrigin',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['getBundleURL', 'getOrigin'])
+      });
+
+      // Domain sharding if configured
+      if (shardingConfig) {
+        urlRuntimeDependencies.push({
+          specifier: '@atlaspack/domain-sharding',
+          symbols: new Map([['shardUrl', {
+            local: 'shardUrl',
+            loc: null,
+            isWeak: false
+          }]]),
+          usedSymbols: new Set(['shardUrl'])
+        });
+      }
+    }
+  } else {
+    // Regular URL runtime may use bundle-url helper
+    if (!(from.env.outputFormat === 'esmodule' && from.env.supports('import-meta-url')) && !(from.env.outputFormat === 'commonjs')) {
+      urlRuntimeDependencies.push({
+        specifier: './helpers/bundle-url',
+        symbols: new Map([['getBundleURL', {
+          local: 'getBundleURL',
+          loc: null,
+          isWeak: false
+        }]]),
+        usedSymbols: new Set(['getBundleURL'])
+      });
+      if (shardingConfig) {
+        urlRuntimeDependencies.push({
+          specifier: '@atlaspack/domain-sharding',
+          symbols: new Map([['shardUrl', {
+            local: 'shardUrl',
+            loc: null,
+            isWeak: false
+          }]]),
+          usedSymbols: new Set(['shardUrl'])
+        });
+      }
+    }
+  }
   return {
     filePath: __filename,
     code,
     dependency,
     env: {
       sourceType: 'module'
+    },
+    // Pre-computed symbols: URL runtime with helper dependencies
+    symbolData: {
+      symbols: new Map([['default', {
+        local: 'module.exports',
+        loc: null
+      }]]),
+      dependencies: urlRuntimeDependencies
     }
   };
 }
 function getRegisterCode(entryBundle, bundleGraph) {
+  // @ts-expect-error TS2304
   let mappings = [];
   bundleGraph.traverseBundles((bundle, _, actions) => {
-    if (bundle.bundleBehavior === 'inline') {
+    if (bundle.bundleBehavior === 'inline' || bundle.bundleBehavior === 'inlineIsolated') {
       return;
     }
 
@@ -625,13 +994,19 @@ function getRegisterCode(entryBundle, bundleGraph) {
   : `require('./helpers/bundle-url').getBundleURL('${entryBundle.publicId}')`;
   return `require('./helpers/bundle-manifest').register(${baseUrl},JSON.parse(${JSON.stringify(JSON.stringify(mappings))}));`;
 }
-function getRelativePathExpr(from, to, options) {
+function getRelativePathExpr(from, to, options, isURL = to.type !== 'js') {
   let relativePath = (0, _utils().relativeBundlePath)(from, to, {
     leadingDotSlash: false
   });
   let res = JSON.stringify(relativePath);
-  if (options.hmrOptions) {
-    res += ' + "?" + Date.now()';
+  if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+    if (isURL && options.hmrOptions) {
+      res += ' + "?" + Date.now()';
+    }
+  } else {
+    if (options.hmrOptions) {
+      res += ' + "?" + Date.now()';
+    }
   }
   return res;
 }
@@ -648,7 +1023,7 @@ function getAbsoluteUrlExpr(relativePathExpr, fromBundle, shardingConfig) {
 }
 function shouldUseRuntimeManifest(bundle, options) {
   let env = bundle.env;
-  return !env.isLibrary && bundle.bundleBehavior !== 'inline' && env.isBrowser() && options.mode === 'production';
+  return !env.isLibrary && bundle.bundleBehavior !== 'inline' && bundle.bundleBehavior !== 'inlineIsolated' && env.isBrowser() && options.mode === 'production';
 }
 function getManifestBundlePriority(bundleGraph, bundle, threshold) {
   let bundleSize = 0;

package/lib/helpers/browser/analytics/analytics.d.js

@@ -0,0 +1 @@
+"use strict";