diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
index e84c04c8..f4547857 100644
--- a/.github/ISSUE_TEMPLATE/bug.yml
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -1,12 +1,20 @@
 name: Bug Report
 description: |
-    Found a bug in NativePHP? Before submitting your report, please make sure you've been through the section "Debugging" in the docs: https://nativephp.com/docs/getting-started/debugging.
+    Found a bug in NativePHP? You're in the right place!
 labels: ["bug"]
 body:
     - type: markdown
       attributes:
           value: |
-              We're sorry to hear you have a problem. Please help us solve it by providing the following details.
+              We're sorry to hear you have a problem.
+              
+              Before submitting your report, please make sure you've been through the section "[Debugging](https://nativephp.com/docs/getting-started/debugging)" in the docs.
+
+              If nothing here has helped you, please provide as much useful context as you can here to help us solve help you.
+
+              Note that reams and reams of logs isn't helpful - please share only relevant errors.
+
+              If possible, please prepare a reproduction repo and link to it in the Notes field.
     - type: textarea
       id: what-doing
       attributes:
@@ -31,7 +39,7 @@ body:
           placeholder: When I do X I see Y.
       validations:
           required: true
-    - type: input
+    - type: textarea
       id: package-version
       attributes:
           label: Package Versions
@@ -84,6 +92,6 @@ body:
       id: notes
       attributes:
           label: Notes
-          description: Use this field to provide any other notes that you feel might be relevant to the issue.
+          description: Use this field to provide any other notes that you feel might be relevant to the issue. Include links to any reproduction repos you've created here.
       validations:
           required: false
diff --git a/.github/workflows/phpstan.yml b/.github/workflows/phpstan.yml
index 3855a084..84219d82 100644
--- a/.github/workflows/phpstan.yml
+++ b/.github/workflows/phpstan.yml
@@ -1,26 +1,42 @@
 name: PHPStan
 
 on:
+  workflow_dispatch:
   push:
-    paths:
-      - '**.php'
-      - 'phpstan.neon.dist'
+    branches-ignore:
+      - 'dependabot/npm_and_yarn/*'
 
 jobs:
   phpstan:
-    name: phpstan
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        php: [8.3]
+
     steps:
-      - uses: actions/checkout@v4
+
+      - name: Checkout code
+        uses: actions/checkout@v4
 
       - name: Setup PHP
         uses: shivammathur/setup-php@v2
         with:
-          php-version: '8.1'
-          coverage: none
+          php-version: ${{ matrix.php }}
+
+      - name: Get composer cache directory
+        id: composer-cache
+        run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
+
+      - name: Cache Composer dependencies
+        uses: actions/cache@v4
+        with:
+          path: ${{ steps.composer-cache.outputs.dir }}
+          key: ${{ runner.os }}-${{ matrix.php }}-composer-${{ hashFiles('**/composer.lock') }}
+          restore-keys: ${{ runner.os }}-${{ matrix.php }}-composer-
 
-      - name: Install composer dependencies
-        uses: ramsey/composer-install@v3
+      - name: Install Dependencies
+        run: composer install -q --no-ansi --no-interaction --no-scripts --no-progress --prefer-dist
 
-      - name: Run PHPStan
-        run: ./vendor/bin/phpstan --error-format=github
+      - name: Run analysis
+        run: ./vendor/bin/phpstan analyse --error-format=github
diff --git a/.gitignore b/.gitignore
index e26945a7..3dd7896c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,6 @@ composer.lock
 coverage
 docs
 phpunit.xml
-phpstan.neon
 testbench.yaml
 vendor
 node_modules
diff --git a/CHANGELOG.md b/CHANGELOG.md
index af3daf40..9a866e6b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,15 @@
 
 All notable changes to `nativephp-laravel` will be documented in this file.
 
+## 0.6.4 - 2024-11-17
+
+### What's Changed
+
+* Fix some DB stuff by @simonhamp in https://github.com/NativePHP/laravel/pull/413
+* Add dedicated PHP ChildProcess endpoint by @gwleuverink in https://github.com/NativePHP/laravel/pull/414
+
+**Full Changelog**: https://github.com/NativePHP/laravel/compare/0.6.3...0.6.4
+
 ## 0.6.3 - 2024-11-14
 
 ### What's Changed
