diff --git a/common.gypi b/common.gypi
index 71712d308472..7eaad1e5ea1e 100644
--- a/common.gypi
+++ b/common.gypi
@@ -43,7 +43,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.34',
+    'v8_embedder_string': '-node.35',
 
     ##### V8 defaults for Node.js #####
 
diff --git a/deps/v8/include/v8-wasm.h b/deps/v8/include/v8-wasm.h
index 550cdfb32783..034912de0f8b 100644
--- a/deps/v8/include/v8-wasm.h
+++ b/deps/v8/include/v8-wasm.h
@@ -8,6 +8,7 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <variant>
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
@@ -106,12 +107,48 @@ class V8_EXPORT WasmModuleObject : public Object {
    */
   CompiledWasmModule GetCompiledModule();
 
+  /**
+   * Options that influence how a Wasm module is compiled. The compile-time
+   * import options mirror those accepted by the JS `WebAssembly.Module`
+   * constructor (`{ builtins, importedStringConstants }`).
+   */
+  struct CompileOptions {
+    // Builtin compile-time imports, mirroring the strings accepted in the
+    // `builtins` array of the JS `WebAssembly.Module` constructor options.
+    // Combine values with bitwise-or to enable multiple builtins.
+    struct Builtins {
+      enum {
+        kNone = 0,
+        kJsString = 1 << 0,  // "js-string"
+      };
+    };
+    // Bitwise-or of `Builtins` values to enable as compile-time imports.
+    int builtins = Builtins::kNone;
+    // If non-null, enable imported string constants from the named module
+    // (e.g. "wasm:js/string-constants"). The string must be null-terminated and
+    // remain valid for the duration of the compile call.
+    const char* imported_string_constants_module = nullptr;
+    // If non-empty, associated with the module's script as its source URL, for
+    // use in stack traces and developer tooling. If a script already exists in
+    // the isolate for the same module, its existing URL is retained. The
+    // string must remain valid for the duration of the compile call.
+    std::string_view source_url = {};
+  };
+
   /**
    * Compile a Wasm module from the provided uncompiled bytes.
    */
   static MaybeLocal<WasmModuleObject> Compile(
       Isolate* isolate, MemorySpan<const uint8_t> wire_bytes);
 
+  /**
+   * Compile a Wasm module from the provided uncompiled bytes, applying the
+   * given compile options.
+   */
+  static MaybeLocal<WasmModuleObject> Compile(
+      Isolate* isolate, MemorySpan<const uint8_t> wire_bytes,
+      const CompileOptions& options);
+
   V8_INLINE static WasmModuleObject* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);
