[pull] main from electron:main#5
Open
pull[bot] wants to merge 3593 commits into
Open
Conversation
…ns (#50328) * feat: allow to set id and groupId * feat: use Id's without hash but check length * feat: adds visual grouping via groupTitle * test: tests added for id, groupId and groupTitle * fix: unused vars on Mac and Linux * fix: remove redundant parameter * fix: add doc links for id and group * fix: throw if groupId is missing * fix: test
remove decorateURL from default_app Co-authored-by: Shelley Vohr <shelley.vohr@gmail.com>
chore: address blink gc plugin errors Key fixes: - Replace `base::WeakPtrFactory` with `gin::WeakCellFactory` in MenuMac, MenuViews, and NetLog, since weak pointers to cppgc-managed objects must go through weak cells - Replace `v8::Global<v8::Value>` with `cppgc::Persistent<Menu>` for the menu reference in BaseWindow - Stop using `gin_helper::Handle<T>` with cppgc types; use raw `T*` and add a `static_assert` to prevent future misuse - Add proper `Trace()` overrides for Menu, MenuMac, MenuViews, and NetLog to ensure cppgc members are visited during garbage collection - Replace `SelfKeepAlive` prevent-GC mechanism in Menu with a `cppgc::Persistent` prevent-GC captured in `BindSelfToClosure` - Introduce `GC_PLUGIN_IGNORE` macro to suppress known-safe violations: mojo::Remote fields, ObjC bridging pointers, and intentional persistent self-references - Mark `ArgumentHolder` as `CPPGC_STACK_ALLOCATED()` in both Electron's and gin's function_template.h to silence raw-pointer-to-GC-type warnings
* feat: capture JS stack trace on renderer OOM
When a renderer process approaches its V8 heap limit, capture the
JavaScript stack trace and write it to both a Crashpad crash key
("js-oom-stack") and stderr.
The stack trace is captured via RequestInterrupt rather than directly
inside the NearHeapLimitCallback because CurrentStackTrace is unsafe
to call during OOM — V8 FATALs on optimized (TurboFan) frames that
have had their deoptimization data garbage-collected. RequestInterrupt
defers the capture to the next V8 safe point, where all frames are
guaranteed to have deopt data available. This matches Node.js's
approach of never capturing JS stacks inside the heap limit callback.
The callback is registered once per isolate via an atomic guard in
RendererClientBase::DidCreateScriptContext, preventing the CHECK
failure V8 raises on duplicate AddNearHeapLimitCallback registrations
(which would otherwise occur on page navigations or multiple contexts).
Refs: #46078
Made-with: Cursor
* Update shell/renderer/oom_stack_trace.cc
Co-authored-by: Niklas Wenzel <dev@nikwen.de>
* Update shell/renderer/oom_stack_trace.cc
Co-authored-by: Niklas Wenzel <dev@nikwen.de>
* test: add crash reporter test for OOM JS stack trace
Add a test that verifies the `electron.v8-oom.stack` crash key contains
the JS stack trace (including function names) when a renderer process
runs out of memory. Also deduplicate the heap info formatting in
oom_stack_trace.cc.
Refs: #46078
Made-with: Cursor
* fix: lint formatting in oom_stack_trace.cc
Made-with: Cursor
* fix: use proper logger API instead of cstdio
* fix: check heap headroom before capturing OOM stack trace
deepak1556: "Should there be check for available heap size [for]
CurrentStackTrace and formatting"
CurrentStackTrace allocates StackTraceInfo + StackFrameInfo on the V8
heap. If the 20 MB bump is partially consumed by the time the interrupt
fires, these allocations trigger a secondary OOM. Guard with a 2 MB
headroom check.
Made-with: Cursor
* fix: handle V8 cage limit when bumping heap for OOM stack capture
deepak1556: "Does this bumping work when we are at the cage limit of
4GB"
V8's pointer compression cage caps the heap at ~4 GB. When
current_heap_limit is already near the ceiling, our 20 MB bump gets
clamped to zero and the interrupt never fires. Detect this and record
heap info as the final crash key instead of waiting for a stack trace
that won't arrive.
Made-with: Cursor
* feat: add V8 heap statistics as OOM crash keys
deepak1556: "V8 seems to capture heap stats as crash keys but it gets
missed today due to the OOM callback override... wonder if we can
include that to get some more heuristics in the dump."
Record heap used/total/limit/available, per-space stats for old_space
and large_object_space, native/detached context counts, and utilization
percentage as crash keys. Also add heap stats in the V8OOMErrorCallback
in node_bindings.cc for the final OOM crash report.
Made-with: Cursor
* feat: support worker thread isolates for OOM stack trace
deepak1556: "You need a separate registration for worker threads via
WorkerScriptReadyForEvaluationOnWorkerThread but that also means the
process global g_registered_isolate would break."
Chromium has one V8 isolate per thread (main + one per web worker), so
thread_local is equivalent to per-isolate storage. Replace the global
atomic + mutex/set with a constinit thread_local OomState* that holds
the isolate pointer and per-isolate is_in_oom flag. The void* data
parameter on AddNearHeapLimitCallback delivers OomState* directly into
callbacks, so the hot path needs no TLS lookup.
Add WorkerScriptReadyForEvaluationOnWorkerThread and
WillDestroyWorkerContextOnWorkerThread overrides to RendererClientBase
so both ElectronRendererClient and ElectronSandboxedRendererClient get
worker OOM registration. Update ElectronRendererClient to call the base
class in both worker lifecycle methods.
Add a web worker OOM test that spawns a dedicated Worker with a memory
leak and verifies the stack trace captures the worker function name.
Made-with: Cursor
* fix: register OOM callback for all script contexts
When context isolation is enabled, ShouldNotifyClient skips
DidCreateScriptContext for the main world, but user JS still runs there
and can OOM. Register in DidInstallConditionalFeatures which fires for
every script context. The TLS dedup guard prevents double-registration
on the same isolate.
Made-with: Cursor
* fix: guard against division by zero and cage size changes in OOM handler
Add a zero-guard on heap_size_limit before computing utilization
percentage — maximizes robustness in an OOM code path.
Add static_assert on kPtrComprCageReservationSize to catch any
upstream V8 change to the cage size at compile time.
Made-with: Cursor
* fix: address review feedback on OOM stack trace PR
- Remove redundant RegisterOomStackTraceCallback from
electron_render_frame_observer.cc; DidCreateScriptContext is sufficient
since main world and isolated world share the same isolate
- Replace thread_local OomState* with base::ThreadLocalOwnedPointer
wrapped in base::NoDestructor per Chromium style for non-trivially
destructible types
- Change heap-headroom and cage-limit logs from ERROR to INFO since
users cannot act on these diagnostics
- Add comment explaining why base class is called last in
WillDestroyWorkerContextOnWorkerThread (OOM deregistration ordering)
Made-with: Cursor
* fix: skip OOM stack trace registration for worklet contexts
Worklets can share a thread and isolate via WorkletThreadHolder's
per-process singleton pattern. With per-thread OOM state, the first
worklet to be destroyed would prematurely remove the callback for
any remaining worklets on the same thread. Skip worklets entirely
to avoid this; can be revisited with ref-counting if needed.
Made-with: Cursor
* fix: prevent dangling raw_ptr<v8::Isolate> in OOM state
The OomState held a raw_ptr<v8::Isolate> that outlived the isolate on
the main thread: gin::IsolateHolder destroyed the isolate during
shutdown, but the OomState (stored in thread-local storage) was only
released later in JavascriptEnvironment::~JavascriptEnvironment. This
triggers a dangling pointer check when building with
enable_dangling_raw_ptr_checks.
Register OomState as a gin::PerIsolateData::DisposeObserver so it
clears the raw_ptr and removes the NearHeapLimitCallback before the
isolate is destroyed, regardless of destructor ordering.
Suggested-by: Deepak Mohan
Made-with: Cursor
* test: verify OOM crash keys end-to-end via crash reporter
Replace stderr-based OOM tests with end-to-end crash dump validation.
Instead of parsing log output, start a crash reporter server, trigger
renderer OOM, and verify the uploaded crash dump contains the expected
`electron.v8-oom.*` annotations — the same code path production crash
reports take.
Consolidate all OOM test scenarios (basic heap leak, JSON.stringify,
web worker) into a single `describe('OOM crash keys')` block inside
api-crash-reporter-spec using the existing crash fixture app with new
renderer-oom-json and renderer-oom-worker crash types.
The web worker test verifies that OOM crash keys are present but does
not assert on the JS function name: the 20 MB heap bump may be
exhausted before V8 reaches a safe point to fire the stack-capture
interrupt, leaving the crash key at "(stack pending)". Increasing the
bump or switching to a synchronous capture strategy would fix this but
is left for a follow-up.
Remove the standalone oom-stack-trace-spec.ts and its fixture app.
Made-with: Cursor
---------
Co-authored-by: Niklas Wenzel <dev@nikwen.de>
* chore: use emplace and use it correctly * chore: redundant cast to the same type [google-readability-casting] * chore: do not create objects with +new [google-objc-avoid-nsobject-new] * chore: default arguments on virtual or override methods are prohibited [google-default-arguments] * chore: warning: C-style casts are discouraged; use static_cast [google-readability-casting] CFLocaleGetValue already returns CFTypeRef so that redundant static_cast was removed * chore: refactor block to avoid use after move warning from clang-tidy Looks like clang-tidy couldn't tell these were two mutually exclusive branches so there was no actual issue, but refactoring is cleaner anyway since it makes it more DRY. * chore: C-style casts are discouraged; use static_cast [google-readability-casting] No cast needed here, everything is already the correct type * chore: C-style casts are discouraged; use static_cast/const_cast/reinterpret_cast [google-readability-casting] * chore: use '= default' to define a trivial destructor [modernize-use-equals-default] * chore: use range-based for loop instead [modernize-loop-convert] * chore: redundant void argument list [modernize-redundant-void-arg] * chore: address code review feedback * chore: use auto Co-authored-by: Charles Kerr <charles@charleskerr.com> --------- Co-authored-by: Charles Kerr <charles@charleskerr.com>
refactor: migrate api::ServiceWorkerContext to cppgc
* refactor: migrate api::Extensions to cppgc * chore: update patch indices
…access_blocklist.patch` (#50909) chore: remove some unnecessary diffs in refactor_expose_file_system_access_blocklist.patch
Adds a new skill mirroring the Chromium upgrade skill, adapted for Node.js rolls. Covers patch conflict resolution, build fix workflow, commit guidelines, and documents high-churn patches and major version upgrade patterns (V8 bridge patch deletions, BoringSSL complexity).
* build: add oxfmt for code formatting and import sorting
Adds oxfmt as a devDependency alongside oxlint and wires it into the
lint pipeline. The .oxfmtrc.json config matches Electron's current JS
style (single quotes, semicolons, 2-space indent, trailing commas off,
printWidth 100) and configures sortImports with custom groups that
mirror the import/order pathGroups previously enforced by ESLint:
@electron/internal, @electron/*, and {electron,electron/**} each get
their own ordered group ahead of external modules.
- `yarn lint:fmt` runs `oxfmt --check` over JS/TS sources and is
chained into `yarn lint` so CI enforces it automatically.
- `yarn format` runs `oxfmt --write` for local fix-up.
- lint-staged invokes `oxfmt --write` on staged .js/.ts/.mjs/.cjs
files before oxlint, so formatting is applied at commit time.
The next commit applies the formatter to the existing codebase so the
check actually passes.
* chore: apply oxfmt formatting to JS and TS sources
Runs `yarn format` across lib/, spec/, script/, build/, default_app/,
and npm/ to bring the codebase in line with the .oxfmtrc.json settings
added in the previous commit. This is a pure formatting pass: import
statements are sorted into the groups defined by the config, method
chains longer than printWidth are broken, single-quoted strings
containing apostrophes are switched to double quotes, and a handful of
single-statement `if` bodies are re-wrapped and get braces added by
`oxlint --fix` to satisfy the `curly: multi-line` rule.
No behavior changes.
…en` (#50874) fix: simpleFullScreen exits when web content calls requestFullscreen SetHtmlApiFullscreen only checked IsFullscreen() to detect that the window was already fullscreen, missing the simple-fullscreen case on macOS. When web content triggered requestFullscreen the code fell through to SetFullScreen(true) which toggled simple fullscreen off. Include IsSimpleFullScreen() in the guard so the HTML-API fullscreen state is updated without touching the window's fullscreen mode.
…0451) * chore: update PR template and add AI tool policy to CONTRIBUTING.md * sentencesmithing
chore: fix oxfmt formatting in api-browser-window-spec Co-authored-by: Claude <noreply@anthropic.com>
* ci: ignore canceled jobs in audit * chore: add another variation
… bytecode (#51602) * perf: push sandboxed renderer startup data via mojo instead of sync IPC Replaces the BROWSER_SANDBOX_LOAD sync IPC pull with a mojo push (ElectronFrameStartup.SetStartupData) sent from the browser at ReadyToCommitNavigation, ahead of CommitNavigation. The push carries preload script contents (as BigBuffer, shared-memory backed for large bundles), the browser's environment snapshot, and process.helperExecPath. The sync IPC parked the renderer main thread on a browser UI-thread roundtrip during every navigation. Its handler was async with await fs.promises.readFile() per preload, so under UI-thread contention each await yielded a turn to other startup work and the stall amplified ~5-8x with two preloads — measured at ~97ms with 20ms busy chunks. The push eliminates the roundtrip entirely; the renderer reads the data from a per-frame cache that is guaranteed to be populated before DidCreateScriptContext fires, because the message is associated with the navigation channel and ordered before CommitNavigation. The legacy sync IPC remains as a fallback for the cases the push does not yet cover (devtools extension subframes, service worker preload realms). process.arch/platform/version/versions are no longer shipped over the wire — they are identical in the renderer (same Electron binary) and are populated from node::per_process::metadata locally. * perf: remove BROWSER_SANDBOX_LOAD sync IPC entirely The previous commit kept the sync IPC as a fallback for paths that don't get a per-frame ElectronFrameStartup push: service worker preload realms (no RenderFrame, worker thread) and window.open() child windows whose synchronous about:blank document is created before the browser knows the window exists. Both now have a dedicated push and the IPC is removed: Service workers — a per-process associated mojom::ElectronWorkerStartup interface is registered via a RenderThreadObserver and the browser pushes from RenderProcessHostObserver::RenderProcessReady(), strictly before any StartWorker can spawn a worker thread. Cached behind a lock + WaitableEvent so the worker thread can block on it. Re-pushed when SW preload scripts are registered or unregistered while a renderer is alive. window.open() child windows — the popup's RenderFrame, its synchronous about:blank document, and its preload all happen inside the renderer's window.open() call stack, after the [Sync] CreateNewWindow IPC returns and before control returns to page script. No async browser-to-renderer mojo message can land in time. The browser does, however, know everything about the popup during CreateNewWindow (it just ran setWindowOpenHandler and may have overridden the preload, partition, etc.), so the only correct zero-extra-IPC transport is to attach the data to the CreateNewWindowReply itself. A new Chromium patch adds an opaque mojo_base.BigBuffer? field to CreateNewWindowReply, plus ContentBrowserClient::GetExtraCreateNewWindowReplyData() and ContentRendererClient::SetPendingCreateNewWindowStartupData() hooks; the renderer stashes the deserialized data process-globally for the next ElectronApiServiceImpl constructor on the same call stack. The browser-side data is built by a new renderer_startup_data::Build() helper shared by the navigation push, the per-process SW push, and the CreateNewWindowReply path. process.env is captured fresh per push via uv_os_environ() — same per-navigation timing as the legacy { ...process.env } spread. process.arch/platform/version/versions are filled from node::per_process::metadata in the renderer (same Electron binary) instead of being shipped over the wire; cldr/tz are runtime ICU state and computed directly from the renderer's ICU. BROWSER_NONSANDBOX_LOAD remains for non-sandboxed renderers — it returns preload paths only (no contents, no env spread), so the contention amplification doesn't apply. Verified against stock Electron 42.0.1 that window.open() popups with setWindowOpenHandler-overridden preloads behave identically. * perf: V8 code cache for sandboxed preload scripts Adds an in-memory + on-disk V8 code cache for preload scripts so the parse + top-level codegen cost is paid once per preload per Electron version instead of per navigation, and moves preload script compilation fully into native code so the contents and cache never bounce through the V8 heap. createPreloadScript() now takes (scriptId, paramNames) instead of a wrapped source string. It looks up the preload contents and code cache directly from the per-frame ElectronApiServiceImpl's mojo-cached startup data — the contents stay in the BigBuffer until a single NewFromUtf8() copy for the compile (rather than BigBuffer → V8 string → template-literal concat → flatten, ~150 KB of allocation and 2-3 copies per preload eliminated), and the cache bytes never enter V8 at all (BufferNotOwned for consume, direct BigBuffer construction from the produced CachedData for ship-back over ElectronWebContentsUtility.SetPreloadCodeCache). BuildStartupData() exposes hasContents instead of contents to JS. The compile uses ScriptCompiler::CompileFunction() with the parameter names directly instead of a string-templated (function(p0, p1, ...){…}) wrapper — no concat, no flatten, and preload stack traces get correct line numbers (the wrapper offsets every line by 1 with no ScriptOrigin::lineOffset compensation). The browser keys the cache by sha256(id) and persists it to userData/Code Cache/electron-preload/. V8's CachedData validation handles invalidation: a blob from a different V8 version, flag set, or source is rejected at consume time, the renderer compiles from source and ships a fresh blob, and the stale one is overwritten. Producing the cache during the cold compile adds ~25% to the first navigation per launch; warm navigations skip the parse (~5 ms saved per nav in a debug build, ~22% reduction in pre-parse blocking time). Service-worker preload realms look up contents from a clone of the worker startup data captured on ServiceWorkerData when the preload realm is created. They have no per-frame ship-back channel so they consume but never produce caches; the experimental --service-worker-preload flow is otherwise unchanged. * test: add spec coverage for preload startup data push and code cache - preload code cache: produces and persists a blob to userData/Code Cache/electron-preload/, runs the preload identically when consuming the cache, rejects and re-produces a corrupt disk cache (V8 CachedData validation rejects garbage and version-mismatched blobs and the renderer self-heals). - preload script stack traces: errors report correct line numbers and the preload's real file path instead of <anonymous>, sandboxed and not. CompileFunction() with an explicit ScriptOrigin gets both right; the legacy template-string wrapper had neither. - service worker preload realm: process.env, process.execPath, process.arch/platform/version, and process.versions.electron/chrome/node are populated from the per-process ElectronWorkerStartup push. - window.open() popup preload: the popup's synchronous about:blank document runs the preload from setWindowOpenHandler's overrideBrowserWindowOptions when set (delivered via CreateNewWindowReply), no preload when only security prefs are inherited (matching legacy Electron), and the opener's preload when explicitly carried through the override. * Delete .claude/scheduled_tasks.lock * refactor: address PR review feedback Review fixups independent of the service-worker delivery change: - preload_code_cache: DCHECK Get/Set are UI-thread only; SKIP_ON_SHUTDOWN for the disk write so an in-flight write isn't abandoned mid-write. Did NOT take the suggested first-writer-wins guard — Get() memoizes a corrupt on-disk blob (only V8 can validate it), so a guard keying on 'entry exists' would pin a bad cache and break the self-heal path; the duplicate-ship case is rare, identical bytes, and Set() is UI-thread serialized so it isn't a data race. - WebContentsPreferences::ShouldUseSandbox(): extract the duplicated 'null prefs => default sandboxed, --enable-sandbox forces sandbox' check used by the per-frame push. - preload_utils: LookupPreloadScript returns const PreloadScriptData* not const unique_ptr<>*; param name V8 conversion moved below the null-check so a missing script bails without paying for it. - electron_api_service_impl: drop unused TakeStartupData(); DCHECK the window.open pending-data slot is touched only on the renderer main thread; tighten the stale startup_data() comment. - Stop assigning the unused PreloadScriptData.type field (the field itself is removed in the following commit with its last setters). * perf: deliver service worker preload data via EmbeddedWorkerStartParams Replaces the per-process ElectronWorkerStartup push + the renderer-side cross-thread global (ElectronRenderThreadObserver: a process-global WaitableEvent + lock the SW worker thread could block on) with delivery through the service worker's own EmbeddedWorkerStartParams. A new ContentBrowserClient::GetServiceWorkerStartupData() hook populates an opaque BigBuffer on the start params; it rides the marshalling StartWorker already performs (GlobalScopeCreationParams moved onto the worker thread by WorkerThread::Start), so the data arrives on the worker thread ordered with worker creation — no global, no lock, no blocking wait, and no 'worker raced the push' edge case to handle. The renderer reads it off WebServiceWorkerContextProxy::ElectronPreloadData() (backed by WorkerGlobalScope) when it builds the preload realm. GetServiceWorkerStartupData() early-returns when the session has no service-worker preloads, so the asar reads + serialization no longer run on every renderer at RenderProcessReady() (addresses the SendToProcess cost raised in review). Registry changes are picked up automatically — the data is rebuilt from SessionPreferences on every StartWorker — so Session::BroadcastWorkerStartupData and its re-push on register/ unregister are removed. Also folds, since they share these files: removal of the now-unused PreloadScriptData.type field and its last setters, the CreateNewWindowReply target_url gate so the embedder blob isn't built for popups that navigate (review feedback), and the corrected CreateNewWindowReply patch commit message.
* fix: native addon compilation with msvc * spec: add dependency on cppgc header
* ci: adjust clang-tidy macOS runner size * ci: try fewer jobs on macOS due to less RAM * ci: try 5 jobs for macOS * ci: add macOS job count comment
* feat: add net.WebSocket
Add a WHATWG-compatible WebSocket client to the net module, backed by
Chromium's network stack via NetworkContext::CreateWebSocket(). This
gives main-process code a WebSocket that goes through the session's
proxy configuration, certificate verification, and cookie store, with
the same drop-in API shape as the browser/Node global WebSocket.
The implementation has two pieces:
- shell/browser/api/electron_api_web_socket.{h,cc}: a gin-wrapped object
that implements network.mojom.{WebSocketHandshakeClient, WebSocketClient,
WebSocketAuthenticationHandler}, drives the mojo data pipes with
back-pressure on both sides, reassembles fragmented frames, tracks
bufferedAmount, and emits low-level events.
- lib/browser/api/net-websocket.ts: a class WebSocket extends EventTarget
that implements the WHATWG surface (addEventListener, on{open,message,
error,close}, readyState, bufferedAmount, protocol, extensions,
binaryType, send(), close(), CONNECTING/OPEN/CLOSING/CLOSED) plus
Electron-specific options (headers, origin, useSessionCookies, session,
partition).
binaryType supports 'nodebuffer' (default), 'arraybuffer', and 'blob'.
useSessionCookies defaults to false, matching net.request(). The Origin
header defaults to the http(s) equivalent of the WebSocket URL's origin
so that the connection looks first-party for SameSite cookie purposes;
it can be overridden with the origin option.
Main process only for now; webRequest interception is a known follow-up.
* fix: address review findings and migrate WebSocketWrapper to gin::Wrappable
Migrate WebSocketWrapper from gin_helper::DeprecatedWrappable to
gin::Wrappable (cppgc-based, #47922):
- Add kElectronWebSocket wrappable pointer tag.
- Replace Pin()/Unpin() with gin_helper::SelfKeepAlive, cleared on teardown.
- Replace base::WeakPtrFactory with gin::WeakCellFactory + gin::WrapPersistent
for callbacks; add Trace() to visit the weak cell.
- Annotate mojo::Receiver/Remote fields with GC_PLUGIN_IGNORE (browser process
doesn't need execution-context tracking), matching UtilityProcessWrapper.
- Public constructor for cppgc::MakeGarbageCollected; Create() returns T*.
Spec and correctness fixes:
- Drop the unused WebSocketAuthenticationHandler. The 'login' event it emitted
was never bridged to the WHATWG-only TS surface, leaving the mojo
OnAuthRequired callback orphaned and the connection hung on a 401/407
challenge until V8 GC. Pass NullRemote() so the network service fails the
challenge fast (matching WebSocketConnectorImpl). Drop the 'authenticated
proxies' claim from the docs.
- Serialize the send queue so a Blob send (which must read asynchronously)
doesn't let a later string/ArrayBuffer send overtake it on the wire.
- Set readyState to CLOSED before dispatching the 'error' event, per the
WebSocket spec ordering rules.
- Stop nulling the wrapper on close so bufferedAmount reflects untransmitted
bytes (it must not reset to zero) and continues to count post-close sends.
- Use WebIDL [Clamp] semantics for the close() code argument.
- Disable permessage-deflate on the test ws server; it isn't the subject under
test and ws@7's deflate close path can race a server-initiated close.
* chore: correct copyright holder in new files
* fix: address review feedback
- Track all bytes queued in the JS send chain (not just Blob reads) so
bufferedAmount is accurate while a non-Blob send is waiting behind an
asynchronous Blob read.
- Surface the network failure message and net error in CloseEvent.reason
for connection failures (the WHATWG 'error' Event has no payload). Failure
reasons from the network service already embed the net error name; only
append it for internally-generated failures.
- Emit a Node Buffer from the C++ side via electron::Buffer::Copy() instead
of a raw ArrayBuffer, avoiding a TS-side wrap on the default 'nodebuffer'
path.
- Drop the redundant disconnect handler on the WebSocket remote; the
WebSocketClient receiver and the remote terminate at the same WebSocketImpl
in the network process.
* chore: remove accidentally committed lock file
* chore: bump chromium in DEPS to 150.0.7839.0 * chore: bump chromium in DEPS to 150.0.7840.0 * fix(patch-conflict): update sqlite rename_exports.h for sqlite 3.53.1 upgrade The sqlite amalgamation was rolled to 3.53.1, which regenerated rename_exports.h with new line numbers for all exports. Updated the patch context to match the new file while preserving the win32 export renames. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7828672 Co-Authored-By: Claude <svc-devxp-claude@slack-corp.com> * chore: update patch hunk headers Co-Authored-By: Claude <svc-devxp-claude@slack-corp.com> * 7836112: inline media_capture_util after upstream removal Upstream removed extensions/browser/media_capture_util.h/cc as dead code after deleting app_shell. Electron still needs GrantMediaStreamRequest and VerifyMediaAccessPermission, so inline the logic directly into ElectronExtensionHostDelegate. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7836112 * 7801320: add embedded param to GetExtensionIdForMimeType and body_cache to SendExecuteMimeTypeHandlerEvent Upstream added an `embedded` parameter to PluginUtils::GetExtensionIdForMimeType to honor MIME handler can_embed settings, and a `body_cache` parameter to SendExecuteMimeTypeHandlerEvent for PDF fallback-to-native replay. Updated Electron's implementations to accept the new parameters. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7801320 Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7781210 * fix(patch-update): update kIcCloseIcon to kIcCloseOldIcon in picture-in-picture patch Upstream renamed ui/views/vector_icons/ic_close.icon to ic_close_old.icon, which changes the generated symbol from kIcCloseIcon to kIcCloseOldIcon. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7795717 * chore: bump chromium in DEPS to 150.0.7841.0 * fix(patch-conflict): update picture-in-picture patch for kCloseChromeRefresh icon rename Upstream renamed kCloseChromeRefreshIcon to kCloseChromeRefreshOldIcon in the same sweep that renamed kIcCloseIcon to kIcCloseOldIcon. Updated the patch to reference kCloseChromeRefreshOldIcon in the GOOGLE_CHROME_BRANDING guard. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7795717 * chore: update patch hunk headers * 7795717: update window control icon names for upstream rename Upstream renamed all views vector icons with an "Old" suffix as part of the GlowUp icon refresh. Updated kWindowControlMinimizeIcon, kWindowControlMaximizeIcon, kWindowControlRestoreIcon, and kWindowControlCloseIcon to their *OldIcon variants. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7795717 * chore: regenerate filenames.libcxx.gni Removed ctype.h, fenv.h, and inttypes.h which were deleted upstream. * chore: remove obsolete siso patches Upstream rewrote file_parser.go's readFile to use mmapfile.Read instead of os.Open + chunked ReadAt goroutines. The race condition in bindflt.sys that these patches worked around (redundant CreateFileW calls under concurrent opens) can no longer occur with the new mmap-based approach. Also guard the git am step against an empty patches directory. * chore: bump chromium in DEPS to 150.0.7843.0 * chore: bump chromium in DEPS to 150.0.7844.0 * fix(patch-conflict): update mas patch for CATransactionV2 feature guard Upstream guarded the CAContext reallocation on resize behind the kCATransactionV2 feature flag. Updated the MAS build guard to preserve this new condition alongside the existing allow_remote_layers_ check. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7850052 Co-Authored-By: Claude <svc-devxp-claude@slack-corp.com> * chore: update patch hunk headers Co-Authored-By: Claude <svc-devxp-claude@slack-corp.com> * fixup! 7836112: inline media_capture_util after upstream removal * fixup! chore: remove obsolete siso patches * 7832184: [asm.js] Disable asm.js-to-Wasm translation The codepath that produced the warning this Node.js test was asserting on is no longer taken after the upstream change. Refs https://chromium-review.googlesource.com/c/v8/v8/+/7832184 * chore: update patches * chore: back out unrelated formatting changes --------- Co-authored-by: electron-roller[bot] <84116207+electron-roller[bot]@users.noreply.github.com> Co-authored-by: Keeley Hammond <khammond@slack-corp.com> Co-authored-by: Claude <svc-devxp-claude@slack-corp.com> Co-authored-by: David Sanders <dsanders11@ucsbalum.com>
#51697) * build: dedupe get-intrinsic to shrink the sandboxed renderer bundle The hoisted get-intrinsic resolved to 1.2.1 (satisfying the older ^1.0.2..^1.2.0 consumers), so side-channel-weakmap, side-channel-map, call-bound and es-set-tostringtag — which need ^1.2.5/^1.3.0 — each pulled a nested get-intrinsic@1.3.0 copy. webpack bundled three of those nested copies into sandbox_bundle.js (~16.5 KB each). 1.3.0 satisfies every range in the tree (all ^1.x), so pin it via resolutions to collapse to a single copy. Drops sandbox_bundle.js from 364,762 to 323,116 bytes (-41,646, -11.4%) — that bundle is parsed/preparsed in every sandboxed renderer before the HTML parser, so this is a direct per-renderer startup win on top of the IPC and code-cache changes. * perf: build-time V8 code cache for the electron/js2c framework bundles Generate a V8 code cache for Electron's embedded electron/js2c/* bundles at build time and embed it in the binary, so each process deserializes its framework bundle (kConsumeCodeCache) instead of parsing and compiling it from source at startup. V8's code-cache key includes FlagList::Hash() over non-default flags and the snapshot's read-only checksum, both of which differ per process type, so one cache variant is generated per flavor and each process consumes the matching one: sandbox : sandboxed renderer, no Node env (+SAB) renderer : normal renderer, has Node env (+SAB +rehash +no-freeze) browser : main process (+rehash +no-freeze) utility : utility process (+rehash +no-freeze) worker : node/web worker (+rehash +no-freeze) All flavors create their isolate from the v8 context snapshot. The flag deltas are deterministic; --no-freeze-flags-after-init (present iff the process has a Node Environment) lets V8 recompute the flag-hash after init, so the consume-time hash of every node-env process includes --rehash-snapshot. A sandboxed renderer has no Node env (flags stay frozen) so it is a distinct flavor, discriminated at runtime by node::Environment::GetCurrent(context). The generator compiles each bundle with kEagerCompile so the cache covers the inner functions, not just the top-level wrapper -- the framework bundles run in full at startup, so this front-loads the lazy compiles to build time. Cross-arch is supported (the generator is built in v8_snapshot_toolchain so it links V8 with V8_TARGET_ARCH set to the target and reads the target's snapshot blob); cross-OS is untested and gated off. - electron_natives_codecache_main.cc: per-flavor build-time generator compiling each bundle through the same BuiltinLoader path its runtime consumer uses. - shell/common/js2c_bundle_ids.h: shared bundle ids and wrapper-function param names used by the generator and the runtime CompileAndCall call sites, so the source/params hash matches by construction. - node_util.cc feeds the standalone loader; FeedEnvironmentCodeCache feeds the per-Environment loader before LoadEnvironment so the *_init bundles are consumed. - Test-only (DCHECK builds, compiled out of production): a per-process id->accepted status map exposed via v8_util.getJs2cCodeCacheStatus, a sandboxed-preload shim, and spec/api-js2c-code-cache-spec.ts which spawns a clean app and asserts every bundle is consumed in browser/sandbox/renderer/utility. DidClearWindowObject (sandboxed renderer, pre-HTML-parser): ~9.8 ms (cache rejected/absent) -> ~6.4 ms (eager cache consumed), a ~3.4 ms / ~35% cold-start win on every launch. No V8 patch. * chore: export node patch for the js2c build-time code cache
chore: remove Unity service and Unity-specific APIs
The shell: process.platform === 'win32' option in installSpecModules() was originally needed when this spawn invoked npx.cmd directly. Node throws EINVAL on .cmd files without shell: true (see #41893). #48243 (yarn v4 migration) replaced the npx.cmd invocation with a direct process.execPath spawn of the bundled yarn-4.11.0.cjs runtime, but the shell: true option was carried over unchanged from the previous block. For node.exe (a real .exe) shell: true is unnecessary, and on Windows it actively breaks the install: cmd.exe word-splits the unquoted process.execPath on whitespace, so when Node is installed at the default location (C:\Program Files\nodejs\node.exe) the spawn fails to find the executable. Drop the option; Node handles paths with spaces natively when spawning a real executable without shell. Notes: none
* chore: bump chromium in DEPS to 150.0.7847.0 * chore: update patches * 7845702: Speculative fix for pdf summarize button on ChromeOS. Refs https://chromium-review.googlesource.com/c/chromium/src/+/7845702 --------- Co-authored-by: electron-roller[bot] <84116207+electron-roller[bot]@users.noreply.github.com> Co-authored-by: David Sanders <dsanders11@ucsbalum.com>
Assisted-by: Claude Opus 4.7
* chore: bump chromium in DEPS to 150.0.7849.0 * chore: update patches * 7850982: [MenuSimplification] Plumb UsesNativeSystemMenu through Views HWND APIs Refs https://chromium-review.googlesource.com/c/chromium/src/+/7850982 * 7789842: views: Add Windows-only support for excluding Widgets from screen capture Refs https://chromium-review.googlesource.com/c/chromium/src/+/7789842 Assisted-by: Claude Opus 4.7 --------- Co-authored-by: electron-roller[bot] <84116207+electron-roller[bot]@users.noreply.github.com> Co-authored-by: David Sanders <dsanders11@ucsbalum.com>
* chore: turn off analytics setup assistant prompts on macOS * build: just kill Setup Assistant * build: try using sudo to kill Setup Assistant * ci: use su to killall Setup Assistant
…51674) Delegated source lists signal user selection using `OnDelegatedSourceListSelection`, not `OnSourceAdded`. `BaseCapturerPipeWire` adds a placeholder source to preserve the interface shape, but it doesn't mean anything. Ignore `OnSourceAdded` and don't timeout after 3 seconds in case of delegated lists. Assisted-By: Claude Opus 4.7, Claude Code
…#51703) * perf: boot the browser process from an embedded Node startup snapshot Build a Node startup snapshot at build time (node_mksnapshot, gated to native builds) and create the browser-process isolate from it so the Node bootstrap is deserialized instead of re-parsed and re-compiled at every app start. The snapshot is generated by extending the same V8 startup snapshot the rest of the process uses (snapshot_blob.bin), so the read-only heap is shared and V8's one-snapshot-per-process invariant holds. node_snapshot (a separate source_set in third_party/electron_node:unofficial.gni) provides the strong SnapshotBuilder::GetEmbeddedSnapshotData over a now- weak no-op stub; electron_lib deps it so the shipped framework links the real snapshot while node_mksnapshot (which only links libnode + the weak stub) does not -- avoiding the GN dependency cycle that v8_snapshot_ toolchain == default_toolchain would otherwise force on native builds. Browser process only: - javascript_environment.cc: when the embedded snapshot is present, CreateIsolateHolder feeds its blob + external references into the isolate CreateParams (gin passes nullptr external refs so there is no conflict; the browser process has no blink). The ctor skips node::NewContext -- the main context is materialized from the snapshot inside node::CreateEnvironment. - electron_browser_main_parts.cc: passes an empty context to Initialize/CreateEnvironment in the snapshot path; enters the deserialized context after. - node_bindings.cc: CreateEnvironment defers context-dependent setup until the snapshot's main context exists; CreateIsolateData receives the snapshot's per-isolate data; LoadEnvironment merges the build-time js2c cache for electron/js2c/* with the snapshot's per-builtin cache. Renderer / sandboxed renderer / utility / worker processes are unchanged. Measured impact (Testing build, macOS arm64): V8 compile/parse on the browser-process critical path drops from ~17 ms to ~12 ms top-level (V8.PreParse 1003 -> 24 events, V8.ParseProgram 8 -> 0.7 ms), but the 4.4 MB snapshot adds ~5 ms of deserialize cost (V8.DeserializeContext 2.6 ms + V8.DeserializeIsolate 2.0 ms + V8.CompileDeserialize 1.4 ms), so the net wall-clock change is within run-to-run noise. The Testing build keeps every DCHECK in V8's deserializer hot loop compiled in (dcheck_always_on=true); the snapshot-vs-recompile trade-off is expected to be more favorable in Release builds where those are compiled out and the deserialize is mostly memcpy + relocate. Needs a Release benchmark to determine whether this is a net win. The build-time js2c code cache for the browser process is generated against the embedded snapshot's isolate (a dedicated electron_natives_codecache_snapshot host tool links the real node_snapshot and compiles browser_init/node_init via GetEmbeddedSnapshotData + InitializeIsolateParams). A SnapshotCreator- produced snapshot owns a unique read-only-heap checksum that matches no standalone blob, so this is the only way the browser bundles' code-cache read-only checksum matches the runtime isolate; the other flavors keep using the v8 context snapshot. * fix: restore preventDefault on native events in the snapshot path The eager gin_helper Event-constructor warm-up in NodeBindings::Initialize was guarded out when booting from the embedded Node startup snapshot (the context is empty there), on the mistaken assumption the Event ObjectTemplate would be populated lazily. For gin Constructible classes the template -- which carries preventDefault()/defaultPrevented -- is only ever populated by GetConstructor(), so every native gin event emitted in the snapshot-booted browser process was missing those members (e.g. TypeError: event.preventDefault is not a function on -before-unload-fired, will-navigate, etc.). Run the warm-up in CreateEnvironment once the snapshot's main context has been materialized and entered. The template is cached per-isolate, so a single call covers the isolate lifetime as before. * fix: skip the embedded snapshot in the ELECTRON_RUN_AS_NODE path The ELECTRON_RUN_AS_NODE entry point (shell/app/node_main.cc, used by child_process.fork) runs without a --type switch, so IsBrowserProcess() is true for it and JavascriptEnvironment created its isolate from the embedded Node startup snapshot. But node_main.cc builds its IsolateData without snapshot_data and passes a fresh context, so node's CreateEnvironment tripped CHECK_NOT_NULL(isolate_data->snapshot_data()) and the forked process aborted. Gate the snapshot on a new IsRunningAsNode() helper so only the genuine browser process consumes it; the run-as-node path boots a fresh isolate as before. The run-as-node check is lifted out of crash_keys.cc into process_util so both callers share one definition. * fix: avoid double uncaughtException delivery in the snapshot path When the browser process boots from the embedded Node snapshot, node::CreateEnvironment registers the per-isolate message listener while deserializing the snapshot (SetIsolateErrorHandlers in node's src/api/environment.cc, reached only on the snapshot path). Electron's own SetIsolateUpForNode then registered the same listener again, and because V8 message listeners are additive, every uncaught error -- and the uncaughtException that follows -- was delivered twice. A throwing webContents.setWindowOpenHandler surfaced this (guest-window-manager spec). Skip Electron's duplicate registration when booting from the snapshot: the snapshot-registered PerIsolateMessageListener is identical, and the custom fatal/OOM handlers are setters that still take effect. * chore: address review feedback on the snapshot patch - node_mksnapshot: read the base V8 snapshot blob with node::ReadFileSync instead of ifstream/stringstream, reporting a clear error on a missing or unreadable path rather than silently producing an empty blob. - Fix a misleading comment: the Node startup snapshot's embedded code cache and Electron's build-time js2c cache are NOT disjoint -- both carry the electron/js2c/* bundles node_mksnapshot compiled -- so RefreshCodeCache's insert_or_assign (build-time entry wins) is intentional, not a latent replace-vs-emplace bug. Correct the same claim in LoadEnvironment. * fix: register fast-API CFunction objects as snapshot external references V8 CL 7828135 ("[fastapi] Store v8::CFunction pointer directly in FunctionTemplateInfo", already in our pinned V8) wraps the v8::CFunction in a Foreign instead of a Managed<>, which restores serialization of FunctionTemplateInfo. The snapshot serializer now encodes the CFunction object's address, so ExternalReferenceRegistry::Register(CFunction) must register &c_func alongside GetAddress()/GetTypeInfo(). With that, node_mksnapshot serializes fast-API FunctionTemplates with c_function intact, so the DropCFunctionForSnapshot workaround -- which forced the snapshot's templates onto their slow callbacks -- is removed. The browser process keeps the V8 fast-API paths.
* chore: bump chromium in DEPS to 150.0.7851.0 * 7860920: [GlowUp] Create rounded components/vector_icons/ icons Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7860920 * 7865783: Remove `CookiePartitionKeyCollection::Todo()` Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7865783 * chore: update chromium upgrades skill guidelines Skip-Lint: Internal infrastructure commit * chore: bump chromium in DEPS to 150.0.7853.0 * chore: update patches Skip-Lint: no meaningful changes made here * 7864420: CATransactionV2: Several fixes Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7864420 Moved `#ifdef` in ui/accelerated_widget_mac/ca_layer_tree_coordinator.mm due to upstream refactor. * 7866423: Print Preview: Remove PrintManagerHost.UpdatePrintSettings() dict param Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7866423 * chore: update patches * chore: bump chromium in DEPS to 150.0.7855.0 * chore: bump chromium in DEPS to 150.0.7857.0 * chore: bump chromium in DEPS to 150.0.7859.0 * Revert "chore: bump chromium in DEPS to 150.0.7859.0" This reverts commit 6c4c458. Skip-Lint: reverting commit to pickup automated changes. * chore: update patches * 7866423: Print Preview: Remove PrintManagerHost.UpdatePrintSettings() dict param Restore an Electron-specific `UpdatePrintSettings(dict)` Mojo method that the renderer-side `InitPrintSettings` calls when the browser passes settings via `webContents.print(options)`. The browser-side implementation pushes the dict onto the `print_preview_settings_` queue and delegates to upstream's renamed `GetPrintPreviewParams()`. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7866423 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fixup! 7864420: CATransactionV2: Several fixes --------- Co-authored-by: electron-roller[bot] <84116207+electron-roller[bot]@users.noreply.github.com> Co-authored-by: Charles Kerr <charles@charleskerr.com> Co-authored-by: John Kleinschmidt <kleinschmidtorama@gmail.com> Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
* add minimize event wayland note * add minimize event wayland note to browser window * fix WCO typo in web contents * fix WCO typo in chore_modify_chromium_handling_of_mouse_events.patch
* chore: bump chromium in DEPS to 150.0.7863.0 * 7872896: [iOS Blink] Fix build breaks in ca_layer_tree_coordinator.mm Upstream relocated the closing brace of the `if (!ca_context_)` block to after `#endif // !BUILDFLAG(IS_IOS) || BUILDFLAG(IS_IOS_TVOS)`. Repositioned the MAS `#endif` accordingly so the IS_MAS_BUILD guard still wraps the entire function body. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7872896 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> Signed-off-by: John Kleinschmidt <kleinschmidtorama@gmail.com> * 7876807: [GlowUp] Adjust icons Upstream renamed vector_icons::kCloseIcon to kCloseSmallIcon. Updated the Google-branded icon fallback in the PiP close button patch accordingly. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7876807 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> Signed-off-by: John Kleinschmidt <kleinschmidtorama@gmail.com> * 7839163: Reland "Roll out Apple Linker for macOS non-official builds" Upstream moved the use_thin_lto declaration to an earlier declare_args() block and folded is_mac + (is_ios && use_lld) into a single is_apple condition. Re-targeted the patch at the new location and replaced is_apple with is_ios so thin LTO remains disabled on macOS while staying enabled for iOS. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7839163 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> Signed-off-by: John Kleinschmidt <kleinschmidtorama@gmail.com> * 7867233: text-fit: Rename FitText, FitTextType, FitTextTarget, and FitTextMethod Upstream renamed FitText -> TextFit (and ConvertFitText -> ConvertTextFit). Updated the corner-smoothing patch's surrounding declarations and definitions to match the new name, keeping the inserted ConvertCornerSmoothing entry just before ConvertTextFit. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7867233 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> Signed-off-by: John Kleinschmidt <kleinschmidtorama@gmail.com> * chore: update patches * 7777607: Replace ui::DomKey implicit constructor with C++17 inline constexpr Upstream made ui::DomKey's integer constructor explicit, so the implicit conversion from uint32_t no longer works. Cast WebKeyboardEvent::dom_key to ui::DomKey explicitly before calling DomKeyToKeyString. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7777607 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> Signed-off-by: John Kleinschmidt <kleinschmidtorama@gmail.com> * 7872317: [Extensions] Remove duplicate type entries from Manifest::Type Upstream removed the SCREAMING_ENUM_STYLE aliases on extensions::Manifest::Type. Switched from TYPE_EXTENSION to Type::kExtension. Ref: https://chromium-review.googlesource.com/c/chromium/src/+/7872317 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> Signed-off-by: John Kleinschmidt <kleinschmidtorama@gmail.com> --------- Signed-off-by: John Kleinschmidt <kleinschmidtorama@gmail.com> Co-authored-by: electron-roller[bot] <84116207+electron-roller[bot]@users.noreply.github.com> Co-authored-by: chromium-roller[bot] <chromium-roller[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
ci: run builds with -quiet flag Assisted-by: Claude Opus 4.7
Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.35.3 to 4.36.0. - [Release notes](https://github.com/github/codeql-action/releases) - [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md) - [Commits](github/codeql-action@e46ed2c...7211b7c) --- updated-dependencies: - dependency-name: github/codeql-action dependency-version: 4.36.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Bumps [actions/stale](https://github.com/actions/stale) from 10.2.0 to 10.3.0. - [Release notes](https://github.com/actions/stale/releases) - [Changelog](https://github.com/actions/stale/blob/main/CHANGELOG.md) - [Commits](actions/stale@b5d41d4...eb5cf3a) --- updated-dependencies: - dependency-name: actions/stale dependency-version: 10.3.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
20 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
See Commits and Changes for more details.
Created by
pull[bot]
Can you help keep this open source service alive? 💖 Please sponsor : )