@@ -9,7 +9,7 @@ use crate::{
   dependencies::{is_func_iri_attr, parse_xml_stylesheet, serialize_xml_stylesheet},
   srcset::{parse_srcset, serialize_srcset},
 };
-use html5ever::{ExpandedName, expanded_name, local_name, namespace_url, ns};
+use html5ever::{ExpandedName, expanded_name, local_name, namespace_url, ns, tendril::StrTendril};
 use serde::Deserialize;
 use typed_arena::Arena;
 
@@ -143,6 +143,37 @@ pub struct InlineBundle {
   pub module: bool,
 }
 
+/// Escapes JavaScript for an HTML `<script>` element, whose content is raw text that a `</script`
+/// ends, and in which `<!--` can start a comment-like state that hides a following `</script>`.
+/// Replacing `</script` with `</\script` and `<!--` with `<\!--` keeps string and template literals
+/// equal, since `\s` and `\!` are identity escapes there, while `<\/script` could change a regular
+/// expression such as `0</script/`.
+fn escape_inline_script(code: &StrTendril) -> StrTendril {
+  const CLOSE_TAG: &str = "</script";
+  let mut escaped = String::with_capacity(code.len() + 8);
+  let mut rest: &str = code;
+  while let Some(index) = rest.find('<') {
+    escaped.push_str(&rest[..index]);
+    rest = &rest[index..];
+    if rest.starts_with("<!--") {
+      escaped.push_str("<\\!--");
+      rest = &rest[4..];
+    } else if rest
+      .get(..CLOSE_TAG.len())
+      .is_some_and(|tag| tag.eq_ignore_ascii_case(CLOSE_TAG))
+    {
+      escaped.push_str("</\\");
+      escaped.push_str(&rest[2..CLOSE_TAG.len()]);
+      rest = &rest[CLOSE_TAG.len()..];
+    } else {
+      escaped.push('<');
+      rest = &rest[1..];
+    }
+  }
+  escaped.push_str(rest);
+  escaped.into()
+}
+
 pub fn insert_bundle_references<'arena>(
   arena: &'arena Arena<Node<'arena>>,
   dom: &'arena Node<'arena>,
