diff --git a/maldoca/js/ast/transforms/extract_prelude/pass_test.cc b/maldoca/js/ast/transforms/extract_prelude/pass_test.cc
index eb89fcb..a8f9875 100644
--- a/maldoca/js/ast/transforms/extract_prelude/pass_test.cc
+++ b/maldoca/js/ast/transforms/extract_prelude/pass_test.cc
@@ -65,11 +65,13 @@ function bar() {
 
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{kSource, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(kSource, parse_request,
+      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request,
                                                     absl::InfiniteDuration(),
                                                     std::nullopt, babel));
 
@@ -77,11 +79,11 @@ function bar() {
       ExtractPreludeByIndices(kSource, indices, *repr.ast);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsSourceRepr source_repr,
-      ToJsSourceRepr::FromJsAstRepr(*repr.ast, {}, absl::InfiniteDuration(),
+      JsSourceRepr printed_source_repr,
+      ToJsSourceRepr::FromJsAstRepr(repr, {}, absl::InfiniteDuration(),
                                     babel));
 
-  EXPECT_EQ(source_repr.source, kExpectedSourceWithoutPrelude);
+  EXPECT_EQ(printed_source_repr.source, kExpectedSourceWithoutPrelude);
 
   EXPECT_EQ(prelude.prelude_source(), kExpectedPrelude);
   EXPECT_EQ(prelude.extracted_from_scope_uid(), 0);
@@ -103,11 +105,13 @@ function bar() {
 
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{kSource, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(kSource, parse_request,
+      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request,
                                                     absl::InfiniteDuration(),
                                                     std::nullopt, babel));
 
@@ -115,11 +119,11 @@ function bar() {
       ExtractPreludeByAnnotations(kSource, *repr.ast);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsSourceRepr source_repr,
-      ToJsSourceRepr::FromJsAstRepr(*repr.ast, {}, absl::InfiniteDuration(),
+      JsSourceRepr printed_source_repr,
+      ToJsSourceRepr::FromJsAstRepr(repr, {}, absl::InfiniteDuration(),
                                     babel));
 
-  EXPECT_EQ(source_repr.source, kExpectedSourceWithoutPrelude);
+  EXPECT_EQ(printed_source_repr.source, kExpectedSourceWithoutPrelude);
 
   EXPECT_EQ(prelude.prelude_source(), kExpectedPrelude);
   EXPECT_EQ(prelude.extracted_from_scope_uid(), 0);
@@ -141,11 +145,13 @@ function bar() {
 
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{kSource, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(kSource, parse_request,
+      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request,
                                                     absl::InfiniteDuration(),
                                                     std::nullopt, babel));
 
@@ -153,11 +159,11 @@ function bar() {
       ExtractPreludeByIndicesAndAnnotations(kSource, indices, *repr.ast);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsSourceRepr source_repr,
-      ToJsSourceRepr::FromJsAstRepr(*repr.ast, {}, absl::InfiniteDuration(),
+      JsSourceRepr printed_source_repr,
+      ToJsSourceRepr::FromJsAstRepr(repr, {}, absl::InfiniteDuration(),
                                     babel));
 
-  EXPECT_EQ(source_repr.source, kExpectedSourceWithoutPrelude);
+  EXPECT_EQ(printed_source_repr.source, kExpectedSourceWithoutPrelude);
 
   EXPECT_EQ(prelude.prelude_source(), kExpectedPrelude);
   EXPECT_EQ(prelude.extracted_from_scope_uid(), 0);
@@ -171,20 +177,22 @@ TEST(ExtractPreludePassTest, ReuseBabel) {
 
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{kSource, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
   // Parse the source code once so that Babel increments the scope uid counter.
   {
     MALDOCA_ASSERT_OK_AND_ASSIGN(
-        JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(kSource, parse_request,
-                                                      absl::InfiniteDuration(),
-                                                      std::nullopt, babel));
+        JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(
+                            source_repr, parse_request,
+                            absl::InfiniteDuration(), std::nullopt, babel));
   }
 
   // This time the global scope uid is not 0.
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(kSource, parse_request,
+      JsAstRepr repr, ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request,
                                                     absl::InfiniteDuration(),
                                                     std::nullopt, babel));
 
diff --git a/maldoca/js/driver/conversion.cc b/maldoca/js/driver/conversion.cc
index 166b68e..66dbab1 100644
--- a/maldoca/js/driver/conversion.cc
+++ b/maldoca/js/driver/conversion.cc
@@ -42,11 +42,13 @@ namespace maldoca {
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsAstStringRepr> ToJsAstStringRepr::FromJsSourceRepr(
-    absl::string_view source, BabelParseRequest parse_request,
+    const JsSourceRepr &source_repr, BabelParseRequest parse_request,
     absl::Duration timeout, Babel &babel) {
-  MALDOCA_ASSIGN_OR_RETURN(BabelParseResult parse_result,
-                           babel.Parse(source, parse_request, timeout));
-  return JsAstStringRepr{std::move(parse_result.ast_string)};
+  MALDOCA_ASSIGN_OR_RETURN(
+      BabelParseResult parse_result,
+      babel.Parse(source_repr.source, parse_request, timeout));
+  return JsAstStringRepr{std::move(parse_result.ast_string),
+                         source_repr.source_map};
 }
 
 // -----------------------------------------------------------------------------
@@ -54,12 +56,13 @@ absl::StatusOr<JsAstStringRepr> ToJsAstStringRepr::FromJsSourceRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsAstRepr> ToJsAstRepr::FromJsAstStringRepr(
-    const BabelAstString &ast_string,
+    const JsAstStringRepr &ast_string_repr,
     std::optional<int> recursion_depth_limit) {
-  MALDOCA_ASSIGN_OR_RETURN(
-      std::unique_ptr<JsFile> ast,
-      GetFileAstFromAstString(ast_string, recursion_depth_limit));
-  return JsAstRepr{std::move(ast), ast_string.scopes()};
+  MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr<JsFile> ast,
+                           GetFileAstFromAstString(ast_string_repr.ast_string,
+                                                   recursion_depth_limit));
+  return JsAstRepr{std::move(ast), ast_string_repr.ast_string.scopes(),
+                   ast_string_repr.source_map};
 }
 
 // -----------------------------------------------------------------------------
@@ -67,11 +70,11 @@ absl::StatusOr<JsAstRepr> ToJsAstRepr::FromJsAstStringRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsHirRepr> ToJsHirRepr::FromJsAstRepr(
-    const JsFile &ast, const BabelScopes &scopes,
+    const JsAstRepr &ast_repr,
     mlir::MLIRContext &mlir_context) {
   MALDOCA_ASSIGN_OR_RETURN(mlir::OwningOpRef<JsirFileOp> op,
-                   AstToJshirFile(ast, mlir_context));
-  return JsHirRepr{std::move(op), scopes};
+                   AstToJshirFile(*ast_repr.ast, mlir_context));
+  return JsHirRepr{std::move(op), ast_repr.scopes, ast_repr.source_map};
 }
 
 // -----------------------------------------------------------------------------
@@ -79,14 +82,14 @@ absl::StatusOr<JsHirRepr> ToJsHirRepr::FromJsAstRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsAstRepr> ToJsAstRepr::FromJsSourceRepr(
-    absl::string_view source, BabelParseRequest parse_request,
+    const JsSourceRepr &source_repr, BabelParseRequest parse_request,
     absl::Duration timeout, std::optional<int> recursion_depth_limit,
     Babel &babel) {
-  MALDOCA_ASSIGN_OR_RETURN(JsAstStringRepr ast_string,
-                           ToJsAstStringRepr::FromJsSourceRepr(
-                               source, parse_request, timeout, babel));
-  return ToJsAstRepr::FromJsAstStringRepr(ast_string.ast_string,
-                                          recursion_depth_limit);
+  MALDOCA_ASSIGN_OR_RETURN(
+      JsAstStringRepr ast_string,
+      ToJsAstStringRepr::FromJsSourceRepr(source_repr,
+                                          parse_request, timeout, babel));
+  return ToJsAstRepr::FromJsAstStringRepr(ast_string, recursion_depth_limit);
 }
 
 // -----------------------------------------------------------------------------
@@ -94,13 +97,14 @@ absl::StatusOr<JsAstRepr> ToJsAstRepr::FromJsSourceRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsHirRepr> ToJsHirRepr::FromJsSourceRepr(
-    absl::string_view source, BabelParseRequest parse_request,
+    const JsSourceRepr &source_repr, BabelParseRequest parse_request,
     absl::Duration timeout, std::optional<int> recursion_depth_limit,
     Babel &babel, mlir::MLIRContext &mlir_context) {
-  MALDOCA_ASSIGN_OR_RETURN(JsAstRepr ast, ToJsAstRepr::FromJsSourceRepr(
-                                              source, parse_request, timeout,
-                                              recursion_depth_limit, babel));
-  return ToJsHirRepr::FromJsAstRepr(*ast.ast, ast.scopes, mlir_context);
+  MALDOCA_ASSIGN_OR_RETURN(
+      JsAstRepr ast,
+      ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request, timeout,
+                                    recursion_depth_limit, babel));
+  return ToJsHirRepr::FromJsAstRepr(ast, mlir_context);
 }
 
 // -----------------------------------------------------------------------------
@@ -108,12 +112,13 @@ absl::StatusOr<JsHirRepr> ToJsHirRepr::FromJsSourceRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsHirRepr> ToJsHirRepr::FromJsAstStringRepr(
-    const BabelAstString &ast_string, std::optional<int> recursion_depth_limit,
+    const JsAstStringRepr &ast_string_repr,
+    std::optional<int> recursion_depth_limit,
     mlir::MLIRContext &mlir_context) {
   MALDOCA_ASSIGN_OR_RETURN(
       JsAstRepr ast,
-      ToJsAstRepr::FromJsAstStringRepr(ast_string, recursion_depth_limit));
-  return ToJsHirRepr::FromJsAstRepr(*ast.ast, ast.scopes, mlir_context);
+      ToJsAstRepr::FromJsAstStringRepr(ast_string_repr, recursion_depth_limit));
+  return ToJsHirRepr::FromJsAstRepr(ast, mlir_context);
 }
 
 // =============================================================================
@@ -128,7 +133,7 @@ absl::StatusOr<JsAstRepr> ToJsAstRepr::FromJsHirRepr(
     const JsHirRepr &hir_repr) {
   MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr<JsFile> ast,
                            JshirFileToAst(hir_repr.op.get()));
-  return JsAstRepr{std::move(ast), hir_repr.scopes};
+  return JsAstRepr{std::move(ast), hir_repr.scopes, hir_repr.source_map};
 }
 
 // -----------------------------------------------------------------------------
@@ -136,10 +141,10 @@ absl::StatusOr<JsAstRepr> ToJsAstRepr::FromJsHirRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsAstStringRepr> ToJsAstStringRepr::FromJsAstRepr(
-    const JsFile &ast, const BabelScopes &scopes) {
-  BabelAstString ast_string = GetAstStringFromFileAst(ast);
-  *ast_string.mutable_scopes() = scopes;
-  return JsAstStringRepr{std::move(ast_string)};
+    const JsAstRepr &ast_repr) {
+  BabelAstString ast_string = GetAstStringFromFileAst(*ast_repr.ast);
+  *ast_string.mutable_scopes() = ast_repr.scopes;
+  return JsAstStringRepr{std::move(ast_string), ast_repr.source_map};
 }
 
 // -----------------------------------------------------------------------------
@@ -147,12 +152,14 @@ absl::StatusOr<JsAstStringRepr> ToJsAstStringRepr::FromJsAstRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsSourceRepr> ToJsSourceRepr::FromJsAstStringRepr(
-    const BabelAstString &ast_string, BabelGenerateOptions generate_options,
-    absl::Duration timeout, Babel &babel) {
+    const JsAstStringRepr &ast_string_repr,
+    BabelGenerateOptions generate_options, absl::Duration timeout,
+    Babel &babel) {
   MALDOCA_ASSIGN_OR_RETURN(
       BabelGenerateResult generate_result,
-      babel.Generate(ast_string, generate_options, timeout));
-  return JsSourceRepr{std::move(generate_result.source_code)};
+      babel.Generate(ast_string_repr.ast_string, generate_options, timeout));
+  return JsSourceRepr{std::move(generate_result.source_code),
+                      generate_result.source_map};
 }
 
 // -----------------------------------------------------------------------------
@@ -162,7 +169,7 @@ absl::StatusOr<JsSourceRepr> ToJsSourceRepr::FromJsAstStringRepr(
 absl::StatusOr<JsAstStringRepr> ToJsAstStringRepr::FromJsHirRepr(
     const JsHirRepr &hir_repr) {
   MALDOCA_ASSIGN_OR_RETURN(JsAstRepr ast, ToJsAstRepr::FromJsHirRepr(hir_repr));
-  return ToJsAstStringRepr::FromJsAstRepr(*ast.ast, ast.scopes);
+  return ToJsAstStringRepr::FromJsAstRepr(ast);
 }
 
 // -----------------------------------------------------------------------------
@@ -174,7 +181,7 @@ absl::StatusOr<JsSourceRepr> ToJsSourceRepr::FromJsHirRepr(
     absl::Duration timeout, Babel &babel) {
   MALDOCA_ASSIGN_OR_RETURN(JsAstStringRepr ast_string,
                    ToJsAstStringRepr::FromJsHirRepr(hir_repr));
-  return ToJsSourceRepr::FromJsAstStringRepr(ast_string.ast_string,
+  return ToJsSourceRepr::FromJsAstStringRepr(ast_string,
                                              generate_options, timeout, babel);
 }
 
@@ -183,12 +190,11 @@ absl::StatusOr<JsSourceRepr> ToJsSourceRepr::FromJsHirRepr(
 // -----------------------------------------------------------------------------
 
 absl::StatusOr<JsSourceRepr> ToJsSourceRepr::FromJsAstRepr(
-    const JsFile &ast, BabelGenerateOptions generate_options,
+    const JsAstRepr &ast_repr, BabelGenerateOptions generate_options,
     absl::Duration timeout, Babel &babel) {
-  BabelScopes dummy_scopes;
   MALDOCA_ASSIGN_OR_RETURN(JsAstStringRepr ast_string,
-                   ToJsAstStringRepr::FromJsAstRepr(ast, dummy_scopes));
-  return ToJsSourceRepr::FromJsAstStringRepr(ast_string.ast_string,
+                   ToJsAstStringRepr::FromJsAstRepr(ast_repr));
+  return ToJsSourceRepr::FromJsAstStringRepr(ast_string,
                                              generate_options, timeout, babel);
 }
 
diff --git a/maldoca/js/driver/conversion.h b/maldoca/js/driver/conversion.h
index b037794..b130121 100644
--- a/maldoca/js/driver/conversion.h
+++ b/maldoca/js/driver/conversion.h
@@ -40,11 +40,12 @@ namespace maldoca {
 
 struct ToJsSourceRepr {
   static absl::StatusOr<JsSourceRepr> FromJsAstStringRepr(
-      const BabelAstString &ast_string, BabelGenerateOptions generate_options,
-      absl::Duration timeout, Babel &babel);
+      const JsAstStringRepr &ast_string_repr,
+      BabelGenerateOptions generate_options, absl::Duration timeout,
+      Babel &babel);
 
   static absl::StatusOr<JsSourceRepr> FromJsAstRepr(
-      const JsFile &ast, BabelGenerateOptions generate_options,
+      const JsAstRepr &ast_repr, BabelGenerateOptions generate_options,
       absl::Duration timeout, Babel &babel);
 
   static absl::StatusOr<JsSourceRepr> FromJsHirRepr(
@@ -54,11 +55,11 @@ struct ToJsSourceRepr {
 
 struct ToJsAstStringRepr {
   static absl::StatusOr<JsAstStringRepr> FromJsSourceRepr(
-      absl::string_view source, BabelParseRequest parse_request,
+      const JsSourceRepr &source_repr, BabelParseRequest parse_request,
       absl::Duration timeout, Babel &babel);
 
   static absl::StatusOr<JsAstStringRepr> FromJsAstRepr(
-      const JsFile &ast, const BabelScopes &scopes);
+      const JsAstRepr &ast_repr);
 
   static absl::StatusOr<JsAstStringRepr> FromJsHirRepr(
       const JsHirRepr &hir_repr);
@@ -66,12 +67,12 @@ struct ToJsAstStringRepr {
 
 struct ToJsAstRepr {
   static absl::StatusOr<JsAstRepr> FromJsSourceRepr(
-      absl::string_view source, BabelParseRequest parse_request,
+      const JsSourceRepr &source_repr, BabelParseRequest parse_request,
       absl::Duration timeout, std::optional<int> recursion_depth_limit,
       Babel &babel);
 
   static absl::StatusOr<JsAstRepr> FromJsAstStringRepr(
-      const BabelAstString &ast_string,
+      const JsAstStringRepr &ast_string_repr,
       std::optional<int> recursion_depth_limit);
 
   static absl::StatusOr<JsAstRepr> FromJsHirRepr(const JsHirRepr &hir_repr);
@@ -79,17 +80,17 @@ struct ToJsAstRepr {
 
 struct ToJsHirRepr {
   static absl::StatusOr<JsHirRepr> FromJsSourceRepr(
-      absl::string_view source, BabelParseRequest parse_request,
+      const JsSourceRepr &source_repr, BabelParseRequest parse_request,
       absl::Duration timeout, std::optional<int> recursion_depth_limit,
       Babel &babel, mlir::MLIRContext &mlir_context);
 
   static absl::StatusOr<JsHirRepr> FromJsAstStringRepr(
-      const BabelAstString &ast_string,
+      const JsAstStringRepr &ast_string_repr,
       std::optional<int> recursion_depth_limit,
       mlir::MLIRContext &mlir_context);
 
   static absl::StatusOr<JsHirRepr> FromJsAstRepr(
-      const maldoca::JsFile &ast, const BabelScopes &scopes,
+      const JsAstRepr &ast_repr,
       mlir::MLIRContext &mlir_context);
 };
 
diff --git a/maldoca/js/driver/conversion_test.cc b/maldoca/js/driver/conversion_test.cc
index f02bbc5..b18584b 100644
--- a/maldoca/js/driver/conversion_test.cc
+++ b/maldoca/js/driver/conversion_test.cc
@@ -56,7 +56,7 @@ struct TestCase {
 
   // Expected AST
   nlohmann::ordered_json serialized_ast_json;
-  std::unique_ptr<JsFile> ast;
+  JsAstRepr ast;
 
   std::unique_ptr<mlir::MLIRContext> mlir_context;
 
@@ -115,13 +115,14 @@ absl::StatusOr<TestCase> GetTestCase() {
       nlohmann::ordered_json::parse(serialized_ast_json_str);
 
   MALDOCA_ASSIGN_OR_RETURN(auto ast, JsFile::FromJson(serialized_ast_json));
+  JsAstRepr ast_repr{std::move(ast), scopes, std::nullopt};
 
   auto mlir_context = std::make_unique<mlir::MLIRContext>();
   LoadNecessaryDialects(*mlir_context);
 
   MALDOCA_ASSIGN_OR_RETURN(
       JsHirRepr hir_repr,
-      ToJsHirRepr::FromJsAstRepr(*ast, scopes, *mlir_context));
+      ToJsHirRepr::FromJsAstRepr(ast_repr, *mlir_context));
   MALDOCA_ASSIGN_OR_RETURN(auto hir_str, load_content("test_hir.mlir.test"));
 
   BabelAstString lifted_babel_ast_string;
@@ -137,7 +138,7 @@ absl::StatusOr<TestCase> GetTestCase() {
       .parsed_babel_ast_string = babel_ast_string,
 
       .serialized_ast_json = serialized_ast_json,
-      .ast = std::move(ast),
+      .ast = std::move(ast_repr),
 
       .mlir_context = std::move(mlir_context),
 
@@ -156,13 +157,16 @@ TEST(ConversionTest, SourceToAstString) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase());
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{test_case.source, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsAstStringRepr repr,
-      ToJsAstStringRepr::FromJsSourceRepr(test_case.source, parse_request,
-                                          absl::InfiniteDuration(), babel));
+      ToJsAstStringRepr::FromJsSourceRepr(
+          source_repr, parse_request,
+          absl::InfiniteDuration(), babel));
 
   EXPECT_THAT(repr.ast_string, EqualsProto(test_case.parsed_babel_ast_string));
 }
@@ -170,9 +174,12 @@ TEST(ConversionTest, SourceToAstString) {
 TEST(ConversionTest, AstStringToAst) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase());
 
+  JsAstStringRepr ast_string_repr{test_case.parsed_babel_ast_string,
+                                  std::nullopt};
+
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsAstRepr repr,
-      ToJsAstRepr::FromJsAstStringRepr(test_case.parsed_babel_ast_string,
+      ToJsAstRepr::FromJsAstStringRepr(ast_string_repr,
                                        /*recursion_depth_limit=*/std::nullopt));
 
   CheckAst(repr, test_case);
@@ -185,8 +192,7 @@ TEST(ConversionTest, AstToHir) {
   LoadNecessaryDialects(mlir_context);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsHirRepr repr, ToJsHirRepr::FromJsAstRepr(
-                          *test_case.ast, test_case.scopes, mlir_context));
+      JsHirRepr repr, ToJsHirRepr::FromJsAstRepr(test_case.ast, mlir_context));
 
   EXPECT_EQ(mlir::debugString(*repr.op), test_case.hir_dump);
   EXPECT_THAT(repr.scopes, EqualsProto(test_case.scopes));
@@ -196,13 +202,15 @@ TEST(ConversionTest, SourceToAst) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase());
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{test_case.source, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsAstRepr repr,
       ToJsAstRepr::FromJsSourceRepr(
-          test_case.source, parse_request, absl::InfiniteDuration(),
+          source_repr, parse_request, absl::InfiniteDuration(),
           /*recursion_depth_limit=*/std::nullopt, babel));
 
   CheckAst(repr, test_case);
@@ -212,6 +220,8 @@ TEST(ConversionTest, SourceToHir) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase());
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{test_case.source, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
@@ -221,7 +231,7 @@ TEST(ConversionTest, SourceToHir) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsHirRepr repr,
       ToJsHirRepr::FromJsSourceRepr(
-          test_case.source, parse_request, absl::InfiniteDuration(),
+          source_repr, parse_request, absl::InfiniteDuration(),
           /*recursion_depth_limit=*/std::nullopt, babel, mlir_context));
 
   EXPECT_EQ(mlir::debugString(*repr.op), test_case.hir_dump);
@@ -231,12 +241,15 @@ TEST(ConversionTest, SourceToHir) {
 TEST(ConversionTest, AstStringToHir) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase());
 
+  JsAstStringRepr ast_string_repr{test_case.parsed_babel_ast_string,
+                                  std::nullopt};
+
   mlir::MLIRContext mlir_context;
   LoadNecessaryDialects(mlir_context);
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsHirRepr repr,
-      ToJsHirRepr::FromJsAstStringRepr(test_case.parsed_babel_ast_string,
+      ToJsHirRepr::FromJsAstStringRepr(ast_string_repr,
                                        /*recursion_depth_limit=*/std::nullopt,
                                        mlir_context));
 
@@ -262,7 +275,7 @@ TEST(ConversionTest, AstToAstString) {
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsAstStringRepr repr,
-      ToJsAstStringRepr::FromJsAstRepr(*test_case.ast, test_case.scopes));
+      ToJsAstStringRepr::FromJsAstRepr(test_case.ast));
 
   EXPECT_THAT(repr.ast_string, EqualsProto(test_case.lifted_babel_ast_string));
 }
@@ -272,11 +285,14 @@ TEST(ConversionTest, AstStringToSource) {
 
   QuickJsBabel babel;
 
+  JsAstStringRepr ast_string_repr{test_case.lifted_babel_ast_string,
+                                  std::nullopt};
+
   BabelGenerateOptions generate_options;
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsSourceRepr repr,
-      ToJsSourceRepr::FromJsAstStringRepr(test_case.lifted_babel_ast_string,
+      ToJsSourceRepr::FromJsAstStringRepr(ast_string_repr,
                                           generate_options,
                                           absl::InfiniteDuration(), babel));
 
@@ -312,7 +328,7 @@ TEST(ConversionTest, AstToSource) {
 
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsSourceRepr repr,
-      ToJsSourceRepr::FromJsAstRepr(*test_case.ast, BabelGenerateOptions(),
+      ToJsSourceRepr::FromJsAstRepr(test_case.ast, BabelGenerateOptions(),
                                     absl::InfiniteDuration(), babel));
   EXPECT_EQ(repr.source, test_case.source);
 }
diff --git a/maldoca/js/driver/driver.cc b/maldoca/js/driver/driver.cc
index 5e981c9..c310017 100644
--- a/maldoca/js/driver/driver.cc
+++ b/maldoca/js/driver/driver.cc
@@ -15,6 +15,7 @@
 #include "maldoca/js/driver/driver.h"
 
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <utility>
@@ -56,13 +57,20 @@ std::ostream &operator<<(std::ostream &os, JsReprKind kind) {
 
 absl::StatusOr<std::unique_ptr<JsRepr>> JsRepr::FromProto(
     const JsReprPb &proto) {
+  std::optional<std::string> source_map;
+  if (proto.has_source_map()) {
+    source_map = proto.source_map();
+  }
+
   switch (proto.kind_case()) {
     case JsReprPb::KIND_NOT_SET:
       return absl::InvalidArgumentError("JsReprPb kind not set");
     case JsReprPb::kJsSource:
-      return std::make_unique<JsSourceRepr>(proto.js_source());
+      return std::make_unique<JsSourceRepr>(proto.js_source(),
+                                            std::move(source_map));
     case JsReprPb::kBabelAstString:
-      return std::make_unique<JsAstStringRepr>(proto.babel_ast_string());
+      return std::make_unique<JsAstStringRepr>(proto.babel_ast_string(),
+                                               std::move(source_map));
     case JsReprPb::kJsHir:
       return absl::UnimplementedError("JSIR parsing not supported");
   }
@@ -71,18 +79,27 @@ absl::StatusOr<std::unique_ptr<JsRepr>> JsRepr::FromProto(
 absl::StatusOr<JsReprPb> JsSourceRepr::ToProto() const {
   JsReprPb proto;
   proto.set_js_source(source);
+  if (source_map.has_value()) {
+    proto.set_source_map(*source_map);
+  }
   return proto;
 }
 
 absl::StatusOr<JsReprPb> JsAstStringRepr::ToProto() const {
   JsReprPb proto;
   *proto.mutable_babel_ast_string() = ast_string;
+  if (source_map.has_value()) {
+    proto.set_source_map(*source_map);
+  }
   return proto;
 }
 
 absl::StatusOr<JsReprPb> JsHirRepr::ToProto() const {
   JsReprPb proto;
   proto.set_js_hir(mlir::debugString(*op));
+  if (source_map.has_value()) {
+    proto.set_source_map(*source_map);
+  }
   return proto;
 }
 
diff --git a/maldoca/js/driver/driver.h b/maldoca/js/driver/driver.h
index a8ba404..dcb5ea5 100644
--- a/maldoca/js/driver/driver.h
+++ b/maldoca/js/driver/driver.h
@@ -66,6 +66,7 @@ std::ostream& operator<<(std::ostream& os, JsReprKind kind);
 
 struct JsRepr {
   const JsReprKind kind;
+  std::optional<std::string> source_map;
 
   virtual ~JsRepr() = default;
 
@@ -114,14 +115,15 @@ struct JsRepr {
   }
 
  protected:
-  explicit JsRepr(JsReprKind kind) : kind(kind) {}
+  JsRepr(JsReprKind kind, std::optional<std::string> source_map)
+      : kind(kind), source_map(std::move(source_map)) {}
 };
 
 struct JsSourceRepr : JsRepr {
   std::string source;
 
-  explicit JsSourceRepr(absl::string_view source)
-      : JsRepr(JsReprKind::kJsSource), source(source) {}
+  JsSourceRepr(absl::string_view source, std::optional<std::string> source_map)
+      : JsRepr(JsReprKind::kJsSource, std::move(source_map)), source(source) {}
 
   static bool classof(const JsRepr* repr) {
     return repr->kind == JsReprKind::kJsSource;
@@ -135,8 +137,10 @@ struct JsSourceRepr : JsRepr {
 struct JsAstStringRepr : JsRepr {
   BabelAstString ast_string;
 
-  explicit JsAstStringRepr(BabelAstString ast_string)
-      : JsRepr(JsReprKind::kAstString), ast_string(std::move(ast_string)) {}
+  JsAstStringRepr(BabelAstString ast_string,
+                  std::optional<std::string> source_map)
+      : JsRepr(JsReprKind::kAstString, std::move(source_map)),
+        ast_string(std::move(ast_string)) {}
 
   static bool classof(const JsRepr* repr) {
     return repr->kind == JsReprKind::kAstString;
@@ -151,8 +155,9 @@ struct JsAstRepr : JsRepr {
   std::unique_ptr<maldoca::JsFile> ast;
   BabelScopes scopes;
 
-  explicit JsAstRepr(std::unique_ptr<maldoca::JsFile> ast, BabelScopes scopes)
-      : JsRepr(JsReprKind::kAst),
+  JsAstRepr(std::unique_ptr<maldoca::JsFile> ast, BabelScopes scopes,
+            std::optional<std::string> source_map)
+      : JsRepr(JsReprKind::kAst, std::move(source_map)),
         ast(std::move(ast)),
         scopes(std::move(scopes)) {}
 
@@ -180,14 +185,18 @@ struct JsirRepr : JsRepr {
   std::string Dump() const override { return mlir::debugString(*op); }
 
  protected:
-  explicit JsirRepr(JsReprKind kind, mlir::OwningOpRef<JsirFileOp> op,
-                    BabelScopes scopes)
-      : JsRepr(kind), op(std::move(op)), scopes(std::move(scopes)) {}
+  JsirRepr(JsReprKind kind, mlir::OwningOpRef<JsirFileOp> op,
+           BabelScopes scopes, std::optional<std::string> source_map)
+      : JsRepr(kind, std::move(source_map)),
+        op(std::move(op)),
+        scopes(std::move(scopes)) {}
 };
 
 struct JsHirRepr : JsirRepr {
-  explicit JsHirRepr(mlir::OwningOpRef<JsirFileOp> op, BabelScopes scopes)
-      : JsirRepr(JsReprKind::kJshir, std::move(op), std::move(scopes)) {}
+  JsHirRepr(mlir::OwningOpRef<JsirFileOp> op, BabelScopes scopes,
+            std::optional<std::string> source_map)
+      : JsirRepr(JsReprKind::kJshir, std::move(op), std::move(scopes),
+                 std::move(source_map)) {}
 
   static bool classof(const JsRepr* repr) {
     return repr->kind == JsReprKind::kJshir;
diff --git a/maldoca/js/driver/driver.proto b/maldoca/js/driver/driver.proto
index c428fdf..e128a26 100644
--- a/maldoca/js/driver/driver.proto
+++ b/maldoca/js/driver/driver.proto
@@ -33,6 +33,8 @@ message JsReprPb {
     BabelAstString babel_ast_string = 2;
     string js_hir = 3;
   }
+
+  optional string source_map = 7;
 }
 
 // =============================================================================
diff --git a/maldoca/js/driver/internal/conversions.cc b/maldoca/js/driver/internal/conversions.cc
index b47998b..dd18bb5 100644
--- a/maldoca/js/driver/internal/conversions.cc
+++ b/maldoca/js/driver/internal/conversions.cc
@@ -91,7 +91,8 @@ absl::StatusOr<std::unique_ptr<JsAstStringRepr>> JsSourceToAstString::Convert(
     const JsSourceRepr &from) {
   MALDOCA_ASSIGN_OR_RETURN(auto parse_result,
                            babel_.Parse(from.source, request_, timeout_));
-  return std::make_unique<JsAstStringRepr>(std::move(parse_result.ast_string));
+  return std::make_unique<JsAstStringRepr>(std::move(parse_result.ast_string),
+                                           from.source_map);
 }
 
 absl::StatusOr<std::unique_ptr<JsSourceToAstString>>
@@ -114,7 +115,9 @@ absl::StatusOr<std::unique_ptr<JsSourceRepr>> JsAstStringToSource::Convert(
   MALDOCA_ASSIGN_OR_RETURN(
       auto generate_result,
       babel_.Generate(from.ast_string, options_, timeout_));
-  return std::make_unique<JsSourceRepr>(std::move(generate_result.source_code));
+  return std::make_unique<JsSourceRepr>(
+      std::move(generate_result.source_code),
+      std::move(generate_result.source_map));
 }
 
 absl::StatusOr<std::unique_ptr<JsAstStringToSource>>
@@ -137,7 +140,8 @@ absl::StatusOr<std::unique_ptr<JsAstRepr>> JsAstStringToAst::Convert(
   MALDOCA_ASSIGN_OR_RETURN(
       auto ast,
       GetFileAstFromAstString(from.ast_string, recursion_depth_limit_));
-  return std::make_unique<JsAstRepr>(std::move(ast), from.ast_string.scopes());
+  return std::make_unique<JsAstRepr>(std::move(ast), from.ast_string.scopes(),
+                                     from.source_map);
 }
 
 absl::StatusOr<std::unique_ptr<JsAstStringToAst>> JsAstStringToAst::Create(
@@ -156,7 +160,8 @@ absl::StatusOr<std::unique_ptr<JsAstStringToAst>> JsAstStringToAst::Create(
 absl::StatusOr<std::unique_ptr<JsAstStringRepr>> JsAstToAstString::Convert(
     const JsAstRepr &from) {
   auto ast_string = GetAstStringFromFileAst(*from.ast);
-  return std::make_unique<JsAstStringRepr>(std::move(ast_string));
+  return std::make_unique<JsAstStringRepr>(std::move(ast_string),
+                                           from.source_map);
 }
 
 // =============================================================================
@@ -166,7 +171,8 @@ absl::StatusOr<std::unique_ptr<JsAstStringRepr>> JsAstToAstString::Convert(
 absl::StatusOr<std::unique_ptr<JsHirRepr>> JsAstToHir::Convert(
     const JsAstRepr &from) {
   MALDOCA_ASSIGN_OR_RETURN(auto op, AstToJshirFile(*from.ast, mlir_context_));
-  return std::make_unique<JsHirRepr>(std::move(op), from.scopes);
+  return std::make_unique<JsHirRepr>(std::move(op), from.scopes,
+                                     from.source_map);
 }
 
 // =============================================================================
@@ -176,7 +182,8 @@ absl::StatusOr<std::unique_ptr<JsHirRepr>> JsAstToHir::Convert(
 absl::StatusOr<std::unique_ptr<JsAstRepr>> JsHirToAst::Convert(
     const JsHirRepr &from) {
   MALDOCA_ASSIGN_OR_RETURN(auto ast, JshirFileToAst(*from.op));
-  return std::make_unique<JsAstRepr>(std::move(ast), from.scopes);
+  return std::make_unique<JsAstRepr>(std::move(ast), from.scopes,
+                                     from.source_map);
 }
 
 }  // namespace maldoca
diff --git a/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc b/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc
index 579e26e..dec74bc 100644
--- a/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc
+++ b/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc
@@ -16,12 +16,14 @@
 
 #include <iostream>
 #include <optional>
+#include <utility>
 
 #include "llvm/Support/Casting.h"
 #include "mlir/Analysis/DataFlowFramework.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/MLIRContext.h"
+#include "mlir/IR/OwningOpRef.h"
 #include "mlir/Support/LLVM.h"
 #include "gtest/gtest.h"
 #include "absl/container/flat_hash_map.h"
@@ -74,8 +76,9 @@ void RunTest(const JsirAnalysisConfig::DynamicConstantPropagation &config,
   LoadNecessaryDialects(mlir_context);
   mlir_context.loadDialect<JsirBuiltinDialect>();
 
-  MALDOCA_ASSERT_OK_AND_ASSIGN(
-      JsHirRepr repr, ToJsHirRepr::FromJsAstRepr(ast, scopes, mlir_context));
+  MALDOCA_ASSERT_OK_AND_ASSIGN(mlir::OwningOpRef<JsirFileOp> op,
+                               AstToJshirFile(ast, mlir_context));
+  JsHirRepr repr{std::move(op), scopes, std::nullopt};
 
   // Get the const bindings.
   absl::flat_hash_map<JsSymbolId, mlir::Attribute> const_bindings =
@@ -118,13 +121,17 @@ TEST(JsirDynamicConstantPropagationAnalysisTest, Basic) {
   QuickJsBabel babel;
 
   // Convert the source to AST.
+
+  JsSourceRepr source_repr{kSource, std::nullopt};
+
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
-  MALDOCA_ASSERT_OK_AND_ASSIGN(JsAstRepr ast_repr,
-                       ToJsAstRepr::FromJsSourceRepr(kSource, parse_request,
-                                                     absl::InfiniteDuration(),
-                                                     std::nullopt, babel));
+  MALDOCA_ASSERT_OK_AND_ASSIGN(
+      JsAstRepr ast_repr,
+      ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request,
+                                    absl::InfiniteDuration(), std::nullopt,
+                                    babel));
 
   // Create the dynamic prelude.
   JsirAnalysisConfig::DynamicConstantPropagation prelude_config;
@@ -141,14 +148,16 @@ TEST(JsirDynamicConstantPropagationAnalysisTest, Basic) {
 TEST(JsirDynamicConstantPropagationAnalysisTest, CombinedSource) {
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{kCombined, std::nullopt};
+
   // Convert the **combined** source to AST.
   BabelParseRequest parse_request;
   parse_request.set_compute_scopes(true);
 
-  MALDOCA_ASSERT_OK_AND_ASSIGN(JsAstRepr ast_repr,
-                       ToJsAstRepr::FromJsSourceRepr(kCombined, parse_request,
-                                                     absl::InfiniteDuration(),
-                                                     std::nullopt, babel));
+  MALDOCA_ASSERT_OK_AND_ASSIGN(
+      JsAstRepr ast_repr, ToJsAstRepr::FromJsSourceRepr(
+                              source_repr, parse_request,
+                              absl::InfiniteDuration(), std::nullopt, babel));
 
   // Extract the prelude from the AST.
   JsirAnalysisConfig::DynamicConstantPropagation prelude_config =
@@ -179,10 +188,12 @@ TEST(JsirDynamicConstantPropagationAnalysisTest, BabelReuse) {
       babel.Parse(kSource, parse_request, absl::InfiniteDuration()));
 
   // Convert the **combined** source to AST.
-  MALDOCA_ASSERT_OK_AND_ASSIGN(JsAstRepr ast_repr,
-                       ToJsAstRepr::FromJsSourceRepr(kCombined, parse_request,
-                                                     absl::InfiniteDuration(),
-                                                     std::nullopt, babel));
+  JsSourceRepr source_repr{kCombined, std::nullopt};
+  MALDOCA_ASSERT_OK_AND_ASSIGN(
+      JsAstRepr ast_repr,
+      ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request,
+                                    absl::InfiniteDuration(), std::nullopt,
+                                    babel));
 
   // Extract the prelude from the AST.
   JsirAnalysisConfig::DynamicConstantPropagation prelude_config =
diff --git a/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc b/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc
index 69cc4af..c5e224f 100644
--- a/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc
+++ b/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc
@@ -50,6 +50,8 @@ TEST_P(GetLvalueRootSymbolsTest, GetLvalueRootSymbols) {
   LvalueRootSymbolsTestCase test_case = GetParam();
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{test_case.source, std::nullopt};
+
   BabelParseRequest request;
   request.set_compute_scopes(true);
 
@@ -59,7 +61,7 @@ TEST_P(GetLvalueRootSymbolsTest, GetLvalueRootSymbols) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsHirRepr hir_repr,
       ToJsHirRepr::FromJsSourceRepr(
-          test_case.source, request, absl::InfiniteDuration(),
+          source_repr, request, absl::InfiniteDuration(),
           /*recursion_depth_limit=*/std::nullopt, babel, mlir_context));
 
   mlir::Value left = nullptr;
@@ -137,6 +139,8 @@ TEST_P(GetSymbolMutationInfosTest, GetSymbolMutationInfos) {
   GetSymbolMutationInfosTestCase test_case = GetParam();
   QuickJsBabel babel;
 
+  JsSourceRepr source_repr{test_case.source, std::nullopt};
+
   BabelParseRequest request;
   request.set_compute_scopes(true);
 
@@ -146,7 +150,7 @@ TEST_P(GetSymbolMutationInfosTest, GetSymbolMutationInfos) {
   MALDOCA_ASSERT_OK_AND_ASSIGN(
       JsHirRepr hir_repr,
       ToJsHirRepr::FromJsSourceRepr(
-          test_case.source, request, absl::InfiniteDuration(),
+          source_repr, request, absl::InfiniteDuration(),
           /*recursion_depth_limit=*/std::nullopt, babel, mlir_context));
 
   absl::flat_hash_map<JsSymbolId, SymbolMutationInfo> infos =
diff --git a/maldoca/js/ir/jsir_gen_lib.cc b/maldoca/js/ir/jsir_gen_lib.cc
index 3820aa7..d12e57b 100644
--- a/maldoca/js/ir/jsir_gen_lib.cc
+++ b/maldoca/js/ir/jsir_gen_lib.cc
@@ -15,6 +15,7 @@
 #include "maldoca/js/ir/jsir_gen_lib.h"
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -142,7 +143,7 @@ absl::StatusOr<JsirGenOutput> JsirGen(
 
   JsPassContext pass_context{
       .original_source = std::string(source),
-      .repr = std::make_unique<JsSourceRepr>(source),
+      .repr = std::make_unique<JsSourceRepr>(source, std::nullopt),
       .outputs = {},
   };