Removed unnecessary debugger helper

feat: submit new events for ipcMain

.github/CONTRIBUTING.md

@@ -0,0 +1,137 @@
+# Contributing
+
+## Project Scope
+
+The Electron.NET project ultimately tries to provide a framework for developing cross-platform client applications on the basis of .NET and Electron. Anything that is related to this goal will be considered. The project aims to be as close to Electron with .NET as a basis as possible. If your contribution does not reflect that goal, the chances of accepting it are limited.
+
+## Code License
+
+This is an open source project falling under the [MIT License](../LICENSE). By using, distributing, or contributing to this project, you accept and agree that all code within the Electron.NET project and its libraries are licensed under MIT license.
+
+## Becoming a Contributor
+
+Usually appointing someone as a contributor follows this process:
+
+1. An individual contributes actively via discussions (reporting bugs, giving feedback to existing or opening new issues) and / or pull requests
+2. The individual is either directly asked, invited or asks for contributor rights on the project
+3. The individual uses the contribution rights to sustain or increase the active contributions
+
+Every contributor might have to sign the contributor's license agreement (CLA) to establish a legal trust between the project and its contributors.
+
+## Working on Electron.NET
+
+### Issue Discussion
+
+Discussion of issues should be placed transparently in the issue tracker here on GitHub.
+
+* [General issues, bugs, new features](https://github.com/ElectronNET/Electron.NET/issues)
+* [General discussions, help, exchange of ideas](https://github.com/ElectronNET/Electron.NET/discussions)
+
+### Modifying the code
+
+Electron.NET and its libraries uses features from the latest versions of C# (e.g., C# 10). You will therefore need a C# compiler that is up for the job.
+
+1. Fork and clone the repo.
+2. First try to build the ElectronNET.Core library and see if you get the tests running.
+3. You will be required to resolve some dependencies via NuGet.
+
+The build system of Electron.NET uses NUKE.
+
+### Code Conventions
+
+Most parts in the Electron.NET project are fairly straight forward. Among these are:
+
+* Always use statement blocks for control statements, e.g., in a for-loop, if-condition, ...
+* You may use a simple (throw) statement in case of enforcing contracts on argument
+* Be explicit about modifiers (some files follow an older convention of the code base, but we settled on the explicit style)
+
+### Development Workflow
+
+1. If no issue already exists for the work you'll be doing, create one to document the problem(s) being solved and self-assign.
+2. Otherwise please let us know that you are working on the problem. Regular status updates (e.g. "still in progress", "no time anymore", "practically done", "pull request issued") are highly welcome.
+3. Create a new branch—please don't work in the `main` branch directly. It is reserved for releases. We recommend naming the branch to match the issue being addressed (`feature/#777` or `issue-777`).
+4. Add failing tests for the change you want to make. Tests are crucial and should be taken from W3C (or other specification).
+5. Fix stuff. Always go from edge case to edge case.
+6. All tests should pass now. Also your new implementation should not break existing tests.
+7. Update the documentation to reflect any changes. (or document such changes in the original issue)
+8. Push to your fork or push your issue-specific branch to the main repository, then submit a pull request against `develop`.
+
+Just to illustrate the git workflow for Electron.NET a little bit more we've added the following graphs.
+
+Initially, Electron.NET starts at the `main` branch. This branch should contain the latest stable (or released) version.
+
+Here we now created a new branch called `develop`. This is the development branch.
+
+Now active work is supposed to be done. Therefore a new branch should be created. Let's create one:
+
+```sh
+git checkout -b feature/#777
+```
+
+There may be many of these feature branches. Most of them are also pushed to the server for discussion or synchronization.
+
+```sh
+git push -u origin feature/#777
+```
+
+Now feature branches may be closed when they are done. Here we simply merge with the feature branch(es). For instance the following command takes the `feature/#777` branch from the server and merges it with the `develop` branch.
+
+```sh
+git checkout develop
+git pull
+git pull origin feature/#777
+git push
+```
+
+Finally, we may have all the features that are needed to release a new version of Electron.NET. Here we tag the release. For instance for the 1.0 release we use `v1.0`.
+
+```sh
+git checkout main
+git merge develop
+git tag v1.0
+```
+
+(The last part is automatically performed by our CI system. Don't tag manually.)
+
+### Versioning
+
+The rules of [semver](http://semver.org/) don't necessarily apply here, but we will try to stay quite close to them.
+
+Prior to version 1.0.0 we use the following scheme:
+
+1. MINOR versions for reaching a feature milestone potentially combined with dramatic API changes
+2. PATCH versions for refinements (e.g. performance improvements, bug fixes)
+
+After releasing version 1.0.0 the scheme changes to become:
+
+1. MAJOR versions at maintainers' discretion following significant changes to the codebase (e.g., API changes)
+2. MINOR versions for backwards-compatible enhancements (e.g., performance improvements)
+3. PATCH versions for backwards-compatible bug fixes (e.g., spec compliance bugs, support issues)
+
+#### Code style
+
+Regarding code style like indentation and whitespace, **follow the conventions you see used in the source already.** In general most of the [C# coding guidelines from Microsoft](https://msdn.microsoft.com/en-us/library/ff926074.aspx) are followed. This project prefers type inference with `var` to explicitly stating (redundant) information.
+
+It is also important to keep a certain `async`-flow and to always use `ConfigureAwait(false)` in conjunction with an `await` expression.
+
+## Backwards Compatibility
+
+We always try to remain backwards compatible beyond the currently supported versions of .NET.
+
+For instance, in December 2025 there have been activity to remove .NET 6 support from the codebase. We rejected this. Key points:
+
+1. We have absolutely no need to drop `.net6` support. It doesn't hurt us in any way.
+2. Many are still using `.net6`, including Electron.NET (non-Core) users. It doesn't make sense to force them to update two things at the same time (.NET + Electron.NET).
+3. We MUST NOT and NEVER update `Microsoft.Build.Utilities.Core`. This will make Electron.NET stop working on older Visual Studio and MSBuild versions. There's are also no reasons to update it in the first place.
+
+It's important to note that the Microsoft label of "Out of support" on .NET has almost no practical meaning. We've rarely (if ever) seen any bugs fixed in the same .NET version which mattered. The bugs that all new .NET versions have are much worse than mature .NET versions which are declared as "out of support". Keep in mind that the LTS matters most for active development / ongoing supported projects. If, e.g., a TV has been released a decade ago it most likely won't be patched. Still, you might want to deploy applications to it, which then naturally would involve being based on "out of support" versions of the framework.
+
+TL;DR: Unless there is a technical reason (e.g., a crucial new API not being available) we should not drop "out of support" .NET versions. At the time of writing (December 2025) the minimum supported .NET version remains at `.net6`.
+
+## Timeline
+
+**All of this information is related to ElectronNET.Core pre-v1!**
+
+We pretty much release whenever we have something new (i.e., do fixes such as a 0.1.1, or add new features, such as a 0.2.0) quite quickly.
+
+We will go for a 1.0.0 release of this as early as ~mid of January 2026 (unless we find some critical things or want to extend the beta phase for ElectronNET.Core). This should be sufficient time to get some user input and have enough experience to call it stable.

.github/workflows/Build and Publish.yml

@@ -1,33 +1,25 @@
-name: CI
+name: Build and Publish
 
-on: [push, pull_request]
+on: [push]
 
 env:
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
   NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}
 
+concurrency:
+  group: build-publish-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
-  # linux:
-  #   runs-on: ubuntu-latest
-  #   timeout-minutes: 10
+  Integration-Tests:
+    uses: ./.github/workflows/integration-tests.yml
+    name: '1'
 
-  #   steps:
-  #   - uses: actions/checkout@v4
-
-  #   - name: Setup dotnet
-  #     uses: actions/setup-dotnet@v4
-  #     with:
-  #       dotnet-version: |
-  #         6.0.x
-  #         8.0.x
-  #         10.0.x
-
-  #   - name: Build
-  #     run: ./build.sh
-
-  windows:
+  Publish:
+    needs: [Integration-Tests]
     runs-on: windows-latest
     timeout-minutes: 10
+    name: '2 / Publish'
 
     steps:
     - uses: actions/checkout@v4

.github/workflows/PR Validation.yml

@@ -0,0 +1,39 @@
+name: PR Validation
+
+on: [pull_request]
+
+concurrency:
+  group: pr-validation-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  Whitespace-Check:
+    uses: ./.github/workflows/trailing-whitespace-check.yml
+    secrets: inherit
+    name: '1'
+    
+  Tests:
+    needs: Whitespace-Check
+    uses: ./.github/workflows/integration-tests.yml
+    secrets: inherit
+    name: '2'
+
+  build:
+    needs: [Whitespace-Check, Tests]
+    runs-on: windows-latest
+    timeout-minutes: 10
+    name: '3 / Build'
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup dotnet
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: |
+          6.0.x
+          8.0.x
+          10.0.x
+
+    - name: Build
+      run: .\build.ps1

.github/workflows/integration-tests.yml

@@ -1,10 +1,7 @@
-name: Tests
+name: Tests
 
 on:
-  push:
-    branches: [ develop, main ]
-  pull_request:
-    branches: [ develop, main ]
+  workflow_call:
 
 concurrency:
   group: integration-tests-${{ github.ref }}
@@ -12,18 +9,28 @@ concurrency:
 
 jobs:
   tests:
-    name: Integration Tests (${{ matrix.os }})
+    name: ${{ matrix.os }} API-${{ matrix.electronVersion }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
+        os: [ubuntu-22.04, ubuntu-24.04, windows-2022, windows-2025, macos-14, macos-15-intel, macos-26]
+        electronVersion: ['30.4.0', '38.2.2']
         include:
+          - os: ubuntu-22.04
+            rid: linux-x64
           - os: ubuntu-24.04
             rid: linux-x64
           - os: windows-2022
             rid: win-x64
+          - os: windows-2025
+            rid: win-x64
           - os: macos-14
             rid: osx-arm64
+          - os: macos-15-intel
+            rid: osx-x64
+          - os: macos-26
+            rid: osx-arm64
 
     env:
       DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
@@ -35,6 +42,13 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
+      - name: Random delay (0-20 seconds)
+        shell: bash
+        run: |
+          DELAY=$((RANDOM % 21))
+          echo "Waiting for $DELAY seconds..."
+          sleep $DELAY
+
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
@@ -46,28 +60,30 @@ jobs:
           node-version: '22'
 
       - name: Restore
-        run: dotnet restore -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj
+        run: dotnet restore -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj
 
       - name: Build
-        run: dotnet build --no-restore -c Release -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj
+        run: dotnet build --no-restore -c Release -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj
 
       - name: Install Linux GUI dependencies
         if: runner.os == 'Linux'
         run: |
           set -e
           sudo apt-get update
-          # Core Electron dependencies
+          . /etc/os-release
+          if [ "$VERSION_ID" = "24.04" ]; then ALSA_PKG=libasound2t64; else ALSA_PKG=libasound2; fi
+          echo "Using ALSA package: $ALSA_PKG"
           sudo apt-get install -y xvfb \
-            libgtk-3-0 libnss3 libgdk-pixbuf-2.0-0 libdrm2 libgbm1 libxss1 libxtst6 libatk-bridge2.0-0 libatk1.0-0 libatspi2.0-0 libx11-xcb1 libasound2t64
+            libgtk-3-0 libnss3 libgdk-pixbuf-2.0-0 libdrm2 libgbm1 libxss1 libxtst6 libatk-bridge2.0-0 libatk1.0-0 libatspi2.0-0 libx11-xcb1 "$ALSA_PKG"
 
       - name: Run tests (Linux)
         if: runner.os == 'Linux'
         continue-on-error: true
         run: |
-          mkdir -p test-results/Ubuntu
+          mkdir -p test-results
           xvfb-run -a dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj \
-            -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} \
-            --logger "trx;LogFileName=Ubuntu.trx" \
+            -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} \
+            --logger "trx;LogFileName=${{ matrix.os }}-electron-${{ matrix.electronVersion }}.trx" \
             --logger "console;verbosity=detailed" \
             --results-directory test-results
 
@@ -75,21 +91,21 @@ jobs:
         if: runner.os == 'Windows'
         continue-on-error: true
         run: |
-          New-Item -ItemType Directory -Force -Path test-results/Windows | Out-Null
-          dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} --logger "trx;LogFileName=Windows.trx" --logger "console;verbosity=detailed" --results-directory test-results
+          New-Item -ItemType Directory -Force -Path test-results | Out-Null
+          dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} --logger "trx;LogFileName=${{ matrix.os }}-electron-${{ matrix.electronVersion }}.trx" --logger "console;verbosity=detailed" --results-directory test-results
 
       - name: Run tests (macOS)
         if: runner.os == 'macOS'
         continue-on-error: true
         run: |
-          mkdir -p test-results/macOS
-          dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} --logger "trx;LogFileName=macOS.trx" --logger "console;verbosity=detailed" --results-directory test-results
+          mkdir -p test-results
+          dotnet test src/ElectronNET.IntegrationTests/ElectronNET.IntegrationTests.csproj -c Release --no-build -r ${{ matrix.rid }} -p:RuntimeIdentifier=${{ matrix.rid }} -p:ElectronVersion=${{ matrix.electronVersion }} --logger "trx;LogFileName=${{ matrix.os }}-electron-${{ matrix.electronVersion }}.trx" --logger "console;verbosity=detailed" --results-directory test-results
 
       - name: Upload raw test results
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: test-results-${{ matrix.os }}
+          name: test-results-${{ matrix.os }}-electron-${{ matrix.electronVersion }}
           path: test-results/*.trx
           retention-days: 7
 
@@ -121,7 +137,7 @@ jobs:
           dotnet new tool-manifest
           dotnet tool install DotnetCtrfJsonReporter --local
 
-      - name: Convert TRX → CTRF and clean names (keep suites; set filePath=OS)
+      - name: Convert TRX → CTRF and clean names (filePath=OS|Electron X.Y.Z)
         shell: bash
         run: |
           set -euo pipefail
@@ -129,28 +145,28 @@ jobs:
           shopt -s globstar nullglob
           conv=0
           for trx in test-results/**/*.trx; do
-            fname="$(basename "$trx")"
-            os="${fname%.trx}"
-            outdir="ctrf/${os}"
+            base="$(basename "$trx" .trx)"  # e.g. ubuntu-22.04-electron-30.4.0
+            os="${base%%-electron-*}"
+            electron="${base#*-electron-}"
+            label="$os|Electron $electron"
+            outdir="ctrf/${label}"
             mkdir -p "$outdir"
             out="${outdir}/ctrf-report.json"
 
             dotnet tool run DotnetCtrfJsonReporter -p "$trx" -d "$outdir" -f "ctrf-report.json"
 
-            jq --arg os "$os" '.results.tests |= map(.filePath = $os)' "$out" > "${out}.tmp" && mv "${out}.tmp" "$out"
+            jq --arg fp "$label" '.results.tests |= map(.filePath = $fp)' "$out" > "${out}.tmp" && mv "${out}.tmp" "$out"
 
             echo "Converted & normalized $trx -> $out"
             conv=$((conv+1))
           done
           echo "Processed $conv TRX file(s)"
 
-
       - name: Publish Test Report
         if: always()
         uses: ctrf-io/github-test-reporter@v1
         with:
           report-path: 'ctrf/**/*.json'
-
           summary: true
           pull-request: false
           status-check: false
@@ -163,7 +179,6 @@ jobs:
           group-by: 'suite'
           upload-artifact: true
           fetch-previous-results: true
-
           summary-report: false
           summary-delta-report: true
           github-report: true
@@ -181,29 +196,25 @@ jobs:
           flaky-rate-report: true
           fail-rate-report: false
           slowest-report: false
-
           report-order: 'summary-delta-report,failed-report,skipped-report,suite-folded-report,file-report,previous-results-report,github-report'
         env:
           GITHUB_TOKEN: ${{ github.token }}
 
+      - name: Save PR Number
+        if: github.event_name == 'pull_request'
+        run: echo "PR_NUMBER=${{ github.event.pull_request.number }}" >> $GITHUB_ENV
 
-      - name: Create PR Comment
-        if: always()
-        uses: ctrf-io/github-test-reporter@v1
+      - name: Write PR Number to File
+        if: github.event_name == 'pull_request'
+        run: echo "$PR_NUMBER" > pr_number.txt
+        shell: bash
+
+      - name: Upload PR Number Artifact
+        if: github.event_name == 'pull_request'
+        uses: actions/upload-artifact@v4
         with:
-          report-path: 'ctrf/**/*.json'
-
-          summary: true
-          pull-request: true
-          use-suite-name: true
-          update-comment: true
-          always-group-by: true
-          overwrite-comment: true
-          upload-artifact: false
-
-          pull-request-report: true
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
+          name: pr_number
+          path: pr_number.txt
 
       - name: Summary
-        run: echo "All matrix test jobs completed."
+        run: echo "All matrix test jobs completed."

.github/workflows/pr-comment.yml

@@ -0,0 +1,81 @@
+name: Create PR Comments
+
+on:
+  workflow_run:
+    workflows: [ "PR Validation" ]
+    types: [completed]
+
+permissions:
+  contents: read
+  actions: read
+  pull-requests: write
+
+jobs:
+  pr-comment:
+    name: Post Test Result as PR comment
+    runs-on: ubuntu-24.04
+    if: github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion != 'cancelled'
+
+    steps:
+      - name: Download CTRF artifact
+        uses: dawidd6/action-download-artifact@v8
+        with:
+          github_token: ${{ github.token }}
+          run_id: ${{ github.event.workflow_run.id }}
+          name: ctrf-report
+          path: ctrf
+
+      - name: Download PR Number Artifact
+        uses: dawidd6/action-download-artifact@v8
+        with:
+          github_token: ${{ github.token }}
+          run_id: ${{ github.event.workflow_run.id }}
+          name: pr_number
+          path: pr_number
+
+      - name: Read PR Number
+        run: |
+          set -Eeuo pipefail
+          FILE='pr_number/pr_number.txt'
+
+          # Ensure file exists
+          if [ ! -f "$FILE" ] || [ -L "$FILE" ]; then
+            echo "Error: $FILE is missing or is not a regular file." >&2
+            exit 1
+          fi
+
+          # Chec file size
+          if [ "$(wc -c < "$FILE" | tr -d ' ')" -gt 200 ]; then
+            echo "Error: $FILE is too large." >&2
+            exit 1
+          fi
+
+          # Read first line
+          PR_NUMBER=""
+          IFS= read -r PR_NUMBER < "$FILE" || true
+
+          # Validate whether it's a number
+          if ! [[ "$PR_NUMBER" =~ ^[0-9]{1,10}$ ]]; then
+            echo "Error: PR_NUMBER is not a valid integer on the first line." >&2
+            exit 1
+          fi
+
+          printf 'PR_NUMBER=%s\n' "$PR_NUMBER" >> "$GITHUB_ENV"
+
+      - name: Post PR Comment
+        uses: ctrf-io/github-test-reporter@v1
+        with:
+          report-path: 'ctrf/**/*.json'
+          issue: ${{ env.PR_NUMBER }}
+
+          summary: true
+          pull-request: true
+          use-suite-name: true
+          update-comment: true
+          always-group-by: true
+          overwrite-comment: true
+          upload-artifact: false
+
+          pull-request-report: true
+        env:
+          GITHUB_TOKEN: ${{ github.token }}

.github/workflows/retry-test-jobs.yml

