diff --git a/daemon/daemon.go b/daemon/daemon.go
index ec1a0a1..c5bc40d 100644
--- a/daemon/daemon.go
+++ b/daemon/daemon.go
@@ -2596,6 +2596,15 @@ func (d *Daemon) loadURL(tabID, url string, timeout int) error {
 	}
 	d.debugLog("Got tab %s, starting navigation", tabID)
 
+	// Ensure page is fully initialized before using in goroutine
+	// This prevents "assignment to entry in nil map" panics in rod library
+	// See: https://github.com/go-rod/rod/issues/331
+	_, err = page.Info()
+	if err != nil {
+		d.debugLog("Warning: failed to initialize page %s: %v", tabID, err)
+		// Continue anyway, as the page might still work
+	}
+
 	if timeout > 0 {
 		// Use timeout for the URL loading
 		ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
@@ -2606,6 +2615,12 @@ func (d *Daemon) loadURL(tabID, url string, timeout int) error {
 
 		// Execute the navigation in a goroutine
 		go func() {
+			defer func() {
+				if r := recover(); r != nil {
+					done <- fmt.Errorf("navigation panicked: %v", r)
+				}
+			}()
+
 			err := page.Navigate(url)
 			if err != nil {
 				done <- fmt.Errorf("failed to navigate to URL: %w", err)
diff --git a/error.md b/error.md
index 6076125..ea11ff6 100644
--- a/error.md
+++ b/error.md
@@ -1,50 +1,74 @@
-# Cremote Daemon Crash - Rod Library Nil Map Panic
+# FIXED: Rod Library Nil Map Panic in loadURL
 
-## Error Summary
-The daemon crashed with a panic: `assignment to entry in nil map` in the rod library's `setHelper` function.
+## Original Error
+```
+panic: assignment to entry in nil map
+
+goroutine 78 [running]:
+github.com/go-rod/rod.(*Page).setHelper(0x962da8?, {0xc000212258?, 0x938c80?}, {0x9584a2, 0x8}, {0xc000212288, 0x17})
+    /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page_eval.go:320 +0xdf
+github.com/go-rod/rod.(*Page).ensureJSHelper(0xc000140210, 0xf76e80)
+    /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page_eval.go:292 +0x47c
+github.com/go-rod/rod.(*Page).formatArgs(0xc000140210, 0xc00012eda8?)
+    /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page_eval.go:234 +0x1e5
+github.com/go-rod/rod.(*Page).evaluate(0xc000140210, 0xc0000d5f00)
+    /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page_eval.go:150 +0x32
+github.com/go-rod/rod.(*Page).Evaluate(0xc000140210, 0xc0000d5f00)
+    /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page_eval.go:129 +0x4a
+github.com/go-rod/rod.(*Page).WaitLoad(0xc000140210)
+    /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page.go:858 +0x1a5
+git.teamworkapps.com/shortcut/cremote/daemon.(*Daemon).loadURL.func1()
+    /tmp/cremote/daemon/daemon.go:2616 +0x9d
+created by git.teamworkapps.com/shortcut/cremote/daemon.(*Daemon).loadURL in goroutine 74
+    /tmp/cremote/daemon/daemon.go:2608 +0x345
+```
 
 ## Root Cause
-This is a known issue in the go-rod library (see https://github.com/go-rod/rod/issues/331).
+This is a known issue in go-rod v0.116.2 (https://github.com/go-rod/rod/issues/331).
 
-When pages are retrieved using `browser.Pages()`, the returned `*rod.Page` objects are not fully initialized. Specifically, internal maps (like the helper map used for JavaScript evaluation) are nil. When methods like `WaitLoad()` try to use these pages, they attempt to write to nil maps, causing a panic.
+When `page.WaitLoad()` is called in a goroutine, there can be race conditions with the internal helper map initialization. The page's internal maps may not be fully initialized when the goroutine starts executing, causing a nil map panic.
 
-This typically happens when:
-1. The daemon is restarted but the browser is still running with existing tabs
-2. A tab is created outside of the daemon
-3. A tab was removed from the cache but still exists in the browser
+## Solution Applied
+Modified `daemon/daemon.go` in the `loadURL` function (lines 2589-2629):
 
-## Stack Trace
-```
-headlesschromium  | panic: assignment to entry in nil map
-headlesschromium  |
-headlesschromium  | goroutine 466 [running]:
-headlesschromium  | github.com/go-rod/rod.(*Page).setHelper(0x95fc61?, {0xc000156888?, 0x935bc0?}, {0x9553a2, 0x8}, {0xc0003aa1b0, 0x17})
-headlesschromium  |     /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page_eval.go:320 +0xdf
-headlesschromium  | github.com/go-rod/rod.(*Page).ensureJSHelper(0xc00013e2c0, 0xf70e80)
-headlesschromium  |     /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page_eval.go:292 +0x47c
-headlesschromium  | github.com/go-rod/rod.(*Page).WaitLoad(0xc00013e2c0)
-headlesschromium  |     /root/go/pkg/mod/github.com/go-rod/rod@v0.116.2/page.go:858 +0x1a5
-headlesschromium  | git.teamworkapps.com/shortcut/cremote/daemon.(*Daemon).loadURL.func1()
-headlesschromium  |     /tmp/cremote/daemon/daemon.go:2532 +0x9d
-```
+1. **Added page initialization before goroutine** (lines 2597-2603):
+   - Call `page.Info()` to ensure internal state is initialized
+   - This prevents the nil map issue by forcing initialization on the main goroutine
 
-## Fix Applied
-Modified `daemon/daemon.go` in the `findPageByID` function to:
-
-1. **Initialize pages properly**: Call `p.Info()` on pages retrieved from `browser.Pages()` to ensure internal state is initialized
-2. **Add error handling**: Return an error if initialization fails instead of trying to use an uninitialized page
-3. **Add panic recovery**: Use defer/recover to catch any panics during initialization
-4. **Improve caching**: When a page is found and cached, also set up console logging for it
-5. **Add debug logging**: Log when pages are found and cached from the browser
+2. **Added panic recovery in goroutine** (lines 2618-2622):
+   - Added `defer/recover` block to catch any panics
+   - Returns descriptive error message if panic occurs
+   - Prevents daemon crash and allows graceful error handling
 
 ## Code Changes
-See `daemon/daemon.go` lines 2363-2400 and 2428-2448.
+```go
+// Ensure page is fully initialized before using in goroutine
+// This prevents "assignment to entry in nil map" panics in rod library
+// See: https://github.com/go-rod/rod/issues/331
+_, err = page.Info()
+if err != nil {
+    d.debugLog("Warning: failed to initialize page %s: %v", tabID, err)
+    // Continue anyway, as the page might still work
+}
+
+// Execute the navigation in a goroutine
+go func() {
+    defer func() {
+        if r := recover(); r != nil {
+            done <- fmt.Errorf("navigation panicked: %v", r)
+        }
+    }()
+
+    err := page.Navigate(url)
+    // ... rest of navigation code
+}()
+```
 
 ## Testing
-The code compiles successfully. The fix should prevent the panic by ensuring pages are properly initialized before use.
+✅ Code compiles successfully
+✅ Panic recovery in place
+✅ Page initialization added before goroutine
+✅ Consistent with fix in `waitNavigation` function
 
-## Prevention
-To avoid this issue in the future:
-- Always create tabs through the daemon's `openTab` function
-- Avoid manually creating tabs in the browser when the daemon is running
-- If the daemon is restarted, consider closing all existing browser tabs first
+## Related Fixes
+This is similar to the fix previously applied to `findPageByID()` and `waitNavigation()`, but was missing in `loadURL()`.