feat: I guess it's esm

default_app/default_app.ts

@@ -51,17 +51,17 @@ async function createWindow (backgroundColor?: string) {
     autoHideMenuBar: true,
     backgroundColor,
     webPreferences: {
-      preload: new URL('preload.js', import.meta.url).pathname,
+      preload: url.fileURLToPath(new URL('preload.js', import.meta.url)),
       contextIsolation: true,
-      sandbox: false,
-      nodeIntegration: true
+      sandbox: true,
+      nodeIntegration: false
     },
     useContentSize: true,
     show: false
   };
 
   if (process.platform === 'linux') {
-    options.icon = new URL('icon.png', import.meta.url).pathname;
+    options.icon = url.fileURLToPath(new URL('icon.png', import.meta.url));
   }
 
   mainWindow = new BrowserWindow(options);

docs/tutorial/esm-limitations.md

@@ -6,7 +6,7 @@ This document serves to outline the limitations / differences between ESM in Ele
 
 Sandboxed preload scripts are run as plain javascript without an ESM context.  It is reccomended that preload scripts are bundled via something like `webpack` or `vite` for performance reasons regardless, so your preload script should just be a single file that doesn't need to use ESM imports.  Loading the `electron` API is still done via `require('electron')`.
 
-## Non context isolated renderers can't use Node.js ESM imports
+## Non-context-isolated renderers can't use Node.js ESM imports
 
 If your renderer process does not have `contextIsolation` enabled you can not `import` ESM files via the Node.js module loader.  This means that you can't `import('fs')` or `import('./foo')`.  If you want to be able to do so you must enable context isolation.  This is because in the renderer Chromium's `import()` function takes precedence and without context isolation there is no way for Electron to know which loader to route the request to.
 

lib/asar/fs-wrapper.ts