@@ -0,0 +1,49 @@
+name: Tests auto-rerun
+
+on:
+  workflow_run:
+    workflows: [ "PR Validation", "Build and Publish" ]
+    types: [ completed ]
+
+jobs:
+  rerun-failed-matrix-jobs-once:
+    if: >
+      ${{
+        github.event.workflow_run.conclusion == 'failure' &&
+        github.event.workflow_run.run_attempt == 1
+      }}
+    runs-on: ubuntu-24.04
+
+    permissions:
+      actions: write
+      contents: read
+
+    steps:
+      - name: Decide whether to rerun (only if matrix jobs failed)
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+          RUN_ID: ${{ github.event.workflow_run.id }}
+        run: |
+          echo "Inspecting jobs of workflow run $RUN_ID in $REPO"
+
+          jobs_json="$(gh api -R $REPO repos/$REPO/actions/runs/$RUN_ID/jobs)"
+
+          echo "Jobs and conclusions:"
+          echo "$jobs_json" | jq '.jobs[] | {name: .name, conclusion: .conclusion}'
+
+          failed_matrix_jobs=$(echo "$jobs_json" | jq -r '
+            [ .jobs[]
+              | select(.conclusion == "failure"
+                       and (.name | contains(" API-")))
+            ]
+            | length // 0
+          ')
+          failed_matrix_jobs=${failed_matrix_jobs:-0}
+
+          if [ "${failed_matrix_jobs}" -gt 0 ]; then
+            echo "Detected failing Integration Tests jobs – re-running failed jobs for this run."
+            gh run rerun -R "$REPO" "$RUN_ID" --failed
+          else
+            echo "Only non-matrix jobs (like Test Results) failed – not auto-rerunning."
+          fi

.github/workflows/trailing-whitespace-check.yml

@@ -1,11 +1,10 @@
-name: Trailing Whitespace Check
+name: Whitespace Check
 
 on:
-  pull_request:
-    types: [opened, synchronize, reopened]
+  workflow_call:
 
 jobs:
-  check-trailing-whitespace:
+  check-whitespace:
     runs-on: ubuntu-latest
     permissions:
       contents: read

Changelog.md

@@ -1,3 +1,46 @@
+# 0.4.1
+
+## ElectronNET.Core
+
+- Fixed handling of `Center` property for windows (#1001)
+- Added missing methods on `Cookies` (#1000)
+
+# 0.4.0
+
+## ElectronNET.Core
+
+- Fixed ElectronSingleInstance handling (#996) @softworkz
+- Fixed `PackageId` handling (#993) @softworkz
+- Added cross-platform npm restore and check mismatch on publish (#988) @softworkz
+
+# 0.3.1
+
+## ElectronNET.Core
+
+- Fixed issue transforming the project ID (#989, #990) @softworkz
+
+# 0.3.0
+
+## ElectronNET.Core
+
+- Updated infrastructure (#937, #939) @softworkz
+- Updated all model classes to Electron API 39.2 (#949) @softworkz
+- Fixed output path for `electron-builder` (#942) @softworkz
+- Fixed floating point display resolution (#944) @softworkz
+- Fixed error in case of missing electron-host-hook (#978)
+- Fixed previous API break using exposed `JsonElement` objects (#938) @softworkz
+- Fixed and improved several test cases (#962) @softworkz
+- Fixed startup of Electron.NET from VS Code Debug Adapter (#952)
+- Fixed the `BrowserWindowOptions` (#945) @softworkz
+- Fixed example for `AutoMenuHide` to reflect platform capabilities (#982) @markatosi
+- Added several migration checks for publishing (#966) @softworkz
+- Added more test runners for E2E tests (#950, #951) @agracio
+- Added dynamic updates for tray menu (#973) @davidroth
+- Added matrix tests with 6 runners and 2 electron version (#948) @softworkz
+- Added additional APIs for WebContents (#958) @agracio
+- Added documentation for MacOS package publish (#983) @markatosi
+- Added sample application for `ElectronHostHook` (#967) @adityashirsatrao007
+
 # 0.2.0
 
 ## ElectronNET.Core

README.md

@@ -14,9 +14,9 @@ Build cross platform desktop applications with .NET 6/8/10 - from console apps t
 
 ## Wait - how does that work exactly?
 
-Well... there are lots of different approaches how to get a X-plat desktop app running. Electron.NET provides a range of  ways to build .NET based solutions using Electron at the side of presentation.
+Well... there are lots of different approaches how to get a X-plat desktop app running. Electron.NET provides a range of ways to build .NET-based solutions using Electron at the side of presentation.
 
-While the classic Electron.NET setup, using an ASP.NET host ran by the Electron side is still the primary way, there's more flexibility now: both, dotnet and Electron are now able to launch the other for better lifetime management, and when you don't need a local web server - like when running content from files or remote servers, you can  drop the ASP.NET stack altogether and got with a lightweight console app instead.
+While the classic Electron.NET setup (using an ASP.NET host run by the Electron side) is still the primary way, there's more flexibility now. Both .NET and Electron are now able to launch the other for better lifetime management, and when you don't need a local web server (like when running content from files or remote servers), you can drop the ASP.NET stack altogether and go with a lightweight console app instead.
 
 ## 📦 NuGet
 
@@ -133,9 +133,10 @@ builder.UseElectron(args, async () =>
 {
     var options = new BrowserWindowOptions {
         Show = false,
-        AutoHideMenuBar = true,
         IsRunningBlazor = true, // <-- crucial
     };
+    if (OperatingSystem.IsWindows() || OperatingSystem.IsLinux())
+        options.AutoHideMenuBar = true;
     var browserWindow = await Electron.WindowManager.CreateWindowAsync(options);
     browserWindow.OnReadyToShow += () => browserWindow.Show();
 });
@@ -169,7 +170,7 @@ Just press `F5` in Visual Studio or use dotnet for debugging.
 
 ## 📔 Usage of the Electron API
 
-A complete documentation is available on the Wiki.
+Complete documentation is available on the Wiki.
 
 In this YouTube video, we show you how you can create a new project, use the Electron.NET API, debug a application and build an executable desktop app for Windows: [Electron.NET - Getting Started](https://www.youtube.com/watch?v=nuM6AojRFHk)  
   

docs/Core/Migration-Checks.md

@@ -0,0 +1,256 @@
+# Migration Checks
+
+Electron.NET includes automatic build-time validation checks that help users migrating from previous versions avoid common configuration issues. These checks run automatically during the build process and provide helpful guidance when problems are detected.
+
+## Overview
+
+When you build an Electron.NET project, the following validation checks are performed:
+
+| Code | Check | Description |
+|------|-------|-------------|
+| [ELECTRON001](#1-packagejson-rules) | package.json location rules | Ensures `package.json`/`package-lock.json` aren’t present in unsupported locations (root `package.json` handled separately) |
+| [ELECTRON008](#1-packagejson-rules) | root package.json contains electron | Warns when root `package.json` contains the word `electron` (case-insensitive) |
+| [ELECTRON009](#1-packagejson-rules) | root package.json copied to output | Warns when root `package.json` is configured to be copied to output/publish |
+| [ELECTRON002](#2-electron-manifestjson-not-allowed) | electron-manifest.json not allowed | Detects deprecated manifest files |
+| [ELECTRON003](#3-electron-builderjson-location) | electron-builder.json location | Verifies electron-builder.json exists in Properties folder |
+| [ELECTRON004](#3-electron-builderjson-location) | electron-builder.json wrong location | Warns if electron-builder.json is found in incorrect locations |
+| [ELECTRON005](#4-parent-paths-not-allowed-in-electron-builderjson) | Parent paths not allowed | Checks for `..` references in config |
+| [ELECTRON006](#5-publish-profile-validation) | ASP.NET publish profile mismatch | Warns when ASP.NET projects have console-style profiles |
+| [ELECTRON007](#5-publish-profile-validation) | Console publish profile mismatch | Warns when console projects have ASP.NET-style profiles |
+
+---
+
+## 1. package.json rules
+
+**Warning Codes:** `ELECTRON001`, `ELECTRON008`, `ELECTRON009`
+
+### What is checked
+
+The build system scans for `package.json` and `package-lock.json` files in your project directory.
+
+Rules:
+
+- **ELECTRON001**: `package.json` / `package-lock.json` must not exist in the project directory or subdirectories
+  - Exception: `ElectronHostHook` folder is allowed
+  - Note: a **root** `package.json` is **excluded** from `ELECTRON001` and validated by `ELECTRON008` / `ELECTRON009`
+
+- **ELECTRON008**: If a root `package.json` exists, it must **not** contain electron-related dependencies or configuration.
+
+- **ELECTRON009**: If a root `package.json` exists, it must **not** be configured to be copied to output/publish (for example via `CopyToOutputDirectory` / `CopyToPublishDirectory` metadata)
+
+### Why this matters
+
+Electron.NET generates its Electron-related `package.json` during publishing based on MSBuild properties. A user-maintained Electron-related `package.json` can conflict with that process.
+
+Also, ensuring the root `package.json` is not copied prevents accidentally shipping it with the published app.
+
+### Exception
+
+A `package.json` / `package-lock.json` file **is allowed** in the `ElectronHostHook` folder if you're using custom host hooks.
+
+### How to fix
+
+If you have an Electron-related `package.json` from older Electron.NET versions:
+
+1. **Open your project's `.csproj` file**
+2. **Add the required properties** to a PropertyGroup with the label `ElectronNetCommon`:
+
+```xml
+<PropertyGroup Label="ElectronNetCommon">
+  <ElectronPackageId>my-electron-app</ElectronPackageId>
+  <Title>My Electron App</Title>
+  <Version>1.0.0</Version>
+  <Description>My awesome Electron.NET application</Description>
+  <Company>My Company</Company>
+  <Copyright>Copyright © 2025</Copyright>
+  <ElectronVersion>30.0.9</ElectronVersion>
+</PropertyGroup>
+```
+
+3. **Delete** Electron-related `package.json` / `package-lock.json` files (except those under `ElectronHostHook` if applicable)
+
+If you keep a root `package.json` for non-Electron reasons:
+
+- Ensure it does **not** contain electron dependencies or configuration (fixes `ELECTRON008`)
+- Ensure it is **not** copied to output/publish (fixes `ELECTRON009`)
+
+> **See also:** [Migration Guide](Migration-Guide.md) for complete migration instructions.
+
+---
+
+## 2. electron-manifest.json not allowed
+
+**Warning Code:** `ELECTRON002`
+
+### What is checked
+
+The build system checks for the presence of `electron.manifest.json` or `electron-manifest.json` files in your project.
+
+### Why this matters
+
+The `electron.manifest.json` file format is deprecated. All configuration should now be specified using:
+- MSBuild properties in your `.csproj` file (for application metadata)
+- The `electron-builder.json` file in the `Properties` folder (for build configuration)
+
+### How to fix
+
+1. **Migrate application properties** to your `.csproj` file (see [Migration Guide](Migration-Guide.md))
+2. **Move the `build` section** from `electron.manifest.json` to `Properties/electron-builder.json`
+3. **Delete the old `electron.manifest.json`** file
+
+**Example electron-builder.json:**
+```json
+{
+    "compression": "maximum",
+    "win": {
+        "icon": "Assets/app.ico",
+        "target": ["nsis", "portable"]
+    },
+    "linux": {
+        "icon": "Assets/app.png",
+        "target": ["AppImage", "deb"]
+    },
+    "mac": {
+        "icon": "Assets/app.icns",
+        "target": ["dmg", "zip"]
+    }
+}
+```
+
+---
+
+## 3. electron-builder.json Location
+
+**Warning Codes:** `ELECTRON003`, `ELECTRON004`
+
+### What is checked
+
+- `ELECTRON003`: Verifies that an `electron-builder.json` file exists in the `Properties` folder
+- `ELECTRON004`: Warns if `electron-builder.json` is found in incorrect locations
+
+### Why this matters
+
+The `electron-builder.json` file must be located in the `Properties` folder so it can be properly copied to the output directory during publishing.
+
+### How to fix
+
+1. **Create the Properties folder** if it doesn't exist
+2. **Move or create** `electron-builder.json` in `Properties/electron-builder.json`
+3. **Remove** any `electron-builder.json` files from other locations
+
+**Expected structure:**
+```
+MyProject/
+├── Properties/
+│   ├── electron-builder.json    ✅ Correct location
+│   ├── launchSettings.json
+│   └── PublishProfiles/
+├── MyProject.csproj
+└── Program.cs
+```
+
+---
+
+## 4. Parent paths not allowed in electron-builder.json
+
+**Warning Code:** `ELECTRON005`
+
+### What is checked
+
+The build system scans the `electron-builder.json` file for parent-path references (`..`).
+
+### Why this matters
+
+During the publish process, the `electron-builder.json` file is copied to the build output directory. Any relative paths in this file are resolved from that location, not from your project directory. Parent-path references (`../`) will not work correctly because they would point outside the published application.
+
+### How to fix
+
+1. **Move resource files** (icons, installers, etc.) inside your project folder structure
+2. **Configure the files** to be copied to the output directory in your `.csproj`:
+
+```xml
+<ItemGroup>
+  <Content Include="Assets\**\*">
+    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+  </Content>
+</ItemGroup>
+```
+
+3. **Update paths** in `electron-builder.json` to use relative paths without `..`:
+
+**Before (incorrect):**
+```json
+{
+    "win": {
+        "icon": "../SharedAssets/app.ico"
+    }
+}
+```
+
+**After (correct):**
+```json
+{
+    "win": {
+        "icon": "Assets/app.ico"
+    }
+}
+```
+
+---
+
+## 5. Publish Profile Validation
+
+**Warning Codes:** `ELECTRON006`, `ELECTRON007`
+
+### What is checked
+
+The build system examines `.pubxml` files in the `Properties/PublishProfiles` folder and validates that they match the project type:
+
+- **ELECTRON006**: For **ASP.NET projects** (using `Microsoft.NET.Sdk.Web`), checks that publish profiles include `WebPublishMethod`. This property is required for proper ASP.NET publishing.
+
+- **ELECTRON007**: For **console/other projects** (not using the Web SDK), checks that publish profiles do NOT include the `WebPublishMethod`  property. These ASP.NET-specific properties are incorrect for non-web applications.
+
+### Why this matters
+
+Electron.NET supports both ASP.NET and console application project types, each requiring different publish profile configurations:
+
+| Project Type | SDK | Expected Properties |
+|--------------|-----|---------------------|
+| ASP.NET (Razor Pages, MVC, Blazor) | `Microsoft.NET.Sdk.Web` | `WebPublishMethod`, no `PublishProtocol` |
+| Console Application | `Microsoft.NET.Sdk` | `PublishProtocol`, no `WebPublishMethod` |
+
+Using the wrong publish profile type can lead to incomplete or broken builds.
+
+### How to fix
+
+1. **Delete existing publish profiles** from `Properties/PublishProfiles/`
+2. **Create new publish profiles** using the Visual Studio Publishing Wizard:
+   - Right-click on the project in Solution Explorer
+   - Select **Publish...**
+   - Follow the wizard to create a **Folder** publish profile
+
+For correct publish profile examples for both ASP.NET and Console applications, see **[Package Building](../Using/Package-Building.md#step-1-create-publish-profiles)**.
+
+---
+
+## Disabling Migration Checks
+
+If you need to disable specific migration checks (not recommended), you can set the following properties in your `.csproj` file:
+
+```xml
+<PropertyGroup>
+  <!-- Disable all migration checks -->
+  <ElectronSkipMigrationChecks>true</ElectronSkipMigrationChecks>
+</PropertyGroup>
+```
+
+> ⚠️ **Warning:** Disabling migration checks may result in build or runtime errors. Only disable checks if you fully understand the implications.
+
+---
+
+## See Also
+
+- [Migration Guide](Migration-Guide.md) - Complete step-by-step migration instructions
+- [Advanced Migration Topics](Advanced-Migration-Topics.md) - Complex migration scenarios
+- [Configuration](../Using/Configuration.md) - Project configuration options
+- [Package Building](../Using/Package-Building.md) - Building distributable packages

docs/Core/Migration-Guide.md

@@ -31,7 +31,7 @@ dotnet add package ElectronNET.Core.AspNet  # For ASP.NET projects
 ### Step 2: Configure Project Settings
 
 **Auto-generated Configuration:**  
-ElectronNET.Core automatically creates `electron-builder.json` during the first build or NuGet restore. No manual configuration is needed for basic setups.
+ElectronNET.Core automatically creates `electron-builder.json` in the `Properties` folder of your project during the first build or NuGet restore. No manual configuration is needed for basic setups.
 
 **Migrate Existing Configuration:**  
 If you have an existing `electron.manifest.json` file:
@@ -63,6 +63,9 @@ You can also manually edit `electron-builder.json`:
 }
 ```
 
+**Modify Launch Settings:**
+ElectronNET.Core no longer needs a separate CLI tool (electronize.exe) for launching. You should update your launch settings to use either the ASP.NET-first or Electron-first approach. See [Debugging](../Using/Debugging.md) for details.
+
 ## 🎯 Testing Migration
 
 After completing the migration steps:

docs/GettingStarted/Console-App.md

@@ -54,7 +54,7 @@ Add the Electron.NET configuration to your `.csproj` file:
 </PropertyGroup>
 
 <ItemGroup>
-  <PackageReference Include="ElectronNET.Core" Version="0.2.0" />
+  <PackageReference Include="ElectronNET.Core" Version="0.4.1" />
 </ItemGroup>
 ```
 

docs/SignalR-Authentication-Guide.md

@@ -0,0 +1,583 @@
+# Electron.NET SignalR Authentication Guide
+
+This guide explains the token-based authentication system implemented for SignalR mode in Electron.NET, designed to protect applications in multi-user environments.
+
+## Table of Contents
+
+1. [Overview](#overview)
+2. [Threat Model](#threat-model)
+3. [Authentication Architecture](#authentication-architecture)
+4. [Implementation Details](#implementation-details)
+5. [Security Properties](#security-properties)
+6. [Troubleshooting](#troubleshooting)
+7. [FAQ](#faq)
+
+## Overview
+
+Electron.NET's SignalR mode includes built-in authentication to ensure that only the Electron process spawned by a specific .NET instance can connect to that instance's HTTP and SignalR endpoints.
+
+**When is this important?**
+- Multi-user Windows Server environments (Terminal Services, RDP)
+- Shared development machines with multiple users
+- Any scenario where multiple users run the same application simultaneously
+
+**What does it protect against?**
+- User A's Electron process connecting to User B's .NET backend
+- Unauthorized port scanning and connection attempts from other users
+- Accidental misconfigurations causing cross-user connections
+
+## Threat Model
+
+### The Problem
+
+When multiple users run the same Electron.NET application on a shared server:
+
+1. Each .NET process binds to a TCP port (e.g., `http://localhost:58971`)
+2. TCP ports are visible to **all users** on the machine
+3. Without authentication, User A's Electron could connect to User B's backend
+
+```
+┌─────────────────────────────────────────────────┐
+│ Windows Server (Terminal Services)             │
+├─────────────────────────────────────────────────┤
+│ User A Session                                  │
+│   ├─ .NET Process (localhost:58971)            │
+│   └─ Electron Process                          │
+│                                                 │
+│ User B Session                                  │
+│   ├─ .NET Process (localhost:61234)            │
+│   └─ Electron Process (could connect to 58971) │ ❌ Prevent this!
+└─────────────────────────────────────────────────┘
+```
+
+### The Solution
+
+Each .NET process generates a unique authentication token when launching Electron. Only requests with the correct token are allowed to connect.
+
+```
+┌─────────────────────────────────────────────────┐
+│ User A Session                                  │
+│   ├─ .NET (token: abc123...)                   │
+│   └─ Electron (has token abc123...)            │ ✅ Authenticated
+│                                                 │
+│ User B Session                                  │
+│   ├─ .NET (token: xyz789...)                   │
+│   └─ Electron (has token xyz789...)            │ ✅ Authenticated
+│                                                 │
+│   ❌ User B's Electron → User A's .NET          │
+│      (lacks token abc123...)                    │ ❌ Rejected (401)
+└─────────────────────────────────────────────────┘
+```
+
+## Authentication Architecture
+
+### Flow Diagram
+
+```
+┌──────────────┐                                    ┌─────────────────┐
+│ .NET Process │                                    │ Electron Process│
+└──────┬───────┘                                    └────────┬────────┘
+       │                                                     │
+       │ 1. Generate Token (GUID)                           │
+       │    Token: a3f8b2c1d4e5...                         │
+       │                                                     │
+       │ 2. Launch Electron                                 │
+       │    --authtoken=a3f8b2c1d4e5...                    │
+       │────────────────────────────────────────────────────>│
+       │                                                     │
+       │                                                     │ 3. Extract Token
+       │                                                     │    global.authToken = ...
+       │                                                     │
+       │                                                     │ 4. Initial Page Load
+       │<────────────────────────────────────────────────────│
+       │    GET /?token=a3f8b2c1d4e5...                     │
+       │                                                     │
+       │ 5. Validate Token                                  │
+       │    ✓ Valid → Set Cookie                            │
+       │────────────────────────────────────────────────────>│
+       │    HTTP 200 + Set-Cookie: ElectronAuth=...        │
+       │                                                     │
+       │                                                     │ 6. SignalR Connection
+       │<────────────────────────────────────────────────────│
+       │    GET /electron-hub?token=a3f8b2c1d4e5...         │
+       │                                                     │
+       │ 7. Validate Token, Set Cookie                      │
+       │────────────────────────────────────────────────────>│
+       │    HTTP 200 + Set-Cookie                           │
+       │                                                     │
+       │                                                     │ 8. Subsequent Requests
+       │<────────────────────────────────────────────────────│
+       │    GET /api/data                                   │
+       │    Cookie: ElectronAuth=a3f8b2c1d4e5...            │
+       │                                                     │
+       │ 9. Validate Cookie                                 │
+       │────────────────────────────────────────────────────>│
+       │    HTTP 200 (authenticated)                        │
+       │                                                     │
+```
+
+### Key Steps
+
+1. **Token Generation**: .NET generates 128-bit cryptographic random GUID
+2. **Command-Line Passing**: Token passed to Electron via `--authtoken` parameter
+3. **Token Extraction**: Electron stores token in `global.authToken`
+4. **URL Appending**: Token appended to initial page and SignalR connection URLs
+5. **Middleware Validation**: Every HTTP request validated by middleware
+6. **Cookie Setting**: Valid token results in secure HttpOnly cookie
+7. **Cookie-Based Requests**: Subsequent requests use cookie (no token in URL)
+
+## Implementation Details
+
+### 1. Token Generation (.NET)
+
+**File**: `src/ElectronNET.AspNet/Runtime/Controllers/RuntimeControllerAspNetDotnetFirstSignalR.cs`
+
+```csharp
+private void LaunchElectron()
+{
+    // Generate secure authentication token (128-bit cryptographic random GUID)
+    this.authenticationToken = Guid.NewGuid().ToString("N"); // 32 hex chars
+    
+    // Register token with authentication service
+    this.authenticationService.SetExpectedToken(this.authenticationToken);
+    
+    // Launch Electron with token
+    var args = $"--unpackeddotnetsignalr --electronurl={this.actualUrl} --authtoken={this.authenticationToken}";
+    this.electronProcess = new ElectronProcessActive(isUnPacked, ElectronNetRuntime.ElectronExecutable, args, this.port.Value);
+    _ = this.electronProcess.Start();
+}
+```
+
+**Token Format**: 32-character hexadecimal string (e.g., `a3f8b2c1d4e5f6a7b8c9d0e1f2a3b4c5`)
+
+### 2. Authentication Service (.NET)
+
+**File**: `src/ElectronNET.AspNet/Services/ElectronAuthenticationService.cs`
+
+```csharp
+public class ElectronAuthenticationService : IElectronAuthenticationService
+{
+    private string _expectedToken;
+    private readonly object _lock = new object();
+
+    public void SetExpectedToken(string token)
+    {
+        lock (_lock)
+        {
+            _expectedToken = token;
+        }
+    }
+
+    public bool ValidateToken(string token)
+    {
+        if (string.IsNullOrEmpty(token))
+            return false;
+
+        lock (_lock)
+        {
+            if (string.IsNullOrEmpty(_expectedToken))
+                return false;
+
+            // Constant-time comparison prevents timing attacks
+            return ConstantTimeEquals(token, _expectedToken);
+        }
+    }
+
+    private static bool ConstantTimeEquals(string a, string b)
+    {
+        if (a == null || b == null || a.Length != b.Length)
+            return false;
+
+        var result = 0;
+        for (int i = 0; i < a.Length; i++)
+        {
+            result |= a[i] ^ b[i];
+        }
+        return result == 0;
+    }
+}
+```
+
+**Key Features**:
+- Thread-safe with lock
+- Constant-time comparison (prevents timing attacks)
+- Singleton lifetime (one per .NET instance)
+
+### 3. Authentication Middleware (.NET)
+
+**File**: `src/ElectronNET.AspNet/Middleware/ElectronAuthenticationMiddleware.cs`
+
+```csharp
+public async Task InvokeAsync(HttpContext context)
+{
+    // Check if authentication cookie exists
+    var authCookie = context.Request.Cookies["ElectronAuth"];
+    
+    if (!string.IsNullOrEmpty(authCookie))
+    {
+        if (_authService.ValidateToken(authCookie))
+        {
+            await _next(context);
+            return;
+        }
+        else
+        {
+            _logger.LogWarning("Invalid cookie for path {Path}", context.Request.Path);
+            context.Response.StatusCode = 401;
+            await context.Response.WriteAsync("Unauthorized: Invalid authentication");
+            return;
+        }
+    }
+
+    // No cookie - check for token in query string
+    var token = context.Request.Query["token"].ToString();
+    
+    if (!string.IsNullOrEmpty(token) && _authService.ValidateToken(token))
+    {
+        // Valid token - set cookie for future requests
+        context.Response.Cookies.Append("ElectronAuth", token, new CookieOptions
+        {
+            HttpOnly = true,
+            SameSite = SameSiteMode.Strict,
+            Path = "/",
+            Secure = false,  // localhost is HTTP
+            IsEssential = true
+        });
+        
+        await _next(context);
+        return;
+    }
+
+    // Reject - no valid cookie or token
+    context.Response.StatusCode = 401;
+    await context.Response.WriteAsync("Unauthorized: Authentication required");
+}
+```
+
+**Middleware Order** (IMPORTANT):
+```csharp
+app.UseMiddleware<ElectronAuthenticationMiddleware>();  // ← FIRST
+app.UseRouting();
+app.UseStaticFiles();
+app.UseAntiforgery();
+app.MapHub<ElectronHub>("/electron-hub");
+app.MapRazorComponents<App>();
+```
+
+### 4. Token Extraction (Electron)
+
+**File**: `src/ElectronNET.Host/main.js`
+
+```javascript
+// Extract authentication token from command-line
+if (app.commandLine.hasSwitch('authtoken')) {
+    global.authToken = app.commandLine.getSwitchValue('authtoken');
+}
+```
+
+### 5. Token in URLs (Electron)
+
+**Initial Page Load** (`src/ElectronNET.Host/api/browserWindows.js`):
+```javascript
+// Append token to window URL
+if (global.authToken) {
+    const separator = electronUrl.includes('?') ? '&' : '?';
+    electronUrl = `${electronUrl}${separator}token=${global.authToken}`;
+}
+window.loadURL(electronUrl);
+```
+
+**SignalR Connection** (`src/ElectronNET.Host/api/signalr-bridge.js`):
+```javascript
+async connect() {
+    // Append token to SignalR hub URL
+    const connectionUrl = this.authToken ? 
+        `${this.hubUrl}?token=${this.authToken}` : 
+        this.hubUrl;
+    
+    this.connection = new signalR.HubConnectionBuilder()
+        .withUrl(connectionUrl)
+        .build();
+    
+    await this.connection.start();
+}
+```
+
+### 6. Service Registration (Application)
+
+**File**: Your application's `Program.cs`
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+// Register authentication service as singleton
+builder.Services.AddSingleton<IElectronAuthenticationService, ElectronAuthenticationService>();
+
+builder.Services.AddElectron();
+
+var app = builder.Build();
+
+// Register middleware BEFORE UseRouting()
+app.UseMiddleware<ElectronAuthenticationMiddleware>();
+
+app.UseRouting();
+app.MapHub<ElectronHub>("/electron-hub");
+app.Run();
+```
+
+## Security Properties
+
+### Cookie Configuration
+
+| Property | Value | Purpose |
+|----------|-------|---------|
+| `HttpOnly` | `true` | Prevents JavaScript access (XSS protection) |
+| `SameSite` | `Strict` | Prevents CSRF attacks |
+| `Path` | `/` | Cookie sent with all requests |
+| `Secure` | `false` | Cannot use on localhost HTTP |
+| `IsEssential` | `true` | Required for app to function |
+| **Lifetime** | Session | Expires when Electron closes |
+
+### Token Properties
+
+- **Entropy**: 128 bits (2^128 possible values)
+- **Format**: 32 hexadecimal characters (GUID without hyphens)
+- **Generation**: `Guid.NewGuid()` uses cryptographically secure RNG
+- **Lifetime**: Entire application session
+- **Uniqueness**: Each .NET instance generates unique token
+
+### What's Protected
+
+✅ **All HTTP endpoints**:
+- Blazor Server pages (`/`, `/counter`, etc.)
+- Static files (`/css/app.css`, `/js/script.js`)
+- API endpoints (custom controllers)
+- SignalR hub (`/electron-hub`)
+
+✅ **Both transport modes**:
+- Initial token-based authentication (query parameter)
+- Cookie-based subsequent requests
+
+✅ **Cross-user isolation**:
+- Different users = different tokens
+- Invalid token = 401 Unauthorized
+
+### What's NOT Protected Against
+
+❌ **Same-user attacks** (by design):
+- Process memory inspection
+- Debugger attachment
+- Command-line parameter visibility
+
+**Rationale**: A malicious process running as the same user already has full access to:
+- Process memory (can read token from RAM)
+- Cookies (stored in Electron's data directory)
+- All files owned by the user
+
+Token-based authentication focuses on **cross-user isolation**, not same-user security.
+
+## Troubleshooting
+
+### Problem: 401 Unauthorized on Initial Load
+
+**Symptoms**:
+```
+GET / HTTP/1.1
+Response: 401 Unauthorized
+```
+
+**Possible Causes**:
+1. Token not passed to Electron
+2. Token not appended to URL
+3. Middleware rejecting valid token
+
+**Debugging Steps**:
+
+1. Check Electron command-line:
+   ```javascript
+   console.log('Auth Token:', global.authToken);
+   ```
+   Should print 32-character hex string.
+
+2. Check URL in browser window:
+   ```javascript
+   console.log('Loading URL:', electronUrl);
+   ```
+   Should include `?token=<guid>` parameter.
+
+3. Check .NET logs:
+   ```
+   [Warning] Authentication failed: Invalid token (prefix: a3f8b2c1...)
+   ```
+
+4. Verify middleware registration:
+   ```csharp
+   app.UseMiddleware<ElectronAuthenticationMiddleware>(); // Before UseRouting()
+   ```
+
+### Problem: SignalR Connection Fails
+
+**Symptoms**:
+```
+[SignalRBridge] Authentication failed: The authentication token is invalid or missing.
+```
+
+**Possible Causes**:
+1. Token not passed to `SignalRBridge` constructor
+2. Token not appended to hub URL
+3. Cookie not being sent
+
+**Debugging Steps**:
+
+1. Check token passed to SignalRBridge:
+   ```javascript
+   console.log('SignalRBridge token:', this.authToken);
+   ```
+
+2. Check connection URL:
+   ```javascript
+   console.log('Hub URL:', connectionUrl);
+   ```
+   Should be `http://localhost:PORT/electron-hub?token=<guid>`.
+
+3. Enable verbose logging:
+   ```javascript
+   .configureLogging(signalR.LogLevel.Debug)
+   ```
+
+### Problem: Cookie Not Persisting
+
+**Symptoms**: Every request includes token in URL, cookie never set.
+
+**Possible Causes**:
+1. Cookie settings incompatible with browser
+2. Middleware not setting cookie
+3. Response headers not sent
+
+**Debugging Steps**:
+
+1. Check response headers:
+   ```
+   Set-Cookie: ElectronAuth=a3f8b2c1...; Path=/; HttpOnly; SameSite=Strict
+   ```
+
+2. Check subsequent requests:
+   ```
+   Cookie: ElectronAuth=a3f8b2c1...
+   ```
+
+3. Enable middleware logging:
+   ```csharp
+   _logger.LogInformation("Setting cookie for path {Path}", path);
+   ```
+
+### Problem: Token Visible in Process List
+
+**Observation**:
+```powershell
+wmic process where "name='electron.exe'" get commandline
+...--authtoken=a3f8b2c1d4e5f6a7b8c9d0e1f2a3b4c5...
+```
+
+**Is this a problem?** No, by design.
+
+**Explanation**:
+- Command-line parameters are visible to same-user processes
+- This is acceptable because:
+  - Same user already has access to process memory
+  - Same user can read cookies from Electron's data directory
+  - Token-based auth protects against **other users**, not same-user processes
+
+**If you need same-user protection**: Use OS-level access controls (file permissions, process isolation) or consider named pipes with ACLs.
+
+## FAQ
+
+### Q: Why use tokens instead of Process ID validation?
+
+**A**: PIDs can be recycled and reused, making validation unreliable. Additionally:
+- PIDs don't provide cryptographic security
+- Parent-child validation is platform-specific
+- Adds complexity without meaningful security benefit
+
+Token-based authentication provides:
+- Cryptographic randomness (128-bit entropy)
+- Simple cross-platform implementation
+- No race conditions or PID recycling issues
+
+### Q: Why not use HTTPS with certificates?
+
+**A**: Localhost doesn't support HTTPS certificates easily:
+- Self-signed certificates trigger browser warnings
+- Certificate management adds complexity
+- Token-based auth provides equivalent security for localhost IPC
+
+### Q: Can I disable authentication?
+
+**A**: Not recommended, but possible by removing middleware registration:
+
+```csharp
+// Remove this line:
+// app.UseMiddleware<ElectronAuthenticationMiddleware>();
+```
+
+**Warning**: Only do this if:
+- Application runs on single-user machines only
+- No Terminal Services / RDP access
+- You understand the security implications
+
+### Q: Does this work with hot reload?
+
+**A**: Yes, cookie persists across hot reload as long as Electron process keeps running.
+
+### Q: What about multiple Electron windows?
+
+**A**: All windows in the same Electron process share cookies automatically. Authentication works seamlessly across multiple windows.
+
+### Q: How do I test authentication?
+
+**Test 1 - Happy Path**:
+1. Run application normally
+2. Check logs for "Authentication successful"
+3. Verify cookie is set (DevTools → Application → Cookies)
+4. Subsequent requests should not include token in URL
+
+**Test 2 - Invalid Token**:
+1. Modify token in browser URL: `?token=invalid`
+2. Should receive 401 Unauthorized
+3. Check logs for "Authentication failed: Invalid token"
+
+**Test 3 - No Token**:
+1. Open browser manually to `http://localhost:PORT/`
+2. Should receive 401 Unauthorized
+3. Check logs for "Authentication failed: No cookie or token"
+
+**Test 4 - Multi-User** (Windows Server/Terminal Services):
+1. Launch app as User A
+2. In User B session, try to connect to User A's port
+3. Should receive 401 Unauthorized
+
+### Q: What about packaged applications?
+
+**A**: Authentication works identically in packaged mode. The `--authtoken` parameter is included in the packaged Electron executable.
+
+### Q: Can I customize the cookie name?
+
+**A**: Yes, modify `AuthCookieName` constant in `ElectronAuthenticationMiddleware.cs`:
+
+```csharp
+private const string AuthCookieName = "MyCustomCookieName";
+```
+
+## Summary
+
+Electron.NET's token-based authentication provides:
+
+✅ **Security**: 128-bit entropy, constant-time comparison, secure cookies  
+✅ **Simplicity**: Automatic token generation and validation  
+✅ **Compatibility**: Works with Blazor, SignalR, and static files  
+✅ **Monitoring**: Structured logging for security events  
+✅ **Multi-User**: Cross-user isolation on shared servers  
+
+The authentication system is **enabled by default** in SignalR mode and requires minimal configuration. For most applications, simply register the services and middleware - everything else happens automatically.
+
+For additional help or questions, see the [SignalR Implementation Summary](SignalR-Implementation-Summary.md) or open an issue on GitHub.

docs/SignalR-Implementation-Summary.md

@@ -0,0 +1,450 @@
+# SignalR Implementation Summary
+
+This document summarizes the completed implementation of SignalR-based bidirectional communication in Electron.NET as an alternative to Socket.IO.
+
+## Overview
+
+The SignalR implementation provides a modern, .NET-native alternative to Socket.IO for communication between the ASP.NET Core host and the Electron process. This new startup mode was designed specifically for **Blazor Server applications** where ASP.NET Core and Electron need tighter integration and lifecycle control.
+
+**Key Innovation**: .NET-first startup with dynamic port assignment - ASP.NET Core starts first, binds to port 0 (letting Kestrel choose an available port), then launches Electron with the actual URL.
+
+## Primary Use Case
+
+Blazor Server applications where:
+- ASP.NET Core owns the application lifecycle
+- Dynamic port binding is needed (no fixed port configuration)
+- Modern SignalR infrastructure is preferred over Socket.IO
+- Single process debugging is desired (.NET process controls Electron)
+
+## Implementation Phases (All Complete)
+
+### Phase 1: Core Infrastructure ✅
+- Added new `StartupMethod` enum values:
+  - `UnpackagedDotnetFirstSignalR` 
+  - `PackagedDotnetFirstSignalR`
+- Created `ElectronHub` SignalR hub for bidirectional communication
+- Registered hub endpoint at `/electron-hub` (separate from Blazor's `/_blazor` hub)
+
+### Phase 2: Runtime Controller ✅
+- Created `RuntimeControllerAspNetDotnetFirstSignalR`
+- Implemented logic to:
+  - Bind Kestrel to port 0
+  - Wait for Kestrel startup and capture actual port via `IServerAddressesFeature`
+  - Launch Electron with `--electronurl` parameter
+  - Wait for SignalR connection from Electron
+  - Transition to Ready state when connected
+
+### Phase 3: Electron/Node.js Side ✅
+- Added `@microsoft/signalr` npm package dependency
+- Created SignalR connection module (`signalr-bridge.js`)
+- Updated `main.js` to detect SignalR modes and connect to `/electron-hub`
+- Implemented Socket.IO-compatible interface for API compatibility
+
+### Phase 4: API Bridge Adaptation ✅
+- Created `SignalRFacade` implementing `IFacade` interface
+- Ensured existing Electron API classes work with SignalR
+- Implemented type conversion helper for SignalR's JSON deserialization
+- Event routing from both directions (.NET ↔ Electron)
+
+### Phase 5: Configuration & Extensions ✅
+- Updated `WebHostBuilderExtensions` for automatic SignalR configuration
+- Added startup mode detection via command-line flags
+- Configured dynamic port binding (port 0) for SignalR modes
+- Integrated with `UseElectron()` API for seamless usage
+
+### Phase 6: Testing & Fixes ✅
+- Created sample Blazor Server application
+- Fixed multiple critical issues discovered during integration testing
+- Cleaned up debug logging
+- Added comprehensive code documentation
+
+## Key Components
+
+### 1. SignalRFacade (`src/ElectronNET.AspNet/Bridge/SignalRFacade.cs`)
+- Implements `IFacade` interface to match Socket.IO facade API
+- Handles bidirectional event routing using `IHubContext<ElectronHub>`
+- Includes `ConvertToType<T>` helper for handling SignalR's JSON deserialization quirks
+- Critical fix: Handles `JsonElement` and numeric type conversions (long → int)
+
+### 2. ElectronHub (`src/ElectronNET.AspNet/Hubs/ElectronHub.cs`)
+- SignalR hub for .NET ↔ Electron communication
+- Key methods:
+  - `RegisterElectronClient()` - Called by Electron on connection
+  - `ElectronEvent(string, object[])` - Receives events from Electron
+  - Connection/disconnection handlers notify runtime controller
+
+### 3. RuntimeControllerAspNetDotnetFirstSignalR
+- Manages SignalR mode lifecycle
+- Critical flow:
+  1. Wait for ASP.NET server to start
+  2. Capture dynamic port from `IServerAddressesFeature`
+  3. Update `ElectronNetRuntime.AspNetWebPort` with actual port
+  4. Launch Electron with `--electronurl` parameter
+  5. Wait for `electron-host-ready` signal before calling app ready callback
+
+### 4. SignalRBridge (`src/ElectronNET.Host/api/signalr-bridge.js`)
+- JavaScript SignalR client that mimics Socket.IO interface
+- Provides `on()` and `emit()` methods for API compatibility
+- Critical fix: Event args passed as arrays, spread when calling handlers
+- Uses `@microsoft/signalr` npm package
+
+### 5. Main.js Startup (`src/ElectronNET.Host/main.js`)
+- Detects SignalR mode via `--unpackeddotnetsignalr` or `--dotnetpackedsignalr` flags
+- Creates invisible keep-alive window (destroyed when first real window is created)
+- Loads API modules then signals `electron-host-ready` to .NET
+
+## Usage
+
+Enable SignalR mode by passing the appropriate command-line flag:
+
+```bash
+# Unpacked mode (development)
+dotnet run --unpackeddotnetsignalr
+
+# Packed mode (production)
+dotnet run --dotnetpackedsignalr
+```
+
+Or set environment variable (deprecated, flags preferred):
+```bash
+ELECTRON_USE_SIGNALR=true
+```
+
+In your ASP.NET Core Program.cs:
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+// Add Electron.NET services
+builder.Services.AddElectron();
+
+// Configure Electron with SignalR mode
+builder.WebHost.UseElectron(args, async () =>
+{
+    var window = await Electron.WindowManager.CreateWindowAsync();
+    window.OnReadyToShow += () => window.Show();
+});
+
+var app = builder.Build();
+
+app.UseRouting();
+
+// Map SignalR hub for Electron communication
+app.MapHub<ElectronHub>("/electron-hub");
+
+app.MapRazorComponents<App>().AddInteractiveServerRenderMode();
+app.Run();
+```
+
+**Note**: `UseElectron()` automatically detects SignalR mode and configures everything. The rest happens automatically:
+1. Port 0 binding (dynamic port assignment)
+2. Electron launch with actual URL
+3. SignalR connection establishment (WebSockets enabled automatically by MapHub)
+4. App ready callback execution
+2. Electron launch with actual URL
+3. SignalR connection establishment (WebSockets enabled automatically by `MapHub`)
+4. App ready callback execution
+
+## Architecture Decisions
+
+### Why .NET-First Startup?
+SignalR mode uses .NET-first startup (vs. Electron-first in Socket.IO mode) because:
+1. **No port scanning needed** - .NET can pass the actual URL to Electron
+2. **SignalR hub must be registered** before Electron connects
+3. **Simpler lifecycle** - ASP.NET controls when Electron launches
+4. **Better for Blazor Server** - Blazor is already running when Electron starts
+5. **Single process debugging** - Developer debugs .NET process which owns Electron
+
+### Why IFacade Interface?
+Introducing `IFacade` allows `BridgeConnector.Socket` to return either `SocketIOFacade` or `SignalRFacade` based on startup mode, ensuring existing API code works with both transport mechanisms without modification.
+
+### Why Keep-Alive Window?
+Electron quits immediately on macOS if no windows exist. The keep-alive window ensures Electron stays running during the connection and API initialization phase. It's automatically destroyed when the first real window is created.
+
+### Why 'electron-host-ready' Signal?
+Without this signal, .NET would call the app ready callback before Electron finished loading API modules, causing API calls to fail. The signal ensures proper initialization order:
+1. Electron connects to SignalR
+2. Electron loads all API modules (browserWindows, dialog, menu, etc.)
+3. Electron signals `electron-host-ready`
+4. .NET calls app ready callback
+5. App code can safely use Electron APIs
+
+## Blazor Server Considerations
+
+### SignalR Hub Coexistence
+Blazor Server already uses SignalR for component communication (`/_blazor` hub). Our implementation:
+- Uses separate endpoint (`/electron-hub`) to avoid conflicts
+- Both hubs coexist on the same Kestrel server without interference
+- No impact on Blazor's reconnection logic
+- Compatible with hot reload scenarios
+
+### Lifecycle Integration
+- Electron window creation happens **after** Blazor app is ready
+- `UseElectron()` callback fires when SignalR hub is connected
+- Blazor components can inject Electron services to control windows
+- Proper disposal when Electron process exits
+
+### Development Experience
+- Hot reload works for both Blazor and Electron integration
+- F5 debugging works seamlessly
+- No need to manually coordinate ports
+- Single process to debug (.NET process owns the lifecycle)
+
+## Critical Fixes Applied
+
+### 1. Race Condition: API Module Loading
+**Problem**: .NET called app ready callback before Electron finished loading API modules.
+
+**Solution**: Electron signals `electron-host-ready` after loading all API modules. .NET waits for this signal before calling the app ready callback.
+
+### 2. Event Argument Mismatch
+**Problem**: SignalR sent event data as nested arrays `[[data]]` instead of `[data]`.
+
+**Solution**: 
+- C#: Use explicit `object[] args` parameter (not `params`)
+- JS: Always pass args as array: `invoke('ElectronEvent', eventName, args)`
+- JS: Spread args when calling handlers: `handler(...argsArray)`
+
+### 3. Type Conversion Failures
+**Problem**: SignalR deserializes JSON numbers as `JsonElement` or `long`, causing `Once<int>` handlers to fail silently.
+
+**Solution**: `SignalRFacade.ConvertToType<T>` handles JsonElement deserialization and numeric conversions.
+
+### 4. Window Shutdown Not Triggering Exit
+**Problem**: Keep-alive window prevented `window-all-closed` event from firing.
+
+**Solution**: Destroy keep-alive window when first real window is created using `app.once('browser-window-created')`.
+
+### 5. Dynamic Port Not Propagated
+**Problem**: When using port 0, Kestrel assigns a dynamic port, but `ElectronNetRuntime.AspNetWebPort` was not updated.
+
+**Solution**: Update `AspNetWebPort` after capturing port from `IServerAddressesFeature` in `CapturePortAndLaunchElectron()`.
+
+### 7. Blazor Static Files Not Loading
+**Problem**: Blazor CSS and framework files returned 404 errors.
+
+**Solution**: 
+- Added `app.UseStaticFiles()` to serve wwwroot content
+- Fixed middleware order: `UseAntiforgery()` must be between `UseRouting()` and `UseEndpoints()`
+- Updated scoped CSS asset reference to use lowercase name matching .NET 9+ convention
+
+## Authentication & Security
+
+### Token-Based Authentication (Multi-User Protection)
+
+SignalR mode includes built-in authentication to prevent unauthorized connections in multi-user scenarios (e.g., Windows Server with Terminal Services/RDP).
+
+**Threat Model**: On shared servers, multiple users can run the same application simultaneously. Without authentication, User A's Electron process could potentially connect to User B's ASP.NET backend.
+
+**Solution**: Token-based authentication with secure cookies.
+
+### Authentication Flow
+
+1. **.NET generates token**: When launching Electron, `RuntimeControllerAspNetDotnetFirstSignalR` generates a cryptographically secure GUID (128-bit entropy)
+2. **Token passed via command-line**: Electron receives `--authtoken=<guid>` parameter
+3. **Token appended to URLs**: 
+   - Initial page load: `http://localhost:PORT/?token=<guid>`
+   - SignalR connection: `http://localhost:PORT/electron-hub?token=<guid>`
+4. **Middleware validates token**: `ElectronAuthenticationMiddleware` checks every HTTP request
+5. **Cookie set on first request**: After successful token validation, secure HttpOnly cookie is set
+6. **Subsequent requests use cookie**: No token in URLs after initial authentication
+
+### Security Properties
+
+- **Cookie Settings**:
+  - `HttpOnly`: true (prevents JavaScript access, XSS protection)
+  - `SameSite`: Strict (prevents CSRF)
+  - `Path`: / (applies to all routes)
+  - `Secure`: false (localhost is HTTP, not HTTPS)
+  - `IsEssential`: true (required for app to function)
+  - **Lifetime**: Session scope (expires when Electron closes)
+
+- **Token Validation**:
+  - Constant-time string comparison (prevents timing attacks)
+  - Token stored in singleton service (one per .NET instance)
+  - Never logged in full (only first 8 characters for debugging)
+
+- **Protection Scope**:
+  - All HTTP endpoints (Blazor pages, static files, API calls)
+  - SignalR hub connection (negotiate and all hub traffic)
+  - Both initial request and cookie-based requests validated
+
+### What This Protects Against
+
+✅ **Protected**:
+- Cross-user connections (User A → User B's backend)
+- Port scanning attacks from other users
+- Accidental connections from misconfigured processes
+
+❌ **NOT Protected Against** (By Design):
+- Malicious same-user processes with debugger access
+- Process memory inspection tools (same privilege level)
+- Command-line parameter visibility (same user can see all processes)
+
+**Rationale**: Same-user attacks already have full access to process memory, files, and cookies. Token-based authentication focuses on cross-user isolation, which is the primary threat in multi-user environments.
+
+### Implementation Components
+
+1. **IElectronAuthenticationService** (`src/ElectronNET.AspNet/Services/`)
+   - Singleton service storing expected token
+   - Thread-safe with lock-based validation
+   - Constant-time comparison to prevent timing attacks
+
+2. **ElectronAuthenticationMiddleware** (`src/ElectronNET.AspNet/Middleware/`)
+   - Validates every HTTP request before routing
+   - Checks cookie first, then token query parameter
+   - Sets cookie on first valid token
+   - Returns 401 for invalid/missing authentication
+   - Structured logging for security monitoring
+
+3. **Token Generation** (`RuntimeControllerAspNetDotnetFirstSignalR.cs`)
+   - `Guid.NewGuid().ToString("N")` = 32 hex characters
+   - Called in `LaunchElectron()` method
+   - Registered with authentication service immediately
+
+4. **Electron Integration** (`main.js`, `signalr-bridge.js`)
+   - Extracts token from `--authtoken` parameter
+   - Stores in `global.authToken` for module access
+   - Appends to browser window URL and SignalR connection URL
+
+### Usage in Custom Applications
+
+Authentication is **enabled by default** in SignalR mode. No additional configuration required beyond service registration:
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+// Register authentication service (singleton)
+builder.Services.AddSingleton<IElectronAuthenticationService, ElectronAuthenticationService>();
+
+builder.Services.AddElectron();
+
+var app = builder.Build();
+
+// Register middleware BEFORE UseRouting()
+app.UseMiddleware<ElectronAuthenticationMiddleware>();
+
+app.UseRouting();
+app.MapHub<ElectronHub>("/electron-hub");
+app.MapRazorComponents<App>().AddInteractiveServerRenderMode();
+app.Run();
+```
+
+The rest is automatic:
+- Token generation happens when Electron launches
+- Token validation happens on every request
+- Cookie management is handled by the middleware
+
+### Logging & Monitoring
+
+Authentication events are logged with structured logging:
+
+**Successful authentication**:
+```
+[Information] Authentication successful: Setting cookie for path /
+```
+
+**Failed authentication**:
+```
+[Warning] Authentication failed: Invalid token (prefix: a3f8b2c1...) for path / from 127.0.0.1
+[Warning] Authentication failed: No cookie or token provided for path /api/data from 127.0.0.1
+[Warning] Authentication failed: Invalid cookie for path /_blazor from 127.0.0.1
+```
+
+**SignalR connection failures**:
+```
+[SignalRBridge] Authentication failed: The authentication token is invalid or missing.
+[SignalRBridge] Please ensure the --authtoken parameter is correctly passed to Electron.
+```
+
+Log failed authentication attempts for security monitoring and troubleshooting.
+
+### Testing Multi-User Scenarios
+
+To test authentication in multi-user environments:
+
+1. **Run as different Windows users**:
+   ```powershell
+   # User A session
+   dotnet run
+   
+   # User B session (different RDP/Terminal Services session)
+   dotnet run
+   ```
+
+2. **Verify isolation**: User A's Electron cannot access User B's backend
+3. **Check logs**: Failed auth attempts should be logged
+4. **Monitor tokens**: Each instance generates unique token
+
+For development testing on single-user machines, simulate by running multiple instances and attempting to connect with wrong/missing tokens.
+
+## Backward Compatibility
+
+This is a **new optional startup mode** - all existing modes continue to work unchanged:
+- `PackagedElectronFirst` - unchanged
+- `PackagedDotnetFirst` - unchanged  
+- `UnpackedElectronFirst` - unchanged
+- `UnpackedDotnetFirst` - unchanged
+
+Existing applications do not need to change. SignalR mode is opt-in via command-line flags.
+
+## File Changes Summary
+
+**New Files**:
+- `src/ElectronNET.AspNet/Bridge/SignalRFacade.cs` (225 lines)
+- `src/ElectronNET.AspNet/Hubs/ElectronHub.cs` (108 lines)
+- `src/ElectronNET.AspNet/Runtime/Controllers/RuntimeControllerAspNetDotnetFirstSignalR.cs` (163 lines)
+- `src/ElectronNET.AspNet/Services/IElectronAuthenticationService.cs` (20 lines)
+- `src/ElectronNET.AspNet/Services/ElectronAuthenticationService.cs` (65 lines)
+- `src/ElectronNET.AspNet/Middleware/ElectronAuthenticationMiddleware.cs` (105 lines)
+- `src/ElectronNET.Host/api/signalr-bridge.js` (125 lines)
+
+**Modified Files**:
+- `src/ElectronNET.AspNet/API/WebHostBuilderExtensions.cs` - Added SignalR service registration
+- `src/ElectronNET.Host/main.js` - Added SignalR startup flow and token extraction
+- `src/ElectronNET.Host/api/browserWindows.js` - Token appended to window URLs
+- `src/ElectronNET.Host/package.json` - Added `@microsoft/signalr` dependency
+- `src/ElectronNET.Samples.BlazorSignalR/Program.cs` - Sample with authentication
+
+**Total Changes**: ~1,220 lines added
+
+## Testing Recommendations
+
+1. Test with dynamic port (port 0) to ensure URL propagation works
+2. Verify window-all-closed triggers app exit
+3. Test rapid window creation/destruction
+4. Verify reconnection behavior if SignalR connection drops
+5. Test with both packed and unpacked modes
+6. Verify API calls work correctly (especially those returning data)
+
+## Known Limitations
+
+1. **Request-response pattern not yet implemented** - `InvokeElectronApi` is a placeholder. Current API calls use event-based pattern.
+2. **TouchBar API not yet supported** on macOS SignalR mode
+3. **SignalR automatic reconnection** may cause issues with pending API calls (needs circuit breaker pattern)
+
+## Future Enhancements
+
+1. **Request-response pattern** - Implement proper async/await pattern for API calls that return values
+2. **Metrics/diagnostics** - Add SignalR connection health monitoring
+3. **Circuit breaker** - Handle reconnection scenarios gracefully
+4. **Integration tests** - Comprehensive test suite for SignalR mode
+5. **Performance benchmarks** - Compare SignalR vs Socket.IO performance
+
+## Success Metrics
+
+The implementation is considered complete and functional:
+- ✅ .NET starts first with dynamic port (port 0)
+- ✅ Electron launches with actual URL
+- ✅ SignalR connection establishes successfully
+- ✅ API modules load before app ready callback
+- ✅ Window creation works from .NET
+- ✅ Window shutdown triggers app exit
+- ✅ Blazor Server pages load with correct styling
+- ✅ Both SignalR hubs coexist (Electron + Blazor)
+- ✅ Clean codebase with minimal debug logging
+- ✅ Comprehensive inline documentation
+- ✅ Token-based authentication for multi-user scenarios
+- ✅ Secure cookie-based session management
+- ✅ Structured logging for security monitoring
+- ✅ Protection against cross-user connection attempts

docs/SignalR-Startup-Mode.md

@@ -0,0 +1,236 @@
+# SignalR-Based Startup Mode for Electron.NET
+
+## Overview
+
+This feature adds a new startup mode for Electron.NET where:
+- **.NET/ASP.NET Core starts first** and binds to port 0 (dynamic port)
+- **Kestrel picks an available port** automatically
+- **Electron process is launched** with the actual URL
+- **SignalR is used for communication** instead of socket.io
+- **Blazor Server apps** can coexist with Electron control
+
+## Status
+
+✅ **Phases 1-5 Complete** - Infrastructure ready, basic functionality implemented
+⏸️ **Phase 6 Pending** - Full API integration, testing, and documentation
+
+## How It Works
+
+### Startup Sequence
+
+1. ASP.NET Core application starts
+2. Kestrel binds to `http://localhost:0` (random available port)
+3. `RuntimeControllerAspNetDotnetFirstSignalR` captures the actual port via `IServerAddressesFeature`
+4. Electron process is launched with `--electronUrl=http://localhost:XXXXX`
+5. Electron's main.js detects SignalR mode (via `--dotnetpackedsignalr` or `--unpackeddotnetsignalr` flag)
+6. Electron connects to SignalR hub at `/electron-hub`
+7. Hub notifies runtime controller of successful connection
+8. Application transitions to "Ready" state
+9. `ElectronAppReady` callback is invoked
+
+### Communication Flow
+
+```
+.NET/Kestrel (Port 0) ←→ SignalR Hub (/electron-hub) ←→ Electron Process
+         ↓                        ↓                           ↓
+    Blazor Server          ElectronHub class         SignalR Client
+    (/_blazor hub)         (API commands)           (main.js + signalr-bridge.js)
+```
+
+## Usage
+
+### 1. Enable SignalR Mode
+
+Set the environment variable:
+```bash
+ELECTRON_USE_SIGNALR=true
+```
+
+Or in launchSettings.json:
+```json
+{
+  "environmentVariables": {
+    "ELECTRON_USE_SIGNALR": "true"
+  }
+}
+```
+
+### 2. Configure ASP.NET Core
+
+In your `Program.cs`:
+
+```csharp
+using ElectronNET.API;
+using ElectronNET.API.Entities;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddRazorPages();
+builder.Services.AddElectron();
+
+builder.UseElectron(args, async () =>
+{
+    var window = await Electron.WindowManager.CreateWindowAsync(
+        new BrowserWindowOptions { Show = false });
+    
+    window.OnReadyToShow += () => window.Show();
+});
+
+var app = builder.Build();
+
+// Configure middleware
+app.UseStaticFiles();
+app.UseRouting();
+
+// Map the Electron SignalR hub
+app.MapElectronHub();  // ← Required for SignalR mode
+app.MapRazorPages();
+
+app.Run();
+```
+
+### 3. Run Your Application
+
+Just press F5 in Visual Studio or run:
+```bash
+dotnet run
+```
+
+The application will:
+- Automatically detect SignalR mode via environment variable
+- Bind Kestrel to port 0
+- Launch Electron with the correct URL
+- Establish SignalR connection
+
+## Components
+
+### .NET Side
+
+- **`ElectronHub`** - SignalR hub at `/electron-hub`
+- **`SignalRFacade`** - Mimics `SocketIoFacade` interface for compatibility
+- **`RuntimeControllerAspNetDotnetFirstSignalR`** - Lifecycle management
+- **`StartupMethod.PackagedDotnetFirstSignalR`** - For packaged apps
+- **`StartupMethod.UnpackedDotnetFirstSignalR`** - For debugging
+
+### Electron Side
+
+- **`signalr-bridge.js`** - SignalR client wrapper
+- **`main.js`** - Detects SignalR mode and connects to hub
+- **`@microsoft/signalr`** npm package
+
+## Key Features
+
+✅ **Dynamic Port Assignment** - No hardcoded ports, no conflicts  
+✅ **Blazor Server Compatible** - Separate hub endpoints (`/electron-hub` vs `/_blazor`)  
+✅ **Bidirectional Communication** - Both .NET→Electron and Electron→.NET  
+✅ **Hot Reload Support** - SignalR automatic reconnection  
+✅ **Multiple Instances** - Each instance gets its own port  
+
+## Current Limitations (Phase 6 Work Needed)
+
+⚠️ **Electron API Integration** - Existing Electron APIs (WindowManager, Dialog, etc.) still use SocketIoFacade. Full integration requires:
+- Refactoring APIs to work with both facades, or
+- Creating an adapter pattern
+
+⚠️ **Request-Response Pattern** - Current hub methods are one-way. Need to implement proper async request-response for API calls.
+
+⚠️ **Event Routing** - Electron events need to be routed through SignalR back to .NET.
+
+⚠️ **Testing** - Integration tests needed to validate end-to-end functionality.
+
+## What's Implemented
+
+### Phase 1: Core Infrastructure ✅
+- New `StartupMethod` enum values
+- `ElectronHub` SignalR hub
+- Hub endpoint registration
+
+### Phase 2: Runtime Controller ✅
+- `RuntimeControllerAspNetDotnetFirstSignalR`
+- Port 0 binding logic
+- Electron launch with URL parameter
+- SignalR connection tracking
+
+### Phase 3: Electron/Node.js Side ✅
+- `@microsoft/signalr` package integration
+- SignalR connection module
+- Startup mode detection
+- URL parameter handling
+
+### Phase 4: API Bridge ✅ (Basic Structure)
+- `SignalRFacade` class
+- Event handler system
+- Hub connection integration
+
+### Phase 5: Configuration ✅
+- Environment variable detection
+- Port 0 configuration
+- Automatic service registration
+
+## Next Steps (Phase 6)
+
+To fully utilize this feature, the following work is recommended:
+
+1. **API Integration** - Make existing Electron APIs work with SignalR
+2. **Sample Application** - Create a Blazor Server demo
+3. **Integration Tests** - Validate end-to-end scenarios
+4. **Documentation** - Complete user guides and examples
+5. **Performance Testing** - Compare with socket.io mode
+
+## Files Changed
+
+### .NET
+- `src/ElectronNET.API/Runtime/Data/StartupMethod.cs`
+- `src/ElectronNET.AspNet/Hubs/ElectronHub.cs`
+- `src/ElectronNET.AspNet/Bridge/SignalRFacade.cs`
+- `src/ElectronNET.AspNet/Runtime/Controllers/RuntimeControllerAspNetDotnetFirstSignalR.cs`
+- `src/ElectronNET.AspNet/API/ElectronEndpointRouteBuilderExtensions.cs`
+- `src/ElectronNET.AspNet/API/WebHostBuilderExtensions.cs`
+- `src/ElectronNET.API/Runtime/StartupManager.cs`
+
+### Electron/Node.js
+- `src/ElectronNET.Host/package.json`
+- `src/ElectronNET.Host/main.js`
+- `src/ElectronNET.Host/api/signalr-bridge.js` (new file)
+
+## Commits
+
+```
+7f2ea48 - Add PackagedDotnetFirstSignalR and UnpackedDotnetFirstSignalR startup methods
+8ee81f6 - Add ElectronHub and SignalR infrastructure for new startup modes
+40aed60 - Add RuntimeControllerAspNetDotnetFirstSignalR for SignalR-based startup
+c1740b5 - Add SignalR client support to Electron Host for new startup modes
+cb7d721 - Add SignalRFacade for SignalR-based API communication
+268b9c9 - Update RuntimeControllerAspNetDotnetFirstSignalR to use SignalRFacade
+04ec522 - Fix compilation errors - Phase 4 complete (basic structure)
+054f5b1 - Complete Phase 5: Add SignalR startup detection and port 0 configuration
+```
+
+## Benefits Over Socket.io Mode
+
+- **Better Integration** - Native SignalR is part of ASP.NET Core stack
+- **Type Safety** - SignalR has better TypeScript support
+- **Performance** - SignalR is optimized for ASP.NET Core
+- **Reliability** - Built-in reconnection and error handling
+- **Scalability** - Can leverage SignalR's scale-out features
+- **Consistency** - Blazor Server already uses SignalR
+
+## Contributing
+
+To contribute to Phase 6 (full API integration):
+
+1. Focus on adapting existing Electron API classes to work with SignalRFacade
+2. Implement request-response pattern in ElectronHub
+3. Add integration tests
+4. Create sample applications
+5. Update documentation
+
+## License
+
+MIT - Same as Electron.NET
+
+---
+
+**Created**: January 30, 2026  
+**Status**: Infrastructure Complete, API Integration Pending  
+**Contact**: See Electron.NET maintainers

docs/Using/Configuration.md

@@ -25,7 +25,7 @@ These are the current default values when you don't make any changes:
     <ElectronSingleInstance>true</ElectronSingleInstance>
     <ElectronSplashScreen></ElectronSplashScreen>
     <ElectronIcon></ElectronIcon>
-    <PackageId>$(MSBuildProjectName.Replace(".", "-").ToLower())</PackageId>
+    <ElectronPackageId>$(MSBuildProjectName.Replace(".", "-").ToLower())</ElectronPackageId>
     <ElectronBuilderJson>electron-builder.json</ElectronBuilderJson>
     <Title>$(MSBuildProjectName)</Title>
 </PropertyGroup>
@@ -38,15 +38,15 @@ Since electron builder still expects a `package.json` file to exist, ElectronNET
 
 ```json
 {
-  "name": "$(PackageId)",
+  "name": "$(ElectronPackageId)",
   "productName": "$(ElectronTitle)",
   "build": {
-    "appId": "$(PackageId)",
+    "appId": "$(ElectronPackageId)",
     "linux": {
       "desktop": {
         "entry": { "Name": "$(Title)" }
       },
-      "executableName": "$(PackageId)"
+      "executableName": "$(ElectronPackageId)"
     },
     "deb": {
       "desktop": {

docs/Using/Custom_main.md

@@ -0,0 +1,74 @@
+# Using custom_main.js
+
+This guide explains how to include and use a `custom_main.js` file in your Electron.NET application for advanced Electron/Node.js customization.
+
+## Why use custom_main.js?
+
+- Register custom protocol handlers (e.g., `myapp://`) — protocols must be registered before the app is fully initialized
+- Integrate Node.js modules (e.g., telemetry, OS APIs)
+- Control startup logic (abort, environment checks)
+- Set up IPC messaging or preload scripts
+
+## Step-by-Step Process
+
+### 1. Create the custom_main.js file
+
+Place your custom logic in `electron/custom_main.js`:
+
+```javascript
+module.exports.onStartup = function(host) {
+    // Example: Register a global shortcut for opening dev tools
+    const { app, globalShortcut, BrowserWindow } = require('electron');
+    app.on('ready', () => {
+        const ret = globalShortcut.register('Control+Shift+I', () => {
+            BrowserWindow.getAllWindows().forEach(win => win.webContents.openDevTools());
+            console.log('Ctrl+Shift+I is pressed: DevTools opened!');
+        });
+    });
+    app.on('will-quit', () => {
+        globalShortcut.unregisterAll();
+    });
+    return true;
+};
+```
+
+### 2. Configure your .csproj to copy custom_main.js to output
+
+Add this to your `.csproj` file:
+
+```xml
+<ItemGroup>
+  <None Update="electron\custom_main.js">
+    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    <TargetPath>.electron\custom_main.js</TargetPath>
+  </None>
+</ItemGroup>
+```
+
+### 3. Build and run your app
+
+Use the standard build/run commands:
+
+```powershell
+dotnet build
+dotnet run
+```
+
+Electron.NET will automatically load and execute your `custom_main.js` before initializing the .NET backend.
+
+## Advanced Usage
+
+Use environment variables to control features:
+
+  ```javascript
+  const env = process.env.ASPNETCORE_ENVIRONMENT || 'Production';
+  if (env === 'Development') { /* enable dev features */ }
+  ```
+
+## Notes
+
+- `custom_main.js` must use CommonJS syntax (`module.exports.onStartup = ...`).
+- Place the file in your source directory and copy it to `.electron` using `.csproj`.
+- Electron.NET will abort startup if `onStartup` returns `false`.
+
+### Complete example is available here [ElectronNetSampleApp](https://github.com/niteshsinghal85/ElectronNetSampleApp)

docs/Using/Package-Building.md

@@ -26,12 +26,15 @@ Add publish profiles to `Properties/PublishProfiles/`:
   <PropertyGroup>
     <Configuration>Release</Configuration>
     <Platform>Any CPU</Platform>
-    <PublishDir>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishDir>
-    <PublishProtocol>FileSystem</PublishProtocol>
+    <DeleteExistingFiles>true</DeleteExistingFiles>
+    <PublishProvider>FileSystem</PublishProvider>
+    <PublishUrl>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishUrl>
+    <WebPublishMethod>FileSystem</WebPublishMethod>
+    <_TargetId>Folder</_TargetId>
     <TargetFramework>net10.0</TargetFramework>
     <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <ProjectGuid>48eff821-2f4d-60cc-aa44-be0f1d6e5f35</ProjectGuid>
     <SelfContained>true</SelfContained>
-    <PublishSingleFile>false</PublishSingleFile>
   </PropertyGroup>
 </Project>
 ```
@@ -46,12 +49,61 @@ Add publish profiles to `Properties/PublishProfiles/`:
   <PropertyGroup>
     <Configuration>Release</Configuration>
     <Platform>Any CPU</Platform>
-    <PublishDir>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishDir>
-    <PublishProtocol>FileSystem</PublishProtocol>
+    <DeleteExistingFiles>true</DeleteExistingFiles>
+    <PublishProvider>FileSystem</PublishProvider>
+    <PublishUrl>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishUrl>
+    <WebPublishMethod>FileSystem</WebPublishMethod>
+    <_TargetId>Folder</_TargetId>
     <TargetFramework>net10.0</TargetFramework>
     <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
+    <ProjectGuid>48eff821-2f4d-60cc-aa44-be0f1d6e5f35</ProjectGuid>
+    <SelfContained>true</SelfContained>
+  </PropertyGroup>
+</Project>
+```
+
+#### ASP.NET Application Profile (macOS Apple Silicon ARM64)
+
+**osx-arm64.pubxml:**
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <Platform>Any CPU</Platform>
+    <DeleteExistingFiles>true</DeleteExistingFiles>
+    <PublishProvider>FileSystem</PublishProvider>
+    <PublishUrl>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishUrl>
+    <WebPublishMethod>FileSystem</WebPublishMethod>
+    <_TargetId>Folder</_TargetId>
+    <TargetFramework>net10.0</TargetFramework>
+    <RuntimeIdentifier>osx-arm64</RuntimeIdentifier>
+    <ProjectGuid>48eff821-2f4d-60cc-aa44-be0f1d6e5f35</ProjectGuid>
+    <SelfContained>true</SelfContained>
+  </PropertyGroup>
+</Project>
+```
+
+#### ASP.NET Application Profile (macOS Intel x64)
+
+**osx-x64.pubxml:**
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <Platform>Any CPU</Platform>
+    <DeleteExistingFiles>true</DeleteExistingFiles>
+    <PublishProvider>FileSystem</PublishProvider>
+    <PublishUrl>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishUrl>
+    <WebPublishMethod>FileSystem</WebPublishMethod>
+    <_TargetId>Folder</_TargetId>
+    <TargetFramework>net10.0</TargetFramework>
+    <RuntimeIdentifier>osx-x64</RuntimeIdentifier>
+    <ProjectGuid>48eff821-2f4d-60cc-aa44-be0f1d6e5f35</ProjectGuid>
     <SelfContained>true</SelfContained>
-    <PublishSingleFile>false</PublishSingleFile>
   </PropertyGroup>
 </Project>
 ```
@@ -97,6 +149,46 @@ Add publish profiles to `Properties/PublishProfiles/`:
 </Project>
 ```
 
+#### Console Application Profile (macOS Apple Silicon ARM64)
+
+**osx-arm64.pubxml:**
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <Platform>Any CPU</Platform>
+    <PublishDir>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishDir>
+    <PublishProtocol>FileSystem</PublishProtocol>
+    <TargetFramework>net10.0</TargetFramework>
+    <RuntimeIdentifier>osx-arm64</RuntimeIdentifier>
+    <SelfContained>false</SelfContained>
+    <PublishSingleFile>false</PublishSingleFile>
+  </PropertyGroup>
+</Project>
+```
+
+#### Console Application Profile (macOS Intel x64)
+
+**osx-x64.pubxml:**
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup>
+    <Configuration>Release</Configuration>
+    <Platform>Any CPU</Platform>
+    <PublishDir>publish\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\</PublishDir>
+    <PublishProtocol>FileSystem</PublishProtocol>
+    <TargetFramework>net10.0</TargetFramework>
+    <RuntimeIdentifier>osx-x64</RuntimeIdentifier>
+    <SelfContained>false</SelfContained>
+    <PublishSingleFile>false</PublishSingleFile>
+  </PropertyGroup>
+</Project>
+```
+
 ### Step 2: Configure Electron Builder
 
 ElectronNET.Core automatically adds a default `electron-builder.json` file under `Properties\electron-builder.json`.  

docs/_Sidebar.md

@@ -9,6 +9,7 @@
 
 - [What's new?](Core/What's-New.md)
 - [Migration Guide](Core/Migration-Guide.md)
+- [Migration Checks](Core/Migration-Checks.md)
 - [Advanced Migration](Core/Advanced-Migration-Topics.md)
 
 # Getting Started
@@ -23,6 +24,7 @@
 - [Startup-Methods](Using/Startup-Methods.md)
 - [Debugging](Using/Debugging.md)
 - [Package Building](Using/Package-Building.md)
+- [Adding a `custom_main.js`](Using/Custom_main.md)
 
 # API Reference
 

nuke/_build.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <RootNamespace></RootNamespace>
     <NoWarn>CS0649;CS0169</NoWarn>
     <NukeRootDirectory>..</NukeRootDirectory>
@@ -11,9 +11,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Build" Version="17.11.48" />
-    <PackageReference Include="Microsoft.Build.Tasks.Core" Version="17.11.48" />
-    <PackageReference Include="Nuke.Common" Version="9.0.4" />
+    <PackageReference Include="Microsoft.Build" Version="18.0.2" />
+    <PackageReference Include="Microsoft.Build.Tasks.Core" Version="18.0.2" />
+    <PackageReference Include="Nuke.Common" Version="10.1.0" />
   </ItemGroup>
 
   <ItemGroup>

src/ElectronNET.API/API/ApiBase.cs

@@ -31,7 +31,7 @@ namespace ElectronNET.API
             CamelCase,
         }
 
-        private const int InvocationTimeout = 1000;
+        private static readonly TimeSpan InvocationTimeout = 1000.ms();
 
         private readonly string objectName;
         private readonly ConcurrentDictionary<string, Invocator> invocators;
@@ -116,6 +116,11 @@ namespace ElectronNET.API
         }
 
         protected Task<T> InvokeAsync<T>(object arg = null, [CallerMemberName] string callerName = null)
+        {
+            return this.InvokeAsyncWithTimeout<T>(InvocationTimeout, arg, callerName);
+        }
+
+        protected Task<T> InvokeAsyncWithTimeout<T>(TimeSpan invocationTimeout, object arg = null, [CallerMemberName] string callerName = null)
         {
             Debug.Assert(callerName != null, nameof(callerName) + " != null");
 
@@ -123,7 +128,7 @@ namespace ElectronNET.API
             {
                 return this.invocators.GetOrAdd(callerName, _ =>
                 {
-                    var getter = new Invocator<T>(this, callerName, InvocationTimeout, arg);
+                    var getter = new Invocator<T>(this, callerName, invocationTimeout, arg);
 
                     getter.Task<T>().ContinueWith(_ =>
                     {
@@ -240,7 +245,7 @@ namespace ElectronNET.API
             private readonly Task<T> tcsTask;
             private TaskCompletionSource<T> tcs;
 
-            public Invocator(ApiBase apiBase, string callerName, int timeoutMs, object arg = null)
+            public Invocator(ApiBase apiBase, string callerName, TimeSpan timeout, object arg = null)
             {
                 this.tcs = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
                 this.tcsTask = this.tcs.Task;
@@ -301,7 +306,7 @@ namespace ElectronNET.API
                     _ = apiBase.Id >= 0 ? BridgeConnector.Socket.Emit(messageName, apiBase.Id) : BridgeConnector.Socket.Emit(messageName);
                 }
 
-                System.Threading.Tasks.Task.Delay(InvocationTimeout).ContinueWith(_ =>
+                System.Threading.Tasks.Task.Delay(timeout).ContinueWith(_ =>
                 {
                     if (this.tcs != null)
                     {
@@ -309,7 +314,9 @@ namespace ElectronNET.API
                         {
                             if (this.tcs != null)
                             {
-                                var ex = new TimeoutException($"No response after {timeoutMs:D}ms trying to retrieve value {apiBase.objectName}.{callerName}()");
+                                var ex = new TimeoutException(
+                                    $"No response after {(long)timeout.TotalMilliseconds}ms trying to retrieve value {apiBase.objectName}.{callerName}()"
+                                );
                                 this.tcs.TrySetException(ex);
                                 this.tcs = null;
                             }

src/ElectronNET.API/API/App.cs

@@ -539,7 +539,7 @@ namespace ElectronNET.API
             using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
             {
                 BridgeConnector.Socket.Once<string>("appGetPathCompleted", taskCompletionSource.SetResult);
-                BridgeConnector.Socket.Emit("appGetPath", pathName.GetDescription());
+                BridgeConnector.Socket.Emit("appGetPath", pathName);
 
                 return await taskCompletionSource.Task
                     .ConfigureAwait(false);
@@ -560,7 +560,7 @@ namespace ElectronNET.API
         /// </summary>
         public void SetPath(PathName name, string path)
         {
-            this.CallMethod2(name.GetDescription(), path);
+            this.CallMethod2(name, path);
         }
 
         /// <summary>

src/ElectronNET.API/API/BrowserWindow.cs

@@ -186,6 +186,19 @@ public class BrowserWindow : ApiBase
         remove => RemoveEvent(value, Id);
     }
 
+    /// <summary>
+    /// Emitted when the window is moved or resized.
+    /// </summary>
+    /// <remarks>
+    ///     While not being an original Electron event, this one includes the bounds values,
+    ///     saving the additional roundtrip for calling <see cref="GetBoundsAsync"/>.
+    /// </remarks>
+    public event Action<Rectangle> OnBoundsChanged
+    {
+        add => AddEvent(value, Id);
+        remove => RemoveEvent(value, Id);
+    }
+
     /// <summary>
     /// macOS: Emitted once when the window is moved to a new position.
     /// </summary>
@@ -681,7 +694,7 @@ public class BrowserWindow : ApiBase
     /// <param name="level">Values include normal, floating, torn-off-menu, modal-panel, main-menu,
     /// status, pop-up-menu and screen-saver. The default is floating.
     /// See the macOS docs</param>
-    public void SetAlwaysOnTop(bool flag, OnTopLevel level) => this.CallMethod2(flag, level.GetDescription());
+    public void SetAlwaysOnTop(bool flag, OnTopLevel level) => this.CallMethod2(flag, level);
 
     /// <summary>
     /// Sets whether the window should show always on top of other windows.
@@ -694,7 +707,7 @@ public class BrowserWindow : ApiBase
     /// See the macOS docs</param>
     /// <param name="relativeLevel">The number of layers higher to set this window relative to the given level.
     /// The default is 0. Note that Apple discourages setting levels higher than 1 above screen-saver.</param>
-    public void SetAlwaysOnTop(bool flag, OnTopLevel level, int relativeLevel) => this.CallMethod3(flag, level.GetDescription(), relativeLevel);
+    public void SetAlwaysOnTop(bool flag, OnTopLevel level, int relativeLevel) => this.CallMethod3(flag, level, relativeLevel);
 
     /// <summary>
     /// Whether the window is always on top of other windows.
@@ -1190,7 +1203,7 @@ public class BrowserWindow : ApiBase
     /// menu, popover, sidebar, medium-light or ultra-dark.
     /// See the macOS documentation for more details.</param>
     [SupportedOSPlatform("macOS")]
-    public void SetVibrancy(Vibrancy type) => this.CallMethod1(type.GetDescription());
+    public void SetVibrancy(Vibrancy type) => this.CallMethod1(type);
 
     /// <summary>
     /// Render and control web pages.

src/ElectronNET.API/API/Cookies.cs

@@ -2,6 +2,7 @@ using ElectronNET.API.Entities;
 using ElectronNET.API.Serialization;
 using System;
 using System.Text.Json;
+using System.Threading.Tasks;
 
 namespace ElectronNET.API
 {
@@ -54,10 +55,79 @@ namespace ElectronNET.API
                 _changed -= value;
 
                 if (_changed == null)
+                {
                     BridgeConnector.Socket.Off("webContents-session-cookies-changed" + Id);
+                }
             }
         }
 
         private event Action<Cookie, CookieChangedCause, bool> _changed;
+
+        
+
+        /// <summary>
+        /// Sends a request to get all cookies matching filter, and resolves a callack with the response.
+        /// </summary>
+        /// <param name="filter">
+        /// </param>
+        /// <returns>A task which resolves an array of cookie objects.</returns>
+        public Task<Cookie[]> GetAsync(CookieFilter filter)
+        {
+            var tcs = new TaskCompletionSource<Cookie[]>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<Cookie[]>("webContents-session-cookies-get-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-get", Id, filter, guid);
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="details"></param>
+        /// <returns></returns>
+        public Task SetAsync(CookieDetails details)
+        {
+            var tcs = new TaskCompletionSource<object>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<object>("webContents-session-cookies-set-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-set", Id, details, guid);
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// Removes the cookies matching url and name
+        /// </summary>
+        /// <param name="url">The URL associated with the cookie.</param>
+        /// <param name="name">The name of cookie to remove.</param>
+        /// <returns>A task which resolves when the cookie has been removed</returns>
+        public Task RemoveAsync(string url, string name)
+        {
+            var tcs = new TaskCompletionSource<object>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<object>("webContents-session-cookies-remove-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-remove", Id, url, name, guid);
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// Writes any unwritten cookies data to disk.
+        /// </summary>
+        /// <returns>A task which resolves when the cookie store has been flushed</returns>
+        public Task FlushStoreAsync()
+        {
+            var tcs = new TaskCompletionSource<object>();
+            var guid = Guid.NewGuid().ToString();
+
+            BridgeConnector.Socket.Once<object>("webContents-session-cookies-flushStore-completed" + guid, tcs.SetResult);
+            BridgeConnector.Socket.Emit("webContents-session-cookies-flushStore", Id, guid);
+
+            return tcs.Task;
+        }
     }
 }

src/ElectronNET.API/API/Dialog.cs

@@ -206,10 +206,10 @@ namespace ElectronNET.API
         [SupportedOSPlatform("Windows")]
         public Task ShowCertificateTrustDialogAsync(BrowserWindow browserWindow, CertificateTrustDialogOptions options)
         {
-            var tcs = new TaskCompletionSource<object>();
+            var tcs = new TaskCompletionSource();
             string guid = Guid.NewGuid().ToString();
 
-            BridgeConnector.Socket.Once("showCertificateTrustDialogComplete" + guid, () => tcs.SetResult(null));
+            BridgeConnector.Socket.Once("showCertificateTrustDialogComplete" + guid, () => tcs.SetResult());
             BridgeConnector.Socket.Emit("showCertificateTrustDialog",
                 browserWindow,
                 options,

src/ElectronNET.API/API/Dock.cs

@@ -57,7 +57,7 @@ namespace ElectronNET.API
             using (cancellationToken.Register(() => tcs.TrySetCanceled()))
             {
                 BridgeConnector.Socket.Once<int>("dock-bounce-completed", tcs.SetResult);
-                BridgeConnector.Socket.Emit("dock-bounce", type.GetDescription());
+                BridgeConnector.Socket.Emit("dock-bounce", type);
 
                 return await tcs.Task
                     .ConfigureAwait(false);

src/ElectronNET.API/API/Entities/AboutPanelOptions.cs

@@ -1,8 +1,11 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// About panel options.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class AboutPanelOptions
     {
         /// <summary>
@@ -21,28 +24,35 @@
         public string Copyright { get; set; }
 
         /// <summary>
-        /// The app's build version number.
+        /// The app's build version number (macOS).
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public string Version { get; set; }
 
         /// <summary>
-        /// Credit information.
+        /// Credit information (macOS, Windows).
         /// </summary>
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("windows")]
         public string Credits { get; set; }
 
         /// <summary>
-        /// List of app authors.
+        /// List of app authors (Linux).
         /// </summary>
+        [SupportedOSPlatform("linux")]
         public string[] Authors { get; set; }
 
         /// <summary>
-        /// The app's website.
+        /// The app's website (Linux).
         /// </summary>
+        [SupportedOSPlatform("linux")]
         public string Website { get; set; }
 
         /// <summary>
-        /// Path to the app's icon. On Linux, will be shown as 64x64 pixels while retaining aspect ratio.
+        /// Path to the app's icon in a JPEG or PNG file format. On Linux, will be shown as 64x64 pixels while retaining aspect ratio. On Windows, a 48x48 PNG will result in the best visual quality.
         /// </summary>
+        [SupportedOSPlatform("linux")]
+        [SupportedOSPlatform("windows")]
         public string IconPath { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/AddRepresentationOptions.cs

@@ -1,32 +1,35 @@
+using System.Text.Json.Serialization;
+
 namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class AddRepresentationOptions
     {
         /// <summary>
-        /// Gets or sets the width
+        /// Gets or sets the width in pixels. Defaults to 0. Required if a bitmap buffer is specified as <see cref="Buffer"/>.
         /// </summary>
         public int? Width { get; set; }
 
         /// <summary>
-        /// Gets or sets the height
+        /// Gets or sets the height in pixels. Defaults to 0. Required if a bitmap buffer is specified as <see cref="Buffer"/>.
         /// </summary>
         public int? Height { get; set; }
 
         /// <summary>
-        /// Gets or sets the scalefactor
+        /// Gets or sets the image scale factor. Defaults to 1.0.
         /// </summary>
         public float ScaleFactor { get; set; } = 1.0f;
 
         /// <summary>
-        /// Gets or sets the buffer
+        /// Gets or sets the buffer containing the raw image data.
         /// </summary>
         public byte[] Buffer { get; set; }
 
         /// <summary>
-        /// Gets or sets the dataURL
+        /// Gets or sets the data URL containing a base 64 encoded PNG or JPEG image.
         /// </summary>
         public string DataUrl { get; set; }
     }

src/ElectronNET.API/API/Entities/AppDetailsOptions.cs

@@ -1,32 +1,36 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("windows")]
     public class AppDetailsOptions
     {
         /// <summary>
-        /// Window’s App User Model ID. It has to be set, otherwise the other options will have no effect.
+        /// Window's App User Model ID. It has to be set, otherwise the other options will have no effect.
         /// </summary>
         public string AppId { get; set; }
 
         /// <summary>
-        /// Window’s Relaunch Icon.
+        /// Window's relaunch icon resource path.
         /// </summary>
         public string AppIconPath { get; set; }
 
         /// <summary>
-        /// Index of the icon in appIconPath. Ignored when appIconPath is not set. Default is 0.
+        /// Index of the icon in <see cref="AppIconPath"/>. Ignored when <see cref="AppIconPath"/> is not set. Default is 0.
         /// </summary>
         public int AppIconIndex { get; set; }
 
         /// <summary>
-        /// Window’s Relaunch Command.
+        /// Window's relaunch command.
         /// </summary>
         public string RelaunchCommand { get; set; }
 
         /// <summary>
-        /// Window’s Relaunch Display Name.
+        /// Window's relaunch display name.
         /// </summary>
         public string RelaunchDisplayName { get; set; }
     }

src/ElectronNET.API/API/Entities/AutoResizeOptions.cs

@@ -5,6 +5,7 @@ namespace ElectronNET.API.Entities
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class AutoResizeOptions
     {
         /// <summary>

src/ElectronNET.API/API/Entities/BitmapOptions.cs

@@ -3,10 +3,11 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class BitmapOptions
     {
         /// <summary>
-        /// Gets or sets the scale factor
+        /// The image scale factor. Defaults to 1.0.
         /// </summary>
         public float ScaleFactor { get; set; } = 1.0f;
     }

src/ElectronNET.API/API/Entities/Blob.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class Blob : IPostData
     {
         /// <summary>

src/ElectronNET.API/API/Entities/BrowserViewConstructorOptions.cs

@@ -3,23 +3,26 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class BrowserViewConstructorOptions
     {
         /// <summary>
-        /// See BrowserWindow.
+        /// Gets or sets the web preferences for the view (see WebPreferences).
         /// </summary>
         public WebPreferences WebPreferences { get; set; }
 
         /// <summary>
-        /// A proxy to set on creation in the format host:port.
+        /// Gets or sets a proxy to use on creation in the format host:port.
         /// The proxy can be alternatively set using the BrowserView.WebContents.SetProxyAsync function.
         /// </summary>
+        /// <remarks>This is custom shortcut. Not part of the Electron API.</remarks>
         public string Proxy { get; set; }
 
         /// <summary>
-        /// The credentials of the Proxy in the format username:password.
+        /// Gets or sets the credentials of the proxy in the format username:password.
         /// These will only be used if the Proxy field is also set.
         /// </summary>
+        /// <remarks>This is custom shortcut. Not part of the Electron API.</remarks>
         public string ProxyCredentials { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/BrowserWindowOptions.cs

@@ -1,6 +1,7 @@
 using ElectronNET.Converter;
 using System.ComponentModel;
 using System.Text.Json.Serialization;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
@@ -23,13 +24,13 @@ namespace ElectronNET.API.Entities
         /// ( if y is used) Window's left offset from screen. Default is to center the
         /// window.
         /// </summary>
-        public int X { get; set; } = -1;
+        public int? X { get; set; }
 
         /// <summary>
         /// ( if x is used) Window's top offset from screen. Default is to center the
         /// window.
         /// </summary>
-        public int Y { get; set; } = -1;
+        public int? Y { get; set; }
 
         /// <summary>
         /// The width and height would be used as web page's size, which means the actual
@@ -72,24 +73,32 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// Whether window is movable. This is not implemented on Linux. Default is true.
         /// </summary>
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("windows")]
         [DefaultValue(true)]
         public bool Movable { get; set; } = true;
 
         /// <summary>
         /// Whether window is minimizable. This is not implemented on Linux. Default is true.
         /// </summary>
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("windows")]
         [DefaultValue(true)]
         public bool Minimizable { get; set; } = true;
 
         /// <summary>
         /// Whether window is maximizable. This is not implemented on Linux. Default is true.
         /// </summary>
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("windows")]
         [DefaultValue(true)]
         public bool Maximizable { get; set; } = true;
 
         /// <summary>
         /// Whether window is closable. This is not implemented on Linux. Default is true.
         /// </summary>
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("windows")]
         [DefaultValue(true)]
         public bool Closable { get; set; } = true;
 
@@ -115,14 +124,17 @@ namespace ElectronNET.API.Entities
 
         /// <summary>
         /// Whether the window can be put into fullscreen mode. On macOS, also whether the
-        /// maximize/zoom button should toggle full screen mode or maximize window.Default
-        /// is true.
+        /// maximize/zoom button should toggle full screen mode or maximize window. Default
+        /// is true (Electron default).
         /// </summary>
-        public bool Fullscreenable { get; set; }
+        [DefaultValue(true)]
+        public bool Fullscreenable { get; set; } = true; // FIX: previously defaulted to false in C#
 
         /// <summary>
         /// Whether to show the window in taskbar. Default is false.
         /// </summary>
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("windows")]
         public bool SkipTaskbar { get; set; }
 
         /// <summary>
@@ -141,8 +153,7 @@ namespace ElectronNET.API.Entities
         public string Title { get; set; } = "Electron.NET";
 
         /// <summary>
-        /// The window icon. On Windows it is recommended to use ICO icons to get best
-        /// visual effects, you can also leave it undefined so the executable's icon will be used.
+        /// The window icon. Can be a NativeImage or a string path. On Windows it is recommended to use ICO icons; when undefined, the executable's icon will be used.
         /// </summary>
         public string Icon { get; set; }
 
@@ -153,7 +164,7 @@ namespace ElectronNET.API.Entities
         public bool Show { get; set; } = true;
 
         /// <summary>
-        /// Specify false to create a . Default is true.
+        /// Specify false to create a frameless window. Default is true.
         /// </summary>
         [DefaultValue(true)]
         public bool Frame { get; set; } = true;
@@ -168,6 +179,7 @@ namespace ElectronNET.API.Entities
         /// Whether the web view accepts a single mouse-down event that simultaneously
         /// activates the window.Default is false.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool AcceptFirstMouse { get; set; }
 
         /// <summary>
@@ -178,28 +190,35 @@ namespace ElectronNET.API.Entities
         /// <summary>
         /// Auto hide the menu bar unless the Alt key is pressed. Default is false.
         /// </summary>
+        [SupportedOSPlatform("windows")]
+        [SupportedOSPlatform("linux")]
         public bool AutoHideMenuBar { get; set; }
 
         /// <summary>
         /// Enable the window to be resized larger than screen. Default is false.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool EnableLargerThanScreen { get; set; }
 
         /// <summary>
-        /// Window's background color as Hexadecimal value, like #66CD00 or #FFF or
-        /// #80FFFFFF (alpha is supported). Default is #FFF (white).
+        /// The window's background color in Hex, RGB, RGBA, HSL, HSLA or named CSS color format. Alpha in #AARRGGBB format is supported if transparent is set to true. Default is #FFF (white).
         /// </summary>
         public string BackgroundColor { get; set; }
 
         /// <summary>
-        /// Whether window should have a shadow. This is only implemented on macOS. Default
-        /// is true.
+        /// Initial opacity of the window, between 0.0 (fully transparent) and 1.0 (fully opaque). Only implemented on Windows and macOS.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        [SupportedOSPlatform("macos")]
+        public double? Opacity { get; set; }
+
+        /// <summary>
+        /// Whether window should have a shadow. Default is true.
         /// </summary>
         public bool HasShadow { get; set; }
 
         /// <summary>
-        /// Forces using dark theme for the window, only works on some GTK+3 desktop
-        /// environments.Default is false.
+        /// Forces using dark theme for the window, only works on some GTK+3 desktop environments. Default is false.
         /// </summary>
         public bool DarkTheme { get; set; }
 
@@ -219,6 +238,12 @@ namespace ElectronNET.API.Entities
         /// </summary>
         public TitleBarStyle TitleBarStyle { get; set; }
 
+        /// <summary>
+        /// Set a custom position for the traffic light buttons in frameless windows (macOS).
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public Point TrafficLightPosition { get; set; }
+
         /// <summary>
         /// Configures the window's title bar overlay when using a frameless window.
         /// Can be either:
@@ -232,9 +257,9 @@ namespace ElectronNET.API.Entities
         public TitleBarOverlay TitleBarOverlay { get; set; }
 
         /// <summary>
-        /// Shows the title in the tile bar in full screen mode on macOS for all
-        /// titleBarStyle options.Default is false.
+        /// Shows the title in the title bar in full screen mode on macOS for all titleBarStyle options. Default is false.
         /// </summary>
+        /// <remarks>Not documented by MCP base-window-options / browser-window-options.</remarks>
         public bool FullscreenWindowTitle { get; set; }
 
         /// <summary>
@@ -242,6 +267,7 @@ namespace ElectronNET.API.Entities
         /// window frame.Setting it to false will remove window shadow and window
         /// animations. Default is true.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         [DefaultValue(true)]
         public bool ThickFrame { get; set; } = true;
 
@@ -251,14 +277,17 @@ namespace ElectronNET.API.Entities
         /// Windows versions older than Windows 11 Build 22000 this property has no effect, and
         /// frameless windows will not have rounded corners.
         /// </summary>
+        [SupportedOSPlatform("macos")]
+        [SupportedOSPlatform("windows")]
         [DefaultValue(true)]
         public bool RoundedCorners { get; set; } = true;
 
         /// <summary>
         /// Add a type of vibrancy effect to the window, only on macOS. Can be
-        /// appearance-based, light, dark, titlebar, selection, menu, popover, sidebar,
-        /// medium-light or ultra-dark.
+        /// appearance-based, titlebar, selection, menu, popover, sidebar, header, sheet,
+        /// window, hud, fullscreen-ui, tooltip, content, under-window, or under-page.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public Vibrancy Vibrancy { get; set; }
 
         /// <summary>
@@ -268,6 +297,7 @@ namespace ElectronNET.API.Entities
         /// it to zoom to the width of the screen.This will also affect the behavior when
         /// calling maximize() directly.Default is false.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool ZoomToPageWidth { get; set; }
 
         /// <summary>
@@ -276,6 +306,7 @@ namespace ElectronNET.API.Entities
         /// adds a native new tab button to your window's tab bar and allows your app and
         /// window to receive the new-window-for-tab event.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public string TabbingIdentifier { get; set; }
 
         /// <summary>
@@ -287,12 +318,39 @@ namespace ElectronNET.API.Entities
         /// A proxy to set on creation in the format host:port.
         /// The proxy can be alternatively set using the BrowserWindow.WebContents.SetProxyAsync function.
         /// </summary>
+        /// <remarks>Not documented by MCP base-window-options / browser-window-options.</remarks>
         public string Proxy { get; set; }
 
         /// <summary>
         /// The credentials of the Proxy in the format username:password.
         /// These will only be used if the Proxy field is also set.
         /// </summary>
+        /// <remarks>Not documented by MCP base-window-options / browser-window-options.</remarks>
         public string ProxyCredentials { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether to use pre-Lion fullscreen on macOS. Default is false.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public bool SimpleFullscreen { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the window should be hidden when the user toggles into mission control (macOS).
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public bool HiddenInMissionControl { get; set; }
+
+        /// <summary>
+        /// Gets or sets how the material appearance should reflect window activity state on macOS. Must be used with the vibrancy property.
+        /// Possible values: 'followWindow' (default), 'active', 'inactive'.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public string VisualEffectState { get; set; }
+
+        /// <summary>
+        /// Gets or sets the system-drawn background material on Windows. Can be 'auto', 'none', 'mica', 'acrylic' or 'tabbed'.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        public string BackgroundMaterial { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/CPUUsage.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CPUUsage
     {
         /// <summary>
@@ -11,9 +12,14 @@
         public double PercentCPUUsage { get; set; }
 
         /// <summary>
-        /// The number of average idle cpu wakeups per second since the last call to
-        /// getCPUUsage.First call returns 0.
+        /// Total seconds of CPU time used since process startup, if available.
         /// </summary>
-        public int IdleWakeupsPerSecond { get; set; }
+        public double? CumulativeCPUUsage { get; set; }
+
+        /// <summary>
+        /// The number of average idle CPU wakeups per second since the last call to
+        /// getCPUUsage. First call returns 0. Will always return 0 on Windows.
+        /// </summary>
+        public double IdleWakeupsPerSecond { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/Certificate.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class Certificate
     {
         /// <summary>

src/ElectronNET.API/API/Entities/CertificatePrincipal.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CertificatePrincipal
     {
         /// <summary>

src/ElectronNET.API/API/Entities/CertificateTrustDialogOptions.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CertificateTrustDialogOptions
     {
         /// <summary>

src/ElectronNET.API/API/Entities/ChromeExtensionInfo.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// Provide metadata about the current loaded Chrome extension
     /// </summary>
+    /// <yremarks>Project-specific: no matching Electron structure found in MCP docs (electronjs).</yremarks>
     public class ChromeExtensionInfo
     {
         /// <summary>

src/ElectronNET.API/API/Entities/ClearStorageDataOptions.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class ClearStorageDataOptions
     {
         /// <summary>
@@ -11,13 +12,16 @@
         public string Origin { get; set; }
 
         /// <summary>
-        /// The types of storages to clear, can contain: appcache, cookies, filesystem,
-        /// indexdb, localstorage, shadercache, websql, serviceworkers, cachestorage.
+        /// The types of storages to clear. Can contain: cookies, filesystem, indexdb,
+        /// localstorage, shadercache, websql, serviceworkers, cachestorage.
+        /// If not specified, all storage types are cleared.
         /// </summary>
         public string[] Storages { get; set; }
 
         /// <summary>
-        /// The types of quotas to clear, can contain: temporary, persistent, syncable.
+        /// The types of quotas to clear. Can contain: temporary. If not specified,
+        /// all quotas are cleared. The <c>quotas</c> option is deprecated;
+        /// "temporary" is the only remaining supported quota type.
         /// </summary>
         public string[] Quotas { get; set; }
     }

src/ElectronNET.API/API/Entities/Cookie.cs

@@ -1,53 +1,59 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Cookie structure as used by Electron session.cookies APIs.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class Cookie
     {
         /// <summary>
-        /// The name of the cookie.
+        /// Gets or sets the name of the cookie.
         /// </summary>
         public string Name { get; set; }
 
         /// <summary>
-        /// The value of the cookie.
+        /// Gets or sets the value of the cookie.
         /// </summary>
         public string Value { get; set; }
 
         /// <summary>
-        /// (optional) - The domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains.
+        /// Gets or sets the domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains.
         /// </summary>
         public string Domain { get; set; }
 
         /// <summary>
-        /// (optional) - Whether the cookie is a host-only cookie; this will only be true if no domain was passed.
+        /// Gets or sets a value indicating whether the cookie is a host-only cookie; this will only be true if no domain was passed.
         /// </summary>
-        public bool HostOnly { get; set; }
+        public bool? HostOnly { get; set; }
 
         /// <summary>
-        /// (optional) - The path of the cookie.
+        /// Gets or sets the path of the cookie.
         /// </summary>
         public string Path { get; set; }
 
         /// <summary>
-        /// (optional) - Whether the cookie is marked as secure.
+        /// Gets or sets a value indicating whether the cookie is marked as secure.
         /// </summary>
-        public bool Secure { get; set; }
+        public bool? Secure { get; set; }
 
         /// <summary>
-        /// (optional) - Whether the cookie is marked as HTTP only.
+        /// Gets or sets a value indicating whether the cookie is marked as HTTP only.
         /// </summary>
-        public bool HttpOnly { get; set; }
+        public bool? HttpOnly { get; set; }
 
         /// <summary>
-        /// (optional) - Whether the cookie is a session cookie or a persistent cookie with an expiration date.
+        /// Gets or sets a value indicating whether the cookie is a session cookie or a persistent cookie with an expiration date.
         /// </summary>
-        public bool Session { get; set; }
+        public bool? Session { get; set; }
 
         /// <summary>
-        /// (optional) - The expiration date of the cookie as the number of seconds since the UNIX epoch. Not provided for session cookies.
+        /// Gets or sets the expiration date of the cookie as the number of seconds since the UNIX epoch. Not provided for session cookies.
         /// </summary>
-        public long ExpirationDate { get; set; }
+        public double? ExpirationDate { get; set; }
+
+        /// <summary>
+        /// Gets or sets the SameSite policy applied to this cookie. Can be "unspecified", "no_restriction", "lax" or "strict".
+        /// </summary>
+        public string SameSite { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/CookieChangedCause.cs

@@ -1,16 +1,15 @@
-using System.Text.Json.Serialization;
-
 namespace ElectronNET.API.Entities
 {
+    using System.Text.Json.Serialization;
+
     /// <summary>
-    /// The cause of the change
+    /// The cause of the cookie change (per Electron Cookies 'changed' event).
     /// </summary>
     public enum CookieChangedCause
     {
         /// <summary>
-        ///The cookie was changed directly by a consumer's action.
+        /// The cookie was changed directly by a consumer's action.
         /// </summary>
-        [JsonPropertyName("explicit")]
         @explicit,
 
         /// <summary>
@@ -19,17 +18,17 @@ namespace ElectronNET.API.Entities
         overwrite,
 
         /// <summary>
-        ///  The cookie was automatically removed as it expired.
+        /// The cookie was automatically removed as it expired.
         /// </summary>
         expired,
 
         /// <summary>
-        ///  The cookie was automatically evicted during garbage collection.
+        /// The cookie was automatically evicted during garbage collection.
         /// </summary>
         evicted,
 
         /// <summary>
-        ///   The cookie was overwritten with an already-expired expiration date.
+        /// The cookie was overwritten with an already-expired expiration date.
         /// </summary>
         [JsonPropertyName("expired_overwrite")]
         expiredOverwrite

src/ElectronNET.API/API/Entities/CookieDetails.cs

@@ -5,54 +5,59 @@ namespace ElectronNET.API.Entities
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CookieDetails
     {
         /// <summary>
-        /// The URL to associate the cookie with. The callback will be rejected if the URL is invalid.
+        /// Gets or sets the URL to associate the cookie with. The operation will be rejected if the URL is invalid.
         /// </summary>
         public string Url { get; set; }
 
         /// <summary>
-        /// (optional) - The name of the cookie. Empty by default if omitted.
+        /// Gets or sets the name of the cookie. Empty by default if omitted.
         /// </summary>
         [DefaultValue("")]
         public string Name { get; set; }
 
         /// <summary>
-        /// (optional) - The value of the cookie. Empty by default if omitted.
+        /// Gets or sets the value of the cookie. Empty by default if omitted.
         /// </summary>
         [DefaultValue("")]
         public string Value { get; set; }
 
         /// <summary>
-        /// (optional) - The domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains. Empty by default if omitted.
+        /// Gets or sets the domain of the cookie; this will be normalized with a preceding dot so that it's also valid for subdomains. Empty by default if omitted.
         /// </summary>
         [DefaultValue("")]
         public string Domain { get; set; }
 
         /// <summary>
-        /// (optional) - The path of the cookie. Empty by default if omitted.
+        /// Gets or sets the path of the cookie. Empty by default if omitted.
         /// </summary>
         [DefaultValue("")]
         public string Path { get; set; }
 
         /// <summary>
-        /// (optional) - Whether the cookie is marked as secure. Defaults to false.
+        /// Gets or sets a value indicating whether the cookie should be marked as secure. Defaults to false unless the SameSite policy is set to <c>no_restriction</c> (SameSite=None).
         /// </summary>
         [DefaultValue(false)]
         public bool Secure { get; set; }
 
         /// <summary>
-        /// (optional) - Whether the cookie is marked as HTTP only. Defaults to false.
+        /// Gets or sets a value indicating whether the cookie should be marked as HTTP only. Defaults to false.
         /// </summary>
         [DefaultValue(false)]
         public bool HttpOnly { get; set; }
 
         /// <summary>
-        /// (optional) - The expiration date of the cookie as the number of seconds since the UNIX epoch.
-        /// If omitted then the cookie becomes a session cookie and will not be retained between sessions.
+        /// Gets or sets the expiration date of the cookie as the number of seconds since the UNIX epoch. If omitted, the cookie becomes a session cookie and will not be retained between sessions.
         /// </summary>
         [DefaultValue(0)]
-        public long ExpirationDate { get; set; }
+        public double ExpirationDate { get; set; }
+
+        /// <summary>
+        /// Gets or sets the SameSite policy to apply to this cookie. Can be "unspecified", "no_restriction", "lax" or "strict". Default is "lax".
+        /// </summary>
+        public string SameSite { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/CookieFilter.cs

@@ -3,10 +3,11 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CookieFilter
     {
         /// <summary>
-        /// (optional) - Retrieves cookies which are associated with url.Empty implies retrieving cookies of all URLs.
+        /// (optional) - Retrieves cookies which are associated with url. Empty implies retrieving cookies of all URLs.
         /// </summary>
         public string Url { get; set; }
 
@@ -28,11 +29,16 @@
         /// <summary>
         /// (optional) - Filters cookies by their Secure property.
         /// </summary>
-        public bool Secure { get; set; }
+        public bool? Secure { get; set; }
 
         /// <summary>
         /// (optional) - Filters out session or persistent cookies.
         /// </summary>
-        public bool Session { get; set; }
+        public bool? Session { get; set; }
+
+        /// <summary>
+        /// (optional) - Filters cookies by httpOnly.
+        /// </summary>
+        public bool? HttpOnly { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/CreateFromBitmapOptions.cs

@@ -3,20 +3,21 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CreateFromBitmapOptions
     {
         /// <summary>
-        /// Gets or sets the width
+        /// Gets or sets the width in pixels. Required for nativeImage.createFromBitmap(buffer, options).
         /// </summary>
         public int? Width { get; set; }
 
         /// <summary>
-        /// Gets or sets the height
+        /// Gets or sets the height in pixels. Required for nativeImage.createFromBitmap(buffer, options).
         /// </summary>
         public int? Height { get; set; }
 
         /// <summary>
-        /// Gets or sets the scalefactor
+        /// Gets or sets the image scale factor. Optional, defaults to 1.0.
         /// </summary>
         public float ScaleFactor { get; set; } = 1.0f;
     }

src/ElectronNET.API/API/Entities/CreateFromBufferOptions.cs

@@ -3,20 +3,21 @@ namespace ElectronNET.API.Entities
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CreateFromBufferOptions
     {
         /// <summary>
-        /// Gets or sets the width
+        /// Gets or sets the width. Required for bitmap buffers passed to nativeImage.createFromBuffer.
         /// </summary>
         public int? Width { get; set; }
 
         /// <summary>
-        /// Gets or sets the height
+        /// Gets or sets the height. Required for bitmap buffers passed to nativeImage.createFromBuffer.
         /// </summary>
         public int? Height { get; set; }
 
         /// <summary>
-        /// Gets or sets the scalefactor
+        /// The image scale factor. Optional, defaults to 1.0.
         /// </summary>
         public float ScaleFactor { get; set; } = 1.0f;
     }

src/ElectronNET.API/API/Entities/CreateInterruptedDownloadOptions.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class CreateInterruptedDownloadOptions
     {
         /// <summary>
@@ -16,7 +17,7 @@
         public string[] UrlChain { get; set; }
 
         /// <summary>
-        /// 
+        /// (optional) - MIME type of the download.
         /// </summary>
         public string MimeType { get; set; }
 
@@ -41,9 +42,10 @@
         public string ETag { get; set; }
 
         /// <summary>
-        /// Time when download was started in number of seconds since UNIX epoch.
+        /// (optional) - Time when download was started in number of seconds since UNIX epoch.
+        /// Electron documents this as a Number (Double).
         /// </summary>
-        public int StartTime { get; set; }
+        public double? StartTime { get; set; }
 
         /// <summary>
         /// 

src/ElectronNET.API/API/Entities/Data.cs

@@ -21,6 +21,12 @@
         /// </value>
         public string Html { get; set; }
 
+        /// <summary>
+        /// Gets or sets the image.
+        /// Maps to clipboard.write({ image: NativeImage }).
+        /// </summary>
+        public NativeImage Image { get; set; }
+
 
         /// <summary>
         /// Gets or sets the RTF.

src/ElectronNET.API/API/Entities/DefaultFontFamily.cs

@@ -34,5 +34,10 @@
         /// Defaults to Impact.
         /// </summary>
         public string Fantasy { get; set; }
+
+        /// <summary>
+        /// Defaults to Latin Modern Math.
+        /// </summary>
+        public string Math { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/DevToolsMode.cs

@@ -1,9 +1,9 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// Opens the devtools with specified dock state, can be right, bottom, undocked,
-    /// detach.Defaults to last used dock state.In undocked mode it's possible to dock
-    /// back.In detach mode it's not.
+    /// Opens the devtools with specified dock state, can be left, right, bottom, undocked,
+    /// detach. Defaults to last used dock state. In undocked mode it's possible to dock
+    /// back. In detach mode it's not.
     /// </summary>
     public enum DevToolsMode
     {
@@ -25,6 +25,11 @@
         /// <summary>
         /// The detach
         /// </summary>
-        detach
+        detach,
+
+        /// <summary>
+        /// The left
+        /// </summary>
+        left,
     }
 }

src/ElectronNET.API/API/Entities/Display.cs

@@ -3,10 +3,11 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class Display
     {
         /// <summary>
-        /// Can be available, unavailable, unknown.
+        /// Gets or sets the accelerometer support status; can be 'available', 'unavailable', or 'unknown'.
         /// </summary>
         public string AccelerometerSupport { get; set; }
 
@@ -19,57 +20,72 @@
         public Rectangle Bounds { get; set; }
 
         /// <summary>
-        /// The number of bits per pixel.
+        /// Gets or sets the number of bits per pixel.
         /// </summary>
         public int ColorDepth { get; set; }
 
         /// <summary>
-        /// Represent a color space (three-dimensional object which contains all realizable color combinations) for the purpose of color conversions.
+        /// Gets or sets the color space description used for color conversions.
         /// </summary>
         public string ColorSpace { get; set; }
 
         /// <summary>
-        /// The number of bits per color component.
+        /// Gets or sets the number of bits per color component.
         /// </summary>
         public int DepthPerComponent { get; set; }
 
         /// <summary>
-        /// The display refresh rate.
+        /// Gets or sets a value indicating whether the display is detected by the system.
         /// </summary>
-        public int DisplayFrequency { get; set; }
+        public bool Detected { get; set; }
 
         /// <summary>
-        /// Unique identifier associated with the display.
+        /// Gets or sets the display refresh rate.
+        /// </summary>
+        public double DisplayFrequency { get; set; }
+
+        /// <summary>
+        /// Gets or sets the unique identifier associated with the display. A value of -1 means the display is invalid or the correct id is not yet known, and a value of -10 means the display is a virtual display assigned to a unified desktop.
         /// </summary>
         public long Id { get; set; }
 
         /// <summary>
-        /// true for an internal display and false for an external display.
+        /// Gets or sets a value indicating whether the display is internal (true) or external (false).
         /// </summary>
         public bool Internal { get; set; }
 
         /// <summary>
-        /// User-friendly label, determined by the platform.
+        /// Gets or sets the user-friendly label, determined by the platform.
         /// </summary>
         public string Label { get; set; }
 
         /// <summary>
-        /// Can be 0, 90, 180, 270, represents screen rotation in clock-wise degrees.
+        /// Gets or sets the maximum cursor size in native pixels.
+        /// </summary>
+        public Size MaximumCursorSize { get; set; }
+
+        /// <summary>
+        /// Gets or sets the display's origin in pixel coordinates. Only available on windowing systems that position displays in pixel coordinates (e.g., X11).
+        /// </summary>
+        public Point NativeOrigin { get; set; }
+
+        /// <summary>
+        /// Gets or sets the screen rotation in clock-wise degrees. Can be 0, 90, 180, or 270.
         /// </summary>
         public int Rotation { get; set; }
 
         /// <summary>
-        /// Output device's pixel scale factor.
+        /// Gets or sets the output device's pixel scale factor.
         /// </summary>
         public double ScaleFactor { get; set; }
 
         /// <summary>
-        /// Can be available, unavailable, unknown.
+        /// Gets or sets the touch support status; can be 'available', 'unavailable', or 'unknown'.
         /// </summary>
         public string TouchSupport { get; set; }
 
         /// <summary>
-        /// Whether or not the display is a monochrome display.
+        /// Gets or sets a value indicating whether the display is monochrome.
         /// </summary>
         public bool Monochrome { get; set; }
 
@@ -82,10 +98,10 @@
         public Size Size { get; set; }
 
         /// <summary>
-        /// Gets or sets the work area.
+        /// Gets or sets the work area of the display in DIP points.
         /// </summary>
         /// <value>
-        /// The work area.
+        /// The work area of the display in DIP points.
         /// </value>
         public Rectangle WorkArea { get; set; }
 

src/ElectronNET.API/API/Entities/DisplayBalloonOptions.cs

@@ -1,8 +1,21 @@
-namespace ElectronNET.API
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API
 {
     /// <summary>
     /// 
     /// </summary>
+    public enum DisplayBalloonIconType
+    {
+        none,
+        info,
+        warning,
+        error,
+        custom
+    }
+
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("Windows")]
     public class DisplayBalloonOptions
     {
         /// <summary>
@@ -28,5 +41,29 @@
         /// The content.
         /// </value>
         public string Content { get; set; }
+
+        /// <summary>
+        /// (optional) - Icon type for the balloon: none, info, warning, error or custom.
+        /// Default is custom.
+        /// </summary>
+        public DisplayBalloonIconType IconType { get; set; } = DisplayBalloonIconType.custom;
+
+        /// <summary>
+        /// (optional) - Use the large version of the icon. Default is true.
+        /// Maps to Windows NIIF_LARGE_ICON.
+        /// </summary>
+        public bool LargeIcon { get; set; } = true;
+
+        /// <summary>
+        /// (optional) - Do not play the associated sound. Default is false.
+        /// Maps to Windows NIIF_NOSOUND.
+        /// </summary>
+        public bool NoSound { get; set; }
+
+        /// <summary>
+        /// (optional) - Do not display the balloon if the current user is in "quiet time".
+        /// Default is false. Maps to Windows NIIF_RESPECT_QUIET_TIME.
+        /// </summary>
+        public bool RespectQuietTime { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/DockBounceType.cs

@@ -1,10 +1,13 @@
 using System.ComponentModel;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// Defines the DockBounceType enumeration.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("macOS")]
     public enum DockBounceType
     {
         /// <summary>

src/ElectronNET.API/API/Entities/EnableNetworkEmulationOptions.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class EnableNetworkEmulationOptions
     {
         /// <summary>
@@ -12,17 +13,20 @@
 
         /// <summary>
         /// RTT in ms. Defaults to 0 which will disable latency throttling.
+        /// Electron documents this as a Number (Double).
         /// </summary>
-        public int Latency { get; set; }
+        public double Latency { get; set; }
 
         /// <summary>
         /// Download rate in Bps. Defaults to 0 which will disable download throttling.
+        /// Electron documents this as a Number (Double).
         /// </summary>
-        public int DownloadThroughput { get; set; }
+        public double DownloadThroughput { get; set; }
 
         /// <summary>
         /// Upload rate in Bps. Defaults to 0 which will disable upload throttling.
+        /// Electron documents this as a Number (Double).
         /// </summary>
-        public int UploadThroughput { get; set; }
+        public double UploadThroughput { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/Extension.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// Docs: https://electronjs.org/docs/api/structures/extension
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class Extension
     {
         /// <summary>

src/ElectronNET.API/API/Entities/FileFilter.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class FileFilter
     {
         /// <summary>

src/ElectronNET.API/API/Entities/FileIconOptions.cs

@@ -3,14 +3,13 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class FileIconOptions
     {
         /// <summary>
-        /// Gets the size.
+        /// The requested icon size string passed to app.getFileIcon:
+        /// "small" (16x16), "normal" (32x32), or "large" (48x48 on Linux, 32x32 on Windows; unsupported on macOS).
         /// </summary>
-        /// <value>
-        /// The size.
-        /// </value>
         public string Size { get; private set; }
 
         /// <summary>

src/ElectronNET.API/API/Entities/FileIconSize.cs

@@ -1,23 +1,28 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public enum FileIconSize
     {
         /// <summary>
-        /// The small
+        /// small - 16x16 (per app.getFileIcon size mapping).
         /// </summary>
         small,
 
         /// <summary>
-        /// The normal
+        /// normal - 32x32 (per app.getFileIcon size mapping).
         /// </summary>
         normal,
 
         /// <summary>
-        /// The large
+        /// large - 48x48 on Linux, 32x32 on Windows, unsupported on macOS (per app.getFileIcon size mapping).
         /// </summary>
+        [SupportedOSPlatform("Linux")]
+        [SupportedOSPlatform("Windows")]
         large
     }
 }

src/ElectronNET.API/API/Entities/FocusOptions.cs

@@ -1,15 +1,18 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// Controls the behavior of <see cref="App.Focus(FocusOptions)"/>.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class FocusOptions
     {
         /// <summary>
         /// Make the receiver the active app even if another app is currently active.
-        /// <para/>
-        /// You should seek to use the <see cref="Steal"/> option as sparingly as possible.
+        /// You should seek to use the steal option as sparingly as possible.
         /// </summary>
+        [SupportedOSPlatform("macOS")]
         public bool Steal { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/GPUFeatureStatus.cs

@@ -3,82 +3,97 @@ using System.Text.Json.Serialization;
 namespace ElectronNET.API.Entities
 {
     /// <summary>
+    /// Graphics Feature Status from chrome://gpu/ as returned by app.getGPUFeatureStatus().
+    /// Each field reflects the status of a GPU capability reported by Chromium.
     /// 
+    /// Possible values for all fields:
+    /// - disabled_software: Software only. Hardware acceleration disabled (yellow)
+    /// - disabled_off: Disabled (red)
+    /// - disabled_off_ok: Disabled (yellow)
+    /// - unavailable_software: Software only, hardware acceleration unavailable (yellow)
+    /// - unavailable_off: Unavailable (red)
+    /// - unavailable_off_ok: Unavailable (yellow)
+    /// - enabled_readback: Hardware accelerated but at reduced performance (yellow)
+    /// - enabled_force: Hardware accelerated on all pages (green)
+    /// - enabled: Hardware accelerated (green)
+    /// - enabled_on: Enabled (green)
+    /// - enabled_force_on: Force enabled (green)
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class GPUFeatureStatus
     {
         /// <summary>
-        /// Canvas.
+        /// Gets or sets the status for Canvas.
         /// </summary>
         [JsonPropertyName("2d_canvas")]
         public string Canvas { get; set; }
 
         /// <summary>
-        /// Flash.
+        /// Gets or sets the status for Flash.
         /// </summary>
         [JsonPropertyName("flash_3d")]
         public string Flash3D { get; set; }
 
         /// <summary>
-        /// Flash Stage3D.
+        /// Gets or sets the status for Flash Stage3D.
         /// </summary>
         [JsonPropertyName("flash_stage3d")]
         public string FlashStage3D { get; set; }
 
         /// <summary>
-        /// Flash Stage3D Baseline profile.
+        /// Gets or sets the status for Flash Stage3D Baseline profile.
         /// </summary>
         [JsonPropertyName("flash_stage3d_baseline")]
         public string FlashStage3dBaseline { get; set; }
 
         /// <summary>
-        /// Compositing.
+        /// Gets or sets the status for Compositing.
         /// </summary>
         [JsonPropertyName("gpu_compositing")]
         public string GpuCompositing { get; set; }
 
         /// <summary>
-        /// Multiple Raster Threads.
+        /// Gets or sets the status for Multiple Raster Threads.
         /// </summary>
         [JsonPropertyName("multiple_raster_threads")]
         public string MultipleRasterThreads { get; set; }
 
         /// <summary>
-        /// Native GpuMemoryBuffers.
+        /// Gets or sets the status for Native GpuMemoryBuffers.
         /// </summary>
         [JsonPropertyName("native_gpu_memory_buffers")]
         public string NativeGpuMemoryBuffers { get; set; }
 
         /// <summary>
-        /// Rasterization.
+        /// Gets or sets the status for Rasterization.
         /// </summary>
         public string Rasterization { get; set; }
 
         /// <summary>
-        /// Video Decode.
+        /// Gets or sets the status for Video Decode.
         /// </summary>
         [JsonPropertyName("video_decode")]
         public string VideoDecode { get; set; }
 
         /// <summary>
-        /// Video Encode.
+        /// Gets or sets the status for Video Encode.
         /// </summary>
         [JsonPropertyName("video_encode")]
         public string VideoEncode { get; set; }
 
         /// <summary>
-        /// VPx Video Decode.
+        /// Gets or sets the status for VPx Video Decode.
         /// </summary>
         [JsonPropertyName("vpx_decode")]
         public string VpxDecode { get; set; }
 
         /// <summary>
-        /// WebGL.
+        /// Gets or sets the status for WebGL.
         /// </summary>
         public string Webgl { get; set; }
 
         /// <summary>
-        /// WebGL2.
+        /// Gets or sets the status for WebGL2.
         /// </summary>
         public string Webgl2 { get; set; }
     }

src/ElectronNET.API/API/Entities/IPostData.cs

@@ -1,15 +1,17 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// Interface to use Electrons PostData Object
+    /// Represents a postData item for loadURL/webContents.loadURL options.
+    /// Valid types per Electron docs: 'rawData' and 'file'.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public interface IPostData
     {
         /// <summary>
         /// One of the following:
-        /// rawData - <see cref="UploadRawData"/> The data is available as a Buffer, in the rawData field.
-        /// file - <see cref="UploadFile"/> The object represents a file. The filePath, offset, length and modificationTime fields will be used to describe the file.
-        /// blob - <see cref="Blob"/> The object represents a Blob. The blobUUID field will be used to describe the Blob.
+        /// rawData - <see cref="UploadRawData"/>.
+        /// file - <see cref="UploadFile"/>.
+        /// Based on Electron postData definitions.
         /// </summary>
         public string Type { get; }
     }

src/ElectronNET.API/API/Entities/ImportCertificateOptions.cs

@@ -1,8 +1,12 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Options for app.importCertificate(options) on Linux.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("linux")]
     public class ImportCertificateOptions
     {
         /// <summary>

src/ElectronNET.API/API/Entities/InputEvent.cs

@@ -6,8 +6,10 @@ namespace ElectronNET.API.Entities
     using System.Text.Json.Serialization;
 
     /// <summary>
-    /// 
+    /// Input event payload as used by webContents 'input-event' and 'before-input-event'.
+    /// Fields map to KeyboardEvent properties where noted, and type/modifiers follow Electron's InputEvent structure.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class InputEvent
     {
         /// <summary>
@@ -57,15 +59,95 @@ namespace ElectronNET.API.Entities
 
         /// <summary>
         /// An array of modifiers of the event, can be `shift`, `control`, `ctrl`, `alt`,
-        /// `meta`, `command`, `cmd`, `isKeypad`, `isAutoRepeat`, `leftButtonDown`,
-        /// `middleButtonDown`, `rightButtonDown`, `capsLock`, `numLock`, `left`, `right`
+        /// `meta`, `command`, `cmd`, `iskeypad`, `isautorepeat`, `leftbuttondown`,
+        /// `middlebuttondown`, `rightbuttondown`, `capslock`, `numlock`, `left`, `right`.
         /// </summary>
         [JsonConverter(typeof(ModifierTypeListConverter))]
         public List<ModifierType> Modifiers { get; set; }
 
+        /// <summary>
+        /// For MouseInputEvent: The x-coordinate of the event (Integer).
+        /// </summary>
+        public int? X { get; set; }
+
+        /// <summary>
+        /// For MouseInputEvent: The y-coordinate of the event (Integer).
+        /// </summary>
+        public int? Y { get; set; }
+
+        /// <summary>
+        /// For MouseInputEvent: The button pressed, can be 'left', 'middle', or 'right' (optional).
+        /// </summary>
+        public string Button { get; set; }
+
+        /// <summary>
+        /// For MouseInputEvent: Global x in screen coordinates (Integer, optional).
+        /// </summary>
+        public int? GlobalX { get; set; }
+
+        /// <summary>
+        /// For MouseInputEvent: Global y in screen coordinates (Integer, optional).
+        /// </summary>
+        public int? GlobalY { get; set; }
+
+        /// <summary>
+        /// For MouseInputEvent: Movement delta on x-axis since last event (Integer, optional).
+        /// </summary>
+        public int? MovementX { get; set; }
+
+        /// <summary>
+        /// For MouseInputEvent: Movement delta on y-axis since last event (Integer, optional).
+        /// </summary>
+        public int? MovementY { get; set; }
+
+        /// <summary>
+        /// For MouseInputEvent: Click count (Integer, optional).
+        /// </summary>
+        public int? ClickCount { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: Horizontal scroll delta (Integer, optional).
+        /// </summary>
+        public int? DeltaX { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: Vertical scroll delta (Integer, optional).
+        /// </summary>
+        public int? DeltaY { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: Horizontal wheel ticks (Integer, optional).
+        /// </summary>
+        public int? WheelTicksX { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: Vertical wheel ticks (Integer, optional).
+        /// </summary>
+        public int? WheelTicksY { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: Horizontal acceleration ratio (Integer, optional).
+        /// </summary>
+        public int? AccelerationRatioX { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: Vertical acceleration ratio (Integer, optional).
+        /// </summary>
+        public int? AccelerationRatioY { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: True if wheel deltas are precise (optional).
+        /// </summary>
+        public bool? HasPreciseScrollingDeltas { get; set; }
+
+        /// <summary>
+        /// For MouseWheelInputEvent: True if the target can scroll (optional).
+        /// </summary>
+        public bool? CanScroll { get; set; }
+
         /// <summary>
         /// Can be `undefined`, `mouseDown`, `mouseUp`, `mouseMove`, `mouseEnter`,
-        /// `mouseLeave`, `contextMenu`, `mouseWheel`, `rawKeyDown`, `keyDown`, `keyUp`,
+        /// `mouseLeave`, `contextMenu`, `mouseWheel`, `rawKeyDown`, `keyDown`, `keyUp`, `char`,
         /// `gestureScrollBegin`, `gestureScrollEnd`, `gestureScrollUpdate`,
         /// `gestureFlingStart`, `gestureFlingCancel`, `gesturePinchBegin`,
         /// `gesturePinchEnd`, `gesturePinchUpdate`, `gestureTapDown`, `gestureShowPress`,

src/ElectronNET.API/API/Entities/InputEventType.cs

@@ -60,6 +60,11 @@ public enum InputEventType
     /// </summary>
     keyUp,
 
+    /// <summary>
+    /// 
+    /// </summary>
+    @char,
+
     /// <summary>
     /// 
     /// </summary>

src/ElectronNET.API/API/Entities/JumpListCategory.cs

@@ -1,24 +1,28 @@
 using System.Text.Json.Serialization;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Jump List category definition used with app.setJumpList(categories).
+    /// Matches Electron's JumpListCategory structure.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("windows")]
     public class JumpListCategory
     {
         /// <summary>
-        /// Must be set if type is custom, otherwise it should be omitted.
+        /// Gets or sets the name; must be set if <c>type</c> is <c>custom</c>, otherwise it should be omitted.
         /// </summary>
         public string Name { get; set; }
 
         /// <summary>
-        /// Array of objects if type is tasks or custom, otherwise it should be omitted.
+        /// Gets or sets the array of <see cref="JumpListItem"/> objects if <c>type</c> is <c>tasks</c> or <c>custom</c>; otherwise it should be omitted.
         /// </summary>
         public JumpListItem[] Items { get; set; }
 
         /// <summary>
-        /// One of the following: "tasks" | "frequent" | "recent" | "custom"
+        /// Gets or sets the category type. One of: <c>tasks</c> | <c>frequent</c> | <c>recent</c> | <c>custom</c>.
         /// </summary>
         public JumpListCategoryType Type { get; set; }
     }

src/ElectronNET.API/API/Entities/JumpListCategoryType.cs

@@ -1,8 +1,12 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Jump list category kinds for app.setJumpList (Windows).
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("Windows")]
     public enum JumpListCategoryType
     {
         /// <summary>

src/ElectronNET.API/API/Entities/JumpListItem.cs

@@ -1,56 +1,65 @@
 using System.Text.Json.Serialization;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Jump List item used in app.setJumpList(categories) on Windows.
+    /// Matches Electron's JumpListItem structure.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("windows")]
     public class JumpListItem
     {
         /// <summary>
-        /// The command line arguments when program is executed. Should only be set if type is task.
+        /// Gets or sets the command line arguments when <c>program</c> is executed. Should only be set if <c>type</c> is <c>task</c>.
         /// </summary>
         public string Args { get; set; }
 
         /// <summary>
-        /// Description of the task (displayed in a tooltip). Should only be set if type is task.
+        /// Gets or sets the description of the task (displayed in a tooltip). Should only be set if <c>type</c> is <c>task</c>. Maximum length 260 characters.
         /// </summary>
         public string Description { get; set; }
 
         /// <summary>
-        /// The index of the icon in the resource file. If a resource file contains multiple
+        /// Gets or sets the index of the icon in the resource file. If a resource file contains multiple
         /// icons this value can be used to specify the zero-based index of the icon that
-        /// should be displayed for this task.If a resource file contains only one icon,
+        /// should be displayed for this task. If a resource file contains only one icon,
         /// this property should be set to zero.
         /// </summary>
         public int IconIndex { get; set; }
 
         /// <summary>
-        /// The absolute path to an icon to be displayed in a Jump List, which can be an
+        /// Gets or sets the absolute path to an icon to be displayed in a Jump List, which can be an
         /// arbitrary resource file that contains an icon(e.g. .ico, .exe, .dll). You can
         /// usually specify process.execPath to show the program icon.
         /// </summary>
         public string IconPath { get; set; }
 
         /// <summary>
-        /// Path of the file to open, should only be set if type is file.
+        /// Gets or sets the path of the file to open; should only be set if <c>type</c> is <c>file</c>.
         /// </summary>
         public string Path { get; set; }
 
         /// <summary>
-        /// Path of the program to execute, usually you should specify process.execPath
-        /// which opens the current program.Should only be set if type is task.
+        /// Gets or sets the path of the program to execute, usually specify process.execPath
+        /// which opens the current program. Should only be set if <c>type</c> is <c>task</c>.
         /// </summary>
         public string Program { get; set; }
 
         /// <summary>
-        /// The text to be displayed for the item in the Jump List. Should only be set if type is task.
+        /// Gets or sets the text to be displayed for the item in the Jump List. Should only be set if <c>type</c> is <c>task</c>.
         /// </summary>
         public string Title { get; set; }
 
         /// <summary>
-        /// One of the following: "task" | "separator" | "file"
+        /// Gets or sets the item type. One of: <c>task</c> | <c>separator</c> | <c>file</c>.
         /// </summary>
         public JumpListItemType Type { get; set; }
+
+        /// <summary>
+        /// Gets or sets the working directory. Default is empty.
+        /// </summary>
+        public string WorkingDirectory { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/JumpListItemType.cs

@@ -1,8 +1,12 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Jump list item kinds for app.setJumpList (Windows).
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("Windows")]
     public enum JumpListItemType
     {
         /// <summary>

src/ElectronNET.API/API/Entities/JumpListSettings.cs

@@ -1,20 +1,24 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Settings returned by app.getJumpListSettings() on Windows.
+    /// Matches Electron's JumpListSettings object.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("windows")]
     public class JumpListSettings
     {
         /// <summary>
-        /// The minimum number of items that will be shown in the Jump List (for a more detailed description of this value see the
-        /// <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/dd378398(v=vs.85).aspx">MSDN</see> docs).
+        /// The minimum number of items that will be shown in the Jump List.
         /// </summary>
         public int MinItems { get; set; } = 0;
 
         /// <summary>
         /// Array of JumpListItem objects that correspond to items that the user has explicitly removed from custom categories
-        /// in the Jump List. These items must not be re-added to the Jump List in the next call to <see cref="App.SetJumpList"/>, Windows will
-        /// not display any custom category that contains any of the removed items.
+        /// in the Jump List. These items must not be re-added to the Jump List in the next call to app.setJumpList(categories);
+        /// Windows will not display any custom category that contains any of the removed items.
         /// </summary>
         public JumpListItem[] RemovedItems { get; set; } = new JumpListItem[0];
     }

src/ElectronNET.API/API/Entities/LoadURLOptions.cs

@@ -1,12 +1,14 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Options for BrowserWindow.loadURL(url, options) / webContents.loadURL(url, options).
+    /// Matches Electron's loadURL options.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class LoadURLOptions
     {
         /// <summary>
-        /// A HTTP Referrer url.
+        /// An HTTP Referrer URL. In Electron this may be a string or a Referrer object.
         /// </summary>
         public string HttpReferrer { get; set; }
 
@@ -16,20 +18,18 @@
         public string UserAgent { get; set; }
 
         /// <summary>
-        /// Base url (with trailing path separator) for files to be loaded by the data url.
-        /// This is needed only if the specified url is a data url and needs to load other
-        /// files.
+        /// Base URL (with trailing path separator) for files to be loaded by the data URL.
+        /// Needed only if the specified URL is a data URL and needs to load other files.
         /// </summary>
         public string BaseURLForDataURL { get; set; }
 
         /// <summary>
-        /// Extra headers for the request.
+        /// Extra headers separated by "\n".
         /// </summary>
         public string ExtraHeaders { get; set; }
 
         /// <summary>
-        /// PostData Object for the request.
-        /// Can be <see cref="UploadRawData"/>, <see cref="UploadFile"/> or <see cref="Blob"/>
+        /// Post data for the request. Matches Electron's postData: (UploadRawData | UploadFile)[]
         /// </summary>
         public IPostData[] PostData { get; set; }
     }

src/ElectronNET.API/API/Entities/LoginItemLaunchItem.cs

@@ -0,0 +1,37 @@
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
+{
+    /// <summary>
+    /// Windows launch entry as returned by app.getLoginItemSettings().launchItems.
+    /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("windows")]
+    public class LoginItemLaunchItem
+    {
+        /// <summary>
+        /// Name value of a registry entry.
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The executable to an app that corresponds to a registry entry.
+        /// </summary>
+        public string Path { get; set; }
+
+        /// <summary>
+        /// The command-line arguments to pass to the executable.
+        /// </summary>
+        public string[] Args { get; set; }
+
+        /// <summary>
+        /// One of <c>user</c> or <c>machine</c>. Indicates whether the registry entry is under HKEY_CURRENT_USER or HKEY_LOCAL_MACHINE.
+        /// </summary>
+        public string Scope { get; set; }
+
+        /// <summary>
+        /// True if the app registry key is startup approved and therefore shows as enabled in Task Manager and Windows settings.
+        /// </summary>
+        public bool Enabled { get; set; }
+    }
+}

src/ElectronNET.API/API/Entities/LoginItemSettings.cs

@@ -1,8 +1,11 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Return object for app.getLoginItemSettings() on macOS and Windows.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class LoginItemSettings
     {
         /// <summary>
@@ -11,29 +14,52 @@
         public bool OpenAtLogin { get; set; }
 
         /// <summary>
-        /// <see langword="true"/> if the app is set to open as hidden at login. This setting is not available
+        /// <see langword="true"/> if the app is set to open as hidden at login. Deprecated on macOS 13 and up; not available
         /// on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool OpenAsHidden { get; set; }
 
         /// <summary>
         /// <see langword="true"/> if the app was opened at login automatically. This setting is not available
         /// on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool WasOpenedAtLogin { get; set; }
 
         /// <summary>
         /// <see langword="true"/> if the app was opened as a hidden login item. This indicates that the app should not
-        /// open any windows at startup. This setting is not available on
+        /// open any windows at startup. Deprecated on macOS 13 and up; not available on
         /// <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool WasOpenedAsHidden { get; set; }
 
         /// <summary>
         /// <see langword="true"/> if the app was opened as a login item that should restore the state from the previous
         /// session. This indicates that the app should restore the windows that were open the last time the app was closed.
-        /// This setting is not available on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
+        /// Deprecated on macOS 13 and up; not available on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool RestoreState { get; set; }
+
+        /// <summary>
+        /// macOS status: one of <c>not-registered</c>, <c>enabled</c>, <c>requires-approval</c>, or <c>not-found</c>.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public string Status { get; set; }
+
+        /// <summary>
+        /// Windows: true if app is set to open at login and its run key is not deactivated.
+        /// Differs from <c>OpenAtLogin</c> as it ignores the <c>args</c> option; this is true if the given executable would be launched at login with any arguments.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        public bool ExecutableWillLaunchAtLogin { get; set; }
+
+        /// <summary>
+        /// Windows launch entries found in registry.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        public LoginItemLaunchItem[] LaunchItems { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/LoginItemSettingsOptions.cs

@@ -1,4 +1,6 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
@@ -8,11 +10,25 @@
         /// <summary>
         /// The executable path to compare against. Defaults to process.execPath.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         public string Path { get; set; }
 
         /// <summary>
         /// The command-line arguments to compare against. Defaults to an empty array.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         public string[] Args { get; set; }
+
+        /// <summary>
+        /// The type of service to query on macOS 13+. Defaults to 'mainAppService'. Only available on macOS 13 and up.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public string Type { get; set; }
+
+        /// <summary>
+        /// The name of the service. Required if type is non-default. Only available on macOS 13 and up.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public string ServiceName { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/LoginSettings.cs

@@ -1,8 +1,11 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Settings object for app.setLoginItemSettings() on macOS and Windows.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class LoginSettings
     {
         /// <summary>
@@ -14,19 +17,46 @@
         /// <summary>
         /// <see langword="true"/> to open the app as hidden. Defaults to <see langword="false"/>. The user can edit this
         /// setting from the System Preferences so app.getLoginItemSettings().wasOpenedAsHidden should be checked when the app is
-        /// opened to know the current value. This setting is not available on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see>.
+        /// opened to know the current value. This setting is not available on <see href="https://www.electronjs.org/docs/tutorial/mac-app-store-submission-guide">MAS builds</see> and does not work on macOS 13 and up.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool OpenAsHidden { get; set; }
 
         /// <summary>
         /// The executable to launch at login. Defaults to process.execPath.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         public string Path { get; set; }
 
         /// <summary>
         /// The command-line arguments to pass to the executable. Defaults to an empty
         /// array.Take care to wrap paths in quotes.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         public string[] Args { get; set; }
+
+        /// <summary>
+        /// The type of service to add as a login item. Defaults to 'mainAppService'. Only available on macOS 13 and up.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public string Type { get; set; }
+
+        /// <summary>
+        /// The name of the service. Required if <c>Type</c> is non-default. Only available on macOS 13 and up.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public string ServiceName { get; set; }
+
+        /// <summary>
+        /// Change the startup approved registry key and enable/disable the app in Task Manager and Windows Settings. Defaults to true.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        public bool Enabled { get; set; } = true;
+
+        /// <summary>
+        /// Value name to write into registry. Defaults to the app's AppUserModelId().
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        public string Name { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/Margins.cs

@@ -1,33 +1,42 @@
 namespace ElectronNET.API.Entities;
 
 /// <summary>
-/// 
+/// Margins object used by webContents.print options and webContents.printToPDF.
 /// </summary>
+/// <remarks>Up-to-date with Electron API 39.2</remarks>
 public class Margins
 {
     /// <summary>
-    /// Can be `default`, `none`, `printableArea`, or `custom`. If `custom` is chosen,
+    /// Gets or sets the margin type. Can be `default`, `none`, `printableArea`, or `custom`. If `custom` is chosen,
     /// you will also need to specify `top`, `bottom`, `left`, and `right`.
     /// </summary>
     public string MarginType { get; set; }
 
     /// <summary>
-    /// The top margin of the printed web page, in pixels.
+    /// Gets or sets the top margin of the printed web page. Units depend on API:
+    /// - webContents.print: pixels
+    /// - webContents.printToPDF: inches
     /// </summary>
-    public int Top { get; set; }
+    public double Top { get; set; }
 
     /// <summary>
-    /// The bottom margin of the printed web page, in pixels.
+    /// Gets or sets the bottom margin of the printed web page. Units depend on API:
+    /// - webContents.print: pixels
+    /// - webContents.printToPDF: inches
     /// </summary>
-    public int Bottom { get; set; }
+    public double Bottom { get; set; }
 
     /// <summary>
-    /// The left margin of the printed web page, in pixels.
+    /// Gets or sets the left margin of the printed web page. Units depend on API:
+    /// - webContents.print: pixels
+    /// - webContents.printToPDF: inches
     /// </summary>
-    public int Left { get; set; }
+    public double Left { get; set; }
 
     /// <summary>
-    /// The right margin of the printed web page, in pixels.
+    /// Gets or sets the right margin of the printed web page. Units depend on API:
+    /// - webContents.print: pixels
+    /// - webContents.printToPDF: inches
     /// </summary>
-    public int Right { get; set; }
+    public double Right { get; set; }
 }

src/ElectronNET.API/API/Entities/MemoryInfo.cs

@@ -1,24 +1,28 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Process memory info as returned by process.getProcessMemoryInfo().
+    /// Values are reported in Kilobytes.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class MemoryInfo
     {
         /// <summary>
-        /// The amount of memory currently pinned to actual physical RAM.
+        /// Gets or sets the amount of memory currently pinned to actual physical RAM.
         /// </summary>
         public int WorkingSetSize { get; set; }
 
         /// <summary>
-        /// The maximum amount of memory that has ever been pinned to actual physical RAM.
+        /// Gets or sets the maximum amount of memory that has ever been pinned to actual physical RAM.
         /// </summary>
         public int PeakWorkingSetSize { get; set; }
 
         /// <summary>
-        /// The amount of memory not shared by other processes, such as JS heap or HTML
-        /// content.
+        /// Gets or sets the amount of memory not shared by other processes, such as JS heap or HTML content. Windows only.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         public int PrivateBytes { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/MenuItem.cs

@@ -1,11 +1,13 @@
 using System;
 using System.Text.Json.Serialization;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class MenuItem
     {
         /// <summary>
@@ -16,13 +18,12 @@ namespace ElectronNET.API.Entities
         public Action Click { get; set; }
 
         /// <summary>
-        /// Define the action of the menu item, when specified the click property will be
-        /// ignored.
+        /// Gets or sets the action (role) of the menu item. When specified, the click property will be ignored.
         /// </summary>
         public MenuRole Role { get; set; }
 
         /// <summary>
-        /// Can be normal, separator, submenu, checkbox or radio.
+        /// Gets or sets the menu item type. Can be normal, separator, submenu, checkbox, radio, header (macOS 14+), or palette (macOS 14+).
         /// </summary>
         public MenuType Type { get; set; }
 
@@ -42,8 +43,15 @@ namespace ElectronNET.API.Entities
         /// <value>
         /// The sublabel.
         /// </value>
+        [SupportedOSPlatform("macos")]
         public string Sublabel { get; set; }
 
+        /// <summary>
+        /// Hover text for this menu item (macOS).
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public string ToolTip { get; set; }
+
 
         /// <summary>
         /// Gets or sets the accelerator.
@@ -63,17 +71,31 @@ namespace ElectronNET.API.Entities
         public string Icon { get; set; }
 
         /// <summary>
-        /// If false, the menu item will be greyed out and unclickable.
+        /// Gets or sets a value indicating whether the item is enabled. If false, the menu item will be greyed out and unclickable.
         /// </summary>
         public bool Enabled { get; set; } = true;
 
         /// <summary>
-        /// If false, the menu item will be entirely hidden.
+        /// Gets or sets a value indicating whether the item is visible. If false, the menu item will be entirely hidden.
         /// </summary>
         public bool Visible { get; set; } = true;
 
         /// <summary>
-        /// Should only be specified for checkbox or radio type menu items.
+        /// Gets or sets a value indicating whether the accelerator should work when the item is hidden. Default is true (macOS).
+        /// When false, prevents the accelerator from triggering the item if the item is not visible.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public bool? AcceleratorWorksWhenHidden { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the accelerator should be registered with the system or only displayed (Linux/Windows). Defaults to true.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        [SupportedOSPlatform("linux")]
+        public bool? RegisterAccelerator { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the item is checked. Should only be specified for checkbox or radio items.
         /// </summary>
         public bool Checked { get; set; }
 
@@ -85,15 +107,44 @@ namespace ElectronNET.API.Entities
         public MenuItem[] Submenu { get; set; }
 
         /// <summary>
-        /// Unique within a single menu. If defined then it can be used as a reference to
-        /// this item by the position attribute.
+        /// The item to share when the role is shareMenu (macOS).
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public SharingItem SharingItem { get; set; }
+
+        /// <summary>
+        /// Gets or sets a unique id within a single menu. If defined then it can be used as a reference for placement.
         /// </summary>
         public string Id { get; internal set; }
 
         /// <summary>
-        /// This field allows fine-grained definition of the specific location within a
-        /// given menu.
+        /// This field allows fine-grained definition of the specific location within a given menu.
         /// </summary>
         public string Position { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of item ids. Inserts this item before the item(s) with the specified id(s).
+        /// If the referenced item doesn't exist the item will be inserted at the end of the menu.
+        /// Also implies that this item should be placed in the same group as the referenced item(s).
+        /// </summary>
+        public string[] Before { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of item ids. Inserts this item after the item(s) with the specified id(s).
+        /// If the referenced item doesn't exist the item will be inserted at the end of the menu.
+        /// </summary>
+        public string[] After { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of item ids. Places this item's containing group before the containing group
+        /// of the item(s) with the specified id(s).
+        /// </summary>
+        public string[] BeforeGroupContaining { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of item ids. Places this item's containing group after the containing group
+        /// of the item(s) with the specified id(s).
+        /// </summary>
+        public string[] AfterGroupContaining { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/MenuRole.cs

@@ -31,14 +31,14 @@
         paste,
 
         /// <summary>
-        /// The pasteandmatchstyle
+        /// The pasteAndMatchStyle
         /// </summary>
-        pasteandmatchstyle,
+        pasteAndMatchStyle,
 
         /// <summary>
-        /// The selectall
+        /// The selectAll
         /// </summary>
-        selectall,
+        selectAll,
 
         /// <summary>
         /// The delete
@@ -68,12 +68,12 @@
         /// <summary>
         /// Reload the current window ignoring the cache.
         /// </summary>
-        forcereload,
+        forceReload,
 
         /// <summary>
         /// Toggle developer tools in the current window
         /// </summary>
-        toggledevtools,
+        toggleDevTools,
 
         /// <summary>
         /// Toggle full screen mode on the current window
@@ -83,17 +83,17 @@
         /// <summary>
         /// Reset the focused page’s zoom level to the original size
         /// </summary>
-        resetzoom,
+        resetZoom,
 
         /// <summary>
         /// Zoom in the focused page by 10%
         /// </summary>
-        zoomin,
+        zoomIn,
 
         /// <summary>
         /// Zoom out the focused page by 10%
         /// </summary>
-        zoomout,
+        zoomOut,
 
         /// <summary>
         /// Whole default “Edit” menu (Undo, Copy, etc.)
@@ -118,7 +118,7 @@
         /// <summary>
         /// Only macOS: Map to the hideOtherApplications action
         /// </summary>
-        hideothers,
+        hideOthers,
 
         /// <summary>
         /// Only macOS: Map to the unhideAllApplications action
@@ -128,12 +128,12 @@
         /// <summary>
         /// Only macOS: Map to the startSpeaking action
         /// </summary>
-        startspeaking,
+        startSpeaking,
 
         /// <summary>
         /// Only macOS: Map to the stopSpeaking action
         /// </summary>
-        stopspeaking,
+        stopSpeaking,
 
         /// <summary>
         /// Only macOS: Map to the arrangeInFront action
@@ -158,6 +158,108 @@
         /// <summary>
         /// Only macOS: The submenu is a “Services” menu
         /// </summary>
-        services
+        services,
+
+        /// <summary>
+        /// Toggle built-in spellchecker.
+        /// </summary>
+        toggleSpellChecker,
+
+        /// <summary>
+        /// The submenu is a "File" menu.
+        /// </summary>
+        fileMenu,
+
+        /// <summary>
+        /// The submenu is a "View" menu.
+        /// </summary>
+        viewMenu,
+
+        /// <summary>
+        /// The application menu.
+        /// </summary>
+        appMenu,
+
+        /// <summary>
+        /// The submenu is a "Share" menu.
+        /// </summary>
+        shareMenu,
+
+        /// <summary>
+        /// Displays a list of files recently opened by the app.
+        /// </summary>
+        recentDocuments,
+
+        /// <summary>
+        /// Clear the recent documents list.
+        /// </summary>
+        clearRecentDocuments,
+
+        /// <summary>
+        /// Toggle the tab bar (macOS).
+        /// </summary>
+        toggleTabBar,
+
+        /// <summary>
+        /// Select the next tab (macOS).
+        /// </summary>
+        selectNextTab,
+
+        /// <summary>
+        /// Select the previous tab (macOS).
+        /// </summary>
+        selectPreviousTab,
+
+        /// <summary>
+        /// Show all tabs (macOS).
+        /// </summary>
+        showAllTabs,
+
+        /// <summary>
+        /// Merge all windows (macOS).
+        /// </summary>
+        mergeAllWindows,
+
+        /// <summary>
+        /// Move the current tab to a new window (macOS).
+        /// </summary>
+        moveTabToNewWindow,
+
+        /// <summary>
+        /// Show substitutions panel (macOS).
+        /// </summary>
+        showSubstitutions,
+
+        /// <summary>
+        /// Toggle smart quotes (macOS).
+        /// </summary>
+        toggleSmartQuotes,
+
+        /// <summary>
+        /// Toggle smart dashes (macOS).
+        /// </summary>
+        toggleSmartDashes,
+
+        /// <summary>
+        /// Toggle text replacement (macOS).
+        /// </summary>
+        toggleTextReplacement,
+
+        // Backwards-compatibility aliases (old identifiers) to avoid breaking existing code.
+        // These map to the same enum values as their official values.
+        pasteandmatchstyle = pasteAndMatchStyle,
+        selectall = selectAll,
+        forcereload = forceReload,
+        toggledevtools = toggleDevTools,
+        resetzoom = resetZoom,
+        zoomin = zoomIn,
+        zoomout = zoomOut,
+        hideothers = hideOthers,
+        startspeaking = startSpeaking,
+        stopspeaking = stopSpeaking,
+        togglespellchecker = toggleSpellChecker,
+        togglesmartquotes = toggleSmartQuotes,
+        togglesmartdashes = toggleSmartDashes,
+        toggletextreplacement = toggleTextReplacement
     }
 }

src/ElectronNET.API/API/Entities/MenuType.cs

@@ -1,33 +1,48 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Menu item types matching Electron's MenuItem.type values.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public enum MenuType
     {
         /// <summary>
-        /// The normal
+        /// Normal menu item.
         /// </summary>
         normal,
 
         /// <summary>
-        /// The separator
+        /// Separator between items.
         /// </summary>
         separator,
 
         /// <summary>
-        /// The submenu
+        /// Submenu container.
         /// </summary>
         submenu,
 
         /// <summary>
-        /// The checkbox
+        /// Checkbox item.
         /// </summary>
         checkbox,
 
         /// <summary>
-        /// The radio
+        /// Radio item.
         /// </summary>
-        radio
+        radio,
+
+        /// <summary>
+        /// Header item (macOS 14+).
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        header,
+
+        /// <summary>
+        /// Palette item (macOS 14+).
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        palette
     }
 }

src/ElectronNET.API/API/Entities/MessageBoxOptions.cs

@@ -1,88 +1,82 @@
 using System.Text.Json.Serialization;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Options for dialog.showMessageBox / dialog.showMessageBoxSync.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class MessageBoxOptions
     {
         /// <summary>
-        ///  Can be "none", "info", "error", "question" or "warning". On Windows, "question"
-        ///  displays the same icon as "info", unless you set an icon using the "icon"
-        ///  option. On macOS, both "warning" and "error" display the same warning icon.
+        /// Gets or sets the type. Can be "none", "info", "error", "question" or "warning". On Windows, "question" displays the same icon as "info", unless you set an icon using the "icon" option. On macOS, both "warning" and "error" display the same warning icon.
         /// </summary>
         public MessageBoxType Type { get; set; }
 
         /// <summary>
-        /// Array of texts for buttons. On Windows, an empty array will result in one button
-        /// labeled "OK".
+        /// Gets or sets the array of texts for buttons. On Windows, an empty array will result in one button labeled "OK".
         /// </summary>
         public string[] Buttons { get; set; }
 
         /// <summary>
-        /// Index of the button in the buttons array which will be selected by default when
-        /// the message box opens.
+        /// Gets or sets the index of the button in the buttons array which will be selected by default when the message box opens.
         /// </summary>
         public int DefaultId { get; set; }
 
         /// <summary>
-        /// Title of the message box, some platforms will not show it.
+        /// Gets or sets the title of the message box; some platforms will not show it.
         /// </summary>
         public string Title { get; set; }
 
         /// <summary>
-        /// Content of the message box.
+        /// Gets or sets the content of the message box.
         /// </summary>
         public string Message { get; set; }
 
         /// <summary>
-        /// Extra information of the message.
+        /// Gets or sets the extra information of the message.
         /// </summary>
         public string Detail { get; set; }
 
         /// <summary>
-        /// If provided, the message box will include a checkbox with the given label. The
-        /// checkbox state can be inspected only when using callback.
+        /// Gets or sets the checkbox label. If provided, the message box will include a checkbox with the given label.
         /// </summary>
         public string CheckboxLabel { get; set; }
 
         /// <summary>
-        /// Initial checked state of the checkbox. false by default.
+        /// Gets or sets the initial checked state of the checkbox. Defaults to false.
         /// </summary>
         public bool CheckboxChecked { get; set; }
 
         /// <summary>
-        /// Gets or sets the icon.
+        /// Gets or sets the icon for the message box.
         /// </summary>
-        /// <value>
-        /// The icon.
-        /// </value>
         public string Icon { get; set; }
 
         /// <summary>
-        /// The index of the button to be used to cancel the dialog, via the Esc key. By
-        /// default this is assigned to the first button with "cancel" or "no" as the label.
-        /// If no such labeled buttons exist and this option is not set, 0 will be used as
-        /// the return value or callback response. This option is ignored on Windows.
+        /// Gets or sets the custom width of the text in the message box.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public int? TextWidth { get; set; }
+
+        /// <summary>
+        /// Gets or sets the index of the button to be used to cancel the dialog via the Esc key. By default this is assigned to the first button with "cancel" or "no" as the label. If no such labeled buttons exist and this option is not set, 0 will be used.
         /// </summary>
         public int CancelId { get; set; }
 
         /// <summary>
-        /// On Windows Electron will try to figure out which one of the buttons are common
-        /// buttons(like "Cancel" or "Yes"), and show the others as command links in the
-        /// dialog.This can make the dialog appear in the style of modern Windows apps. If
-        /// you don't like this behavior, you can set noLink to true.
+        /// Gets or sets a value indicating whether to disable Windows command-links behavior (noLink).
+        /// On Windows Electron will try to figure out which one of the buttons are common buttons (like "Cancel" or "Yes"), and show the others as command links in the dialog. Set to true to disable this behavior.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         public bool NoLink { get; set; }
 
         /// <summary>
-        /// Normalize the keyboard access keys across platforms. Default is false. Enabling
-        /// this assumes AND character is used in the button labels for the placement of the keyboard
+        /// Gets or sets a value indicating whether to normalize the keyboard access keys across platforms. Default is false. Enabling this assumes '&amp;' is used in the button labels for the placement of the keyboard
         /// shortcut access key and labels will be converted so they work correctly on each
-        /// platform, AND characters are removed on macOS, converted to _ on Linux, and left
-        /// untouched on Windows.For example, a button label of VieANDw will be converted to
-        /// Vie_w on Linux and View on macOS and can be selected via Alt-W on Windows and
+        /// platform, '&amp;' characters are removed on macOS, converted to '_' on Linux, and left
+        /// untouched on Windows. For example, a button label of "View" will be converted to "Vie_w" on Linux and "View" on macOS and can be selected via Alt-W on Windows and
         /// Linux.
         /// </summary>
         public bool NormalizeAccessKeys { get; set; }

src/ElectronNET.API/API/Entities/MessageBoxResult.cs

@@ -1,24 +1,19 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Result returned by dialog.showMessageBox / dialog.showMessageBoxSync.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class MessageBoxResult
     {
         /// <summary>
-        /// Gets or sets the response.
+        /// The index of the clicked button.
         /// </summary>
-        /// <value>
-        /// The response.
-        /// </value>
         public int Response { get; set; }
 
         /// <summary>
-        /// Gets or sets a value indicating whether [checkbox checked].
+        /// The checked state of the checkbox if CheckboxLabel was set; otherwise false.
         /// </summary>
-        /// <value>
-        ///   <c>true</c> if [checkbox checked]; otherwise, <c>false</c>.
-        /// </value>
         public bool CheckboxChecked { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/MessageBoxType.cs

@@ -1,8 +1,9 @@
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// Message box type for dialog.showMessageBox/showMessageBoxSync.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public enum MessageBoxType
     {
         /// <summary>

src/ElectronNET.API/API/Entities/ModifierType.cs

@@ -1,8 +1,9 @@
 namespace ElectronNET.API.Entities;
 
 /// <summary>
-/// Specifies the possible modifier keys for a keyboard input.
+/// Specifies the possible modifier keys for a keyboard input (maps to InputEvent.modifiers).
 /// </summary>
+/// <remarks>Up-to-date with Electron API 39.2</remarks>
 public enum ModifierType
 {
     /// <summary>

src/ElectronNET.API/API/Entities/NativeImage.cs

@@ -7,6 +7,7 @@ using System.IO;
 using System.Linq;
 using System.Text.Json.Serialization;
 using System.Text.RegularExpressions;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
@@ -268,6 +269,12 @@ namespace ElectronNET.API.Entities
         /// </summary>
         public bool IsTemplateImage => _isTemplateImage;
 
+        /// <summary>
+        /// Whether the image is considered a macOS template image.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public bool IsMacTemplateImage => _isTemplateImage;
+
         /// <summary>
         /// Deprecated. Marks the image as a template image.
         /// </summary>

src/ElectronNET.API/API/Entities/NativeImageJsonConverter.cs

@@ -8,6 +8,7 @@ using System.Text.Json.Serialization;
 
 namespace ElectronNET.API.Entities
 {
+    /// <yremarks>Project-specific: JSON converter for NativeImage; no MCP structure equivalent.</yremarks>
     internal class NativeImageJsonConverter : JsonConverter<NativeImage>
     {
         public override void Write(Utf8JsonWriter writer, NativeImage value, JsonSerializerOptions options)

src/ElectronNET.API/API/Entities/NotificationAction.cs

@@ -1,17 +1,21 @@
-namespace ElectronNET.API.Entities
+using System.Runtime.Versioning;
+
+namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("macos")]
     public class NotificationAction
     {
         /// <summary>
-        /// The label for the given action.
+        /// Gets or sets the label for the action.
         /// </summary>
         public string Text { get; set; }
 
         /// <summary>
-        /// The type of action, can be button.
+        /// Gets or sets the type of action; can be 'button'.
         /// </summary>
         public string Type { get; set; }
     }

src/ElectronNET.API/API/Entities/NotificationOptions.cs

@@ -7,75 +7,85 @@ namespace ElectronNET.API.Entities
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class NotificationOptions
     {
         /// <summary>
-        /// A title for the notification, which will be shown at the top of the notification
-        /// window when it is shown.
+        /// Gets or sets the title for the notification, which will be shown at the top of the notification window when it is shown.
         /// </summary>
         public string Title { get; set; }
 
         /// <summary>
-        /// A subtitle for the notification, which will be displayed below the title.
+        /// Gets or sets the subtitle for the notification, which will be displayed below the title.
         /// </summary>
-        public string SubTitle { get; set; }
+        [SupportedOSPlatform("macos")]
+        [JsonPropertyName("subtitle")]
+        public string Subtitle { get; set; }
 
         /// <summary>
-        /// The body text of the notification, which will be displayed below the title or
-        /// subtitle.
+        /// Gets or sets the body text of the notification, which will be displayed below the title or subtitle.
         /// </summary>
         public string Body { get; set; }
 
         /// <summary>
-        /// Whether or not to emit an OS notification noise when showing the notification.
+        /// Gets or sets a value indicating whether to suppress the OS notification noise when showing the notification.
         /// </summary>
         public bool Silent { get; set; }
 
         /// <summary>
-        /// An icon to use in the notification.
+        /// Gets or sets an icon to use in the notification. Can be a string path or a NativeImage. If a string is passed, it must be a valid path to a local icon file.
         /// </summary>
         public string Icon { get; set; }
 
         /// <summary>
-        /// Whether or not to add an inline reply option to the notification.
+        /// Gets or sets a value indicating whether to add an inline reply option to the notification.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public bool HasReply { get; set; }
 
         /// <summary>
-        /// The timeout duration of the notification. Can be 'default' or 'never'.
+        /// Gets or sets the timeout duration of the notification. Can be 'default' or 'never'.
         /// </summary>
-        [SupportedOSPlatform("Linux")]
-        [SupportedOSPlatform("Windows")]
+        [SupportedOSPlatform("linux")]
+        [SupportedOSPlatform("windows")]
         public string TimeoutType { get; set; }
 
         /// <summary>
-        /// The placeholder to write in the inline reply input field.
+        /// Gets or sets the placeholder to write in the inline reply input field.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public string ReplyPlaceholder { get; set; }
 
         /// <summary>
-        /// The name of the sound file to play when the notification is shown.
+        /// Gets or sets the name of the sound file to play when the notification is shown.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public string Sound { get; set; }
 
         /// <summary>
-        /// The urgency level of the notification. Can be 'normal', 'critical', or 'low'.
+        /// Gets or sets the urgency level of the notification. Can be 'normal', 'critical', or 'low'.
         /// </summary>
-        [SupportedOSPlatform("Linux")]
+        [SupportedOSPlatform("linux")]
         public string Urgency { get; set; }
 
         /// <summary>
-        /// Actions to add to the notification. Please read the available actions and
-        /// limitations in the NotificationAction documentation.
+        /// Gets or sets the actions to add to the notification. Please read the available actions and limitations in the NotificationAction documentation.
         /// </summary>
-        public NotificationAction Actions { get; set; }
+        [SupportedOSPlatform("macos")]
+        public NotificationAction[] Actions { get; set; }
 
         /// <summary>
-        /// A custom title for the close button of an alert. An empty string will cause the
-        /// default localized text to be used.
+        /// Gets or sets a custom title for the close button of an alert. An empty string will cause the default localized text to be used.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public string CloseButtonText { get; set; }
 
+        /// <summary>
+        /// Gets or sets a custom description of the Notification on Windows superseding all properties above. Provides full customization of design and behavior of the notification.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        public string ToastXml { get; set; }
+
         /// <summary>
         /// Emitted when the notification is shown to the user, note this could be fired
         /// multiple times as a notification can be shown multiple times through the Show()
@@ -131,7 +141,7 @@ namespace ElectronNET.API.Entities
         /// The string the user entered into the inline reply field
         /// </summary>
         [JsonIgnore]
-        [SupportedOSPlatform("macOS")]
+        [SupportedOSPlatform("macos")]
         public Action<string> OnReply { get; set; }
 
         /// <summary>
@@ -144,11 +154,11 @@ namespace ElectronNET.API.Entities
         internal string ReplyID { get; set; }
 
         /// <summary>
-        /// macOS only - The index of the action that was activated
+        /// macOS only - The index of the action that was activated.
         /// </summary>
         [JsonIgnore]
-        [SupportedOSPlatform("macOS")]
-        public Action<string> OnAction { get; set; }
+        [SupportedOSPlatform("macos")]
+        public Action<int> OnAction { get; set; }
 
         /// <summary>
         /// Gets or sets the action identifier.
@@ -159,6 +169,14 @@ namespace ElectronNET.API.Entities
         [JsonInclude]
         internal string ActionID { get; set; }
 
+        /// <summary>
+        /// Windows only: Emitted when an error is encountered while creating and showing the native notification.
+        /// Corresponds to the 'failed' event on Notification.
+        /// </summary>
+        [JsonIgnore]
+        [SupportedOSPlatform("windows")]
+        public Action<string> OnFailed { get; set; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="NotificationOptions"/> class.
         /// </summary>
@@ -170,4 +188,4 @@ namespace ElectronNET.API.Entities
             Body = body;
         }
     }
-}
+}

src/ElectronNET.API/API/Entities/OnDidFailLoadInfo.cs

@@ -15,4 +15,24 @@ public class OnDidFailLoadInfo
     /// Validated URL.
     /// </summary>
     public string ValidatedUrl { get; set; }
+
+    /// <summary>
+    /// Error description string.
+    /// </summary>
+    public string ErrorDescription { get; set; }
+
+    /// <summary>
+    /// True if the event pertains to the main frame.
+    /// </summary>
+    public bool IsMainFrame { get; set; }
+
+    /// <summary>
+    /// The process id for the frame.
+    /// </summary>
+    public int FrameProcessId { get; set; }
+
+    /// <summary>
+    /// The routing id for the frame.
+    /// </summary>
+    public int FrameRoutingId { get; set; }
 }

src/ElectronNET.API/API/Entities/OnDidNavigateInfo.cs

@@ -1,17 +1,23 @@
 namespace ElectronNET.API.Entities;
 
 /// <summary>
-/// 'OnDidNavigate' event details.
+/// 'did-navigate' event details for main frame navigation.
 /// </summary>
+/// <remarks>Up-to-date with Electron API 39.2</remarks>
 public class OnDidNavigateInfo
 {
     /// <summary>
-    /// Navigated URL.
+    /// The URL navigated to.
     /// </summary>
     public string Url { get; set; }
 
     /// <summary>
-    /// HTTP response code.
+    /// HTTP response code (-1 for non-HTTP navigations).
     /// </summary>
     public int HttpResponseCode { get; set; }
+
+    /// <summary>
+    /// HTTP status text (empty for non-HTTP navigations).
+    /// </summary>
+    public string HttpStatusText { get; set; }
 }

src/ElectronNET.API/API/Entities/OnTopLevel.cs

@@ -1,10 +1,14 @@
 using System.ComponentModel;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// 
+    /// String values for the 'level' parameter of BrowserWindow.setAlwaysOnTop.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
+    [SupportedOSPlatform("macOS")]
+    [SupportedOSPlatform("Windows")]
     public enum OnTopLevel
     {
         /// <summary>

src/ElectronNET.API/API/Entities/OpenDevToolsOptions.cs

@@ -8,10 +8,19 @@ namespace ElectronNET.API.Entities
     public class OpenDevToolsOptions
     {
         /// <summary>
-        /// Opens the devtools with specified dock state, can be right, bottom, undocked,
-        /// detach.Defaults to last used dock state.In undocked mode it's possible to dock
-        /// back.In detach mode it's not.
+        /// Opens the DevTools with specified dock state. Can be left, right, bottom, undocked, or detach.
+        /// Defaults to the last used dock state. In undocked mode it's possible to dock back; in detach mode it's not.
         /// </summary>
         public DevToolsMode Mode { get; set; }
+
+        /// <summary>
+        /// Whether to bring the opened DevTools window to the foreground. Default is true.
+        /// </summary>
+        public bool Activate { get; set; } = true;
+
+        /// <summary>
+        /// A title for the DevTools window (only visible in undocked or detach mode).
+        /// </summary>
+        public string Title { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/OpenDialogOptions.cs

@@ -2,9 +2,12 @@ using System.Text.Json.Serialization;
 
 namespace ElectronNET.API.Entities
 {
+    using System.Runtime.Versioning;
+
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class OpenDialogOptions
     {
         /// <summary>
@@ -29,18 +32,19 @@ namespace ElectronNET.API.Entities
         public string ButtonLabel { get; set; }
 
         /// <summary>
-        /// Contains which features the dialog should use. The following values are supported:
+        /// Gets or sets which features the dialog should use. The following values are supported:
         /// 'openFile' | 'openDirectory' | 'multiSelections' | 'showHiddenFiles' | 'createDirectory' | 'promptToCreate' | 'noResolveAliases' | 'treatPackageAsDirectory'
         /// </summary>
         public OpenDialogProperty[] Properties { get; set; }
 
         /// <summary>
-        /// Message to display above input boxes.
+        /// Gets or sets the message to display above input boxes.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         public string Message { get; set; }
 
         /// <summary>
-        /// The filters specifies an array of file types that can be displayed or
+        /// Gets or sets the filters specifying an array of file types that can be displayed or
         /// selected when you want to limit the user to a specific type. For example:
         /// </summary>
         /// <example>
@@ -55,5 +59,11 @@ namespace ElectronNET.API.Entities
         /// </code>
         /// </example>
         public FileFilter[] Filters { get; set; }
+
+        /// <summary>
+        /// Create security scoped bookmarks when packaged for the Mac App Store.
+        /// </summary>
+        [SupportedOSPlatform("macos")]
+        public bool SecurityScopedBookmarks { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/OpenDialogProperty.cs

@@ -1,5 +1,7 @@
 namespace ElectronNET.API.Entities
 {
+    using System.Runtime.Versioning;
+
     /// <summary>
     /// 
     /// </summary>
@@ -28,21 +30,31 @@
         /// <summary>
         /// The create directory
         /// </summary>
+        [SupportedOSPlatform("macos")]
         createDirectory,
 
         /// <summary>
         /// The prompt to create
         /// </summary>
+        [SupportedOSPlatform("windows")]
         promptToCreate,
 
         /// <summary>
         /// The no resolve aliases
         /// </summary>
+        [SupportedOSPlatform("macos")]
         noResolveAliases,
 
         /// <summary>
         /// The treat package as directory
         /// </summary>
-        treatPackageAsDirectory
+        [SupportedOSPlatform("macos")]
+        treatPackageAsDirectory,
+
+        /// <summary>
+        /// Do not add the item being opened to the recent documents list (Windows).
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        dontAddToRecent
     }
 }

src/ElectronNET.API/API/Entities/OpenExternalOptions.cs

@@ -1,21 +1,32 @@
 using System.ComponentModel;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
     /// Controls the behavior of OpenExternal.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class OpenExternalOptions
     {
         /// <summary>
-        /// <see langword="true"/> to bring the opened application to the foreground. The default is <see langword="true"/>.
+        /// Gets or sets whether to bring the opened application to the foreground. The default is <see langword="true"/>.
         /// </summary>
+        [SupportedOSPlatform("macos")]
         [DefaultValue(true)]
         public bool Activate { get; set; } = true;
 
         /// <summary>
-        /// The working directory.
+        /// Gets or sets the working directory.
         /// </summary>
+        [SupportedOSPlatform("windows")]
         public string WorkingDirectory { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating a user-initiated launch that enables tracking of frequently used programs and other behaviors. The default is <see langword="false"/>.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        [DefaultValue(false)]
+        public bool LogUsage { get; set; } = false;
     }
 }

src/ElectronNET.API/API/Entities/PageSize.cs

@@ -4,17 +4,35 @@ public class PageSize
 {
     private readonly string _value;
 
+    /// <summary>
+    /// Represents the page size for printing/PDF.
+    /// Matches Electron semantics: either a named size (e.g. 'A4', 'Letter', 'Legal', 'Tabloid', 'Ledger', etc.)
+    /// or a custom size specified by Height and Width in inches.
+    /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public PageSize()
     {
     }
 
     private PageSize(string value) : this() => _value = value;
 
+    /// <summary>
+    /// Gets or sets the custom page height in inches (when using object form instead of a named size).
+    /// </summary>
     public double Height { get; set; }
 
+    /// <summary>
+    /// Gets or sets the custom page width in inches (when using object form instead of a named size).
+    /// </summary>
     public double Width { get; set; }
 
+    /// <summary>
+    /// Implicit conversion to string to represent named page sizes (e.g. 'A4', 'Letter').
+    /// </summary>
     public static implicit operator string(PageSize pageSize) => pageSize?._value;
 
+    /// <summary>
+    /// Implicit conversion from string to represent named page sizes (e.g. 'A4', 'Letter').
+    /// </summary>
     public static implicit operator PageSize(string value) => new(value);
 }

src/ElectronNET.API/API/Entities/PathName.cs

@@ -1,95 +1,102 @@
 using System.ComponentModel;
+using System.Runtime.Versioning;
 
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// Defines the PathName enumeration.
+    /// Names for app.getPath(name). Aligned with Electron docs.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public enum PathName
     {
         /// <summary>
-        /// User’s home directory.
+        /// User's home directory.
         /// </summary>
-        [Description("home")]
         Home,
 
         /// <summary>
         /// Per-user application data directory.
         /// </summary>
-        [Description("appData")]
         AppData,
 
         /// <summary>
-        /// The directory for storing your app’s configuration files,
-        /// which by default it is the appData directory appended with your app’s name.
+        /// The directory for storing your app's configuration files, which by default is the appData directory appended with your app's name.
         /// </summary>
-        [Description("userData")]
         UserData,
 
+        /// <summary>
+        /// The directory for storing data generated by Session, such as localStorage, cookies, disk cache, downloaded dictionaries, network state, devtools files.
+        /// By default this points to userData.
+        /// </summary>
+        SessionData,
+
         /// <summary>
         /// Temporary directory.
         /// </summary>
-        [Description("temp")]
         Temp,
 
         /// <summary>
         /// The current executable file.
         /// </summary>
-        [Description("exe")]
         Exe,
 
         /// <summary>
-        /// The libchromiumcontent library.
+        /// The location of the Chromium module. By default this is synonymous with exe.
         /// </summary>
-        [Description("Module")]
         Module,
 
         /// <summary>
-        /// The current user’s Desktop directory.
+        /// The current user's Desktop directory.
         /// </summary>
-        [Description("desktop")]
         Desktop,
 
         /// <summary>
-        /// Directory for a user’s “My Documents”.
+        /// Directory for a user's "My Documents".
         /// </summary>
-        [Description("documents")]
         Documents,
 
         /// <summary>
-        /// Directory for a user’s downloads.
+        /// Directory for a user's downloads.
         /// </summary>
-        [Description("downloads")]
         Downloads,
 
         /// <summary>
-        /// Directory for a user’s music.
+        /// Directory for a user's music.
         /// </summary>
-        [Description("music")]
         Music,
 
         /// <summary>
-        /// Directory for a user’s pictures.
+        /// Directory for a user's pictures.
         /// </summary>
-        [Description("pictures")]
         Pictures,
 
         /// <summary>
-        /// Directory for a user’s videos.
+        /// Directory for a user's videos.
         /// </summary>
-        [Description("videos")]
         Videos,
 
         /// <summary>
-        /// The logs.
+        /// Directory for the user's recent files. Windows only.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        Recent,
+
+        /// <summary>
+        /// Directory for your app's log folder.
         /// </summary>
-        [Description("logs")]
         Logs,
 
         /// <summary>
-        /// Full path to the system version of the Pepper Flash plugin.
+        /// Directory where crash dumps are stored.
         /// </summary>
-        [Description("PepperFlashSystemPlugin")]
-        PepperFlashSystemPlugin
+        CrashDumps,
+
+        /// <summary>
+        /// The directory where app assets such as resources.pak are stored.
+        /// Available on Windows and Linux only.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        [SupportedOSPlatform("linux")]
+        Assets
     }
 }

src/ElectronNET.API/API/Entities/Point.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// 
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class Point
     {
         /// <summary>

src/ElectronNET.API/API/Entities/PrintOptions.cs

@@ -3,15 +3,16 @@ namespace ElectronNET.API.Entities
     /// <summary>
     /// Print dpi
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class PrintDpi
     {
         /// <summary>
-        /// The horizontal dpi
+        /// Gets or sets the horizontal DPI.
         /// </summary>
         public float Horizontal { get; set; }
 
         /// <summary>
-        /// The vertical dpi
+        /// Gets or sets the vertical DPI.
         /// </summary>
         public float Vertical { get; set; }
     }
@@ -19,15 +20,16 @@ namespace ElectronNET.API.Entities
     /// <summary>
     /// The page range to print
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class PrintPageRange
     {
         /// <summary>
-        /// From
+        /// Gets or sets the starting page index (0-based).
         /// </summary>
         public int From { get; set; }
 
         /// <summary>
-        /// To
+        /// Gets or sets the ending page index (inclusive, 0-based).
         /// </summary>
         public int To { get; set; }
     }
@@ -35,72 +37,89 @@ namespace ElectronNET.API.Entities
     /// <summary>
     /// Print options
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class PrintOptions
     {
         /// <summary>
-        /// Don't ask user for print settings
+        /// Gets or sets a value indicating whether to suppress print settings prompts.
         /// </summary>
         public bool Silent { get; set; }
 
         /// <summary>
-        /// Prints the background color and image of the web page
+        /// Gets or sets a value indicating whether to print background graphics.
         /// </summary>
         public bool PrintBackground { get; set; }
 
         /// <summary>
-        /// Set the printer device name to use
+        /// Gets or sets the printer device name to use.
         /// </summary>
         public string DeviceName { get; set; }
 
         /// <summary>
-        /// Set whether the printed web page will be in color or grayscale
+        /// Gets or sets a value indicating whether the page will be printed in color.
         /// </summary>
         public bool Color { get; set; }
 
         /// <summary>
-        /// Specifies the type of margins to use. Uses 0 for default margin, 1 for no
-        /// margin, and 2 for minimum margin.
+        /// Gets or sets the margins for the print job. Use MarginType plus top/bottom/left/right for custom.
+        /// Units for margins with webContents.print are pixels (per MCP); for webContents.printToPDF, inches.
         /// </summary>
-        public int MarginsType { get; set; }
+        public Margins Margins { get; set; }
 
         /// <summary>
-        /// true for landscape, false for portrait.
+        /// Gets or sets a value indicating whether to print in landscape orientation.
         /// </summary>
         public bool Landscape { get; set; }
 
         /// <summary>
-        /// The scale factor of the web page
+        /// Gets or sets the scale factor of the web page.
         /// </summary>
         public float ScaleFactor { get; set; }
 
         /// <summary>
-        /// The number of pages to print per page sheet
+        /// Gets or sets the number of pages to print per sheet.
         /// </summary>
         public int PagesPerSheet { get; set; }
 
         /// <summary>
-        /// The number of copies of the web page to print
+        /// Gets or sets the number of copies to print.
         /// </summary>
-        public bool Copies { get; set; }
+        public int Copies { get; set; }
 
         /// <summary>
-        /// Whether the web page should be collated
+        /// Gets or sets a value indicating whether pages should be collated.
         /// </summary>
         public bool Collate { get; set; }
 
         /// <summary>
-        /// The page range to print
+        /// Gets or sets the page range(s) to print. On macOS, only one range is honored.
         /// </summary>
-        public PrintPageRange PageRanges { get; set; }
+        public PrintPageRange[] PageRanges { get; set; }
 
         /// <summary>
-        /// Set the duplex mode of the printed web page. Can be simplex, shortEdge, or longEdge.
+        /// Gets or sets the duplex mode of the printed web page. Can be simplex, shortEdge, or longEdge.
         /// </summary>
         public string DuplexMode { get; set; }
 
         /// <summary>
-        /// Dpi
+        /// Gets or sets the DPI settings for the print job.
         /// </summary>
         public PrintDpi Dpi { get; set; }
+
+        /// <summary>
+        /// Gets or sets the string to be printed as page header.
+        /// </summary>
+        public string Header { get; set; }
+
+        /// <summary>
+        /// Gets or sets the string to be printed as page footer.
+        /// </summary>
+        public string Footer { get; set; }
+
+        /// <summary>
+        /// Gets or sets the page size of the printed document. Can be A0–A6, Legal, Letter, Tabloid,
+        /// or an object. For webContents.print, custom sizes use microns (Chromium validates width_microns/height_microns).
+        /// </summary>
+        public PageSize PageSize { get; set; }
     }
 }

src/ElectronNET.API/API/Entities/PrintToPDFOptions.cs

@@ -6,30 +6,31 @@ namespace ElectronNET.API.Entities;
 /// <summary>
 /// 
 /// </summary>
+/// <remarks>Up-to-date with Electron API 39.2</remarks>
 public class PrintToPDFOptions
 {
     /// <summary>
-    /// Paper orientation. `true` for landscape, `false` for portrait. Defaults to false.
+    /// Gets or sets the paper orientation. `true` for landscape, `false` for portrait. Defaults to false.
     /// </summary>
     public bool Landscape { get; set; } = false;
 
     /// <summary>
-    /// Whether to display header and footer. Defaults to false.
+    /// Gets or sets whether to display header and footer. Defaults to false.
     /// </summary>
     public bool DisplayHeaderFooter { get; set; } = false;
 
     /// <summary>
-    /// Whether to print background graphics. Defaults to false.
+    /// Gets or sets whether to print background graphics. Defaults to false.
     /// </summary>
     public bool PrintBackground { get; set; } = false;
 
     /// <summary>
-    /// Scale of the webpage rendering. Defaults to 1.
+    /// Gets or sets the scale of the webpage rendering. Defaults to 1.
     /// </summary>
     public double Scale { get; set; } = 1;
 
     /// <summary>
-    /// Specify page size of the generated PDF. Can be `A0`, `A1`, `A2`, `A3`, `A4`,
+    /// Gets or sets the page size of the generated PDF. Can be `A0`, `A1`, `A2`, `A3`, `A4`,
     /// `A5`, `A6`, `Legal`, `Letter`, `Tabloid`, `Ledger`, or an Object containing
     /// `height` and `width` in inches. Defaults to `Letter`.
     /// </summary>
@@ -37,13 +38,13 @@ public class PrintToPDFOptions
     public PageSize PageSize { get; set; } = "Letter";
 
     /// <summary>
-    /// Paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string,
+    /// Gets or sets the paper ranges to print, e.g., '1-5, 8, 11-13'. Defaults to the empty string,
     /// which means print all pages.
     /// </summary>
     public string PageRanges { get; set; } = "";
 
     /// <summary>
-    /// HTML template for the print header. Should be valid HTML markup with following
+    /// Gets or sets the HTML template for the print header. Should be valid HTML markup with following
     /// classes used to inject printing values into them: `date` (formatted print date),
     /// `title` (document title), `url` (document location), `pageNumber` (current page
     /// number) and `totalPages` (total pages in the document). For example, `<span class="title"></span>`
@@ -52,16 +53,28 @@ public class PrintToPDFOptions
     public string HeaderTemplate { get; set; }
 
     /// <summary>
-    /// HTML template for the print footer. Should use the same format as the
+    /// Gets or sets the HTML template for the print footer. Should use the same format as the
     /// `headerTemplate`.
     /// </summary>
     public string FooterTemplate { get; set; }
 
     /// <summary>
-    /// Whether or not to prefer page size as defined by css. Defaults to false, in
+    /// Gets or sets whether to prefer page size as defined by css. Defaults to false, in
     /// which case the content will be scaled to fit the paper size.
     /// </summary>
     public bool PreferCSSPageSize { get; set; } = false;
 
+    /// <summary>
+    /// Gets or sets whether to generate a tagged (accessible) PDF. Defaults to false.
+    /// Experimental per Electron docs; the generated PDF may not adhere fully to PDF/UA and WCAG standards.
+    /// </summary>
+    public bool GenerateTaggedPDF { get; set; } = false;
+
+    /// <summary>
+    /// Gets or sets whether to generate a PDF document outline from content headers. Defaults to false.
+    /// Experimental per Electron docs.
+    /// </summary>
+    public bool GenerateDocumentOutline { get; set; } = false;
+
     public Margins Margins { get; set; }
 }

src/ElectronNET.API/API/Entities/PrinterInfo.cs

@@ -1,28 +1,43 @@
+using System.Collections.Generic;
+
 namespace ElectronNET.API.Entities
 {
     /// <summary>
-    /// Printer info
+    /// PrinterInfo structure as returned by webContents.getPrintersAsync(). Fields backed by MCP: name, displayName, description, options.
     /// </summary>
+    /// <remarks>Up-to-date with Electron API 39.2</remarks>
     public class PrinterInfo
     {
         /// <summary>
-        /// Name
+        /// Gets or sets the name of the printer as understood by the OS.
         /// </summary>
         public string Name { get; set; }
 
         /// <summary>
-        /// Name
+        /// Gets or sets the name of the printer as shown in Print Preview.
+        /// </summary>
+        public string DisplayName { get; set; }
+
+        /// <summary>
+        /// Gets or sets a longer description of the printer's type.
         /// </summary>
         public string Description { get; set; }
 
         /// <summary>
-        /// Status
+        /// Gets or sets the status code reported by the OS. Semantics are platform-specific.
+        /// Not MCP-backed: this field is not listed in Electron's PrinterInfo structure.
         /// </summary>
         public int Status { get; set; }
 
         /// <summary>
-        /// Is default
+        /// Gets or sets a value indicating whether this printer is the system default.
+        /// Not MCP-backed: this field is not listed in Electron's PrinterInfo structure.
         /// </summary>
         public bool IsDefault { get; set; }
+
+        /// <summary>
+        /// Gets or sets the platform-specific printer information as an object (keys/values vary by OS).
+        /// </summary>
+        public Dictionary<string, string> Options { get; set; }
     }
 }