@@ -224,13 +261,15 @@ class V8_EXPORT WasmStreaming final {
 class V8_EXPORT WasmModuleCompilation final {
  public:
   using ModuleCachingCallback = WasmStreaming::ModuleCachingCallback;
+  using CompileOptions = WasmModuleObject::CompileOptions;
 
   /**
-   * Start an asynchronous module compilation. This can be called on any thread.
+   * Start an asynchronous module compilation, applying the given compile
+   * options. This can be called on any thread. Providing
+   * {CompileOptions::source_url} is equivalent to calling {SetUrl}.
    * TODO(clemensb): Add some way to pass enabled features.
-   * TODO(clemensb): Add some way to pass compile time imports.
    */
-  WasmModuleCompilation();
+  explicit WasmModuleCompilation(const CompileOptions& options = {});
 
   ~WasmModuleCompilation();
 
diff --git a/deps/v8/src/api/api.cc b/deps/v8/src/api/api.cc
index eb3cd7dee28f..181d1a126faf 100644
--- a/deps/v8/src/api/api.cc
+++ b/deps/v8/src/api/api.cc
@@ -8853,7 +8853,15 @@ MaybeLocal<WasmModuleObject> WasmModuleObject::FromCompiledModule(
 
 MaybeLocal<WasmModuleObject> WasmModuleObject::Compile(
     Isolate* v8_isolate, MemorySpan<const uint8_t> wire_bytes) {
+  return Compile(v8_isolate, wire_bytes, CompileOptions{});
+}
+
+MaybeLocal<WasmModuleObject> WasmModuleObject::Compile(
+    Isolate* v8_isolate, MemorySpan<const uint8_t> wire_bytes,
+    const CompileOptions& options) {
 #if V8_ENABLE_WEBASSEMBLY
+  i::wasm::CompileTimeImports compile_imports =
+      i::wasm::CompileTimeImportsFromOptions(options);
   base::OwnedVector<const uint8_t> bytes = base::OwnedCopyOf(wire_bytes);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   // We don't check for `IsWasmCodegenAllowed` here, because this function is
@@ -8864,10 +8872,11 @@ MaybeLocal<WasmModuleObject> WasmModuleObject::Compile(
     i::wasm::ErrorThrower thrower(i_isolate, "WasmModuleObject::Compile()");
     auto enabled_features =
         i::wasm::WasmEnabledFeatures::FromIsolate(i_isolate);
-    // TODO(14179): Provide an API method that supports compile options.
     maybe_compiled = i::wasm::GetWasmEngine()->SyncCompile(
-        i_isolate, enabled_features, i::wasm::CompileTimeImports{}, &thrower,
-        std::move(bytes));
+        i_isolate, enabled_features, std::move(compile_imports), &thrower,
+        std::move(bytes),
+        base::Vector<const char>(options.source_url.data(),
+                                 options.source_url.size()));
   }
   CHECK_EQ(maybe_compiled.is_null(), i_isolate->has_exception());
   if (maybe_compiled.is_null()) return {};
diff --git a/deps/v8/src/wasm/wasm-engine.cc b/deps/v8/src/wasm/wasm-engine.cc
index 1380f8166b0f..c9184ef647c3 100644
--- a/deps/v8/src/wasm/wasm-engine.cc
+++ b/deps/v8/src/wasm/wasm-engine.cc
@@ -666,7 +666,8 @@ DirectHandle<WasmModuleObject> WasmEngine::FinalizeTranslatedAsmJs(
 MaybeDirectHandle<WasmModuleObject> WasmEngine::SyncCompile(
     Isolate* isolate, WasmEnabledFeatures enabled_features,
     CompileTimeImports compile_imports, ErrorThrower* thrower,
-    base::OwnedVector<const uint8_t> bytes) {
+    base::OwnedVector<const uint8_t> bytes,
+    base::Vector<const char> source_url) {
   int compilation_id = next_compilation_id_.fetch_add(1);
   TRACE_EVENT1("v8.wasm", "wasm.SyncCompile", "id", compilation_id);
   v8::metrics::Recorder::ContextId context_id =
@@ -718,9 +719,8 @@ MaybeDirectHandle<WasmModuleObject> WasmEngine::SyncCompile(
   }
 #endif
 
-  constexpr base::Vector<const char> kNoSourceUrl;
   DirectHandle<Script> script =
-      GetOrCreateScript(isolate, native_module, kNoSourceUrl);
+      GetOrCreateScript(isolate, native_module, source_url);
 
   native_module->LogWasmCodes(isolate, *script);
 
diff --git a/deps/v8/src/wasm/wasm-engine.h b/deps/v8/src/wasm/wasm-engine.h
index 7bb3bd1ea16e..a9ed91692cf9 100644
--- a/deps/v8/src/wasm/wasm-engine.h
+++ b/deps/v8/src/wasm/wasm-engine.h
@@ -192,7 +192,8 @@ class V8_EXPORT_PRIVATE WasmEngine {
   MaybeDirectHandle<WasmModuleObject> SyncCompile(
       Isolate* isolate, WasmEnabledFeatures enabled,
       CompileTimeImports compile_imports, ErrorThrower* thrower,
-      base::OwnedVector<const uint8_t> bytes);
+      base::OwnedVector<const uint8_t> bytes,
+      base::Vector<const char> source_url = {});
 
   // Synchronously instantiate the given Wasm module with the given imports.
   // If the module represents an asm.js module, then the supplied {memory}
diff --git a/deps/v8/src/wasm/wasm-js.cc b/deps/v8/src/wasm/wasm-js.cc
index d8866284523f..b739c36754cf 100644
--- a/deps/v8/src/wasm/wasm-js.cc
+++ b/deps/v8/src/wasm/wasm-js.cc
@@ -232,11 +232,16 @@ class WasmModuleCompilation::Impl {
   const std::shared_ptr<i::wasm::StreamingDecoder> streaming_decoder_;
 };
 
-// TODO(clemensb): Pass enabled features and compile time imports.
-WasmModuleCompilation::WasmModuleCompilation()
-    : impl_(std::make_unique<Impl>(WasmEnabledFeatures::FromFlags(),
-                                   CompileTimeImports{})) {
+// TODO(clemensb): Pass enabled features.
+WasmModuleCompilation::WasmModuleCompilation(const CompileOptions& options)
+    : impl_(std::make_unique<Impl>(
+          WasmEnabledFeatures::FromFlags(),
+          i::wasm::CompileTimeImportsFromOptions(options))) {
   TRACE_EVENT0("v8.wasm", "wasm.ModuleCompilation");
+  if (!options.source_url.empty()) {
+    impl_->SetUrl(
+        base::VectorOf(options.source_url.data(), options.source_url.size()));
+  }
 }
 
 WasmModuleCompilation::~WasmModuleCompilation() = default;
@@ -3959,6 +3964,27 @@ void WasmJs::InstallResizableBufferIntegration(
               wasm::WebAssemblyMemoryToResizableBuffer, 0);
 }
 
+namespace wasm {
+CompileTimeImports CompileTimeImportsFromOptions(
+    const v8::WasmModuleObject::CompileOptions& options) {
+  CompileTimeImports result;
+  using Builtins = v8::WasmModuleObject::CompileOptions::Builtins;
+  if (options.builtins & Builtins::kJsString) {
+    result.Add(CompileTimeImport::kJsString);
+  }
+  if (options.imported_string_constants_module != nullptr) {
+    result.constants_module() = options.imported_string_constants_module;
+    result.Add(CompileTimeImport::kStringConstants);
+  }
+  // Mirror the JS `WebAssembly.Module` constructor, which disables denormal
+  // floats at compile time when the host FPU flushes them.
+  if (base::FPU::GetFlushDenormals()) {
+    result.Add(CompileTimeImport::kDisableDenormalFloats);
+  }
+  return result;
+}
+}  // namespace wasm
+
 // static
 CompileTimeImports WasmJs::CompileTimeImportsFromArgument(
     DirectHandle<Object> arg, Isolate* isolate,
diff --git a/deps/v8/src/wasm/wasm-js.h b/deps/v8/src/wasm/wasm-js.h
index 901ba8c342af..d6061c5283e1 100644
--- a/deps/v8/src/wasm/wasm-js.h
+++ b/deps/v8/src/wasm/wasm-js.h
@@ -11,6 +11,7 @@
 
 #include <memory>
 
+#include "include/v8-wasm.h"
 #include "src/common/globals.h"
 #include "src/wasm/wasm-features.h"
 
@@ -18,7 +19,6 @@ namespace v8 {
 class Value;
 template <typename T>
 class FunctionCallbackInfo;
-class WasmStreaming;
 }  // namespace v8
 
 namespace v8::internal {
@@ -30,6 +30,11 @@ class StreamingDecoder;
 V8_EXPORT_PRIVATE std::unique_ptr<WasmStreaming> StartStreamingForTesting(
     Isolate*, std::shared_ptr<wasm::CompilationResultResolver>);
 
+// Convert compile options from the public API into compile-time imports,
+// including the host-FPU denormal handling applied to all compilations.
+V8_EXPORT_PRIVATE CompileTimeImports
+CompileTimeImportsFromOptions(const v8::WasmModuleObject::CompileOptions&);
+
 #define WASM_JS_EXTERNAL_REFERENCE_LIST(V) \
   V(WebAssemblyCompile)                    \
   V(WebAssemblyException)                  \
diff --git a/deps/v8/test/unittests/api/api-wasm-unittest.cc b/deps/v8/test/unittests/api/api-wasm-unittest.cc
index 1262a8dccd14..8592d4a05f6c 100644
--- a/deps/v8/test/unittests/api/api-wasm-unittest.cc
+++ b/deps/v8/test/unittests/api/api-wasm-unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include <memory>
+#include <span>
 #include <thread>  // NOLINT(build/c++11)
 
 #include "include/v8-context.h"
@@ -16,6 +17,7 @@
 #include "src/handles/global-handles.h"
 #include "src/wasm/wasm-features.h"
 #include "src/wasm/wasm-js.h"
+#include "src/wasm/wasm-module.h"
 #include "test/common/flag-utils.h"
 #include "test/common/wasm/wasm-macro-gen.h"
 #include "test/unittests/heap/heap-utils.h"
@@ -48,6 +50,27 @@ class ApiWasmTest : public TestWithIsolate {
     EmptyMessageQueues();
     CHECK_EQ(expected_state, promise->State());
   }
+
+  Local<WasmModuleObject> FinishModuleCompilation(
+      WasmModuleCompilation& compilation, std::span<const uint8_t> bytes) {
+    compilation.OnBytesReceived(bytes.data(), bytes.size());
+    // The resolution callback runs within a separate task with its own
+    // HandleScope, so persist the result in a Global.
+    Global<WasmModuleObject> module_object;
+    compilation.Finish(
+        isolate(), {},
+        [this,
+         &module_object](std::variant<Local<WasmModuleObject>, Local<Value>>
+                             module_or_error) {
+          CHECK(
+              std::holds_alternative<Local<WasmModuleObject>>(module_or_error));
+          module_object.Reset(
+              isolate(), std::get<Local<WasmModuleObject>>(module_or_error));
+        });
+    EmptyMessageQueues();
+    CHECK(!module_object.IsEmpty());
+    return module_object.Get(isolate());
+  }
 };
 
 void WasmStreamingTestFinalizer(const WeakCallbackInfo<void>& data) {
@@ -186,6 +209,122 @@ TEST_F(ApiWasmTest, WasmCompileToWasmModuleObject) {
   CHECK(!maybe_module.IsEmpty());
 }
 
+namespace {
+// Number of imports reflected by `WebAssembly.Module.imports`. Compile-time
+// imports are bound during compilation and are not reflected here.
+int ReflectedImportCount(Isolate* isolate, Local<WasmModuleObject> module) {
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  i::DirectHandle<i::WasmModuleObject> module_object =
+      i::Cast<i::WasmModuleObject>(Utils::OpenDirectHandle(*module));
+  i::DirectHandle<i::JSArray> imports =
+      i::wasm::GetImports(i_isolate, module_object);
+  return static_cast<int>(i::Object::NumberValue(imports->length()));
+}
+}  // namespace
+
+TEST_F(ApiWasmTest, WasmCompileWithJsStringBuiltins) {
+  using namespace internal::wasm;  // NOLINT(build/namespaces)
+  Local<Context> context = Context::New(isolate());
+  Context::Scope context_scope(context);
+
+  // Imports `charCodeAt` from the "wasm:js-string" builtins module with the
+  // signature (externref, i32) -> i32, matching the builtin.
+  const uint8_t valid_module[] = {
+      WASM_MODULE_HEADER,
+      SECTION(Type, ENTRY_COUNT(1),
+              SIG_ENTRY_x_xx(kI32Code, kExternRefCode, kI32Code)),
+      SECTION(Import, ENTRY_COUNT(1),
+              // module name: "wasm:js-string"
+              14, 'w', 'a', 's', 'm', ':', 'j', 's', '-', 's', 't', 'r', 'i',
+              'n', 'g',
+              // field name: "charCodeAt"
+              10, 'c', 'h', 'a', 'r', 'C', 'o', 'd', 'e', 'A', 't',
+              kExternalFunction, 0)};
+  // The same import but declaring an i64 result, which no builtin provides.
+  const uint8_t invalid_module[] = {
+      WASM_MODULE_HEADER,
+      SECTION(Type, ENTRY_COUNT(1),
+              SIG_ENTRY_x_xx(kI64Code, kExternRefCode, kI32Code)),
+      SECTION(Import, ENTRY_COUNT(1), 14, 'w', 'a', 's', 'm', ':', 'j', 's',
+              '-', 's', 't', 'r', 'i', 'n', 'g', 10, 'c', 'h', 'a', 'r', 'C',
+              'o', 'd', 'e', 'A', 't', kExternalFunction, 0)};
+
+  WasmModuleObject::CompileOptions options{
+      .builtins = WasmModuleObject::CompileOptions::Builtins::kJsString};
+
+  // Without compile-time imports the "wasm:js-string" import is an ordinary
+  // import resolved at instantiation, so it is reflected and both modules
+  // compile.
+  Local<WasmModuleObject> plain =
+      WasmModuleObject::Compile(isolate(), valid_module).ToLocalChecked();
+  CHECK_EQ(1, ReflectedImportCount(isolate(), plain));
+  CHECK(!WasmModuleObject::Compile(isolate(), invalid_module).IsEmpty());
+
+  // With the builtins enabled the valid import is bound at compile time, so it
+  // is no longer reflected.
+  Local<WasmModuleObject> bound =
+      WasmModuleObject::Compile(isolate(), valid_module, options)
+          .ToLocalChecked();
+  CHECK_EQ(0, ReflectedImportCount(isolate(), bound));
+
+  // The invalid signature is rejected at compile time.
+  {
+    TryCatch try_catch(isolate());
+    CHECK(WasmModuleObject::Compile(isolate(), invalid_module, options)
+              .IsEmpty());
+    CHECK(try_catch.HasCaught());
+  }
+}
+
+TEST_F(ApiWasmTest, WasmCompileWithImportedStringConstants) {
+  using namespace internal::wasm;  // NOLINT(build/namespaces)
+  Local<Context> context = Context::New(isolate());
+  Context::Scope context_scope(context);
+
+  // Imports an externref global "foo" from the "strings" module, which is
+  // turned into a string constant when the constants module is provided.
+  const uint8_t module[] = {
+      WASM_MODULE_HEADER,
+      SECTION(Import, ENTRY_COUNT(1),
+              // module name: "strings"
+              7, 's', 't', 'r', 'i', 'n', 'g', 's',
+              // field name: "foo"
+              3, 'f', 'o', 'o', kExternalGlobal, kExternRefCode, 0)};
+
+  // Without a constants module the global is an ordinary reflected import.
+  Local<WasmModuleObject> plain =
+      WasmModuleObject::Compile(isolate(), module).ToLocalChecked();
+  CHECK_EQ(1, ReflectedImportCount(isolate(), plain));
+
+  // Naming "strings" as the constants module binds the import at compile time,
+  // so it is no longer reflected.
+  Local<WasmModuleObject> bound =
+      WasmModuleObject::Compile(isolate(), module,
+                                {.imported_string_constants_module = "strings"})
+          .ToLocalChecked();
+  CHECK_EQ(0, ReflectedImportCount(isolate(), bound));
+}
+
+TEST_F(ApiWasmTest, WasmCompileWithSourceUrl) {
+  Local<Context> context = Context::New(isolate());
+  Context::Scope context_scope(context);
+
+  constexpr std::string_view kUrl = "file:///test/module.wasm";
+  Local<WasmModuleObject> with_url =
+      WasmModuleObject::Compile(isolate(), kMinimalWasmModuleBytes,
+                                {.source_url = kUrl})
+          .ToLocalChecked();
+  CHECK_EQ(kUrl, with_url->GetCompiledModule().source_url());
+
+  // A distinct module, since scripts (and their URLs) are cached per module
+  // per isolate. Without a source URL a wasm:// URL is synthesized.
+  const uint8_t distinct_module[] = {0x00, 0x61, 0x73, 0x6d, 0x01, 0x00,
+                                     0x00, 0x00, 0x00, 0x02, 0x01, 'x'};
+  Local<WasmModuleObject> plain =
+      WasmModuleObject::Compile(isolate(), distinct_module).ToLocalChecked();
+  CHECK_EQ(0u, plain->GetCompiledModule().source_url().find("wasm://wasm/"));
+}
+
 TEST_F(ApiWasmTest, WasmStreamingSetCallback) {
   TestWasmStreaming(WasmStreamingMoreFunctionsCanBeSerializedCallback,
                     Promise::kPending);
@@ -317,6 +456,68 @@ TEST_F(ApiWasmTest, WasmModuleCompilation_Basic) {
   CHECK(!isolate()->HasPendingException());
 }
 
+
+
+TEST_F(ApiWasmTest, WasmModuleCompilation_CompileOptions) {
+  using namespace internal::wasm;  // NOLINT(build/namespaces)
+  Isolate::Scope iscope(isolate());
+  HandleScope scope(isolate());
+  Local<Context> context = Context::New(isolate());
+  Context::Scope cscope(context);
+  TryCatch try_catch(isolate());
+
+  // Imports `charCodeAt` from the "wasm:js-string" builtins module, matching
+  // the builtin signature, so it binds at compile time when enabled.
+  const uint8_t module_bytes[] = {
+      WASM_MODULE_HEADER,
+      SECTION(Type, ENTRY_COUNT(1),
+              SIG_ENTRY_x_xx(kI32Code, kExternRefCode, kI32Code)),
+      SECTION(Import, ENTRY_COUNT(1), 14, 'w', 'a', 's', 'm', ':', 'j', 's',
+              '-', 's', 't', 'r', 'i', 'n', 'g', 10, 'c', 'h', 'a', 'r', 'C',
+              'o', 'd', 'e', 'A', 't', kExternalFunction, 0)};
+
+  constexpr std::string_view kUrl = "file:///test/async-module.wasm";
+  WasmModuleCompilation compilation(
+      {.builtins = WasmModuleObject::CompileOptions::Builtins::kJsString,
+       .source_url = kUrl});
+  Local<WasmModuleObject> module =
+      FinishModuleCompilation(compilation, module_bytes);
+  CHECK(!try_catch.HasCaught());
+  CHECK_EQ(0, ReflectedImportCount(isolate(), module));
+  CHECK_EQ(kUrl, module->GetCompiledModule().source_url());
+}
+
+TEST_F(ApiWasmTest, WasmModuleCompilation_SourceUrl) {
+  Isolate::Scope iscope(isolate());
+  HandleScope scope(isolate());
+  Local<Context> context = Context::New(isolate());
+  Context::Scope cscope(context);
+  TryCatch try_catch(isolate());
+
+  // SetUrl cleanly replaces a URL provided via compile options.
+  {
+    constexpr std::string_view kSetUrl = "file:///test/replaced.wasm";
+    WasmModuleCompilation compilation(
+        {.source_url = "file:///test/original.wasm"});
+    compilation.SetUrl(kSetUrl.data(), kSetUrl.size());
+    Local<WasmModuleObject> module =
+        FinishModuleCompilation(compilation, kMinimalWasmModuleBytes);
+    CHECK_EQ(kSetUrl, module->GetCompiledModule().source_url());
+  }
+
+  // Without a URL, a wasm:// URL is synthesized. A distinct module, since
+  // scripts (and their URLs) are cached per module per isolate.
+  {
+    const uint8_t distinct_module[] = {0x00, 0x61, 0x73, 0x6d, 0x01, 0x00,
+                                       0x00, 0x00, 0x00, 0x02, 0x01, 'y'};
+    WasmModuleCompilation compilation;
+    Local<WasmModuleObject> module =
+        FinishModuleCompilation(compilation, distinct_module);
+    CHECK_EQ(0u, module->GetCompiledModule().source_url().find("wasm://wasm/"));
+  }
+  CHECK(!try_catch.HasCaught());
+}
+
 TEST_F(ApiWasmTest, WasmModuleCompilation_MultiThreaded) {
   using namespace internal::wasm;  // NOLINT(build/namespaces)
   // The module we are about to compile. It contains two functions, each