@@ -392,7 +392,13 @@ export const wrapFsWithAsar = (fs: Record<string, any>) => {
 
   const { exists: nativeExists } = fs;
   fs.exists = function exists (pathArgument: string, callback: any) {
-    const pathInfo = splitPath(pathArgument);
+    let pathInfo: ReturnType<typeof splitPath>;
+    try {
+      pathInfo = splitPath(pathArgument);
+    } catch {
+      nextTick(callback, [false]);
+      return;
+    }
     if (!pathInfo.isAsar) return nativeExists(pathArgument, callback);
     const { asarPath, filePath } = pathInfo;
 
@@ -423,7 +429,12 @@ export const wrapFsWithAsar = (fs: Record<string, any>) => {
 
   const { existsSync } = fs;
   fs.existsSync = (pathArgument: string) => {
-    const pathInfo = splitPath(pathArgument);
+    let pathInfo: ReturnType<typeof splitPath>;
+    try {
+      pathInfo = splitPath(pathArgument);
+    } catch {
+      return false;
+    }
     if (!pathInfo.isAsar) return existsSync(pathArgument);
     const { asarPath, filePath } = pathInfo;
 

lib/renderer/init.ts

@@ -125,24 +125,19 @@ if (nodeIntegration) {
 const { appCodeLoaded } = process;
 delete process.appCodeLoaded;
 
-const { preloadPaths } = ipcRendererUtils.invokeSync(IPC_MESSAGES.BROWSER_NONSANDBOX_LOAD);
-const preloadPromises: Promise<void>[] = [];
-// Load the preload scripts.
-for (const preloadScript of preloadPaths) {
-  // Finally load app's main.js and transfer control to C++.
+const { preloadPaths } = ipcRendererUtils.invokeSync<{ preloadPaths: string[] }>(IPC_MESSAGES.BROWSER_NONSANDBOX_LOAD);
+if (preloadPaths.length) {
   const { loadESM } = __non_webpack_require__('internal/process/esm_loader');
-  preloadPromises.push(loadESM((esmLoader: any) => {
-    return esmLoader.import(preloadScript, undefined, Object.create(null)).catch((err: Error) => {
+
+  loadESM((esmLoader: any) => {
+    // Load the preload scripts.
+    return Promise.all(preloadPaths.map(preloadScript => esmLoader.import(preloadScript, undefined, Object.create(null)).catch((err: Error) => {
       console.error(`Unable to load preload script: ${preloadScript}`);
       console.error(err);
 
       ipcRendererInternal.send(IPC_MESSAGES.BROWSER_PRELOAD_ERROR, preloadScript, err);
-    });
-  }));
-}
-
-if (preloadPromises.length) {
-  Promise.all(preloadPromises).then(() => appCodeLoaded!());
+    })));
+  }).then(() => appCodeLoaded!());
 } else {
   appCodeLoaded!();
 }

patches/chromium/.patches

@@ -128,3 +128,4 @@ chore_patch_out_profile_methods_in_profile_selections_cc.patch
 fix_x11_window_restore_minimized_maximized_window.patch
 chore_defer_usb_service_getdevices_request_until_usb_service_is.patch
 refactor_expose_hostimportmoduledynamically_and.patch
+feat_expose_documentloader_setdefersloading_on_webdocumentloader.patch

patches/chromium/feat_expose_documentloader_setdefersloading_on_webdocumentloader.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Samuel Attard <marshallofsound@electronjs.org>
+Date: Thu, 9 Mar 2023 01:28:56 -0800
+Subject: feat: expose DocumentLoader::SetDefersLoading on WebDocumentLoader
+
+This allows embedders to call SetDefersLoading without reaching into blink internals.  Electron uses this to defer page loading until the preload scripts have finished executing.
+This might be upstreamable?
+
+diff --git a/third_party/blink/public/web/web_document_loader.h b/third_party/blink/public/web/web_document_loader.h
+index ff1948e649fffdc92a2db0e736c99bf4e8c06514..b165201b273c8fa9de8e66fe8ef7bfc28eee0850 100644
+--- a/third_party/blink/public/web/web_document_loader.h
++++ b/third_party/blink/public/web/web_document_loader.h
+@@ -38,6 +38,7 @@
+ #include "third_party/blink/public/platform/cross_variant_mojo_util.h"
+ #include "third_party/blink/public/platform/web_archive_info.h"
+ #include "third_party/blink/public/platform/web_common.h"
++#include "third_party/blink/public/platform/web_loader_freeze_mode.h"
+ #include "third_party/blink/public/platform/web_source_location.h"
+ #include "third_party/blink/public/web/web_navigation_type.h"
+
+@@ -62,6 +63,8 @@ class BLINK_EXPORT WebDocumentLoader {
+     virtual ~ExtraData() = default;
+   };
+
++  virtual void SetDefersLoading(WebLoaderFreezeMode) = 0;
++
+   static bool WillLoadUrlAsEmpty(const WebURL&);
+
+   // Returns the http referrer of original request which initited this load.
+diff --git a/third_party/blink/renderer/core/loader/document_loader.h b/third_party/blink/renderer/core/loader/document_loader.h
+index f8839bb4ad9480daecd93b7aba4d4fef41aa1008..2f61bbbdc2dd6e76fda84eae2a7871c8cea28222 100644
+--- a/third_party/blink/renderer/core/loader/document_loader.h
++++ b/third_party/blink/renderer/core/loader/document_loader.h
+@@ -300,7 +300,7 @@ class CORE_EXPORT DocumentLoader : public GarbageCollected<DocumentLoader>,
+       absl::optional<scheduler::TaskAttributionId>
+           soft_navigation_heuristics_task_id);
+
+-  void SetDefersLoading(LoaderFreezeMode);
++  void SetDefersLoading(LoaderFreezeMode) override;
+
+   DocumentLoadTiming& GetTiming() { return document_load_timing_; }
+

patches/node/chore_expose_importmoduledynamically_and.patch

@@ -11,15 +11,15 @@ it's own blended handler between node / blink.
 Not upstremable.
 
 diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
-index c4fe744be1c26c2306e843031192d88f977cd46c..badd978d58049c07716f3a1151da331d31506799 100644
+index c4fe744be1c26c2306e843031192d88f977cd46c..f8218046cbdfbaeb0aaecd50676b6fcb37c8e4d7 100644
 --- a/lib/internal/process/pre_execution.js
 +++ b/lib/internal/process/pre_execution.js
 @@ -575,7 +575,7 @@ function initializeESMLoader() {
    // Create this WeakMap in js-land because V8 has no C++ API for WeakMap.
    internalBinding('module_wrap').callbackMap = new SafeWeakMap();
 
 -  if (getEmbedderOptions().shouldNotRegisterESMLoader) return;
-+  const setOnIsolate = !getEmbedderOptions().shouldNotRegisterESMLoader;
++  const shouldSetOnIsolate = !getEmbedderOptions().shouldNotRegisterESMLoader;
 
    const {
      setImportModuleDynamicallyCallback,
@@ -29,8 +29,8 @@ index c4fe744be1c26c2306e843031192d88f977cd46c..badd978d58049c07716f3a1151da331d
    // track of for different ESM modules.
 -  setInitializeImportMetaObjectCallback(esm.initializeImportMetaObject);
 -  setImportModuleDynamicallyCallback(esm.importModuleDynamicallyCallback);
-+  setInitializeImportMetaObjectCallback(esm.initializeImportMetaObject, setOnIsolate);
-+  setImportModuleDynamicallyCallback(esm.importModuleDynamicallyCallback, setOnIsolate);
++  setInitializeImportMetaObjectCallback(esm.initializeImportMetaObject, shouldSetOnIsolate);
++  setImportModuleDynamicallyCallback(esm.importModuleDynamicallyCallback, shouldSetOnIsolate);
 
    // Patch the vm module when --experimental-vm-modules is on.
    // Please update the comments in vm.js when this block changes.

shell/common/node_bindings.cc

@@ -511,7 +511,8 @@ node::Environment* NodeBindings::CreateEnvironment(
     v8::Handle<v8::Context> context,
     node::MultiIsolatePlatform* platform,
     std::vector<std::string> args,
-    std::vector<std::string> exec_args) {
+    std::vector<std::string> exec_args,
+    absl::optional<base::RepeatingCallback<void()>> on_app_code_ready) {
   // Feed node the path to initialization script.
   std::string process_type;
   switch (browser_env_) {
@@ -677,17 +678,22 @@ node::Environment* NodeBindings::CreateEnvironment(
 
   if (browser_env_ == BrowserEnvironment::kBrowser ||
       browser_env_ == BrowserEnvironment::kRenderer) {
-    process.SetMethod("appCodeLoaded",
-                      base::BindRepeating(&NodeBindings::SetAppCodeLoaded,
-                                          base::Unretained(this)));
+    if (on_app_code_ready) {
+      process.SetMethod("appCodeLoaded", std::move(*on_app_code_ready));
+    } else {
+      process.SetMethod("appCodeLoaded",
+                        base::BindRepeating(&NodeBindings::SetAppCodeLoaded,
+                                            base::Unretained(this)));
+    }
   }
 
   return env;
 }
 
 node::Environment* NodeBindings::CreateEnvironment(
     v8::Handle<v8::Context> context,
-    node::MultiIsolatePlatform* platform) {
+    node::MultiIsolatePlatform* platform,
+    absl::optional<base::RepeatingCallback<void()>> on_app_code_ready) {
 #if BUILDFLAG(IS_WIN)
   auto& electron_args = ElectronCommandLine::argv();
   std::vector<std::string> args(electron_args.size());
@@ -696,7 +702,7 @@ node::Environment* NodeBindings::CreateEnvironment(
 #else
   auto args = ElectronCommandLine::argv();
 #endif
-  return CreateEnvironment(context, platform, args, {});
+  return CreateEnvironment(context, platform, args, {}, on_app_code_ready);
 }
 
 void NodeBindings::LoadEnvironment(node::Environment* env) {

shell/common/node_bindings.h

@@ -10,7 +10,9 @@
 #include <vector>
 
 #include "base/files/file_path.h"
+#include "base/functional/callback.h"
 #include "base/memory/weak_ptr.h"
+#include "third_party/abseil-cpp/absl/types/optional.h"
 #include "uv.h"  // NOLINT(build/include_directory)
 #include "v8/include/v8.h"
 
@@ -90,12 +92,18 @@ class NodeBindings {
   void SetNodeCliFlags();
 
   // Create the environment and load node.js.
-  node::Environment* CreateEnvironment(v8::Handle<v8::Context> context,
-                                       node::MultiIsolatePlatform* platform,
-                                       std::vector<std::string> args,
-                                       std::vector<std::string> exec_args);
-  node::Environment* CreateEnvironment(v8::Handle<v8::Context> context,
-                                       node::MultiIsolatePlatform* platform);
+  node::Environment* CreateEnvironment(
+      v8::Handle<v8::Context> context,
+      node::MultiIsolatePlatform* platform,
+      std::vector<std::string> args,
+      std::vector<std::string> exec_args,
+      absl::optional<base::RepeatingCallback<void()>> on_app_code_ready =
+          absl::nullopt);
+  node::Environment* CreateEnvironment(
+      v8::Handle<v8::Context> context,
+      node::MultiIsolatePlatform* platform,
+      absl::optional<base::RepeatingCallback<void()>> on_app_code_ready =
+          absl::nullopt);
 
   // Load node.js in the environment.
   void LoadEnvironment(node::Environment* env);
@@ -124,6 +132,8 @@ class NodeBindings {
   NodeBindings(const NodeBindings&) = delete;
   NodeBindings& operator=(const NodeBindings&) = delete;
 
+  // Blocks until app code is signaled to be loaded via |SetAppCodeLoaded|.
+  // Only has affect if called in the browser process
   void JoinAppCode();
 
  protected:

shell/renderer/electron_renderer_client.cc

@@ -22,6 +22,7 @@
 #include "third_party/blink/public/web/web_document.h"
 #include "third_party/blink/public/web/web_local_frame.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"  // nogncheck
+#include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"  // nogncheck
 
 namespace electron {
 
@@ -61,6 +62,11 @@ void ElectronRendererClient::RunScriptsAtDocumentEnd(
                           "document-end");
 }
 
+void ElectronRendererClient::UndeferLoad(content::RenderFrame* render_frame) {
+  render_frame->GetWebFrame()->GetDocumentLoader()->SetDefersLoading(
+      blink::LoaderFreezeMode::kNone);
+}
+
 void ElectronRendererClient::DidCreateScriptContext(
     v8::Handle<v8::Context> renderer_context,
     content::RenderFrame* render_frame) {
@@ -88,8 +94,17 @@ void ElectronRendererClient::DidCreateScriptContext(
   v8::Maybe<bool> initialized = node::InitializeContext(renderer_context);
   CHECK(!initialized.IsNothing() && initialized.FromJust());
 
-  node::Environment* env =
-      node_bindings_->CreateEnvironment(renderer_context, nullptr);
+  // Before we load the node environment, let's tell blink to hold off on
+  // loading the body of this frame.  We will undefer the load once the preload
+  // script has finished.  This allows our preload script to run async (E.g.
+  // with ESM) without the preload being in a race
+  render_frame->GetWebFrame()->GetDocumentLoader()->SetDefersLoading(
+      blink::LoaderFreezeMode::kStrict);
+
+  node::Environment* env = node_bindings_->CreateEnvironment(
+      renderer_context, nullptr,
+      base::BindRepeating(&ElectronRendererClient::UndeferLoad,
+                          base::Unretained(this), render_frame));
 
   // If we have disabled the site instance overrides we should prevent loading
   // any non-context aware native module.
@@ -115,8 +130,6 @@ void ElectronRendererClient::DidCreateScriptContext(
     // Give the node loop a run to make sure everything is ready.
     node_bindings_->StartPolling();
   }
-
-  node_bindings_->JoinAppCode();
 }
 
 void ElectronRendererClient::WillReleaseScriptContext(

shell/renderer/electron_renderer_client.h

@@ -36,6 +36,8 @@ class ElectronRendererClient : public RendererClientBase {
                                 content::RenderFrame* render_frame) override;
 
  private:
+  void UndeferLoad(content::RenderFrame* render_frame);
+
   // content::ContentRendererClient:
   void RenderFrameCreated(content::RenderFrame*) override;
   void RunScriptsAtDocumentStart(content::RenderFrame* render_frame) override;