diff --git a/composer.json b/composer.json
index c3950b1e..9f7b760f 100644
--- a/composer.json
+++ b/composer.json
@@ -38,9 +38,9 @@
     },
     "require-dev": {
         "guzzlehttp/guzzle": "^7.0",
+        "larastan/larastan": "^2.0|^3.0",
         "laravel/pint": "^1.0",
         "nunomaduro/collision": "^7.9",
-        "nunomaduro/larastan": "^2.0.1",
         "orchestra/testbench": "^8.0",
         "pestphp/pest": "^2.0",
         "pestphp/pest-plugin-arch": "^2.0",
@@ -52,8 +52,7 @@
     },
     "autoload": {
         "psr-4": {
-            "Native\\Laravel\\": "src/",
-            "Native\\Laravel\\Database\\Factories\\": "database/factories/"
+            "Native\\Laravel\\": "src/"
         }
     },
     "autoload-dev": {
@@ -62,6 +61,11 @@
         }
     },
     "scripts": {
+        "qa" : [
+            "@composer format",
+            "@composer analyse",
+            "@composer test"
+        ],
         "post-autoload-dump": "@php ./vendor/bin/testbench package:discover --ansi",
         "analyse": "vendor/bin/phpstan analyse",
         "test": "vendor/bin/pest",
diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
deleted file mode 100644
index e69de29b..00000000
diff --git a/phpstan.neon b/phpstan.neon
new file mode 100644
index 00000000..33be1e3a
--- /dev/null
+++ b/phpstan.neon
@@ -0,0 +1,18 @@
+parameters:
+
+    paths:
+        - src/
+        - config/
+#        - tests/
+
+
+    # Level 9 is the highest level
+    level: 5
+
+    ignoreErrors:
+       - '#Class App\\Providers\\NativeAppServiceProvider not found#'
+       - '#Class Native\\Laravel\\ChildProcess has an uninitialized readonly property#'
+
+#
+#    excludePaths:
+#        - ./*/*/FileToBeExcluded.php
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
deleted file mode 100644
index 260b5e18..00000000
--- a/phpstan.neon.dist
+++ /dev/null
@@ -1,13 +0,0 @@
-includes:
-    - phpstan-baseline.neon
-
-parameters:
-    level: 4
-    paths:
-        - src
-        - config
-        - database
-    tmpDir: build/phpstan
-    checkOctaneCompatibility: true
-    checkModelProperties: true
-
diff --git a/src/ChildProcess.php b/src/ChildProcess.php
index 171210fb..f524370c 100644
--- a/src/ChildProcess.php
+++ b/src/ChildProcess.php
@@ -3,8 +3,9 @@
 namespace Native\Laravel;
 
 use Native\Laravel\Client\Client;
+use Native\Laravel\Contracts\ChildProcess as ChildProcessContract;
 
-class ChildProcess
+class ChildProcess implements ChildProcessContract
 {
     public readonly int $pid;
 
@@ -18,9 +19,9 @@ class ChildProcess
 
     public readonly bool $persistent;
 
-    public function __construct(protected Client $client) {}
+    final public function __construct(protected Client $client) {}
 
-    public function get(?string $alias = null): ?static
+    public function get(?string $alias = null): ?self
     {
         $alias = $alias ?? $this->alias;
 
@@ -51,17 +52,22 @@ public function all(): array
         return $hydrated;
     }
 
+    /**
+     * @param  string|string[]  $cmd
+     * @return $this
+     */
     public function start(
         string|array $cmd,
         string $alias,
         ?string $cwd = null,
         ?array $env = null,
         bool $persistent = false
-    ): static {
+    ): self {
+        $cmd = is_array($cmd) ? array_values($cmd) : [$cmd];
 
         $process = $this->client->post('child-process/start', [
             'alias' => $alias,
-            'cmd' => (array) $cmd,
+            'cmd' => $cmd,
             'cwd' => $cwd ?? base_path(),
             'env' => $env,
             'persistent' => $persistent,
@@ -70,12 +76,18 @@ public function start(
         return $this->fromRuntimeProcess($process);
     }
 
+    /**
+     * @param  string|string[]  $cmd
+     * @return $this
+     */
     public function php(string|array $cmd, string $alias, ?array $env = null, ?bool $persistent = false): self
     {
+        $cmd = is_array($cmd) ? array_values($cmd) : [$cmd];
+
         $process = $this->client->post('child-process/start-php', [
             'alias' => $alias,
-            'cmd' => (array) $cmd,
-            'cwd' => $cwd ?? base_path(),
+            'cmd' => $cmd,
+            'cwd' => base_path(),
             'env' => $env,
             'persistent' => $persistent,
         ])->json();
@@ -83,9 +95,15 @@ public function php(string|array $cmd, string $alias, ?array $env = null, ?bool
         return $this->fromRuntimeProcess($process);
     }
 
+    /**
+     * @param  string|string[]  $cmd
+     * @return $this
+     */
     public function artisan(string|array $cmd, string $alias, ?array $env = null, ?bool $persistent = false): self
     {
-        $cmd = ['artisan', ...(array) $cmd];
+        $cmd = is_array($cmd) ? array_values($cmd) : [$cmd];
+
+        $cmd = ['artisan', ...$cmd];
 
         return $this->php($cmd, $alias, env: $env, persistent: $persistent);
     }
@@ -97,7 +115,7 @@ public function stop(?string $alias = null): void
         ])->json();
     }
 
-    public function restart(?string $alias = null): ?static
+    public function restart(?string $alias = null): ?self
     {
         $process = $this->client->post('child-process/restart', [
             'alias' => $alias ?? $this->alias,
@@ -110,7 +128,7 @@ public function restart(?string $alias = null): ?static
         return $this->fromRuntimeProcess($process);
     }
 
-    public function message(string $message, ?string $alias = null): static
+    public function message(string $message, ?string $alias = null): self
     {
         $this->client->post('child-process/message', [
             'alias' => $alias ?? $this->alias,
@@ -120,9 +138,10 @@ public function message(string $message, ?string $alias = null): static
         return $this;
     }
 
-    protected function fromRuntimeProcess($process): static
+    protected function fromRuntimeProcess($process)
     {
         if (isset($process['pid'])) {
+            // @phpstan-ignore-next-line
             $this->pid = $process['pid'];
         }
 
diff --git a/src/Client/Client.php b/src/Client/Client.php
index e444ea4a..9a8ec815 100644
--- a/src/Client/Client.php
+++ b/src/Client/Client.php
@@ -21,9 +21,9 @@ public function __construct()
             ->asJson();
     }
 
-    public function get(string $endpoint): Response
+    public function get(string $endpoint, array|string|null $query = null): Response
     {
-        return $this->client->get($endpoint);
+        return $this->client->get($endpoint, $query);
     }
 
     public function post(string $endpoint, array $data = []): Response
diff --git a/src/Commands/SeedDatabaseCommand.php b/src/Commands/SeedDatabaseCommand.php
index c83879e7..cdc032e0 100644
--- a/src/Commands/SeedDatabaseCommand.php
+++ b/src/Commands/SeedDatabaseCommand.php
@@ -15,6 +15,6 @@ public function handle()
     {
         (new NativeServiceProvider($this->laravel))->rewriteDatabase();
 
-        parent::handle();
+        return parent::handle();
     }
 }
diff --git a/src/Compactor/Php.php b/src/Compactor/Php.php
index f4838bfd..7b5d3ad1 100644
--- a/src/Compactor/Php.php
+++ b/src/Compactor/Php.php
@@ -3,6 +3,8 @@
 namespace Native\Laravel\Compactor;
 
 use PhpToken;
+use RuntimeException;
+use Webmozart\Assert\Assert;
 
 class Php
 {
@@ -17,7 +19,7 @@ public function compact(string $file, string $contents): string
             return $this->compactContent($contents);
         }
 
-        $this->compactContent($contents);
+        return $this->compactContent($contents);
     }
 
     protected function compactContent(string $contents): string
@@ -145,7 +147,6 @@ private function retokenizeAttribute(array &$tokens, int $opener): ?array
     {
         Assert::keyExists($tokens, $opener);
 
-        /** @var PhpToken $token */
         $token = $tokens[$opener];
         $attributeBody = mb_substr($token->text, 2);
         $subTokens = PhpToken::tokenize('<?php '.$attributeBody);
diff --git a/src/Contracts/ChildProcess.php b/src/Contracts/ChildProcess.php
new file mode 100644
index 00000000..9859e3e6
--- /dev/null
+++ b/src/Contracts/ChildProcess.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Native\Laravel\Contracts;
+
+interface ChildProcess
+{
+    public function get(?string $alias = null): ?self;
+
+    public function all(): array;
+
+    public function start(
+        string|array $cmd,
+        string $alias,
+        ?string $cwd = null,
+        ?array $env = null,
+        bool $persistent = false
+    ): self;
+
+    public function php(string|array $cmd, string $alias, ?array $env = null, ?bool $persistent = false): self;
+
+    public function artisan(string|array $cmd, string $alias, ?array $env = null, ?bool $persistent = false): self;
+
+    public function stop(?string $alias = null): void;
+
+    public function restart(?string $alias = null): ?self;
+
+    public function message(string $message, ?string $alias = null): self;
+}
diff --git a/src/Contracts/GlobalShortcut.php b/src/Contracts/GlobalShortcut.php
new file mode 100644
index 00000000..2fff35e8
--- /dev/null
+++ b/src/Contracts/GlobalShortcut.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Native\Laravel\Contracts;
+
+interface GlobalShortcut
+{
+    public function key(string $key): self;
+
+    public function event(string $event): self;
+
+    public function register(): void;
+
+    public function unregister(): void;
+}
diff --git a/src/Contracts/PowerMonitor.php b/src/Contracts/PowerMonitor.php
new file mode 100644
index 00000000..e8ec3d52
--- /dev/null
+++ b/src/Contracts/PowerMonitor.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Native\Laravel\Contracts;
+
+use Native\Laravel\Enums\SystemIdleStatesEnum;
+use Native\Laravel\Enums\ThermalStatesEnum;
+
+interface PowerMonitor
+{
+    public function getSystemIdleState(int $threshold): SystemIdleStatesEnum;
+
+    public function getSystemIdleTime(): int;
+
+    public function getCurrentThermalState(): ThermalStatesEnum;
+
+    public function isOnBatteryPower(): bool;
+}
diff --git a/src/Contracts/WindowManager.php b/src/Contracts/WindowManager.php
new file mode 100644
index 00000000..e4bbe63e
--- /dev/null
+++ b/src/Contracts/WindowManager.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Contracts;
+
+use Native\Laravel\Windows\Window;
+
+interface WindowManager
+{
+    public function open(string $id = 'main');
+
+    public function close($id = null);
+
+    public function hide($id = null);
+
+    public function current(): Window;
+
+    /**
+     * @return array<int, Window>
+     */
+    public function all(): array;
+
+    public function get(string $id): Window;
+}
diff --git a/src/Dialog.php b/src/Dialog.php
index 6188efab..5b8d8913 100644
--- a/src/Dialog.php
+++ b/src/Dialog.php
@@ -26,7 +26,7 @@ class Dialog
 
     protected $windowReference;
 
-    public function __construct(protected Client $client) {}
+    final public function __construct(protected Client $client) {}
 
     public static function new()
     {
diff --git a/src/Dock.php b/src/Dock.php
index dbd091dc..9691ff89 100644
--- a/src/Dock.php
+++ b/src/Dock.php
@@ -17,4 +17,40 @@ public function menu(Menu $menu)
             'items' => $items,
         ]);
     }
+
+    public function show()
+    {
+        $this->client->post('dock/show');
+    }
+
+    public function hide()
+    {
+        $this->client->post('dock/hide');
+    }
+
+    public function icon(string $path)
+    {
+        $this->client->post('dock/icon', ['path' => $path]);
+    }
+
+    public function bounce(string $type = 'informational')
+    {
+        $this->client->post('dock/bounce', ['type' => $type]);
+    }
+
+    public function cancelBounce()
+    {
+        $this->client->post('dock/cancel-bounce');
+    }
+
+    public function badge(?string $label = null): ?string
+    {
+        if (is_null($label)) {
+            return $this->client->get('dock/badge');
+        }
+
+        $this->client->post('dock/badge', ['label' => $label]);
+
+        return null;
+    }
 }
diff --git a/src/Enums/RolesEnum.php b/src/Enums/RolesEnum.php
index 337c4798..0039d72a 100644
--- a/src/Enums/RolesEnum.php
+++ b/src/Enums/RolesEnum.php
@@ -4,12 +4,24 @@
 
 enum RolesEnum: string
 {
-    case APP_MENU = 'appMenu';
+    case APP_MENU = 'appMenu'; // macOS
     case FILE_MENU = 'fileMenu';
     case EDIT_MENU = 'editMenu';
     case VIEW_MENU = 'viewMenu';
     case WINDOW_MENU = 'windowMenu';
+    case HELP = 'help'; // macOS
+    case UNDO = 'undo';
+    case REDO = 'redo';
+    case CUT = 'cut';
+    case COPY = 'copy';
+    case PASTE = 'paste';
+    case PASTE_STYLE = 'pasteAndMatchStyle';
+    case RELOAD = 'reload';
+    case HIDE = 'hide'; // macOS
+    case MINIMIZE = 'minimize';
+    case CLOSE = 'close';
     case QUIT = 'quit';
     case TOGGLE_FULL_SCREEN = 'togglefullscreen';
     case TOGGLE_DEV_TOOLS = 'toggleDevTools';
+    case ABOUT = 'about';
 }
diff --git a/src/Events/Menu/MenuItemClicked.php b/src/Events/Menu/MenuItemClicked.php
index d9daa74f..961ed1c7 100644
--- a/src/Events/Menu/MenuItemClicked.php
+++ b/src/Events/Menu/MenuItemClicked.php
@@ -12,7 +12,7 @@ class MenuItemClicked implements ShouldBroadcastNow
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
-    public function __construct(public array $item) {}
+    public function __construct(public array $item, public array $combo = []) {}
 
     public function broadcastOn()
     {
diff --git a/src/Events/MenuBar/MenuBarClicked.php b/src/Events/MenuBar/MenuBarClicked.php
new file mode 100644
index 00000000..4ac8f9e9
--- /dev/null
+++ b/src/Events/MenuBar/MenuBarClicked.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Events\MenuBar;
+
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class MenuBarClicked implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct(public array $combo, public array $bounds, public array $position) {}
+
+    public function broadcastOn()
+    {
+        return [
+            new Channel('nativephp'),
+        ];
+    }
+}
diff --git a/src/Events/MenuBar/MenuBarDoubleClicked.php b/src/Events/MenuBar/MenuBarDoubleClicked.php
new file mode 100644
index 00000000..b6450c20
--- /dev/null
+++ b/src/Events/MenuBar/MenuBarDoubleClicked.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Events\MenuBar;
+
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class MenuBarDoubleClicked implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct(public array $combo, public array $bounds) {}
+
+    public function broadcastOn()
+    {
+        return [
+            new Channel('nativephp'),
+        ];
+    }
+}
diff --git a/src/Events/MenuBar/MenuBarContextMenuOpened.php b/src/Events/MenuBar/MenuBarRightClicked.php
similarity index 77%
rename from src/Events/MenuBar/MenuBarContextMenuOpened.php
rename to src/Events/MenuBar/MenuBarRightClicked.php
index f4d85f6a..69cdde5c 100644
--- a/src/Events/MenuBar/MenuBarContextMenuOpened.php
+++ b/src/Events/MenuBar/MenuBarRightClicked.php
@@ -8,10 +8,12 @@
 use Illuminate\Foundation\Events\Dispatchable;
 use Illuminate\Queue\SerializesModels;
 
-class MenuBarContextMenuOpened implements ShouldBroadcastNow
+class MenuBarRightClicked implements ShouldBroadcastNow
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
+    public function __construct(public array $combo, public array $bounds) {}
+
     public function broadcastOn()
     {
         return [
diff --git a/src/Events/PowerMonitor/ScreenLocked.php b/src/Events/PowerMonitor/ScreenLocked.php
new file mode 100644
index 00000000..dbaca58a
--- /dev/null
+++ b/src/Events/PowerMonitor/ScreenLocked.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Events\PowerMonitor;
+
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class ScreenLocked implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct() {}
+
+    public function broadcastOn()
+    {
+        return [
+            new Channel('nativephp'),
+        ];
+    }
+}
diff --git a/src/Events/PowerMonitor/ScreenUnlocked.php b/src/Events/PowerMonitor/ScreenUnlocked.php
new file mode 100644
index 00000000..b4d15241
--- /dev/null
+++ b/src/Events/PowerMonitor/ScreenUnlocked.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Events\PowerMonitor;
+
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class ScreenUnlocked implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct() {}
+
+    public function broadcastOn()
+    {
+        return [
+            new Channel('nativephp'),
+        ];
+    }
+}
diff --git a/src/Events/PowerMonitor/Shutdown.php b/src/Events/PowerMonitor/Shutdown.php
new file mode 100644
index 00000000..19e563cb
--- /dev/null
+++ b/src/Events/PowerMonitor/Shutdown.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Events\PowerMonitor;
+
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class Shutdown implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct() {}
+
+    public function broadcastOn()
+    {
+        return [
+            new Channel('nativephp'),
+        ];
+    }
+}
diff --git a/src/Events/PowerMonitor/UserDidBecomeActive.php b/src/Events/PowerMonitor/UserDidBecomeActive.php
new file mode 100644
index 00000000..e077a526
--- /dev/null
+++ b/src/Events/PowerMonitor/UserDidBecomeActive.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Events\PowerMonitor;
+
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class UserDidBecomeActive implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct() {}
+
+    public function broadcastOn()
+    {
+        return [
+            new Channel('nativephp'),
+        ];
+    }
+}
diff --git a/src/Events/PowerMonitor/UserDidResignActive.php b/src/Events/PowerMonitor/UserDidResignActive.php
new file mode 100644
index 00000000..5608102a
--- /dev/null
+++ b/src/Events/PowerMonitor/UserDidResignActive.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Native\Laravel\Events\PowerMonitor;
+
+use Illuminate\Broadcasting\Channel;
+use Illuminate\Broadcasting\InteractsWithSockets;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
+use Illuminate\Foundation\Events\Dispatchable;
+use Illuminate\Queue\SerializesModels;
+
+class UserDidResignActive implements ShouldBroadcastNow
+{
+    use Dispatchable, InteractsWithSockets, SerializesModels;
+
+    public function __construct() {}
+
+    public function broadcastOn()
+    {
+        return [
+            new Channel('nativephp'),
+        ];
+    }
+}
diff --git a/src/Facades/ChildProcess.php b/src/Facades/ChildProcess.php
index 89b72361..0436507e 100644
--- a/src/Facades/ChildProcess.php
+++ b/src/Facades/ChildProcess.php
@@ -3,7 +3,8 @@
 namespace Native\Laravel\Facades;
 
 use Illuminate\Support\Facades\Facade;