@@ -211,7 +242,12 @@ pub fn insert_bundle_references<'arena>(
           if let Some(key) = node.get_attribute(data_parcel_key.clone()) {
             if let Some(bundle) = inline_bundles.get(&SerializableTendril(key)) {
               node.remove_attribute(data_parcel_key.clone());
-              node.set_text_content(arena, bundle.contents.0.clone());
+              let contents = if name.ns == ns!(html) {
+                escape_inline_script(&bundle.contents.0)
+              } else {
+                bundle.contents.0.clone()
+              };
+              node.set_text_content(arena, contents);
               if bundle.module {
                 node.set_attribute(expanded_name!("", "type"), "module");
               }
@@ -392,6 +428,15 @@ mod tests {
     ]
   }
 
+  #[test]
+  fn inline_scripts_escape_closing_tags_and_comments() {
+    let code: StrTendril = r#"a='</script>';b='</SCRIPT >';c='<!-- x';d=1<2;e='<scripts>'"#.into();
+    assert_eq!(
+      &*escape_inline_script(&code),
+      r#"a='</\script>';b='</\SCRIPT >';c='<\!-- x';d=1<2;e='<scripts>'"#
+    );
+  }
+
   #[test]
   fn positional_scripts_and_stylesheets_keep_order_and_deduplicate_per_page() {
     let result = package_html(PackageOptions {
 
@@ -30,11 +30,6 @@ pub(crate) fn bundle_dependencies(bundle_graph: &BundleGraph, bundle: &Bundle) -
     return bundle_graph.bundle_dependency_targets(bundle).collect();
   }
 
-  if bundle.target.source_type == SourceType::Script {
-    // Classic scripts are emitted as is, without resolving dependencies.
-    return Vec::new();
-  }
-
   let mut dependencies = Vec::new();
 
   // A root's runtime maps the stable keys of everything its context loads to final names.
 
@@ -2,7 +2,12 @@ use std::{fmt::Write, sync::Arc};
 
 use indexmap::{IndexMap, IndexSet};
 use parcel_core::*;
-use parcel_js_swc_core::{Ast, async_module::wrap_async_module, tree_shake::tree_shake};
+use parcel_js_swc_core::{
+  Ast,
+  async_module::wrap_async_module,
+  script::{link_script, minify_script},
+  tree_shake::tree_shake,
+};
 use swc_core::{
   common::{DUMMY_SP, SyntaxContext},
   ecma::ast::{
@@ -67,51 +72,27 @@ impl JsContent {
     const RUNTIME: &str = include_str!(concat!(env!("OUT_DIR"), "/runtime.min.js"));
     const DEV_RUNTIME: &str = include_str!("../dev-runtime.js");
 
-    if bundle.target.source_type == SourceType::Script {
-      assert_eq!(bundle.assets.len(), 1);
-      let asset = &bundle_graph
-        .asset_graph
-        .asset(bundle.main_entry_asset.unwrap());
-      if let Some(content) = asset.content.downcast_ref::<JsContent>() {
-        let should_optimize = bundle
-          .target
-          .flags
-          .contains(EnvironmentFlags::SHOULD_OPTIMIZE);
-        let mut ast = content.ast.clone();
-        insert_node_replacements(&mut ast, content, asset, bundle, should_optimize);
-        insert_node_replacement_helpers(
-          &mut ast,
-          content,
-          bundle.target.output_format,
-          should_optimize,
-        );
-        let (code, map) = content.to_code(
-          &ast,
-          bundle.target.source_map.is_some(),
-          bundle_source_root(bundle, &options.project_root).as_deref(),
-          false,
-        )?;
-        if let Some(map) = map {
-          return Ok(Arc::new(ContentWithSourceMap::new(code, map.into_bytes())));
-        }
-
-        return Ok(Arc::new(BufferContent::new(code)));
-      }
-
-      return Ok(asset.content.clone());
-    }
-
     let should_build_source_map = bundle.target.source_map.is_some();
     let should_optimize = bundle
       .target
       .flags
       .contains(EnvironmentFlags::SHOULD_OPTIMIZE);
 
+    // A classic script's only asset runs unwrapped, so its top-level declarations are globals (see
+    // `package_script`). What its dependencies resolve to goes in the module table before it.
+    let script = if bundle.target.source_type == SourceType::Script {
+      assert_eq!(bundle.assets.len(), 1);
+      Some(bundle.assets[0])
+    } else {
+      None
+    };
+
     // Resolve dependencies before writing the bundle preamble. Some dependency
     // resolutions, such as synchronous bundles in ESM output, must be emitted
     // as top-level imports before the module table.
     let mut synthetic_assets = IndexSet::new();
     let mut asset_plans = Vec::with_capacity(bundle.assets.len());
+    let mut script_dependencies = IndexMap::new();
     for asset_index in &bundle.assets {
       let asset = &bundle_graph.asset_graph.asset(*asset_index);
       let dependencies = asset_dependencies(
@@ -123,9 +104,32 @@ impl JsContent {
         get_inline_bundle_content,
         &options.project_root,
       )?;
-      asset_plans.push((*asset_index, dependencies));
+      if script == Some(*asset_index) {
+        script_dependencies = dependencies;
+      } else {
+        asset_plans.push((*asset_index, dependencies));
+      }
     }
 
+    let script = match script {
+      Some(asset_index) => {
+        let asset = bundle_graph.asset_graph.asset(asset_index);
+        let Some(content) = asset.content.downcast_ref::<JsContent>() else {
+          return Ok(asset.content.clone());
+        };
+        let script = package_script(content, asset, bundle, script_dependencies, options)?;
+        // Without a module table, the script is the whole bundle.
+        if synthetic_assets.is_empty() {
+          return Ok(match script.1 {
+            Some(map) => Arc::new(ContentWithSourceMap::new(script.0, map.into_bytes())),
+            None => Arc::new(BufferContent::new(script.0)),
+          });
+        }
+        Some(script)
+      }
+      None => None,
+    };
+
     // Async modules are entered through the runtime's module evaluator, and async entries evaluated
     // by it (see `tla-runtime.js`).
     if bundle
@@ -160,7 +164,10 @@ impl JsContent {
       }
     }
 
-    write_node_replacement_helpers(&mut printer, bundle_graph, bundle, options)?;
+    // A script declares its own (see `package_script`).
+    if script.is_none() {
+      write_node_replacement_helpers(&mut printer, bundle_graph, bundle, options)?;
+    }
     let externals = write_external_imports(&mut printer, bundle_graph, bundle)?;
     let sync_bundles =
       write_sync_bundle_imports(&mut printer, bundle_graph, bundle, &synthetic_assets)?;
@@ -263,10 +270,50 @@ impl JsContent {
     if is_global {
       printer.write_str("\n})();")?;
     }
+    if let Some((code, map)) = script {
+      printer.newline()?;
+      printer.add_source_map(map)?;
+      printer.write_str(std::str::from_utf8(&code).unwrap())?;
+    }
     printer.into_content()
   }
 }
 
+/// Generates a classic script, linking its dependencies through the global require of the module
+/// table before it, and minified without renaming its top-level declarations, which are globals.
+fn package_script(
+  content: &JsContent,
+  asset: &Asset,
+  bundle: &Bundle,
+  dependencies: IndexMap<String, Resolution<'_>>,
+  options: &ParcelOptions,
+) -> Result<(Vec<u8>, Option<String>), DiagnosticList> {
+  let should_optimize = bundle
+    .target
+    .flags
+    .contains(EnvironmentFlags::SHOULD_OPTIMIZE);
+  let mut ast = content.ast.clone();
+  insert_node_replacements(&mut ast, content, asset, bundle, should_optimize);
+  insert_node_replacement_helpers(
+    &mut ast,
+    content,
+    bundle.target.output_format,
+    should_optimize,
+  );
+  if !dependencies.is_empty() {
+    link_script(&mut ast, dependencies, "parcelRequire".into());
+  }
+  if should_optimize {
+    minify_script(&mut ast);
+  }
+  content.to_code(
+    &ast,
+    bundle.target.source_map.is_some(),
+    bundle_source_root(bundle, &options.project_root).as_deref(),
+    should_optimize,
+  )
+}
+
 fn sync_bundle_binding(bundle: &Bundle) -> String {
   format!("__parcelSyncBundle{:x}", bundle.id)
 }
@@ -837,7 +884,9 @@ fn write_runtime_globals(
   if let Some(entry) = rsc_server_entry {
     write!(printer, "'{}',", entry)?;
   }
-  for entry in &bundle.entry_assets {
+  // A classic script's entry runs after the module table rather than from it.
+  let is_script = bundle.target.source_type == SourceType::Script;
+  for entry in bundle.entry_assets.iter().filter(|_| !is_script) {
     write!(
       printer,
       "'{}',",
@@ -867,7 +916,7 @@ fn write_runtime_globals(
   if let Some(main) = bundle
     .main_entry_asset
     .as_ref()
-    .filter(|_| !bundle.entry_assets.is_empty())
+    .filter(|_| !bundle.entry_assets.is_empty() && !is_script)
   {
     printer.write_var(
       runtime_main_entry,
 
@@ -1,5 +1,5 @@
 <!doctype html>
 <script type="module">
   import {a, b, c} from './script.js';
-  output({a, b, c});
+  output = {a, b, c};
 </script>
@@ -0,0 +1 @@
+export default 'async ' + globalVar;
@@ -0,0 +1,14 @@
+<!doctype html>
+<html>
+  <body>
+    <script>
+      var globalVar = 'global';
+      import('./async.js').then(function (m) {
+        output = m.default;
+      });
+    </script>
+    <script>
+      sideEffect(typeof globalVar);
+    </script>
+  </body>
+</html>
@@ -0,0 +1,29 @@
+[
+  {
+    "description": "should load dynamic imports from inline classic scripts",
+    "input": "index.html",
+    "skipNodeModules": true,
+    "bundles": [
+      {"type": "html", "assets": ["index.html"]},
+      {"type": "js", "assets": ["index.html"]},
+      {"type": "js", "assets": ["index.html"]},
+      {"type": "js", "assets": ["async.js"]}
+    ],
+    "output": "async global",
+    "sideEffects": ["string"]
+  },
+  {
+    "description": "should load dynamic imports from inline classic scripts in production",
+    "input": "index.html",
+    "options": {"mode": "production"},
+    "skipNodeModules": true,
+    "bundles": [
+      {"type": "html", "assets": ["index.html"]},
+      {"type": "js", "assets": ["index.html"]},
+      {"type": "js", "assets": ["index.html"]},
+      {"type": "js", "assets": ["async.js"]}
+    ],
+    "output": "async global",
+    "sideEffects": ["string"]
+  }
+]
@@ -0,0 +1 @@
+export default 'async ' + globalVar;
@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+  <body>
+    <script src="index.js"></script>
+    <script>
+      sideEffect(typeof globalVar);
+    </script>
+  </body>
+</html>
@@ -0,0 +1,7 @@
+var globalVar = 'global';
+function load() {
+  return import('./async.js');
+}
+load().then(function (m) {
+  output = m.default;
+});