-use Native\Laravel\ChildProcess as Implement;
+use Native\Laravel\Contracts\ChildProcess as ChildProcessContract;
+use Native\Laravel\Fakes\ChildProcessFake;
 
 /**
  * @method static \Native\Laravel\ChildProcess[] all()
@@ -17,10 +18,17 @@
  */
 class ChildProcess extends Facade
 {
+    public static function fake()
+    {
+        return tap(static::getFacadeApplication()->make(ChildProcessFake::class), function ($fake) {
+            static::swap($fake);
+        });
+    }
+
     protected static function getFacadeAccessor()
     {
-        self::clearResolvedInstance(Implement::class);
+        self::clearResolvedInstance(ChildProcessContract::class);
 
-        return Implement::class;
+        return ChildProcessContract::class;
     }
 }
diff --git a/src/Facades/Dock.php b/src/Facades/Dock.php
index f9386433..b088219d 100644
--- a/src/Facades/Dock.php
+++ b/src/Facades/Dock.php
@@ -6,7 +6,13 @@
 use Native\Laravel\Menu\Menu;
 
 /**
+ * @method static void bounce()
+ * @method static void|string badge(string $type = null)
+ * @method static void cancelBounce()
+ * @method static void hide()
+ * @method static void icon(string $Path)
  * @method static void menu(Menu $menu)
+ * @method static void show()
  */
 class Dock extends Facade
 {
diff --git a/src/Facades/GlobalShortcut.php b/src/Facades/GlobalShortcut.php
index f0131682..d5a506f0 100644
--- a/src/Facades/GlobalShortcut.php
+++ b/src/Facades/GlobalShortcut.php
@@ -3,6 +3,8 @@
 namespace Native\Laravel\Facades;
 
 use Illuminate\Support\Facades\Facade;
+use Native\Laravel\Contracts\GlobalShortcut as GlobalShortcutContract;
+use Native\Laravel\Fakes\GlobalShortcutFake;
 
 /**
  * @method static \Native\Laravel\GlobalShortcut key(string $key)
@@ -12,8 +14,15 @@
  */
 class GlobalShortcut extends Facade
 {
+    public static function fake()
+    {
+        return tap(static::getFacadeApplication()->make(GlobalShortcutFake::class), function ($fake) {
+            static::swap($fake);
+        });
+    }
+
     protected static function getFacadeAccessor()
     {
-        return \Native\Laravel\GlobalShortcut::class;
+        return GlobalShortcutContract::class;
     }
 }
diff --git a/src/Facades/Menu.php b/src/Facades/Menu.php
new file mode 100644
index 00000000..332de247
--- /dev/null
+++ b/src/Facades/Menu.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Native\Laravel\Facades;
+
+use Illuminate\Support\Facades\Facade;
+use Native\Laravel\Contracts\MenuItem;
+use Native\Laravel\Menu\Items\Checkbox;
+use Native\Laravel\Menu\Items\Label;
+use Native\Laravel\Menu\Items\Link;
+use Native\Laravel\Menu\Items\Radio;
+use Native\Laravel\Menu\Items\Role;
+use Native\Laravel\Menu\Items\Separator;
+
+/**
+ * @method static \Native\Laravel\Menu\Menu make(MenuItem ...$items)
+ * @method static Checkbox checkbox(string $label, bool $checked = false, ?string $hotkey = null)
+ * @method static Label label(string $label)
+ * @method static Link link(string $url, string $label = null, ?string $hotkey = null)
+ * @method static Link route(string $url, string $label = null, ?string $hotkey = null)
+ * @method static Radio radio(string $label, bool $checked = false, ?string $hotkey = null)
+ * @method static Role app()
+ * @method static Role file()
+ * @method static Role edit()
+ * @method static Role view()
+ * @method static Role window()
+ * @method static Role help()
+ * @method static Role fullscreen()
+ * @method static Role separator()
+ * @method static Role devTools()
+ * @method static Role undo()
+ * @method static Role redo()
+ * @method static Role cut()
+ * @method static Role copy()
+ * @method static Role paste()
+ * @method static Role pasteAndMatchStyle()
+ * @method static Role reload()
+ * @method static Role minimize()
+ * @method static Role close()
+ * @method static Role quit()
+ * @method static Role hide()
+ * @method static void create(MenuItem ...$items)
+ * @method static void default()
+ */
+class Menu extends Facade
+{
+    protected static function getFacadeAccessor()
+    {
+        return \Native\Laravel\Menu\MenuBuilder::class;
+    }
+}
diff --git a/src/Facades/Notification.php b/src/Facades/Notification.php
index 4f9f56d3..425fea13 100644
--- a/src/Facades/Notification.php
+++ b/src/Facades/Notification.php
@@ -5,9 +5,9 @@
 use Illuminate\Support\Facades\Facade;
 
 /**
- * @method static object title(string $title)
- * @method static object event(string $event)
- * @method static object message(string $body)
+ * @method static static title(string $title)
+ * @method static static event(string $event)
+ * @method static static message(string $body)
  * @method static void show()
  */
 class Notification extends Facade
diff --git a/src/Facades/PowerMonitor.php b/src/Facades/PowerMonitor.php
index 52338562..d72d9d73 100644
--- a/src/Facades/PowerMonitor.php
+++ b/src/Facades/PowerMonitor.php
@@ -3,17 +3,26 @@
 namespace Native\Laravel\Facades;
 
 use Illuminate\Support\Facades\Facade;
+use Native\Laravel\Contracts\PowerMonitor as PowerMonitorContract;
+use Native\Laravel\Fakes\PowerMonitorFake;
 
 /**
- * @method static \Native\Laravel\Enums\SystemIdelStatesEnum getSystemIdleState(int $threshold)
+ * @method static \Native\Laravel\Enums\SystemIdleStatesEnum getSystemIdleState(int $threshold)
  * @method static int getSystemIdleTime()
  * @method static \Native\Laravel\Enums\ThermalStatesEnum getCurrentThermalState()
  * @method static bool isOnBatteryPower()
  */
 class PowerMonitor extends Facade
 {
-    protected static function getFacadeAccessor()
+    public static function fake()
     {
-        return \Native\Laravel\PowerMonitor::class;
+        return tap(static::getFacadeApplication()->make(PowerMonitorFake::class), function ($fake) {
+            static::swap($fake);
+        });
+    }
+
+    protected static function getFacadeAccessor(): string
+    {
+        return PowerMonitorContract::class;
     }
 }
diff --git a/src/Facades/Settings.php b/src/Facades/Settings.php
index d1126c5c..527c0f91 100644
--- a/src/Facades/Settings.php
+++ b/src/Facades/Settings.php
@@ -5,8 +5,10 @@
 use Illuminate\Support\Facades\Facade;
 
 /**
- * @method static void set($key, $value)
- * @method static void mixed($key, $default = null)
+ * @method static void set(string $key, $value)
+ * @method static mixed get(string $key, $default = null)
+ * @method static void forget(string $key)
+ * @method static void clear()
  */
 class Settings extends Facade
 {
diff --git a/src/Facades/Window.php b/src/Facades/Window.php
index 5ac1e901..f73e2164 100644
--- a/src/Facades/Window.php
+++ b/src/Facades/Window.php
@@ -3,6 +3,8 @@
 namespace Native\Laravel\Facades;
 
 use Illuminate\Support\Facades\Facade;
+use Native\Laravel\Contracts\WindowManager as WindowManagerContract;
+use Native\Laravel\Fakes\WindowManagerFake;
 
 /**
  * @method static \Native\Laravel\Windows\PendingOpenWindow open(string $id = 'main')
@@ -18,8 +20,15 @@
  */
 class Window extends Facade
 {
+    public static function fake()
+    {
+        return tap(static::getFacadeApplication()->make(WindowManagerFake::class), function ($fake) {
+            static::swap($fake);
+        });
+    }
+
     protected static function getFacadeAccessor()
     {
-        return \Native\Laravel\Windows\WindowManager::class;
+        return WindowManagerContract::class;
     }
 }
diff --git a/src/Fakes/ChildProcessFake.php b/src/Fakes/ChildProcessFake.php
new file mode 100644
index 00000000..4e6add8b
--- /dev/null
+++ b/src/Fakes/ChildProcessFake.php
@@ -0,0 +1,252 @@
+<?php
+
+namespace Native\Laravel\Fakes;
+
+use Closure;
+use Native\Laravel\Contracts\ChildProcess as ChildProcessContract;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class ChildProcessFake implements ChildProcessContract
+{
+    /**
+     * @var array<int, string|null>
+     */
+    public array $gets = [];
+
+    /**
+     * @var array<int, array{cmd: array|string, alias: string, cwd: string|null, env: array|null, persistent: bool}>
+     */
+    public array $starts = [];
+
+    /**
+     * @var array<int, array{cmd: array|string, alias: string, env: array|null, persistent: bool}>
+     */
+    public array $phps = [];
+
+    /**
+     * @var array<int, array{cmd: array|string, alias: string, env: array|null, persistent: bool}>
+     */
+    public array $artisans = [];
+
+    /**
+     * @var array<int, string|null>
+     */
+    public array $stops = [];
+
+    /**
+     * @var array<int, string|null>
+     */
+    public array $restarts = [];
+
+    /**
+     * @var array<int, array{message: string, alias: string|null}>
+     */
+    public array $messages = [];
+
+    public function get(?string $alias = null): self
+    {
+        $this->gets[] = $alias;
+
+        return $this;
+    }
+
+    public function all(): array
+    {
+        return [$this];
+    }
+
+    public function start(
+        array|string $cmd,
+        string $alias,
+        ?string $cwd = null,
+        ?array $env = null,
+        bool $persistent = false
+    ): self {
+        $this->starts[] = [
+            'cmd' => $cmd,
+            'alias' => $alias,
+            'cwd' => $cwd,
+            'env' => $env,
+            'persistent' => $persistent,
+        ];
+
+        return $this;
+    }
+
+    public function php(
+        array|string $cmd,
+        string $alias,
+        ?array $env = null,
+        ?bool $persistent = false
+    ): self {
+        $this->phps[] = [
+            'cmd' => $cmd,
+            'alias' => $alias,
+            'env' => $env,
+            'persistent' => $persistent,
+        ];
+
+        return $this;
+    }
+
+    public function artisan(
+        array|string $cmd,
+        string $alias,
+        ?array $env = null,
+        ?bool $persistent = false
+    ): self {
+        $this->artisans[] = [
+            'cmd' => $cmd,
+            'alias' => $alias,
+            'env' => $env,
+            'persistent' => $persistent,
+        ];
+
+        return $this;
+    }
+
+    public function stop(?string $alias = null): void
+    {
+        $this->stops[] = $alias;
+    }
+
+    public function restart(?string $alias = null): self
+    {
+        $this->restarts[] = $alias;
+
+        return $this;
+    }
+
+    public function message(string $message, ?string $alias = null): self
+    {
+        $this->messages[] = [
+            'message' => $message,
+            'alias' => $alias,
+        ];
+
+        return $this;
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $alias
+     */
+    public function assertGet(string|Closure $alias): void
+    {
+        if (is_callable($alias) === false) {
+            PHPUnit::assertContains($alias, $this->gets);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->gets,
+                fn (mixed $get) => $alias($get) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  Closure(array|string $cmd, string $alias, ?string $cwd, ?array $env, bool $persistent): bool  $callback
+     */
+    public function assertStarted(Closure $callback): void
+    {
+        $hit = empty(
+            array_filter(
+                $this->starts,
+                fn (array $started) => $callback(...$started) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  Closure(array|string $cmd, string $alias, ?array $env, ?bool $persistent): bool  $callback
+     */
+    public function assertPhp(Closure $callback): void
+    {
+        $hit = empty(
+            array_filter(
+                $this->phps,
+                fn (array $php) => $callback(...$php) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  Closure(array|string $cmd, string $alias, ?array $env, ?bool $persistent): bool  $callback
+     */
+    public function assertArtisan(Closure $callback): void
+    {
+        $hit = empty(
+            array_filter(
+                $this->artisans,
+                fn (array $artisan) => $callback(...$artisan) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $alias
+     */
+    public function assertStop(string|Closure $alias): void
+    {
+        if (is_callable($alias) === false) {
+            PHPUnit::assertContains($alias, $this->stops);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->stops,
+                fn (mixed $stop) => $alias($stop) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $alias
+     */
+    public function assertRestart(string|Closure $alias): void
+    {
+        if (is_callable($alias) === false) {
+            PHPUnit::assertContains($alias, $this->restarts);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->restarts,
+                fn (mixed $restart) => $alias($restart) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  Closure(string $message, string|null $alias): bool  $callback
+     */
+    public function assertMessage(Closure $callback): void
+    {
+        $hit = empty(
+            array_filter(
+                $this->messages,
+                fn (array $message) => $callback(...$message) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+}
diff --git a/src/Fakes/GlobalShortcutFake.php b/src/Fakes/GlobalShortcutFake.php
new file mode 100644
index 00000000..13efa1ee
--- /dev/null
+++ b/src/Fakes/GlobalShortcutFake.php
@@ -0,0 +1,100 @@
+<?php
+
+namespace Native\Laravel\Fakes;
+
+use Closure;
+use Native\Laravel\Contracts\GlobalShortcut as GlobalShortcutContract;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class GlobalShortcutFake implements GlobalShortcutContract
+{
+    /**
+     * @var array<int, string>
+     */
+    public array $keys = [];
+
+    /**
+     * @var array<int, string>
+     */
+    public array $events = [];
+
+    public int $registeredCount = 0;
+
+    public int $unregisteredCount = 0;
+
+    public function key(string $key): self
+    {
+        $this->keys[] = $key;
+
+        return $this;
+    }
+
+    public function event(string $event): self
+    {
+        $this->events[] = $event;
+
+        return $this;
+    }
+
+    public function register(): void
+    {
+        $this->registeredCount++;
+    }
+
+    public function unregister(): void
+    {
+        $this->unregisteredCount++;
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $key
+     */
+    public function assertKey(string|Closure $key): void
+    {
+        if (is_callable($key) === false) {
+            PHPUnit::assertContains($key, $this->keys);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->keys,
+                fn (string $keyIteration) => $key($keyIteration) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $event
+     */
+    public function assertEvent(string|Closure $event): void
+    {
+        if (is_callable($event) === false) {
+            PHPUnit::assertContains($event, $this->events);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->events,
+                fn (string $eventIteration) => $event($eventIteration) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    public function assertRegisteredCount(int $count): void
+    {
+        PHPUnit::assertSame($count, $this->registeredCount);
+    }
+
+    public function assertUnregisteredCount(int $count): void
+    {
+        PHPUnit::assertSame($count, $this->unregisteredCount);
+    }
+}
diff --git a/src/Fakes/PowerMonitorFake.php b/src/Fakes/PowerMonitorFake.php
new file mode 100644
index 00000000..2af99167
--- /dev/null
+++ b/src/Fakes/PowerMonitorFake.php
@@ -0,0 +1,93 @@
+<?php
+
+namespace Native\Laravel\Fakes;
+
+use Closure;
+use Native\Laravel\Contracts\PowerMonitor as PowerMonitorContract;
+use Native\Laravel\Enums\SystemIdleStatesEnum;
+use Native\Laravel\Enums\ThermalStatesEnum;
+use PHPUnit\Framework\Assert as PHPUnit;
+
+class PowerMonitorFake implements PowerMonitorContract
+{
+    public array $getSystemIdleStateCalls = [];
+
+    public int $getSystemIdleStateCount = 0;
+
+    public int $getSystemIdleTimeCount = 0;
+
+    public int $getCurrentThermalStateCount = 0;
+
+    public int $isOnBatteryPowerCount = 0;
+
+    public function getSystemIdleState(int $threshold): SystemIdleStatesEnum
+    {
+        $this->getSystemIdleStateCount++;
+
+        $this->getSystemIdleStateCalls[] = $threshold;
+
+        return SystemIdleStatesEnum::UNKNOWN;
+    }
+
+    public function getSystemIdleTime(): int
+    {
+        $this->getSystemIdleTimeCount++;
+
+        return 0;
+    }
+
+    public function getCurrentThermalState(): ThermalStatesEnum
+    {
+        $this->getCurrentThermalStateCount++;
+
+        return ThermalStatesEnum::UNKNOWN;
+    }
+
+    public function isOnBatteryPower(): bool
+    {
+        $this->isOnBatteryPowerCount++;
+
+        return false;
+    }
+
+    /**
+     * @param  int|Closure(int): bool  $key
+     */
+    public function assertGetSystemIdleState(int|Closure $key): void
+    {
+        if (is_callable($key) === false) {
+            PHPUnit::assertContains($key, $this->getSystemIdleStateCalls);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->getSystemIdleStateCalls,
+                fn (string $keyIteration) => $key($keyIteration) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    public function assertGetSystemIdleStateCount(int $count): void
+    {
+        PHPUnit::assertSame($count, $this->getSystemIdleStateCount);
+    }
+
+    public function assertGetSystemIdleTimeCount(int $count): void
+    {
+        PHPUnit::assertSame($count, $this->getSystemIdleTimeCount);
+    }
+
+    public function assertGetCurrentThermalStateCount(int $count): void
+    {
+        PHPUnit::assertSame($count, $this->getCurrentThermalStateCount);
+    }
+
+    public function assertIsOnBatteryPowerCount(int $count): void
+    {
+        PHPUnit::assertSame($count, $this->isOnBatteryPowerCount);
+    }
+}
diff --git a/src/Fakes/WindowManagerFake.php b/src/Fakes/WindowManagerFake.php
new file mode 100644
index 00000000..8604224f
--- /dev/null
+++ b/src/Fakes/WindowManagerFake.php
@@ -0,0 +1,178 @@
+<?php
+
+namespace Native\Laravel\Fakes;
+
+use Closure;
+use Illuminate\Support\Arr;
+use Native\Laravel\Client\Client;
+use Native\Laravel\Contracts\WindowManager as WindowManagerContract;
+use Native\Laravel\Windows\Window;
+use PHPUnit\Framework\Assert as PHPUnit;
+use Webmozart\Assert\Assert;
+
+class WindowManagerFake implements WindowManagerContract
+{
+    public array $opened = [];
+
+    public array $closed = [];
+
+    public array $hidden = [];
+
+    public array $forcedWindowReturnValues = [];
+
+    public function __construct(
+        protected Client $client
+    ) {}
+
+    /**
+     * @param  array<int, Window>  $windows
+     */
+    public function alwaysReturnWindows(array $windows): self
+    {
+        $this->forcedWindowReturnValues = $windows;
+
+        return $this;
+    }
+
+    public function open(string $id = 'main')
+    {
+        $this->opened[] = $id;
+
+        $this->ensureForceReturnWindowsProvided();
+
+        $matchingWindows = array_filter(
+            $this->forcedWindowReturnValues,
+            fn (Window $window) => $window->getId() === $id
+        );
+
+        if (empty($matchingWindows)) {
+            return $this->forcedWindowReturnValues[array_rand($this->forcedWindowReturnValues)]->setClient($this->client);
+        }
+
+        Assert::count($matchingWindows, 1);
+
+        return Arr::first($matchingWindows)->setClient($this->client);
+    }
+
+    public function close($id = null)
+    {
+        $this->closed[] = $id;
+    }
+
+    public function hide($id = null)
+    {
+        $this->hidden[] = $id;
+    }
+
+    public function current(): Window
+    {
+        $this->ensureForceReturnWindowsProvided();
+
+        return $this->forcedWindowReturnValues[array_rand($this->forcedWindowReturnValues)];
+    }
+
+    /**
+     * @return array<int, Window>
+     */
+    public function all(): array
+    {
+        $this->ensureForceReturnWindowsProvided();
+
+        return $this->forcedWindowReturnValues;
+    }
+
+    public function get(string $id): Window
+    {
+        $this->ensureForceReturnWindowsProvided();
+
+        $matchingWindows = array_filter($this->forcedWindowReturnValues, fn (Window $window) => $window->getId() === $id);
+
+        Assert::notEmpty($matchingWindows);
+        Assert::count($matchingWindows, 1);
+
+        return Arr::first($matchingWindows);
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $id
+     */
+    public function assertOpened(string|Closure $id): void
+    {
+        if (is_callable($id) === false) {
+            PHPUnit::assertContains($id, $this->opened);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->opened,
+                fn (string $openedId) => $id($openedId) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $id
+     */
+    public function assertClosed(string|Closure $id): void
+    {
+        if (is_callable($id) === false) {
+            PHPUnit::assertContains($id, $this->closed);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->closed,
+                fn (mixed $closedId) => $id($closedId) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    /**
+     * @param  string|Closure(string): bool  $id
+     */
+    public function assertHidden(string|Closure $id): void
+    {
+        if (is_callable($id) === false) {
+            PHPUnit::assertContains($id, $this->hidden);
+
+            return;
+        }
+
+        $hit = empty(
+            array_filter(
+                $this->hidden,
+                fn (mixed $hiddenId) => $id($hiddenId) === true
+            )
+        ) === false;
+
+        PHPUnit::assertTrue($hit);
+    }
+
+    public function assertOpenedCount(int $expected): void
+    {
+        PHPUnit::assertCount($expected, $this->opened);
+    }
+
+    public function assertClosedCount(int $expected): void
+    {
+        PHPUnit::assertCount($expected, $this->closed);
+    }
+
+    public function assertHiddenCount(int $expected): void
+    {
+        PHPUnit::assertCount($expected, $this->hidden);
+    }
+
+    private function ensureForceReturnWindowsProvided(): void
+    {
+        Assert::notEmpty($this->forcedWindowReturnValues, 'No windows were provided to return');
+    }
+}
diff --git a/src/GlobalShortcut.php b/src/GlobalShortcut.php
index 991c3418..3859e6af 100644
--- a/src/GlobalShortcut.php
+++ b/src/GlobalShortcut.php
@@ -3,8 +3,9 @@
 namespace Native\Laravel;
 
 use Native\Laravel\Client\Client;
+use Native\Laravel\Contracts\GlobalShortcut as GlobalShortcutContract;
 
-class GlobalShortcut
+class GlobalShortcut implements GlobalShortcutContract
 {
     protected string $key;
 
diff --git a/src/Menu/Items/Checkbox.php b/src/Menu/Items/Checkbox.php
index 7482170b..baa44fc9 100644
--- a/src/Menu/Items/Checkbox.php
+++ b/src/Menu/Items/Checkbox.php
@@ -6,8 +6,9 @@ class Checkbox extends MenuItem
 {
     protected string $type = 'checkbox';
 
-    public function __construct(string $label, protected bool $isChecked = false, protected ?string $accelerator = null)
-    {
-        $this->label = $label;
-    }
+    public function __construct(
+        protected ?string $label,
+        protected bool $isChecked = false,
+        protected ?string $accelerator = null
+    ) {}
 }
diff --git a/src/Menu/Items/Event.php b/src/Menu/Items/Event.php
deleted file mode 100644
index 02af55ee..00000000
--- a/src/Menu/Items/Event.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace Native\Laravel\Menu\Items;
-
-class Event extends MenuItem
-{
-    public function __construct(protected string $event, protected ?string $label, protected ?string $accelerator = null) {}
-
-    public function toArray(): array
-    {
-        return array_merge(parent::toArray(), [
-            'type' => 'event',
-            'event' => $this->event,
-            'label' => $this->label,
-        ]);
-    }
-}
diff --git a/src/Menu/Items/Label.php b/src/Menu/Items/Label.php
index 571c5ae5..cd03d091 100644
--- a/src/Menu/Items/Label.php
+++ b/src/Menu/Items/Label.php
@@ -4,8 +4,8 @@
 
 class Label extends MenuItem
 {
-    public function __construct(string $label)
-    {
-        $this->label = $label;
-    }
+    public function __construct(
+        protected ?string $label,
+        protected ?string $accelerator = null
+    ) {}
 }
diff --git a/src/Menu/Items/Link.php b/src/Menu/Items/Link.php
index ec5a1cd7..25bc3c17 100644
--- a/src/Menu/Items/Link.php
+++ b/src/Menu/Items/Link.php
@@ -6,12 +6,26 @@ class Link extends MenuItem
 {
     protected string $type = 'link';
 
-    public function __construct(protected string $url, protected ?string $label, protected ?string $accelerator = null) {}
+    protected bool $openInBrowser = false;
+
+    public function __construct(
+        protected string $url,
+        protected ?string $label,
+        protected ?string $accelerator = null
+    ) {}
+
+    public function openInBrowser(bool $openInBrowser = true): self
+    {
+        $this->openInBrowser = $openInBrowser;
+
+        return $this;
+    }
 
     public function toArray(): array
     {
         return array_merge(parent::toArray(), [
             'url' => $this->url,
+            'openInBrowser' => $this->openInBrowser,
         ]);
     }
 }
diff --git a/src/Menu/Items/MenuItem.php b/src/Menu/Items/MenuItem.php
index 34d41ba0..7fe90517 100644
--- a/src/Menu/Items/MenuItem.php
+++ b/src/Menu/Items/MenuItem.php
@@ -3,11 +3,15 @@
 namespace Native\Laravel\Menu\Items;
 
 use Native\Laravel\Contracts\MenuItem as MenuItemContract;
+use Native\Laravel\Facades\Menu as MenuFacade;
+use Native\Laravel\Menu\Menu;
 
 abstract class MenuItem implements MenuItemContract
 {
     protected string $type = 'normal';
 
+    protected ?string $id = null;
+
     protected ?string $label = null;
 
     protected ?string $sublabel = null;
@@ -18,15 +22,33 @@ abstract class MenuItem implements MenuItemContract
 
     protected ?string $toolTip = null;
 
+    protected ?Menu $submenu = null;
+
     protected bool $isEnabled = true;
 
     protected bool $isVisible = true;
 
     protected bool $isChecked = false;
 
-    public function enabled($enabled = true): self
+    protected ?string $event = null;
+
+    public function enabled(): self
+    {
+        $this->isEnabled = true;
+
+        return $this;
+    }
+
+    public function disabled(): self
+    {
+        $this->isEnabled = false;
+
+        return $this;
+    }
+
+    public function id(string $id): self
     {
-        $this->isEnabled = $enabled;
+        $this->id = $id;
 
         return $this;
     }
@@ -66,6 +88,11 @@ public function accelerator(string $accelerator): self
         return $this;
     }
 
+    public function hotkey(string $hotkey): self
+    {
+        return $this->accelerator($hotkey);
+    }
+
     public function checked($checked = true): self
     {
         $this->isChecked = $checked;
@@ -73,18 +100,34 @@ public function checked($checked = true): self
         return $this;
     }
 
-    public function toolTip(string $toolTip): self
+    public function tooltip(string $toolTip): self
     {
         $this->toolTip = $toolTip;
 
         return $this;
     }
 
+    public function submenu(MenuItemContract ...$items): self
+    {
+        $this->submenu = MenuFacade::make(...$items);
+
+        return $this;
+    }
+
+    public function event(string $event): self
+    {
+        $this->event = $event;
+
+        return $this;
+    }
+
     public function toArray(): array
     {
         return array_filter([
             'type' => $this->type,
+            'id' => $this->id,
             'label' => $this->label,
+            'event' => $this->event,
             'sublabel' => $this->sublabel,
             'toolTip' => $this->toolTip,
             'enabled' => $this->isEnabled,
@@ -92,6 +135,7 @@ public function toArray(): array
             'checked' => $this->isChecked,
             'accelerator' => $this->accelerator,
             'icon' => $this->icon,
+            'submenu' => $this->submenu?->toArray(),
         ], fn ($value) => $value !== null);
     }
 }
diff --git a/src/Menu/Items/Radio.php b/src/Menu/Items/Radio.php
index 63587a2e..759af459 100644
--- a/src/Menu/Items/Radio.php
+++ b/src/Menu/Items/Radio.php
@@ -6,8 +6,9 @@ class Radio extends MenuItem
 {
     protected string $type = 'radio';
 
-    public function __construct(string $label)
-    {
-        $this->label = $label;
-    }
+    public function __construct(
+        protected ?string $label,
+        protected bool $isChecked = false,
+        protected ?string $accelerator = null
+    ) {}
 }
diff --git a/src/Menu/Items/Role.php b/src/Menu/Items/Role.php
index 3fa3b244..bde40a4a 100644
--- a/src/Menu/Items/Role.php
+++ b/src/Menu/Items/Role.php
@@ -8,7 +8,10 @@ class Role extends MenuItem
 {
     protected string $type = 'role';
 
-    public function __construct(protected RolesEnum $role, protected ?string $label = '') {}
+    public function __construct(
+        protected RolesEnum $role,
+        protected ?string $label = ''
+    ) {}
 
     public function toArray(): array
     {
diff --git a/src/Menu/Menu.php b/src/Menu/Menu.php
index 47a81b07..c97a30d7 100644
--- a/src/Menu/Menu.php
+++ b/src/Menu/Menu.php
@@ -3,31 +3,20 @@
 namespace Native\Laravel\Menu;
 
 use Illuminate\Support\Traits\Conditionable;
+use JsonSerializable;
 use Native\Laravel\Client\Client;
 use Native\Laravel\Contracts\MenuItem;
-use Native\Laravel\Enums\RolesEnum;
-use Native\Laravel\Menu\Items\Checkbox;
-use Native\Laravel\Menu\Items\Event;
-use Native\Laravel\Menu\Items\Label;
-use Native\Laravel\Menu\Items\Link;
-use Native\Laravel\Menu\Items\Role;
-use Native\Laravel\Menu\Items\Separator;
 
-class Menu implements MenuItem
+class Menu implements JsonSerializable, MenuItem
 {
     use Conditionable;
 
     protected array $items = [];
 
-    protected string $prepend = '';
+    protected string $label = '';
 
     public function __construct(protected Client $client) {}
 
-    public static function new(): static
-    {
-        return new static(new Client);
-    }
-
     public function register(): void
     {
         $items = $this->toArray()['submenu'];
@@ -37,81 +26,11 @@ public function register(): void
         ]);
     }
 
-    public function prepend(string $prepend): self
-    {
-        $this->prepend = $prepend;
-
-        return $this;
-    }
-
-    public function submenu(string $header, Menu $submenu): static
-    {
-        return $this->add($submenu->prepend($header));
-    }
-
-    public function separator(): static
-    {
-        return $this->add(new Separator);
-    }
-
-    public function quit(): static
-    {
-        return $this->add(new Role(RolesEnum::QUIT));
-    }
-
     public function label(string $label): self
     {
-        return $this->add(new Label($label));
-    }
-
-    public function checkbox(string $label, bool $checked = false, ?string $hotkey = null): self
-    {
-        return $this->add(new Checkbox($label, $checked, $hotkey));
-    }
-
-    public function event(string $event, string $text, ?string $hotkey = null): self
-    {
-        return $this->add(new Event($event, $text, $hotkey));
-    }
-
-    public function link(string $url, string $text, ?string $hotkey = null): self
-    {
-        return $this->add(new Link($url, $text, $hotkey));
-    }
+        $this->label = $label;
 
-    public function appMenu(): static
-    {
-        return $this->add(new Role(RolesEnum::APP_MENU));
-    }
-
-    public function fileMenu($label = 'File'): static
-    {
-        return $this->add(new Role(RolesEnum::FILE_MENU, $label));
-    }
-
-    public function editMenu($label = 'Edit'): static
-    {
-        return $this->add(new Role(RolesEnum::EDIT_MENU, $label));
-    }
-
-    public function viewMenu($label = 'View'): static
-    {
-        return $this->add(new Role(RolesEnum::VIEW_MENU, $label));
-    }
-
-    public function windowMenu($label = 'Window'): static
-    {
-        return $this->add(new Role(RolesEnum::WINDOW_MENU, $label));
-    }
-
-    public function toggleFullscreen(): static
-    {
-        return $this->add(new Role(RolesEnum::TOGGLE_FULL_SCREEN));
-    }
-
-    public function toggleDevTools(): static
-    {
-        return $this->add(new Role(RolesEnum::TOGGLE_DEV_TOOLS));
+        return $this;
     }
 
     public function add(MenuItem $item): self
@@ -123,12 +42,18 @@ public function add(MenuItem $item): self
 
     public function toArray(): array
     {
-        $items = collect($this->items)->map(fn (MenuItem $item) => $item->toArray())->toArray();
-        $label = $this->prepend;
+        $items = collect($this->items)
+            ->map(fn (MenuItem $item) => $item->toArray())
+            ->toArray();
 
         return [
-            'label' => $label,
+            'label' => $this->label,
             'submenu' => $items,
         ];
     }
+
+    public function jsonSerialize(): array
+    {
+        return $this->toArray();
+    }
 }
diff --git a/src/Menu/MenuBuilder.php b/src/Menu/MenuBuilder.php
new file mode 100644
index 00000000..f0627f78
--- /dev/null
+++ b/src/Menu/MenuBuilder.php
@@ -0,0 +1,170 @@
+<?php
+
+namespace Native\Laravel\Menu;
+
+use Native\Laravel\Client\Client;
+use Native\Laravel\Contracts\MenuItem;
+use Native\Laravel\Enums\RolesEnum;
+
+class MenuBuilder
+{
+    public function __construct(protected Client $client) {}
+
+    public function make(MenuItem ...$items): Menu
+    {
+        $menu = new Menu($this->client);
+
+        foreach ($items as $item) {
+            $menu->add($item);
+        }
+
+        return $menu;
+    }
+
+    public function create(MenuItem ...$items): void
+    {
+        $this->make(...$items)
+            ->register();
+    }
+
+    public function default(): void
+    {
+        $this->create(
+            $this->app(),
+            $this->file(),
+            $this->edit(),
+            $this->view(),
+            $this->window(),
+        );
+    }
+
+    public function label(string $label, ?string $hotkey = null): Items\Label
+    {
+        return new Items\Label($label, $hotkey);
+    }
+
+    public function checkbox(string $label, bool $checked = false, ?string $hotkey = null): Items\Checkbox
+    {
+        return new Items\Checkbox($label, $checked, $hotkey);
+    }
+
+    public function radio(string $label, bool $checked = false, ?string $hotkey = null): Items\Radio
+    {
+        return new Items\Radio($label, $checked, $hotkey);
+    }
+
+    public function link(string $url, ?string $label = null, ?string $hotkey = null): Items\Link
+    {
+        return new Items\Link($url, $label, $hotkey);
+    }
+
+    public function route(string $route, ?string $label = null, ?string $hotkey = null): Items\Link
+    {
+        return new Items\Link(route($route), $label, $hotkey);
+    }
+
+    public function app(): Items\Role
+    {
+        return new Items\Role(RolesEnum::APP_MENU);
+    }
+
+    public function file(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::FILE_MENU, $label);
+    }
+
+    public function edit(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::EDIT_MENU, $label);
+    }
+
+    public function view(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::VIEW_MENU, $label);
+    }
+
+    public function window(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::WINDOW_MENU, $label);
+    }
+
+    public function separator(): Items\Separator
+    {
+        return new Items\Separator;
+    }
+
+    public function fullscreen(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::TOGGLE_FULL_SCREEN, $label);
+    }
+
+    public function devTools(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::TOGGLE_DEV_TOOLS, $label);
+    }
+
+    public function undo(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::UNDO, $label);
+    }
+
+    public function redo(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::REDO, $label);
+    }
+
+    public function cut(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::CUT, $label);
+    }
+
+    public function copy(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::COPY, $label);
+    }
+
+    public function paste(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::PASTE, $label);
+    }
+
+    public function pasteAndMatchStyle(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::PASTE_STYLE, $label);
+    }
+
+    public function reload(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::RELOAD, $label);
+    }
+
+    public function minimize(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::MINIMIZE, $label);
+    }
+
+    public function close(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::CLOSE, $label);
+    }
+
+    public function quit(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::QUIT, $label);
+    }
+
+    public function help(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::HELP, $label);
+    }
+
+    public function hide(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::HIDE, $label);
+    }
+
+    public function about(?string $label = null): Items\Role
+    {
+        return new Items\Role(RolesEnum::ABOUT, $label);
+    }
+}
diff --git a/src/MenuBar/MenuBar.php b/src/MenuBar/MenuBar.php
index cfc2873f..13a57092 100644
--- a/src/MenuBar/MenuBar.php
+++ b/src/MenuBar/MenuBar.php
@@ -30,8 +30,6 @@ class MenuBar
 
     protected bool $alwaysOnTop = false;
 
-    protected ?string $event = null;
-
     protected bool $showDockIcon = false;
 
     protected Client $client;
@@ -97,13 +95,6 @@ public function alwaysOnTop($alwaysOnTop = true): self
         return $this;
     }
 
-    public function event(string $event): self
-    {
-        $this->event = $event;
-
-        return $this;
-    }
-
     public function withContextMenu(Menu $menu): self
     {
         $this->contextMenu = $menu;
@@ -131,7 +122,6 @@ public function toArray(): array
             'onlyShowContextMenu' => $this->onlyShowContextMenu,
             'contextMenu' => ! is_null($this->contextMenu) ? $this->contextMenu->toArray()['submenu'] : null,
             'alwaysOnTop' => $this->alwaysOnTop,
-            'event' => $this->event,
         ];
     }
 }
diff --git a/src/NativeServiceProvider.php b/src/NativeServiceProvider.php
index d9c28a1f..22e39913 100644
--- a/src/NativeServiceProvider.php
+++ b/src/NativeServiceProvider.php
@@ -3,18 +3,27 @@
 namespace Native\Laravel;
 
 use Illuminate\Console\Application;
+use Illuminate\Foundation\Application as Foundation;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\Artisan;
 use Illuminate\Support\Facades\DB;
+use Native\Laravel\ChildProcess as ChildProcessImplementation;
 use Native\Laravel\Commands\FreshCommand;
 use Native\Laravel\Commands\LoadPHPConfigurationCommand;
 use Native\Laravel\Commands\LoadStartupConfigurationCommand;
 use Native\Laravel\Commands\MigrateCommand;
 use Native\Laravel\Commands\MinifyApplicationCommand;
 use Native\Laravel\Commands\SeedDatabaseCommand;
+use Native\Laravel\Contracts\ChildProcess as ChildProcessContract;
+use Native\Laravel\Contracts\GlobalShortcut as GlobalShortcutContract;
+use Native\Laravel\Contracts\PowerMonitor as PowerMonitorContract;
+use Native\Laravel\Contracts\WindowManager as WindowManagerContract;
 use Native\Laravel\Events\EventWatcher;
 use Native\Laravel\Exceptions\Handler;
+use Native\Laravel\GlobalShortcut as GlobalShortcutImplementation;
 use Native\Laravel\Logging\LogWatcher;
+use Native\Laravel\PowerMonitor as PowerMonitorImplementation;
+use Native\Laravel\Windows\WindowManager as WindowManagerImplementation;
 use Spatie\LaravelPackageTools\Package;
 use Spatie\LaravelPackageTools\PackageServiceProvider;
 
@@ -40,6 +49,7 @@ public function packageRegistered()
         $this->mergeConfigFrom($this->package->basePath('/../config/nativephp-internal.php'), 'nativephp-internal');
 
         $this->app->singleton(FreshCommand::class, function ($app) {
+            /* @phpstan-ignore-next-line (beacause we support Laravel 10 & 11) */
             return new FreshCommand($app['migrator']);
         });
 
@@ -47,6 +57,22 @@ public function packageRegistered()
             return new MigrateCommand($app['migrator'], $app['events']);
         });
 
+        $this->app->bind(WindowManagerContract::class, function (Foundation $app) {
+            return $app->make(WindowManagerImplementation::class);
+        });
+
+        $this->app->bind(ChildProcessContract::class, function (Foundation $app) {
+            return $app->make(ChildProcessImplementation::class);
+        });
+
+        $this->app->bind(GlobalShortcutContract::class, function (Foundation $app) {
+            return $app->make(GlobalShortcutImplementation::class);
+        });
+
+        $this->app->bind(PowerMonitorContract::class, function (Foundation $app) {
+            return $app->make(PowerMonitorImplementation::class);
+        });
+
         if (config('nativephp-internal.running')) {
             $this->app->singleton(
                 \Illuminate\Contracts\Debug\ExceptionHandler::class,
@@ -65,6 +91,13 @@ public function packageRegistered()
         }
     }
 
+    public function bootingPackage()
+    {
+        if (config('nativephp-internal.running')) {
+            $this->rewriteDatabase();
+        }
+    }
+
     protected function configureApp()
     {
         if (config('app.debug')) {
@@ -75,8 +108,6 @@ protected function configureApp()
 
         $this->rewriteStoragePath();
 
-        $this->rewriteDatabase();
-
         $this->configureDisks();
 
         config(['session.driver' => 'file']);
@@ -118,13 +149,15 @@ public function rewriteDatabase()
             }
         }
 
-        config(['database.connections.nativephp' => [
-            'driver' => 'sqlite',
-            'url' => env('DATABASE_URL'),
-            'database' => $databasePath,
-            'prefix' => '',
-            'foreign_key_constraints' => env('DB_FOREIGN_KEYS', true),
-        ]]);
+        config([
+            'database.connections.nativephp' => [
+                'driver' => 'sqlite',
+                'url' => env('DATABASE_URL'),
+                'database' => $databasePath,
+                'prefix' => '',
+                'foreign_key_constraints' => env('DB_FOREIGN_KEYS', true),
+            ],
+        ]);
 
         config(['database.default' => 'nativephp']);
 
@@ -144,7 +177,7 @@ public function removeDatabase()
 
         @unlink($databasePath);
         @unlink($databasePath.'-shm');
-        @unlink($database.'-wal');
+        @unlink($databasePath.'-wal');
     }
 
     protected function configureDisks(): void
@@ -167,12 +200,14 @@ protected function configureDisks(): void
                 continue;
             }
 
-            config(['filesystems.disks.'.$disk => [
-                'driver' => 'local',
-                'root' => env($env, ''),
-                'throw' => false,
-                'links' => 'skip',
-            ]]);
+            config([
+                'filesystems.disks.'.$disk => [
+                    'driver' => 'local',
+                    'root' => env($env, ''),
+                    'throw' => false,
+                    'links' => 'skip',
+                ],
+            ]);
         }
     }
 }
diff --git a/src/Notification.php b/src/Notification.php
index 85c7a73a..82d13d82 100644
--- a/src/Notification.php
+++ b/src/Notification.php
@@ -12,7 +12,7 @@ class Notification
 
     protected string $event = '';
 
-    public function __construct(protected Client $client) {}
+    final public function __construct(protected Client $client) {}
 
     public static function new()
     {
diff --git a/src/PowerMonitor.php b/src/PowerMonitor.php
index ea0d587c..c0307b11 100644
--- a/src/PowerMonitor.php
+++ b/src/PowerMonitor.php
@@ -3,10 +3,11 @@
 namespace Native\Laravel;
 
 use Native\Laravel\Client\Client;
+use Native\Laravel\Contracts\PowerMonitor as PowerMonitorContract;
 use Native\Laravel\Enums\SystemIdleStatesEnum;
 use Native\Laravel\Enums\ThermalStatesEnum;
 
-class PowerMonitor
+class PowerMonitor implements PowerMonitorContract
 {
     public function __construct(protected Client $client) {}
 
diff --git a/src/ProgressBar.php b/src/ProgressBar.php
index 74ca9d70..c9e318f8 100644
--- a/src/ProgressBar.php
+++ b/src/ProgressBar.php
@@ -16,7 +16,7 @@ class ProgressBar
 
     protected float $maxSecondsBetweenRedraws = 1;
 
-    public function __construct(protected int $maxSteps, protected Client $client) {}
+    final public function __construct(protected int $maxSteps, protected Client $client) {}
 
     public static function create(int $maxSteps): static
     {
diff --git a/src/Settings.php b/src/Settings.php
index 68e65b57..e849c729 100644
--- a/src/Settings.php
+++ b/src/Settings.php
@@ -8,15 +8,25 @@ class Settings
 {
     public function __construct(protected Client $client) {}
 
-    public function set($key, $value): void
+    public function set(string $key, $value): void
     {
         $this->client->post('settings/'.$key, [
             'value' => $value,
         ]);
     }
 
-    public function get($key, $default = null): mixed
+    public function get(string $key, $default = null): mixed
     {
         return $this->client->get('settings/'.$key)->json('value') ?? $default;
     }
+
+    public function forget(string $key): void
+    {
+        $this->client->delete('settings/'.$key);
+    }
+
+    public function clear(): void
+    {
+        $this->client->delete('settings/');
+    }
 }
diff --git a/src/Windows/WindowManager.php b/src/Windows/WindowManager.php
index 49574e61..64046869 100644
--- a/src/Windows/WindowManager.php
+++ b/src/Windows/WindowManager.php
@@ -4,8 +4,9 @@
 
 use Native\Laravel\Client\Client;
 use Native\Laravel\Concerns\DetectsWindowId;
+use Native\Laravel\Contracts\WindowManager as WindowManagerContract;
 
-class WindowManager
+class WindowManager implements WindowManagerContract
 {
     use DetectsWindowId;
 
diff --git a/tests/Fakes/FakeChildProcessTest.php b/tests/Fakes/FakeChildProcessTest.php
new file mode 100644
index 00000000..57b0c354
--- /dev/null
+++ b/tests/Fakes/FakeChildProcessTest.php
@@ -0,0 +1,217 @@
+<?php
+
+use Native\Laravel\Contracts\ChildProcess as ChildProcessContract;
+use Native\Laravel\Facades\ChildProcess;
+use Native\Laravel\Fakes\ChildProcessFake;
+use PHPUnit\Framework\AssertionFailedError;
+
+use function Pest\Laravel\swap;
+
+it('swaps implementations using facade', function () {
+    ChildProcess::fake();
+
+    expect(app(ChildProcessContract::class))->toBeInstanceOf(ChildProcessFake::class);
+});
+
+it('asserts get using string', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->get('testA');
+    $fake->get('testB');
+
+    $fake->assertGet('testA');
+    $fake->assertGet('testB');
+
+    try {
+        $fake->assertGet('testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts get using callable', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->get('testA');
+    $fake->get('testB');
+
+    $fake->assertGet(fn (string $alias) => $alias === 'testA');
+    $fake->assertGet(fn (string $alias) => $alias === 'testB');
+
+    try {
+        $fake->assertGet(fn (string $alias) => $alias === 'testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts started using callable', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->start('cmdA', 'aliasA', 'cwdA', ['envA'], true);
+    $fake->start('cmdB', 'aliasB', 'cwdB', ['envB'], false);
+
+    $fake->assertStarted(fn ($cmd, $alias, $cwd, $env, $persistent) => $alias === 'aliasA' &&
+        $cmd === 'cmdA' &&
+        $cwd === 'cwdA' &&
+        $env === ['envA'] &&
+        $persistent === true);
+
+    $fake->assertStarted(fn ($cmd, $alias, $cwd, $env, $persistent) => $alias === 'aliasB' &&
+        $cmd === 'cmdB' &&
+        $cwd === 'cwdB' &&
+        $env === ['envB'] &&
+        $persistent === false);
+
+    try {
+        $fake->assertStarted(fn ($cmd, $alias, $cwd, $env, $persistent) => $alias === 'aliasC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts php using callable', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->php('cmdA', 'aliasA', ['envA'], true);
+    $fake->php('cmdB', 'aliasB', ['envB'], false);
+
+    $fake->assertPhp(fn ($cmd, $alias, $env, $persistent) => $alias === 'aliasA' &&
+        $cmd === 'cmdA' &&
+        $env === ['envA'] &&
+        $persistent === true);
+
+    $fake->assertPhp(fn ($cmd, $alias, $env, $persistent) => $alias === 'aliasB' &&
+        $cmd === 'cmdB' &&
+        $env === ['envB'] &&
+        $persistent === false);
+
+    try {
+        $fake->assertPhp(fn ($cmd, $alias, $env, $persistent) => $alias === 'aliasC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts artisan using callable', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->artisan('cmdA', 'aliasA', ['envA'], true);
+    $fake->artisan('cmdB', 'aliasB', ['envB'], false);
+
+    $fake->assertArtisan(fn ($cmd, $alias, $env, $persistent) => $alias === 'aliasA' &&
+        $cmd === 'cmdA' &&
+        $env === ['envA'] &&
+        $persistent === true);
+
+    $fake->assertArtisan(fn ($cmd, $alias, $env, $persistent) => $alias === 'aliasB' &&
+        $cmd === 'cmdB' &&
+        $env === ['envB'] &&
+        $persistent === false);
+
+    try {
+        $fake->assertArtisan(fn ($cmd, $alias, $env, $persistent) => $alias === 'aliasC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts stop using string', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->stop('testA');
+    $fake->stop('testB');
+
+    $fake->assertStop('testA');
+    $fake->assertStop('testB');
+
+    try {
+        $fake->assertStop('testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts stop using callable', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->stop('testA');
+    $fake->stop('testB');
+
+    $fake->assertStop(fn (string $alias) => $alias === 'testA');
+    $fake->assertStop(fn (string $alias) => $alias === 'testB');
+
+    try {
+        $fake->assertStop(fn (string $alias) => $alias === 'testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts restart using string', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->restart('testA');
+    $fake->restart('testB');
+
+    $fake->assertRestart('testA');
+    $fake->assertRestart('testB');
+
+    try {
+        $fake->assertRestart('testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts restart using callable', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->restart('testA');
+    $fake->restart('testB');
+
+    $fake->assertRestart(fn (string $alias) => $alias === 'testA');
+    $fake->assertRestart(fn (string $alias) => $alias === 'testB');
+
+    try {
+        $fake->assertRestart(fn (string $alias) => $alias === 'testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts message using callable', function () {
+    swap(ChildProcessContract::class, $fake = app(ChildProcessFake::class));
+
+    $fake->message('messageA', 'aliasA');
+    $fake->message('messageB', 'aliasB');
+
+    $fake->assertMessage(fn (string $message, string $alias) => $message === 'messageA' && $alias === 'aliasA');
+    $fake->assertMessage(fn (string $message, string $alias) => $message === 'messageB' && $alias === 'aliasB');
+
+    try {
+        $fake->assertMessage(fn (string $message, string $alias) => $message === 'messageC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
diff --git a/tests/Fakes/FakeGlobalShortcutTest.php b/tests/Fakes/FakeGlobalShortcutTest.php
new file mode 100644
index 00000000..0847cb97
--- /dev/null
+++ b/tests/Fakes/FakeGlobalShortcutTest.php
@@ -0,0 +1,122 @@
+<?php
+
+use Native\Laravel\Contracts\GlobalShortcut as GlobalShortcutContract;
+use Native\Laravel\Facades\GlobalShortcut;
+use Native\Laravel\Fakes\GlobalShortcutFake;
+use PHPUnit\Framework\AssertionFailedError;
+
+use function Pest\Laravel\swap;
+
+it('swaps implementations using facade', function () {
+    GlobalShortcut::fake();
+
+    expect(app(GlobalShortcutContract::class))->toBeInstanceOf(GlobalShortcutFake::class);
+});
+
+it('asserts key using string', function () {
+    swap(GlobalShortcutContract::class, $fake = app(GlobalShortcutFake::class));
+
+    $fake->key('testA');
+    $fake->key('testB');
+
+    $fake->assertKey('testA');
+    $fake->assertKey('testB');
+
+    try {
+        $fake->assertKey('testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts key using callable', function () {
+    swap(GlobalShortcutContract::class, $fake = app(GlobalShortcutFake::class));
+
+    $fake->key('testA');
+    $fake->key('testB');
+
+    $fake->assertKey(fn (string $key) => $key === 'testA');
+    $fake->assertKey(fn (string $key) => $key === 'testB');
+
+    try {
+        $fake->assertKey(fn (string $key) => $key === 'testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts event using string', function () {
+    swap(GlobalShortcutContract::class, $fake = app(GlobalShortcutFake::class));
+
+    $fake->event('testA');
+    $fake->event('testB');
+
+    $fake->assertEvent('testA');
+    $fake->assertEvent('testB');
+
+    try {
+        $fake->assertEvent('testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts event using callable', function () {
+    swap(GlobalShortcutContract::class, $fake = app(GlobalShortcutFake::class));
+
+    $fake->event('testA');
+    $fake->event('testB');
+
+    $fake->assertEvent(fn (string $event) => $event === 'testA');
+    $fake->assertEvent(fn (string $event) => $event === 'testB');
+
+    try {
+        $fake->assertEvent(fn (string $event) => $event === 'testC');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts registered count', function () {
+    swap(GlobalShortcutContract::class, $fake = app(GlobalShortcutFake::class));
+
+    $fake->register();
+    $fake->register();
+    $fake->register();
+
+    $fake->assertRegisteredCount(3);
+
+    try {
+        $fake->assertRegisteredCount(2);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts unregistered count', function () {
+    swap(GlobalShortcutContract::class, $fake = app(GlobalShortcutFake::class));
+
+    $fake->unregister();
+    $fake->unregister();
+    $fake->unregister();
+
+    $fake->assertUnregisteredCount(3);
+
+    try {
+        $fake->assertUnregisteredCount(2);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
diff --git a/tests/Fakes/FakePowerMonitorTest.php b/tests/Fakes/FakePowerMonitorTest.php
new file mode 100644
index 00000000..4761877c
--- /dev/null
+++ b/tests/Fakes/FakePowerMonitorTest.php
@@ -0,0 +1,123 @@
+<?php
+
+use Native\Laravel\Contracts\PowerMonitor as PowerMonitorContract;
+use Native\Laravel\Facades\PowerMonitor;
+use Native\Laravel\Fakes\PowerMonitorFake;
+use PHPUnit\Framework\AssertionFailedError;
+
+use function Pest\Laravel\swap;
+
+it('swaps implementations using facade', function () {
+    PowerMonitor::fake();
+
+    expect(app(PowerMonitorContract::class))
+        ->toBeInstanceOf(PowerMonitorFake::class);
+});
+
+it('asserts getSystemIdleState using int', function () {
+    swap(PowerMonitorContract::class, $fake = app(PowerMonitorFake::class));
+
+    $fake->getSystemIdleState(10);
+    $fake->getSystemIdleState(60);
+
+    $fake->assertGetSystemIdleState(10);
+    $fake->assertGetSystemIdleState(60);
+
+    try {
+        $fake->assertGetSystemIdleState(20);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts getSystemIdleState using callable', function () {
+    swap(PowerMonitorContract::class, $fake = app(PowerMonitorFake::class));
+
+    $fake->getSystemIdleState(10);
+    $fake->getSystemIdleState(60);
+
+    $fake->assertGetSystemIdleState(fn (int $key) => $key === 10);
+    $fake->assertGetSystemIdleState(fn (int $key) => $key === 60);
+
+    try {
+        $fake->assertGetSystemIdleState(fn (int $key) => $key === 20);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts getSystemIdleState count', function () {
+    swap(PowerMonitorContract::class, $fake = app(PowerMonitorFake::class));
+
+    $fake->getSystemIdleState(10);
+    $fake->getSystemIdleState(20);
+    $fake->getSystemIdleState(60);
+
+    $fake->assertGetSystemIdleStateCount(3);
+
+    try {
+        $fake->assertGetSystemIdleStateCount(2);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts getSystemIdleTime count', function () {
+    swap(PowerMonitorContract::class, $fake = app(PowerMonitorFake::class));
+
+    $fake->getSystemIdleTime();
+    $fake->getSystemIdleTime();
+    $fake->getSystemIdleTime();
+
+    $fake->assertGetSystemIdleTimeCount(3);
+
+    try {
+        $fake->assertGetSystemIdleTimeCount(2);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts getCurrentThermalState count', function () {
+    swap(PowerMonitorContract::class, $fake = app(PowerMonitorFake::class));
+
+    $fake->getCurrentThermalState();
+    $fake->getCurrentThermalState();
+    $fake->getCurrentThermalState();
+
+    $fake->assertGetCurrentThermalStateCount(3);
+
+    try {
+        $fake->assertGetCurrentThermalStateCount(2);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts isOnBatteryPower count', function () {
+    swap(PowerMonitorContract::class, $fake = app(PowerMonitorFake::class));
+
+    $fake->isOnBatteryPower();
+    $fake->isOnBatteryPower();
+    $fake->isOnBatteryPower();
+
+    $fake->assertIsOnBatteryPowerCount(3);
+
+    try {
+        $fake->assertIsOnBatteryPowerCount(2);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
diff --git a/tests/Fakes/FakeWindowManagerTest.php b/tests/Fakes/FakeWindowManagerTest.php
new file mode 100644
index 00000000..b2f4af25
--- /dev/null
+++ b/tests/Fakes/FakeWindowManagerTest.php
@@ -0,0 +1,317 @@
+<?php
+
+use Illuminate\Support\Facades\Http;
+use Native\Laravel\Contracts\WindowManager as WindowManagerContract;
+use Native\Laravel\Facades\Window;
+use Native\Laravel\Fakes\WindowManagerFake;
+use Native\Laravel\Windows\PendingOpenWindow;
+use Native\Laravel\Windows\Window as WindowClass;
+use PHPUnit\Framework\AssertionFailedError;
+use Webmozart\Assert\InvalidArgumentException;
+
+use function Pest\Laravel\swap;
+
+it('swaps implementations using facade', function () {
+    Window::fake();
+
+    expect(app(WindowManagerContract::class))->toBeInstanceOf(WindowManagerFake::class);
+});
+
+it('asserts that a window was opened', function () {
+    Http::fake(['*' => Http::response(status: 200)]);
+
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows([
+        new PendingOpenWindow('doesnt-matter'),
+    ]);
+    app(WindowManagerContract::class)->open('main');
+    app(WindowManagerContract::class)->open('secondary');
+
+    $fake->assertOpened('main');
+    $fake->assertOpened('secondary');
+
+    try {
+        $fake->assertOpened('tertiary');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts that a window was opened using callable', function () {
+    Http::fake(['*' => Http::response(status: 200)]);
+
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows([
+        new PendingOpenWindow('doesnt-matter'),
+    ]);
+
+    app(WindowManagerContract::class)->open('main');
+    app(WindowManagerContract::class)->open('secondary');
+
+    $fake->assertOpened(fn (string $id) => $id === 'main');
+    $fake->assertOpened(fn (string $id) => $id === 'secondary');
+
+    try {
+        $fake->assertOpened(fn (string $id) => $id === 'tertiary');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts that a window was closed', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->close('main');
+    app(WindowManagerContract::class)->close('secondary');
+
+    $fake->assertClosed('main');
+    $fake->assertClosed('secondary');
+
+    try {
+        $fake->assertClosed('tertiary');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts that a window was closed using callable', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->close('main');
+    app(WindowManagerContract::class)->close('secondary');
+
+    $fake->assertClosed(fn (string $id) => $id === 'main');
+    $fake->assertClosed(fn (string $id) => $id === 'secondary');
+
+    try {
+        $fake->assertClosed(fn (string $id) => $id === 'tertiary');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts that a window was hidden', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->hide('main');
+    app(WindowManagerContract::class)->hide('secondary');
+
+    $fake->assertHidden('main');
+    $fake->assertHidden('secondary');
+
+    try {
+        $fake->assertHidden('tertiary');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts that a window was hidden using callable', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->hide('main');
+    app(WindowManagerContract::class)->hide('secondary');
+
+    $fake->assertHidden(fn (string $id) => $id === 'main');
+    $fake->assertHidden(fn (string $id) => $id === 'secondary');
+
+    try {
+        $fake->assertHidden(fn (string $id) => $id === 'tertiary');
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts opened count', function () {
+    Http::fake(['*' => Http::response(status: 200)]);
+
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows([
+        new PendingOpenWindow('doesnt-matter'),
+    ]);
+
+    app(WindowManagerContract::class)->open('main');
+    app(WindowManagerContract::class)->open();
+    app(WindowManagerContract::class)->open();
+
+    $fake->assertOpenedCount(3);
+
+    try {
+        $fake->assertOpenedCount(4);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts closed count', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->close('main');
+    app(WindowManagerContract::class)->close();
+    app(WindowManagerContract::class)->close();
+
+    $fake->assertClosedCount(3);
+
+    try {
+        $fake->assertClosedCount(4);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('asserts hidden count', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->hide('main');
+    app(WindowManagerContract::class)->hide();
+    app(WindowManagerContract::class)->hide();
+
+    $fake->assertHiddenCount(3);
+
+    try {
+        $fake->assertHiddenCount(4);
+    } catch (AssertionFailedError) {
+        return;
+    }
+
+    $this->fail('Expected assertion to fail');
+});
+
+it('forces the return value of current window', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new WindowClass('testA'),
+        new WindowClass('testB'),
+    ]);
+
+    expect($windows)->toContain(app(WindowManagerContract::class)->current());
+});
+
+it('forces the return value of all windows', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new WindowClass('testA'),
+        new WindowClass('testB'),
+    ]);
+
+    expect(app(WindowManagerContract::class)->all())->toBe($windows);
+});
+
+it('forces the return value of a specific window', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new WindowClass('testA'),
+        new WindowClass('testB'),
+    ]);
+
+    expect(app(WindowManagerContract::class)->get('testA'))->toBe($windows[0]);
+    expect(app(WindowManagerContract::class)->get('testB'))->toBe($windows[1]);
+});
+
+test('that the get method throws an exception if multiple matching window ids exist', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new WindowClass('testA'),
+        new WindowClass('testA'),
+    ]);
+
+    app(WindowManagerContract::class)->get('testA');
+})->throws(InvalidArgumentException::class);
+
+test('that the get method throws an exception if no matching window id exists', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new WindowClass('testA'),
+    ]);
+
+    app(WindowManagerContract::class)->get('testB');
+})->throws(InvalidArgumentException::class);
+
+test('that the current method throws an exception if no forced window return values are provided', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->current();
+})->throws(InvalidArgumentException::class);
+
+test('that the all method throws an exception if no forced window return values are provided', function () {
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->all();
+})->throws(InvalidArgumentException::class);
+
+test('that the open method throws an exception if no forced window return values are provided', function () {
+    Http::fake([
+        '*' => Http::response(status: 200),
+    ]);
+
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    app(WindowManagerContract::class)->open('test');
+})->throws(InvalidArgumentException::class);
+
+test('that the open method throws an exception if multiple matching window ids exist', function () {
+    Http::fake([
+        '*' => Http::response(status: 200),
+    ]);
+
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new WindowClass('testA'),
+        new WindowClass('testA'),
+    ]);
+
+    app(WindowManagerContract::class)->open('testA');
+})->throws(InvalidArgumentException::class);
+
+test('that the open method returns a random window if none match the id provided', function () {
+    Http::fake([
+        '*' => Http::response(status: 200),
+    ]);
+
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new PendingOpenWindow('testA'),
+    ]);
+
+    expect($windows)->toContain(app(WindowManagerContract::class)->open('testC'));
+});
+
+test('that the open method returns a window if a matching window id exists', function () {
+    Http::fake([
+        '*' => Http::response(status: 200),
+    ]);
+
+    swap(WindowManagerContract::class, $fake = app(WindowManagerFake::class));
+
+    $fake->alwaysReturnWindows($windows = [
+        new PendingOpenWindow('testA'),
+    ]);
+
+    expect(app(WindowManagerContract::class)->open('testA'))->toBe($windows[0]);
+});
diff --git a/tests/MenuBar/MenuBarTest.php b/tests/MenuBar/MenuBarTest.php
index ec1c022d..4b86aa95 100644
--- a/tests/MenuBar/MenuBarTest.php
+++ b/tests/MenuBar/MenuBarTest.php
@@ -1,7 +1,7 @@
 <?php
 
+use Native\Laravel\Facades\Menu;
 use Native\Laravel\Facades\MenuBar;
-use Native\Laravel\Menu\Menu;
 
 it('menubar with create', function () {
     config()->set('nativephp-internal.api_url', 'https://jsonplaceholder.typicode.com/todos/1');
@@ -13,7 +13,10 @@
         ->icon('nativephp.png')
         ->url('https://github.com/milwad-dev')
         ->withContextMenu(
-            Menu::new()->label('My Application')->quit(),
+            Menu::make(
+                Menu::label('My Application'),
+                Menu::quit(),
+            ),
         );
     $menuBarArray = $menuBar->toArray();