browser-use 0.6.1 → 0.7.1

package/dist/browser/session.js

@@ -35,9 +35,48 @@ const execFileAsync = promisify(execFile);
 const PLAYWRIGHT_OPTION_KEY_OVERRIDES = {
     extra_http_headers: 'extraHTTPHeaders',
 };
+const DOMAIN_POLICY_UNFILTERABLE_RECORDING_KEYS = new Set([
+    'record_video_dir',
+    'record_video_size',
+    'record_video',
+    'recordVideo',
+]);
 const EMPTY_DOM_RETRY_DELAY_MS = 250;
 const REMOTE_RECONNECT_DELAYS_MS = [1000, 2000, 4000];
 const REMOTE_RECONNECT_ATTEMPT_TIMEOUT_MS = 15_000;
+const chmodPrivateStorageFile = (filePath) => {
+    if (process.platform === 'win32') {
+        return;
+    }
+    fs.chmodSync(filePath, 0o600);
+};
+const writePrivateStorageFile = (filePath, contents) => {
+    fs.writeFileSync(filePath, contents, { encoding: 'utf-8', mode: 0o600 });
+    chmodPrivateStorageFile(filePath);
+};
+const chmodPrivateFileBestEffort = (filePath) => {
+    if (process.platform === 'win32') {
+        return;
+    }
+    try {
+        fs.chmodSync(filePath, 0o600);
+    }
+    catch {
+        /* best effort */
+    }
+};
+const ensurePrivateDirectoryIfCreated = (dirPath) => {
+    const existed = fs.existsSync(dirPath);
+    fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+    if (!existed && process.platform !== 'win32') {
+        try {
+            fs.chmodSync(dirPath, 0o700);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+};
 const cloneBrowserProfileConfig = (profile) => typeof structuredClone === 'function'
     ? structuredClone(profile.config)
     : JSON.parse(JSON.stringify(profile.config));
@@ -220,6 +259,8 @@ export class BrowserSession {
     _watchdogs = new Set();
     _defaultWatchdogsAttached = false;
     _captchaWatchdog = null;
+    _scopedExtraHeadersRouteContext = null;
+    _scopedExtraHeadersRouteHandler = null;
     RECONNECT_WAIT_TIMEOUT = 54;
     _reconnecting = false;
     _reconnectTask = null;
@@ -548,7 +589,10 @@ export class BrowserSession {
                 // Check response size (if available)
                 const contentLength = headers['content-length'] || headers['Content-Length'];
                 if (contentLength && parseInt(contentLength, 10) > maxResponseSize) {
-                    this.logger.debug(`Skipping large response (${contentLength} bytes): ${request.url?.().substring?.(0, 50) ?? ''}`);
+                    const requestUrl = typeof request?.url === 'function'
+                        ? request.url()
+                        : String(request?.url ?? '');
+                    this.logger.debug(`Skipping large response (${contentLength} bytes): ${BrowserSession._redact_url_for_logging(requestUrl)}`);
                     pendingRequests.delete(request);
                     return;
                 }
@@ -737,11 +781,11 @@ export class BrowserSession {
             timestamp: new Date().toISOString(),
         };
         if (typeof details.url === 'string' && details.url.trim()) {
-            event.url = details.url.trim();
+            event.url = BrowserSession._redact_url_for_logging(details.url.trim());
         }
         if (typeof details.error_message === 'string' &&
             details.error_message.trim()) {
-            event.error_message = details.error_message.trim();
+            event.error_message = BrowserSession._redact_urls_in_text(details.error_message.trim());
         }
         if (typeof details.page_id === 'number' &&
             Number.isFinite(details.page_id)) {
@@ -813,6 +857,7 @@ export class BrowserSession {
         if (!page || typeof page.evaluate !== 'function') {
             return [];
         }
+        await this.validate_page_after_action(page);
         try {
             const pending = await page.evaluate(() => {
                 const perf = window.performance;
@@ -897,6 +942,9 @@ export class BrowserSession {
             this.logger.debug(`Failed to gather pending network requests: ${error.message}`);
             return [];
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     get tabs() {
         return this._tabs.slice();
@@ -1156,6 +1204,21 @@ export class BrowserSession {
         }
         const result = {};
         for (const [rawKey, rawVal] of Object.entries(value)) {
+            if (rawKey === 'extra_http_headers' &&
+                this._has_url_access_restrictions()) {
+                continue;
+            }
+            if (rawKey === 'permissions' && this._has_url_access_restrictions()) {
+                continue;
+            }
+            if (DOMAIN_POLICY_UNFILTERABLE_RECORDING_KEYS.has(rawKey) &&
+                this._has_url_access_restrictions()) {
+                continue;
+            }
+            if (rawKey === 'http_credentials' &&
+                this._has_url_access_restrictions()) {
+                this._assertHttpCredentialsScoped(rawVal);
+            }
             const convertedValue = this._toPlaywrightOptions(rawVal);
             if (convertedValue === undefined) {
                 continue;
@@ -1166,6 +1229,16 @@ export class BrowserSession {
         }
         return result;
     }
+    _assertHttpCredentialsScoped(value) {
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        const origin = value.origin;
+        if (typeof origin !== 'string' || origin.trim().length === 0) {
+            throw new BrowserError('http_credentials must include an origin when domain restrictions are configured.');
+        }
+        this._assert_url_allowed(origin.trim());
+    }
     async set_extra_headers(headers) {
         const normalizedHeaders = Object.fromEntries(Object.entries(headers)
             .map(([key, value]) => [String(key).trim(), String(value)])
@@ -1175,8 +1248,78 @@ export class BrowserSession {
             typeof this.browser_context.setExtraHTTPHeaders !== 'function') {
             return;
         }
+        if (this._has_url_access_restrictions()) {
+            await this._installScopedExtraHeaders(normalizedHeaders);
+            return;
+        }
+        await this._removeScopedExtraHeadersRoute();
         await this.browser_context.setExtraHTTPHeaders(normalizedHeaders);
     }
+    async _removeScopedExtraHeadersRoute() {
+        const context = this._scopedExtraHeadersRouteContext;
+        const handler = this._scopedExtraHeadersRouteHandler;
+        this._scopedExtraHeadersRouteContext = null;
+        this._scopedExtraHeadersRouteHandler = null;
+        if (!context || !handler || typeof context.unroute !== 'function') {
+            return;
+        }
+        try {
+            await context.unroute('**/*', handler);
+        }
+        catch (error) {
+            this.logger.debug(`Failed to remove scoped extra_http_headers route: ${error.message}`);
+        }
+    }
+    async _installScopedExtraHeaders(headers) {
+        const context = this.browser_context;
+        if (!context || typeof context.route !== 'function') {
+            throw new BrowserError('Cannot safely apply extra_http_headers with domain restrictions because BrowserContext.route is unavailable.');
+        }
+        await this._removeScopedExtraHeadersRoute();
+        if (typeof context.setExtraHTTPHeaders === 'function') {
+            await context.setExtraHTTPHeaders({});
+        }
+        const routeHandler = async (route) => {
+            const continueRoute = async (overrides) => {
+                if (typeof route?.fallback === 'function') {
+                    return await route.fallback(overrides);
+                }
+                if (typeof route?.continue === 'function') {
+                    return await route.continue(overrides);
+                }
+                throw new BrowserError('Cannot continue routed request while applying scoped extra_http_headers.');
+            };
+            const request = typeof route?.request === 'function' ? route.request() : null;
+            const url = typeof request?.url === 'function'
+                ? String(request.url())
+                : typeof request?.url === 'string'
+                    ? request.url
+                    : '';
+            let denialReason = 'invalid_url';
+            if (url) {
+                try {
+                    denialReason = this._get_url_access_denial_reason(url);
+                }
+                catch {
+                    denialReason = 'blocked';
+                }
+            }
+            if (denialReason) {
+                await continueRoute();
+                return;
+            }
+            const requestHeaders = typeof request?.headers === 'function' ? request.headers() : {};
+            await continueRoute({
+                headers: {
+                    ...(requestHeaders ?? {}),
+                    ...headers,
+                },
+            });
+        };
+        await context.route('**/*', routeHandler);
+        this._scopedExtraHeadersRouteContext = context;
+        this._scopedExtraHeadersRouteHandler = routeHandler;
+    }
     async _applyConfiguredExtraHttpHeaders() {
         const configuredHeaders = this.browser_profile.config.extra_http_headers;
         if (!configuredHeaders || Object.keys(configuredHeaders).length === 0) {
@@ -1325,6 +1468,9 @@ export class BrowserSession {
         }
         this._setActivePage(nextPage);
         this.human_current_page = nextPage;
+        if (nextPage) {
+            await this._assert_page_url_allowed_or_rollback(nextPage);
+        }
         await this._syncCurrentTabFromPage(nextPage);
     }
     async reconnect(options = {}) {
@@ -1557,6 +1703,8 @@ export class BrowserSession {
         }
         const activePage = await this.get_current_page();
         if (activePage) {
+            await this._assert_page_url_allowed_or_rollback(activePage);
+            await this._syncCurrentTabFromPage(activePage);
             try {
                 this.currentUrl = normalize_url(activePage.url());
             }
@@ -1598,7 +1746,7 @@ export class BrowserSession {
             throw new Error(`Could not discover CDP URL for browser PID ${browserPid}`);
         }
         this.cdp_url = cdpUrl;
-        this.logger.info(`Discovered CDP URL: ${cdpUrl}`);
+        this.logger.info(`Discovered CDP URL: ${BrowserSession._redact_url_for_logging(cdpUrl)}`);
         // Connect to browser via CDP
         try {
             const playwright = await import('playwright');
@@ -1744,6 +1892,7 @@ export class BrowserSession {
             domState = createEmptyDomState();
         }
         else {
+            await this.validate_page_after_action(page, signal);
             try {
                 const domService = new DomService(page, this.logger);
                 domState = await this._withAbort(domService.get_clickable_elements(this.browser_profile.highlight_elements, -1, this.browser_profile.viewport_expansion), signal);
@@ -1762,7 +1911,7 @@ export class BrowserSession {
                 !this._is_new_tab_page(liveUrl) &&
                 !liveUrl.toLowerCase().endsWith('.pdf');
             if (shouldRetryEmptyDom) {
-                this.logger.debug(`Empty DOM detected for ${liveUrl}; retrying once`);
+                this.logger.debug(`Empty DOM detected for ${BrowserSession._redact_url_for_logging(liveUrl)}; retrying once`);
                 await this._waitWithAbort(EMPTY_DOM_RETRY_DELAY_MS, signal);
                 try {
                     const retryDomService = new DomService(page, this.logger);
@@ -1778,6 +1927,7 @@ export class BrowserSession {
                     this.logger.debug(`Retry after empty DOM failed: ${error.message}`);
                 }
             }
+            await this.validate_page_after_action(page, signal);
         }
         let screenshot = null;
         if (options.include_screenshot && page?.screenshot) {
@@ -1797,6 +1947,7 @@ export class BrowserSession {
                 }
                 this.logger.debug(`Failed to capture screenshot: ${error.message}`);
             }
+            await this.validate_page_after_action(page, signal);
         }
         let pageInfo = null;
         let pixelsAbove = 0;
@@ -1842,10 +1993,11 @@ export class BrowserSession {
                 }
                 this.logger.debug(`Failed to compute page metrics: ${error.message}`);
             }
+            await this.validate_page_after_action(page, signal);
         }
         const pendingNetworkRequests = await this._getPendingNetworkRequests(page);
         if (page) {
-            await this._syncCurrentTabFromPage(page);
+            await this.validate_page_after_action(page, signal);
         }
         if (pageInfo &&
             Number.isFinite(pageInfo.viewport_width) &&
@@ -1878,6 +2030,7 @@ export class BrowserSession {
         });
         // Implement clickable element hash caching to detect new elements
         if (options.cache_clickable_elements_hashes && page) {
+            await this.validate_page_after_action(page, signal);
             const currentUrl = page.url();
             const currentHashes = this._computeElementHashes(domState.selector_map);
             // Mark new elements if we have cached hashes for this URL
@@ -1892,6 +2045,9 @@ export class BrowserSession {
             };
         }
         this._throwIfAborted(signal);
+        if (page) {
+            await this.validate_page_after_action(page, signal);
+        }
         this.cachedBrowserState = summary;
         return summary;
     }
@@ -1940,7 +2096,7 @@ export class BrowserSession {
             tab.title = this.currentTitle || this.currentUrl;
         }
         this._syncSessionManagerFromTabs();
-        return this._tabs.slice();
+        return this._tabs.map((tab) => this._sanitize_tab_for_exposure(tab));
     }
     async navigate_to(url, options = {}) {
         const signal = options.signal ?? null;
@@ -1966,14 +2122,44 @@ export class BrowserSession {
                 }
                 await this._withAbort(page.goto(normalized, gotoOptions), signal);
                 const finalUrl = page.url();
-                this._assert_url_allowed(finalUrl);
+                try {
+                    this._assert_url_allowed(finalUrl);
+                }
+                catch (error) {
+                    if (error instanceof URLNotAllowedError) {
+                        await this._rollback_disallowed_navigation(page, finalUrl);
+                    }
+                    throw error;
+                }
                 completedUrl = normalize_url(finalUrl);
                 await this._waitForStableNetwork(page, signal);
+                const settledUrl = page.url();
+                try {
+                    this._assert_url_allowed(settledUrl);
+                }
+                catch (error) {
+                    if (error instanceof URLNotAllowedError) {
+                        await this._rollback_disallowed_navigation(page, settledUrl);
+                    }
+                    throw error;
+                }
+                completedUrl = normalize_url(settledUrl);
             }
             catch (error) {
                 if (this._isAbortError(error)) {
+                    const disallowedPageError = await this._get_disallowed_page_error_after_navigation_error(page);
+                    if (disallowedPageError) {
+                        throw disallowedPageError;
+                    }
+                    throw error;
+                }
+                if (error instanceof URLNotAllowedError) {
                     throw error;
                 }
+                const disallowedPageError = await this._get_disallowed_page_error_after_navigation_error(page);
+                if (disallowedPageError) {
+                    throw disallowedPageError;
+                }
                 const message = error.message ?? 'Navigation failed';
                 this._recordRecentEvent('navigation_failed', {
                     url: normalized,
@@ -2044,13 +2230,22 @@ export class BrowserSession {
                 this._assert_url_allowed(finalUrl);
                 completedUrl = normalize_url(finalUrl);
                 await this._waitForStableNetwork(page, signal);
+                const settledUrl = page.url();
+                this._assert_url_allowed(settledUrl);
+                completedUrl = normalize_url(settledUrl);
             }
         }
         catch (error) {
-            if (this._isAbortError(error)) {
-                throw error;
-            }
-            const message = error.message ?? 'Failed to open new tab';
+            const isAbortError = this._isAbortError(error);
+            let finalError = error;
+            if (!(finalError instanceof URLNotAllowedError)) {
+                finalError =
+                    (await this._get_disallowed_page_error_after_navigation_error(page, {
+                        replace_on_failure: false,
+                    })) ?? finalError;
+            }
+            const isUrlNotAllowed = finalError instanceof URLNotAllowedError;
+            const message = finalError.message ?? 'Failed to open new tab';
             this._recordRecentEvent('tab_navigation_failed', {
                 url: normalized,
                 page_id: newTab.page_id,
@@ -2094,6 +2289,12 @@ export class BrowserSession {
             }
             this._syncSessionManagerFromTabs();
             this.cachedBrowserState = null;
+            if (isUrlNotAllowed) {
+                throw finalError;
+            }
+            if (isAbortError) {
+                throw finalError;
+            }
             throw new BrowserError(message);
         }
         this.tabPages.set(newTab.page_id, page);
@@ -2195,14 +2396,18 @@ export class BrowserSession {
             }
         }
         await this._waitForLoad(page, 5000, signal);
+        if (page) {
+            await this._assert_page_url_allowed_or_rollback(page);
+            await this._syncCurrentTabFromPage(page);
+        }
         this._recordRecentEvent('tab_switched', {
-            url: tab.url,
+            url: this.active_tab?.url ?? tab.url,
             page_id: tab.page_id,
             tab_id: tab.tab_id,
         });
         await this.event_bus.dispatch(new AgentFocusChangedEvent({
             target_id: tab.target_id ?? tab.tab_id,
-            url: tab.url,
+            url: this.active_tab?.url ?? tab.url,
         }));
         this.cachedBrowserState = null;
         return page;
@@ -2268,39 +2473,62 @@ export class BrowserSession {
         if (delayMs <= 0) {
             return;
         }
-        await this._waitWithAbort(delayMs, signal);
+        const page = await this.get_current_page();
+        try {
+            await this._waitWithAbort(delayMs, signal);
+        }
+        finally {
+            await this.validate_page_after_action(page, signal);
+        }
     }
     async send_keys(keys, options = {}) {
         const signal = options.signal ?? null;
         this._throwIfAborted(signal);
         const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
         const keyboard = page?.keyboard;
         if (!keyboard) {
             throw new BrowserError('Keyboard input is not available on the current page.');
         }
         try {
-            await this._withAbort(keyboard.press(keys), signal);
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('Unknown key')) {
-                for (const char of keys) {
-                    await this._withAbort(keyboard.press(char), signal);
+            try {
+                await this._withAbort(keyboard.press(keys), signal);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('Unknown key')) {
+                    for (const char of keys) {
+                        await this._withAbort(keyboard.press(char), signal);
+                    }
+                    return;
                 }
-                return;
+                throw error;
             }
-            throw error;
+        }
+        finally {
+            await this._waitForLoad(page, 5000, signal);
+            if (page) {
+                await this._assert_page_url_allowed_or_rollback(page);
+                await this._syncCurrentTabFromPage(page);
+            }
+            this.cachedBrowserState = null;
         }
     }
     async click_coordinates(coordinate_x, coordinate_y, options = {}) {
         const signal = options.signal ?? null;
         this._throwIfAborted(signal);
         const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
         if (!page?.mouse?.click) {
             throw new BrowserError('Unable to perform coordinate click on the current page.');
         }
-        await this._withAbort(page.mouse.click(coordinate_x, coordinate_y, {
-            button: options.button ?? 'left',
-        }), signal);
+        try {
+            await this._withAbort(page.mouse.click(coordinate_x, coordinate_y, {
+                button: options.button ?? 'left',
+            }), signal);
+        }
+        finally {
+            await this.validate_page_after_action(page, signal);
+        }
     }
     async scroll(direction, amount, options = {}) {
         const signal = options.signal ?? null;
@@ -2310,110 +2538,129 @@ export class BrowserSession {
             return;
         }
         const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
         if (!page?.evaluate) {
             throw new BrowserError('Unable to access current page for scrolling.');
         }
-        const node = options.node ?? null;
-        if (node?.xpath) {
-            const scrolled = await this._withAbort(page.evaluate((payload) => {
-                const root = document.evaluate(payload.xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-                if (!root) {
-                    return false;
+        try {
+            const node = options.node ?? null;
+            if (node?.xpath) {
+                const scrolled = await this._withAbort(page.evaluate((payload) => {
+                    const root = document.evaluate(payload.xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+                    if (!root) {
+                        return false;
+                    }
+                    const topDelta = payload.direction === 'up'
+                        ? -payload.amount
+                        : payload.direction === 'down'
+                            ? payload.amount
+                            : 0;
+                    const leftDelta = payload.direction === 'left'
+                        ? -payload.amount
+                        : payload.direction === 'right'
+                            ? payload.amount
+                            : 0;
+                    root.scrollBy({
+                        top: topDelta,
+                        left: leftDelta,
+                        behavior: 'auto',
+                    });
+                    return true;
+                }, { xpath: node.xpath, direction, amount: normalizedAmount }), signal);
+                if (scrolled) {
+                    return;
                 }
-                const topDelta = payload.direction === 'up'
-                    ? -payload.amount
-                    : payload.direction === 'down'
-                        ? payload.amount
-                        : 0;
-                const leftDelta = payload.direction === 'left'
-                    ? -payload.amount
-                    : payload.direction === 'right'
-                        ? payload.amount
-                        : 0;
-                root.scrollBy({
-                    top: topDelta,
-                    left: leftDelta,
-                    behavior: 'auto',
-                });
-                return true;
-            }, { xpath: node.xpath, direction, amount: normalizedAmount }), signal);
-            if (scrolled) {
+            }
+            if (direction === 'up' || direction === 'down') {
+                const pixels = direction === 'down' ? -normalizedAmount : normalizedAmount;
+                await this._withAbort(this._scrollContainer(pixels), signal);
                 return;
             }
+            const horizontalDelta = direction === 'left' ? -normalizedAmount : normalizedAmount;
+            await this._withAbort(page.evaluate((x) => window.scrollBy(x, 0), horizontalDelta), signal);
         }
-        if (direction === 'up' || direction === 'down') {
-            const pixels = direction === 'down' ? -normalizedAmount : normalizedAmount;
-            await this._withAbort(this._scrollContainer(pixels), signal);
-            return;
+        finally {
+            await this.validate_page_after_action(page, signal);
         }
-        const horizontalDelta = direction === 'left' ? -normalizedAmount : normalizedAmount;
-        await this._withAbort(page.evaluate((x) => window.scrollBy(x, 0), horizontalDelta), signal);
     }
     async scroll_to_text(text, options = {}) {
         const signal = options.signal ?? null;
         this._throwIfAborted(signal);
         const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
         if (!page?.evaluate) {
             throw new BrowserError('Unable to access page for scrolling.');
         }
-        const success = await this._withAbort(page.evaluate((payload) => {
-            const query = payload.text.toLowerCase();
-            const iterator = document.createNodeIterator(document.body, NodeFilter.SHOW_ELEMENT);
-            let node;
-            while ((node = iterator.nextNode())) {
-                const el = node;
-                if (!el || !el.textContent) {
-                    continue;
-                }
-                if (el.textContent.toLowerCase().includes(query)) {
-                    el.scrollIntoView({
-                        behavior: 'smooth',
-                        block: payload.direction === 'up' ? 'start' : 'center',
-                    });
-                    return true;
+        try {
+            const success = await this._withAbort(page.evaluate((payload) => {
+                const query = payload.text.toLowerCase();
+                const iterator = document.createNodeIterator(document.body, NodeFilter.SHOW_ELEMENT);
+                let node;
+                while ((node = iterator.nextNode())) {
+                    const el = node;
+                    if (!el || !el.textContent) {
+                        continue;
+                    }
+                    if (el.textContent.toLowerCase().includes(query)) {
+                        el.scrollIntoView({
+                            behavior: 'smooth',
+                            block: payload.direction === 'up' ? 'start' : 'center',
+                        });
+                        return true;
+                    }
                 }
+                return false;
+            }, { text, direction: options.direction ?? 'down' }), signal);
+            if (!success) {
+                throw new BrowserError(`Text '${text}' not found on page`);
             }
-            return false;
-        }, { text, direction: options.direction ?? 'down' }), signal);
-        if (!success) {
-            throw new BrowserError(`Text '${text}' not found on page`);
+        }
+        finally {
+            await this.validate_page_after_action(page, signal);
         }
     }
     async get_dropdown_options(element_node, options = {}) {
         const signal = options.signal ?? null;
         this._throwIfAborted(signal);
         const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
         if (!page?.evaluate) {
             throw new BrowserError('Unable to evaluate dropdown options on current page.');
         }
         if (!element_node?.xpath) {
             throw new BrowserError('DOM element does not include an XPath selector.');
         }
-        const payload = await this._withAbort(page.evaluate(({ xpath }) => {
-            const element = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-            if (!element)
+        let payload;
+        try {
+            payload = await this._withAbort(page.evaluate(({ xpath }) => {
+                const element = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+                if (!element)
+                    return null;
+                if (element.tagName?.toLowerCase() === 'select') {
+                    const options = Array.from(element.options).map((opt, index) => ({
+                        text: opt.textContent?.trim() ?? '',
+                        value: (opt.value ?? '').trim(),
+                        index,
+                    }));
+                    return { type: 'select', options };
+                }
+                const ariaRoles = new Set(['menu', 'listbox', 'combobox']);
+                const role = element.getAttribute('role');
+                if (role && ariaRoles.has(role)) {
+                    const nodes = element.querySelectorAll('[role="menuitem"],[role="option"]');
+                    const options = Array.from(nodes).map((node, index) => ({
+                        text: node.textContent?.trim() ?? '',
+                        value: node.textContent?.trim() ?? '',
+                        index,
+                    }));
+                    return { type: 'aria', options };
+                }
                 return null;
-            if (element.tagName?.toLowerCase() === 'select') {
-                const options = Array.from(element.options).map((opt, index) => ({
-                    text: opt.textContent?.trim() ?? '',
-                    value: (opt.value ?? '').trim(),
-                    index,
-                }));
-                return { type: 'select', options };
-            }
-            const ariaRoles = new Set(['menu', 'listbox', 'combobox']);
-            const role = element.getAttribute('role');
-            if (role && ariaRoles.has(role)) {
-                const nodes = element.querySelectorAll('[role="menuitem"],[role="option"]');
-                const options = Array.from(nodes).map((node, index) => ({
-                    text: node.textContent?.trim() ?? '',
-                    value: node.textContent?.trim() ?? '',
-                    index,
-                }));
-                return { type: 'aria', options };
-            }
-            return null;
-        }, { xpath: element_node.xpath }), signal);
+            }, { xpath: element_node.xpath }), signal);
+        }
+        finally {
+            await this.validate_page_after_action(page, signal);
+        }
         if (!payload || !Array.isArray(payload.options)) {
             throw new BrowserError('No options found for the specified dropdown.');
         }
@@ -2452,49 +2699,117 @@ export class BrowserSession {
         if (!page) {
             throw new BrowserError('No active page for selection.');
         }
-        const formatAvailableOptions = (opts) => opts
-            .map((opt) => `  - [${opt.index}] text=${JSON.stringify(opt.text)} value=${JSON.stringify(opt.value)}`)
-            .join('\n');
-        const pageFrames = (() => {
-            const framesAccessor = page.frames;
-            if (typeof framesAccessor === 'function') {
-                try {
-                    const result = framesAccessor.call(page);
-                    return Array.isArray(result) ? result : [];
-                }
-                catch {
-                    return [];
-                }
-            }
-            return Array.isArray(framesAccessor) ? framesAccessor : [];
-        })();
-        for (const frame of pageFrames) {
-            try {
-                const typeInfo = await this._withAbort(frame.evaluate((xpath) => {
-                    const element = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-                    if (!element)
-                        return { found: false };
-                    const tagName = element.tagName?.toLowerCase();
-                    const role = element.getAttribute?.('role');
-                    if (tagName === 'select')
-                        return { found: true, type: 'select' };
-                    if (role && ['menu', 'listbox', 'combobox'].includes(role))
-                        return { found: true, type: 'aria' };
-                    return { found: false };
-                }, element_node.xpath), signal);
-                if (!typeInfo?.found) {
-                    continue;
+        await this.validate_page_after_action(page, signal);
+        try {
+            const formatAvailableOptions = (opts) => opts
+                .map((opt) => `  - [${opt.index}] text=${JSON.stringify(opt.text)} value=${JSON.stringify(opt.value)}`)
+                .join('\n');
+            const pageFrames = (() => {
+                const framesAccessor = page.frames;
+                if (typeof framesAccessor === 'function') {
+                    try {
+                        const result = framesAccessor.call(page);
+                        return Array.isArray(result) ? result : [];
+                    }
+                    catch {
+                        return [];
+                    }
                 }
-                if (typeInfo.type === 'select') {
-                    const selection = await this._withAbort(frame.evaluate(({ xpath, optionText, }) => {
-                        const root = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-                        if (!root || root.tagName?.toLowerCase() !== 'select') {
+                return Array.isArray(framesAccessor) ? framesAccessor : [];
+            })();
+            for (const frame of pageFrames) {
+                try {
+                    const typeInfo = await this._withAbort(frame.evaluate((xpath) => {
+                        const element = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+                        if (!element)
                             return { found: false };
+                        const tagName = element.tagName?.toLowerCase();
+                        const role = element.getAttribute?.('role');
+                        if (tagName === 'select')
+                            return { found: true, type: 'select' };
+                        if (role && ['menu', 'listbox', 'combobox'].includes(role))
+                            return { found: true, type: 'aria' };
+                        return { found: false };
+                    }, element_node.xpath), signal);
+                    if (!typeInfo?.found) {
+                        continue;
+                    }
+                    if (typeInfo.type === 'select') {
+                        const selection = await this._withAbort(frame.evaluate(({ xpath, optionText, }) => {
+                            const root = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+                            if (!root || root.tagName?.toLowerCase() !== 'select') {
+                                return { found: false };
+                            }
+                            const options = Array.from(root.options).map((opt, index) => ({
+                                index,
+                                text: opt.textContent?.trim() ?? '',
+                                value: (opt.value ?? '').trim(),
+                            }));
+                            const targetRaw = optionText.trim();
+                            const targetLower = optionText.trim().toLowerCase();
+                            let matchedIndex = options.findIndex((opt) => opt.text === targetRaw || opt.value === targetRaw);
+                            if (matchedIndex < 0) {
+                                matchedIndex = options.findIndex((opt) => opt.text.trim().toLowerCase() === targetLower ||
+                                    opt.value.trim().toLowerCase() === targetLower);
+                            }
+                            if (matchedIndex < 0) {
+                                return { found: true, success: false, options };
+                            }
+                            const matched = options[matchedIndex];
+                            root.value = matched.value;
+                            root.dispatchEvent(new Event('input', { bubbles: true }));
+                            root.dispatchEvent(new Event('change', { bubbles: true }));
+                            const selectedOption = root.selectedIndex >= 0
+                                ? root.options[root.selectedIndex]
+                                : null;
+                            const selectedText = selectedOption?.textContent?.trim() ?? '';
+                            const selectedValue = (root.value ?? '').trim();
+                            const selectedValueLower = selectedValue.trim().toLowerCase();
+                            const selectedTextLower = selectedText.trim().toLowerCase();
+                            const matchedValueLower = String(matched.value ?? '')
+                                .trim()
+                                .toLowerCase();
+                            const matchedTextLower = String(matched.text ?? '')
+                                .trim()
+                                .toLowerCase();
+                            const verified = selectedValueLower === matchedValueLower ||
+                                selectedTextLower === matchedTextLower;
+                            return {
+                                found: true,
+                                success: verified,
+                                options,
+                                selectedText,
+                                selectedValue,
+                                matched,
+                            };
+                        }, { xpath: element_node.xpath, optionText: text }), signal);
+                        if (selection?.found && selection.success) {
+                            const matchedText = selection.matched?.text ?? text;
+                            const matchedValue = selection.matched?.value ?? '';
+                            const msg = `Selected option ${matchedText} (${matchedValue})`;
+                            return {
+                                message: msg,
+                                short_term_memory: msg,
+                                long_term_memory: msg,
+                                matched_text: String(matchedText),
+                                matched_value: String(matchedValue),
+                            };
                         }
-                        const options = Array.from(root.options).map((opt, index) => ({
+                        if (selection?.found) {
+                            const details = formatAvailableOptions(selection.options ?? []);
+                            throw new BrowserError(`Could not select option '${text}' for index ${element_node.highlight_index ?? 'unknown'}.\nAvailable options:\n${details}`);
+                        }
+                        continue;
+                    }
+                    const clicked = await this._withAbort(frame.evaluate(({ xpath, optionText, }) => {
+                        const root = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+                        if (!root)
+                            return false;
+                        const nodes = root.querySelectorAll('[role="menuitem"],[role="option"]');
+                        const options = Array.from(nodes).map((node, index) => ({
                             index,
-                            text: opt.textContent?.trim() ?? '',
-                            value: (opt.value ?? '').trim(),
+                            text: node.textContent?.trim() ?? '',
+                            value: node.textContent?.trim() ?? '',
                         }));
                         const targetRaw = optionText.trim();
                         const targetLower = optionText.trim().toLowerCase();
@@ -2506,103 +2821,41 @@ export class BrowserSession {
                         if (matchedIndex < 0) {
                             return { found: true, success: false, options };
                         }
-                        const matched = options[matchedIndex];
-                        root.value = matched.value;
-                        root.dispatchEvent(new Event('input', { bubbles: true }));
-                        root.dispatchEvent(new Event('change', { bubbles: true }));
-                        const selectedOption = root.selectedIndex >= 0
-                            ? root.options[root.selectedIndex]
-                            : null;
-                        const selectedText = selectedOption?.textContent?.trim() ?? '';
-                        const selectedValue = (root.value ?? '').trim();
-                        const selectedValueLower = selectedValue.trim().toLowerCase();
-                        const selectedTextLower = selectedText.trim().toLowerCase();
-                        const matchedValueLower = String(matched.value ?? '')
-                            .trim()
-                            .toLowerCase();
-                        const matchedTextLower = String(matched.text ?? '')
-                            .trim()
-                            .toLowerCase();
-                        const verified = selectedValueLower === matchedValueLower ||
-                            selectedTextLower === matchedTextLower;
+                        nodes[matchedIndex].click();
                         return {
                             found: true,
-                            success: verified,
+                            success: true,
                             options,
-                            selectedText,
-                            selectedValue,
-                            matched,
+                            matched: options[matchedIndex],
                         };
                     }, { xpath: element_node.xpath, optionText: text }), signal);
-                    if (selection?.found && selection.success) {
-                        const matchedText = selection.matched?.text ?? text;
-                        const matchedValue = selection.matched?.value ?? '';
-                        const msg = `Selected option ${matchedText} (${matchedValue})`;
+                    if (clicked?.found && clicked.success) {
+                        const matchedText = clicked.matched?.text ?? text;
+                        const msg = `Selected menu item ${matchedText}`;
                         return {
                             message: msg,
                             short_term_memory: msg,
                             long_term_memory: msg,
                             matched_text: String(matchedText),
-                            matched_value: String(matchedValue),
                         };
                     }
-                    if (selection?.found) {
-                        const details = formatAvailableOptions(selection.options ?? []);
+                    if (clicked?.found) {
+                        const details = formatAvailableOptions(clicked.options ?? []);
                         throw new BrowserError(`Could not select option '${text}' for index ${element_node.highlight_index ?? 'unknown'}.\nAvailable options:\n${details}`);
                     }
-                    continue;
                 }
-                const clicked = await this._withAbort(frame.evaluate(({ xpath, optionText }) => {
-                    const root = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-                    if (!root)
-                        return false;
-                    const nodes = root.querySelectorAll('[role="menuitem"],[role="option"]');
-                    const options = Array.from(nodes).map((node, index) => ({
-                        index,
-                        text: node.textContent?.trim() ?? '',
-                        value: node.textContent?.trim() ?? '',
-                    }));
-                    const targetRaw = optionText.trim();
-                    const targetLower = optionText.trim().toLowerCase();
-                    let matchedIndex = options.findIndex((opt) => opt.text === targetRaw || opt.value === targetRaw);
-                    if (matchedIndex < 0) {
-                        matchedIndex = options.findIndex((opt) => opt.text.trim().toLowerCase() === targetLower ||
-                            opt.value.trim().toLowerCase() === targetLower);
-                    }
-                    if (matchedIndex < 0) {
-                        return { found: true, success: false, options };
+                catch (error) {
+                    if (error instanceof BrowserError) {
+                        throw error;
                     }
-                    nodes[matchedIndex].click();
-                    return {
-                        found: true,
-                        success: true,
-                        options,
-                        matched: options[matchedIndex],
-                    };
-                }, { xpath: element_node.xpath, optionText: text }), signal);
-                if (clicked?.found && clicked.success) {
-                    const matchedText = clicked.matched?.text ?? text;
-                    const msg = `Selected menu item ${matchedText}`;
-                    return {
-                        message: msg,
-                        short_term_memory: msg,
-                        long_term_memory: msg,
-                        matched_text: String(matchedText),
-                    };
-                }
-                if (clicked?.found) {
-                    const details = formatAvailableOptions(clicked.options ?? []);
-                    throw new BrowserError(`Could not select option '${text}' for index ${element_node.highlight_index ?? 'unknown'}.\nAvailable options:\n${details}`);
-                }
-            }
-            catch (error) {
-                if (error instanceof BrowserError) {
-                    throw error;
+                    continue;
                 }
-                continue;
             }
+            throw new BrowserError(`Could not select option '${text}' for index ${element_node.highlight_index ?? 'unknown'}`);
+        }
+        finally {
+            await this.validate_page_after_action(page, signal);
         }
-        throw new BrowserError(`Could not select option '${text}' for index ${element_node.highlight_index ?? 'unknown'}`);
     }
     async upload_file(element_node, file_path, options = {}) {
         const signal = options.signal ?? null;
@@ -2618,7 +2871,14 @@ export class BrowserSession {
         if (typeof locatorWithUpload.setInputFiles !== 'function') {
             throw new Error('Element does not support file upload');
         }
-        await this._withAbort(locatorWithUpload.setInputFiles(file_path, { timeout: 5000 }), signal);
+        const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
+        try {
+            await this._withAbort(locatorWithUpload.setInputFiles(file_path, { timeout: 5000 }), signal);
+        }
+        finally {
+            await this.validate_page_after_action(page, signal);
+        }
     }
     async go_back(options = {}) {
         const signal = options.signal ?? null;
@@ -2627,16 +2887,25 @@ export class BrowserSession {
         if (!page?.goBack) {
             return;
         }
+        await this.validate_page_after_action(page, signal);
         const previousUrl = this.currentUrl;
         try {
             await this._withAbort(page.goBack(), signal);
+            await this._waitForStableNetwork(page, signal);
+            await this._assert_page_url_allowed_or_rollback(page);
         }
         catch (error) {
             if (this._isAbortError(error)) {
                 throw error;
             }
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             this.logger.debug(`Failed to navigate back: ${error.message}`);
         }
+        finally {
+            await this.validate_page_after_action(page, signal);
+        }
         this._throwIfAborted(signal);
         await this._syncCurrentTabFromPage(page);
         const currentUrl = this.currentUrl;
@@ -2684,8 +2953,9 @@ export class BrowserSession {
     }
     static async get_unique_filename(directory, filename) {
         const resolvedDir = path.resolve(directory);
-        const parsed = path.parse(filename);
-        let candidate = filename;
+        const safeFilename = BrowserSession._sanitize_download_filename(filename);
+        const parsed = path.parse(safeFilename);
+        let candidate = safeFilename;
         let counter = 1;
         while (fs.existsSync(path.join(resolvedDir, candidate))) {
             candidate = `${parsed.name} (${counter})${parsed.ext}`;
@@ -2693,6 +2963,81 @@ export class BrowserSession {
         }
         return candidate;
     }
+    async _cancel_download_best_effort(download) {
+        if (typeof download?.cancel !== 'function') {
+            return;
+        }
+        try {
+            await download.cancel();
+        }
+        catch (error) {
+            this.logger.debug(`Failed to cancel blocked download: ${error.message}`);
+        }
+    }
+    async _assert_download_url_allowed(download, downloadUrl) {
+        try {
+            this._assert_url_allowed(downloadUrl);
+        }
+        catch (error) {
+            await this._cancel_download_best_effort(download);
+            throw error;
+        }
+    }
+    static _sanitize_download_filename(filename) {
+        const basename = String(filename || '')
+            .replace(/\0/g, '')
+            .replace(/\\/g, '/')
+            .split('/')
+            .pop()
+            ?.trim();
+        if (!basename || basename === '.' || basename === '..') {
+            return 'download';
+        }
+        const sanitized = basename
+            .replace(/[:*?"<>|]+/g, '_')
+            .replace(/\s+/g, ' ')
+            .trim();
+        return sanitized || 'download';
+    }
+    static _redact_url_for_logging(url) {
+        const raw = String(url ?? '');
+        if (!raw) {
+            return raw;
+        }
+        if (/^data:/i.test(raw)) {
+            return 'data:<redacted>';
+        }
+        try {
+            const parsed = new URL(raw);
+            parsed.username = '';
+            parsed.password = '';
+            const [withoutHash] = parsed.href.split('#', 1);
+            const [withoutQuery] = withoutHash.split('?', 1);
+            return `${withoutQuery}${parsed.search ? '?<redacted>' : ''}${parsed.hash ? '#<redacted>' : ''}`;
+        }
+        catch {
+            const queryIndex = raw.indexOf('?');
+            const hashIndex = raw.indexOf('#');
+            const firstSensitiveIndex = [queryIndex, hashIndex]
+                .filter((index) => index >= 0)
+                .sort((a, b) => a - b)[0];
+            if (firstSensitiveIndex === undefined) {
+                return raw;
+            }
+            return `${raw.slice(0, firstSensitiveIndex)}${queryIndex >= 0 ? '?<redacted>' : ''}${hashIndex >= 0 ? '#<redacted>' : ''}`;
+        }
+    }
+    static _redact_urls_in_text(value) {
+        return value.replace(/\b(?:https?|blob):[^\s"'<>]+/gi, (match) => BrowserSession._redact_url_for_logging(match));
+    }
+    static _same_origin(left, right) {
+        try {
+            return new URL(left).origin === new URL(right).origin;
+        }
+        catch {
+            return false;
+        }
+    }
     async get_selector_map(options = {}) {
         if (!this.cachedBrowserState) {
             await this.get_browser_state_with_recovery({
@@ -2763,6 +3108,7 @@ export class BrowserSession {
         if (!page || !node?.xpath) {
             return null;
         }
+        await this.validate_page_after_action(page);
         try {
             const locator = page.locator(`xpath=${node.xpath}`);
             const count = await locator.count();
@@ -2784,12 +3130,19 @@ export class BrowserSession {
         if (!locator) {
             throw new Error('Element not found');
         }
-        await this._withAbort(locator.click({ timeout: 5000 }), signal);
-        if (clear) {
-            await this._withAbort(locator.fill(text, { timeout: 5000 }), signal);
+        const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
+        try {
+            await this._withAbort(locator.click({ timeout: 5000 }), signal);
+            if (clear) {
+                await this._withAbort(locator.fill(text, { timeout: 5000 }), signal);
+            }
+            else {
+                await this._withAbort(locator.type(text, { timeout: 5000 }), signal);
+            }
         }
-        else {
-            await this._withAbort(locator.type(text, { timeout: 5000 }), signal);
+        finally {
+            await this.validate_page_after_action(page, signal);
         }
     }
     async _click_element_node(node, options = {}) {
@@ -2800,76 +3153,87 @@ export class BrowserSession {
             throw new Error('Element not found');
         }
         const page = await this._withAbort(this.get_current_page(), signal);
+        await this.validate_page_after_action(page, signal);
         const performClick = async () => {
             await this._withAbort(locator.click({ timeout: 5000 }), signal);
         };
-        const downloadsDir = this.browser_profile.downloads_path;
-        if (downloadsDir && page?.waitForEvent) {
-            const downloadPromise = page.waitForEvent('download', { timeout: 5000 });
-            await performClick();
-            try {
-                const download = await this._withAbort(downloadPromise, signal);
-                const downloadGuid = uuid7str();
-                const suggested = typeof download.suggestedFilename === 'function'
-                    ? download.suggestedFilename()
-                    : 'download';
-                const downloadUrl = typeof download.url === 'function'
-                    ? download.url()
-                    : (this.currentUrl ?? '');
-                await this.event_bus.dispatch(new DownloadStartedEvent({
-                    guid: downloadGuid,
-                    url: downloadUrl,
-                    suggested_filename: suggested,
-                    auto_download: false,
-                }));
-                const uniqueFilename = await BrowserSession.get_unique_filename(downloadsDir, suggested);
-                const downloadPath = path.join(downloadsDir, uniqueFilename);
-                if (typeof download.saveAs === 'function') {
-                    await download.saveAs(downloadPath);
-                }
-                const stats = fs.existsSync(downloadPath)
-                    ? fs.statSync(downloadPath)
-                    : null;
-                await this.event_bus.dispatch(new DownloadProgressEvent({
-                    guid: downloadGuid,
-                    received_bytes: stats?.size ?? 0,
-                    total_bytes: stats?.size ?? 0,
-                    state: 'completed',
-                }));
-                const fileDownloadedResult = await this.event_bus.dispatch(new FileDownloadedEvent({
-                    guid: downloadGuid,
-                    url: downloadUrl,
-                    path: downloadPath,
-                    file_name: uniqueFilename,
-                    file_size: stats?.size ?? 0,
-                    file_type: path.extname(uniqueFilename).replace('.', '') || null,
-                    mime_type: null,
-                    auto_download: false,
-                }));
-                if (fileDownloadedResult.handler_results.length === 0) {
-                    this.add_downloaded_file(downloadPath);
+        let result = null;
+        try {
+            const downloadsDir = this.browser_profile.downloads_path;
+            if (downloadsDir && page?.waitForEvent) {
+                ensurePrivateDirectoryIfCreated(downloadsDir);
+                const downloadPromise = page.waitForEvent('download', {
+                    timeout: 5000,
+                });
+                await performClick();
+                try {
+                    const download = await this._withAbort(downloadPromise, signal);
+                    const downloadGuid = uuid7str();
+                    const suggested = typeof download.suggestedFilename === 'function'
+                        ? download.suggestedFilename()
+                        : 'download';
+                    const downloadUrl = typeof download.url === 'function'
+                        ? download.url()
+                        : (this.currentUrl ?? '');
+                    await this._assert_download_url_allowed(download, downloadUrl);
+                    await this.event_bus.dispatch(new DownloadStartedEvent({
+                        guid: downloadGuid,
+                        url: downloadUrl,
+                        suggested_filename: suggested,
+                        auto_download: false,
+                    }));
+                    const uniqueFilename = await BrowserSession.get_unique_filename(downloadsDir, suggested);
+                    const downloadPath = path.join(downloadsDir, uniqueFilename);
+                    if (typeof download.saveAs === 'function') {
+                        await download.saveAs(downloadPath);
+                        chmodPrivateFileBestEffort(downloadPath);
+                    }
+                    const stats = fs.existsSync(downloadPath)
+                        ? fs.statSync(downloadPath)
+                        : null;
+                    await this.event_bus.dispatch(new DownloadProgressEvent({
+                        guid: downloadGuid,
+                        received_bytes: stats?.size ?? 0,
+                        total_bytes: stats?.size ?? 0,
+                        state: 'completed',
+                    }));
+                    const fileDownloadedResult = await this.event_bus.dispatch(new FileDownloadedEvent({
+                        guid: downloadGuid,
+                        url: downloadUrl,
+                        path: downloadPath,
+                        file_name: uniqueFilename,
+                        file_size: stats?.size ?? 0,
+                        file_type: path.extname(uniqueFilename).replace('.', '') || null,
+                        mime_type: null,
+                        auto_download: false,
+                    }));
+                    if (fileDownloadedResult.handler_results.length === 0) {
+                        this.add_downloaded_file(downloadPath);
+                    }
+                    result = downloadPath;
                 }
-                return downloadPath;
-            }
-            catch (error) {
-                if (this._isAbortError(error)) {
-                    throw error;
+                catch (error) {
+                    if (this._isAbortError(error)) {
+                        throw error;
+                    }
+                    if (error instanceof URLNotAllowedError) {
+                        throw error;
+                    }
+                    this.logger.debug(`No download triggered within timeout: ${error.message}`);
                 }
-                this.logger.debug(`No download triggered within timeout: ${error.message}`);
+            }
+            else {
+                await performClick();
             }
         }
-        else {
-            await performClick();
-        }
-        await this._waitForLoad(page, 5000, signal);
-        if (page) {
-            await this._syncCurrentTabFromPage(page);
-            if (this.historyStack[this.historyStack.length - 1] !== this.currentUrl) {
+        finally {
+            await this.validate_page_after_action(page, signal);
+            if (page &&
+                this.historyStack[this.historyStack.length - 1] !== this.currentUrl) {
                 this.historyStack.push(this.currentUrl);
             }
         }
-        this.cachedBrowserState = null;
-        return null;
+        return result;
     }
     async _waitForLoad(page, timeout = 5000, signal = null) {
         if (!page || typeof page.waitForLoadState !== 'function') {
@@ -2889,11 +3253,14 @@ export class BrowserSession {
     /**
      * Get all cookies from the current browser context
      */
-    async get_cookies() {
-        if (this.browser_context?.cookies) {
-            return await this.browser_context.cookies();
+    async get_cookies(options = {}) {
+        const cookies = this.browser_context?.cookies
+            ? await this.browser_context.cookies()
+            : [];
+        if (options.include_blocked || !this._has_url_access_restrictions()) {
+            return cookies;
         }
-        return [];
+        return this._filter_cookies_for_exposure(cookies);
     }
     /**
      * Save cookies to a file (deprecated, use save_storage_state instead)
@@ -2925,19 +3292,19 @@ export class BrowserSession {
             const resolvedPath = path.resolve(targetPath);
             const dirPath = path.dirname(resolvedPath);
             // Create directory if it doesn't exist
-            if (!fs.existsSync(dirPath)) {
-                fs.mkdirSync(dirPath, { recursive: true });
-            }
+            ensurePrivateDirectoryIfCreated(dirPath);
             // Get storage state from browser context
-            const storageState = await this.browser_context.storageState();
+            const rawStorageState = await this.browser_context.storageState();
+            const storageState = this._sanitize_storage_state_for_save(rawStorageState);
             // Write to temporary file first
             const tempPath = `${resolvedPath}.tmp`;
-            fs.writeFileSync(tempPath, JSON.stringify(storageState, null, 2));
+            writePrivateStorageFile(tempPath, JSON.stringify(storageState, null, 2));
             // Backup existing file if present
             if (fs.existsSync(resolvedPath)) {
                 const backupPath = `${resolvedPath}.bak`;
                 try {
                     fs.renameSync(resolvedPath, backupPath);
+                    chmodPrivateStorageFile(backupPath);
                 }
                 catch (error) {
                     // Ignore backup errors
@@ -2945,6 +3312,7 @@ export class BrowserSession {
             }
             // Move temp file to target
             fs.renameSync(tempPath, resolvedPath);
+            chmodPrivateStorageFile(resolvedPath);
             const cookieCount = storageState.cookies?.length || 0;
             this.logger.info(`🍪 Saved ${cookieCount} cookies to ${path.basename(resolvedPath)}`);
         }
@@ -2971,15 +3339,216 @@ export class BrowserSession {
             if (this.browser_context?.addCookies) {
                 // Add cookies to context
                 if (storageState.cookies && Array.isArray(storageState.cookies)) {
-                    await this.browser_context.addCookies(storageState.cookies);
-                    this.logger.info(`🍪 Loaded ${storageState.cookies.length} cookies from ${path.basename(resolvedPath)}`);
+                    const allowedCookies = this._filter_storage_state_cookies(storageState.cookies);
+                    if (allowedCookies.length > 0) {
+                        await this.browser_context.addCookies(allowedCookies);
+                    }
+                    this.logger.info(`🍪 Loaded ${allowedCookies.length} cookies from ${path.basename(resolvedPath)}`);
                 }
             }
+            if (Array.isArray(storageState.origins)) {
+                await this._apply_storage_state_origins(storageState.origins);
+            }
         }
         catch (error) {
             this.logger.warning(`❌ Failed to load storage state: ${error.message}`);
         }
     }
+    async _apply_storage_state_origins(origins) {
+        const browserContext = this.browser_context;
+        if (!browserContext?.newPage) {
+            return;
+        }
+        for (const originState of origins) {
+            const origin = originState &&
+                typeof originState === 'object' &&
+                'origin' in originState &&
+                typeof originState.origin === 'string'
+                ? originState.origin.trim()
+                : '';
+            if (!origin || !/^https?:\/\//i.test(origin)) {
+                continue;
+            }
+            const denialReason = this._get_url_access_denial_reason(origin);
+            if (denialReason) {
+                this.logger.warning(`Skipping storage origin ${BrowserSession._redact_url_for_logging(origin)}: ${denialReason}`);
+                continue;
+            }
+            const localStorageEntries = this._normalize_storage_entries(originState.localStorage);
+            const sessionStorageEntries = this._normalize_storage_entries(originState.sessionStorage);
+            if (localStorageEntries.length === 0 &&
+                sessionStorageEntries.length === 0) {
+                continue;
+            }
+            let page = null;
+            try {
+                page = await browserContext.newPage();
+                await page.goto?.(origin, {
+                    waitUntil: 'domcontentloaded',
+                    timeout: 5_000,
+                });
+                const finalUrl = typeof page.url === 'function' ? page.url() : origin;
+                const finalDenialReason = this._get_url_access_denial_reason(finalUrl);
+                if (finalDenialReason) {
+                    this.logger.warning(`Skipping storage origin ${BrowserSession._redact_url_for_logging(origin)} after redirect to blocked URL: ${finalDenialReason}`);
+                    try {
+                        await page.goto?.('about:blank', {
+                            waitUntil: 'load',
+                            timeout: 5_000,
+                        });
+                    }
+                    catch {
+                        // The temporary page is closed below; resetting first is best effort.
+                    }
+                    continue;
+                }
+                if (!BrowserSession._same_origin(origin, finalUrl)) {
+                    this.logger.warning(`Skipping storage origin ${BrowserSession._redact_url_for_logging(origin)} after redirect to a different origin`);
+                    try {
+                        await page.goto?.('about:blank', {
+                            waitUntil: 'load',
+                            timeout: 5_000,
+                        });
+                    }
+                    catch {
+                        // The temporary page is closed below; resetting first is best effort.
+                    }
+                    continue;
+                }
+                await page.evaluate?.((payload) => {
+                    for (const entry of payload.localStorageEntries) {
+                        window.localStorage.setItem(entry.name, entry.value);
+                    }
+                    for (const entry of payload.sessionStorageEntries) {
+                        window.sessionStorage.setItem(entry.name, entry.value);
+                    }
+                }, {
+                    localStorageEntries,
+                    sessionStorageEntries,
+                });
+            }
+            catch (error) {
+                this.logger.debug(`Failed to apply origin storage for ${BrowserSession._redact_url_for_logging(origin)}: ${error.message}`);
+            }
+            finally {
+                try {
+                    await page?.close?.();
+                }
+                catch {
+                    // Ignore cleanup errors.
+                }
+            }
+        }
+    }
+    _normalize_storage_entries(entries) {
+        if (!Array.isArray(entries)) {
+            return [];
+        }
+        const normalized = [];
+        for (const entry of entries) {
+            const name = entry && typeof entry === 'object' && 'name' in entry
+                ? String(entry.name ?? '')
+                : '';
+            if (!name) {
+                continue;
+            }
+            const value = entry && typeof entry === 'object' && 'value' in entry
+                ? String(entry.value ?? '')
+                : '';
+            normalized.push({ name, value });
+        }
+        return normalized;
+    }
+    _sanitize_storage_state_for_save(storageState) {
+        if (!this._has_url_access_restrictions()) {
+            return storageState;
+        }
+        const normalized = storageState && typeof storageState === 'object'
+            ? { ...storageState }
+            : {};
+        const cookies = Array.isArray(normalized.cookies)
+            ? this._filter_storage_state_cookies(normalized.cookies)
+            : [];
+        const origins = Array.isArray(normalized.origins)
+            ? normalized.origins.filter((originState) => {
+                const origin = originState &&
+                    typeof originState === 'object' &&
+                    'origin' in originState &&
+                    typeof originState.origin === 'string'
+                    ? originState.origin.trim()
+                    : '';
+                const denialReason = origin
+                    ? this._get_url_access_denial_reason(origin)
+                    : 'invalid_url';
+                if (!denialReason) {
+                    return true;
+                }
+                this.logger.warning(`Skipping saved storage origin ${origin
+                    ? BrowserSession._redact_url_for_logging(origin)
+                    : '<invalid>'}: ${denialReason}`);
+                return false;
+            })
+            : [];
+        return {
+            ...normalized,
+            cookies,
+            origins,
+        };
+    }
+    _filter_storage_state_cookies(cookies) {
+        return cookies.filter((cookie) => {
+            const denialReason = this._get_cookie_access_denial_reason(cookie);
+            if (!denialReason) {
+                return true;
+            }
+            const cookieName = cookie && typeof cookie === 'object' && 'name' in cookie
+                ? String(cookie.name ?? '')
+                : '';
+            this.logger.warning(`Skipping storage cookie ${cookieName || '<unnamed>'}: ${denialReason}`);
+            return false;
+        });
+    }
+    _filter_cookies_for_exposure(cookies) {
+        return cookies.filter((cookie) => {
+            const denialReason = this._get_cookie_access_denial_reason(cookie);
+            if (!denialReason) {
+                return true;
+            }
+            const cookieName = cookie && typeof cookie === 'object' && 'name' in cookie
+                ? String(cookie.name ?? '')
+                : '';
+            this.logger.debug(`Skipping exposed cookie ${cookieName || '<unnamed>'}: ${denialReason}`);
+            return false;
+        });
+    }
+    _get_cookie_access_denial_reason(cookie) {
+        if (!cookie || typeof cookie !== 'object') {
+            return null;
+        }
+        const cookieLike = cookie;
+        const explicitUrl = typeof cookieLike.url === 'string' ? cookieLike.url.trim() : '';
+        if (explicitUrl) {
+            return this._get_url_access_denial_reason(explicitUrl);
+        }
+        const rawDomain = typeof cookieLike.domain === 'string' ? cookieLike.domain.trim() : '';
+        const host = rawDomain.replace(/^\./, '');
+        if (!host) {
+            return null;
+        }
+        const protocols = cookieLike.secure === true ? ['https:'] : ['https:', 'http:'];
+        let lastReason = null;
+        for (const protocol of protocols) {
+            const reason = this._get_url_access_denial_reason(`${protocol}//${host}`);
+            if (!reason) {
+                return null;
+            }
+            if (reason === 'in_prohibited_domains') {
+                return reason;
+            }
+            lastReason = reason;
+        }
+        return lastReason;
+    }
     // ==================== JavaScript Execution ====================
     /**
      * Execute JavaScript in the current page context
@@ -2989,7 +3558,24 @@ export class BrowserSession {
         if (!page) {
             throw new Error('No page available to execute JavaScript');
         }
-        return await page.evaluate(script);
+        await this.validate_page_after_action(page);
+        try {
+            return await page.evaluate(script);
+        }
+        finally {
+            await this._waitForLoad(page, 5000);
+            await this._assert_page_url_allowed_or_rollback(page);
+            await this._syncCurrentTabFromPage(page);
+            this.cachedBrowserState = null;
+        }
+    }
+    async validate_page_after_action(page, signal = null) {
+        await this._waitForLoad(page, 5000, signal);
+        if (page) {
+            await this._assert_page_url_allowed_or_rollback(page);
+            await this._syncCurrentTabFromPage(page);
+        }
+        this.cachedBrowserState = null;
     }
     // ==================== Page Information ====================
     /**
@@ -3000,49 +3586,55 @@ export class BrowserSession {
         if (!targetPage) {
             return null;
         }
-        const pageData = await targetPage.evaluate(() => {
+        await this.validate_page_after_action(targetPage);
+        try {
+            const pageData = await targetPage.evaluate(() => {
+                return {
+                    // Current viewport dimensions
+                    viewport_width: window.innerWidth,
+                    viewport_height: window.innerHeight,
+                    // Total page dimensions
+                    page_width: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth || 0),
+                    page_height: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight || 0),
+                    // Current scroll position
+                    scroll_x: window.scrollX ||
+                        window.pageXOffset ||
+                        document.documentElement.scrollLeft ||
+                        0,
+                    scroll_y: window.scrollY ||
+                        window.pageYOffset ||
+                        document.documentElement.scrollTop ||
+                        0,
+                };
+            });
+            // Calculate derived values
+            const viewport_width = Math.floor(pageData.viewport_width);
+            const viewport_height = Math.floor(pageData.viewport_height);
+            const page_width = Math.floor(pageData.page_width);
+            const page_height = Math.floor(pageData.page_height);
+            const scroll_x = Math.floor(pageData.scroll_x);
+            const scroll_y = Math.floor(pageData.scroll_y);
+            // Calculate scroll information
+            const pixels_above = scroll_y;
+            const pixels_below = Math.max(0, page_height - (scroll_y + viewport_height));
+            const pixels_left = scroll_x;
+            const pixels_right = Math.max(0, page_width - (scroll_x + viewport_width));
             return {
-                // Current viewport dimensions
-                viewport_width: window.innerWidth,
-                viewport_height: window.innerHeight,
-                // Total page dimensions
-                page_width: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth || 0),
-                page_height: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight || 0),
-                // Current scroll position
-                scroll_x: window.scrollX ||
-                    window.pageXOffset ||
-                    document.documentElement.scrollLeft ||
-                    0,
-                scroll_y: window.scrollY ||
-                    window.pageYOffset ||
-                    document.documentElement.scrollTop ||
-                    0,
+                viewport_width,
+                viewport_height,
+                page_width,
+                page_height,
+                scroll_x,
+                scroll_y,
+                pixels_above,
+                pixels_below,
+                pixels_left,
+                pixels_right,
             };
-        });
-        // Calculate derived values
-        const viewport_width = Math.floor(pageData.viewport_width);
-        const viewport_height = Math.floor(pageData.viewport_height);
-        const page_width = Math.floor(pageData.page_width);
-        const page_height = Math.floor(pageData.page_height);
-        const scroll_x = Math.floor(pageData.scroll_x);
-        const scroll_y = Math.floor(pageData.scroll_y);
-        // Calculate scroll information
-        const pixels_above = scroll_y;
-        const pixels_below = Math.max(0, page_height - (scroll_y + viewport_height));
-        const pixels_left = scroll_x;
-        const pixels_right = Math.max(0, page_width - (scroll_x + viewport_width));
-        return {
-            viewport_width,
-            viewport_height,
-            page_width,
-            page_height,
-            scroll_x,
-            scroll_y,
-            pixels_above,
-            pixels_below,
-            pixels_left,
-            pixels_right,
-        };
+        }
+        finally {
+            await this.validate_page_after_action(targetPage);
+        }
     }
     /**
      * Get the HTML content of the current page
@@ -3052,7 +3644,13 @@ export class BrowserSession {
         if (!page) {
             return '';
         }
-        return await page.content();
+        await this.validate_page_after_action(page);
+        try {
+            return await page.content();
+        }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     /**
      * Get a debug view of the page structure including iframes
@@ -3062,6 +3660,7 @@ export class BrowserSession {
         if (!page) {
             return '';
         }
+        await this.validate_page_after_action(page);
         const debug_script = `(() => {
 			function getPageStructure(element = document, depth = 0, maxDepth = 10) {
 				if (depth >= maxDepth) return '';
@@ -3125,20 +3724,31 @@ export class BrowserSession {
 
 			return getPageStructure();
 		})()`;
-        return await page.evaluate(debug_script);
+        try {
+            return await page.evaluate(debug_script);
+        }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     // ==================== Navigation & History ====================
     /**
      * Navigate forward in browser history
      */
     async go_forward() {
+        const page = await this.get_current_page();
+        if (!page?.goForward) {
+            return;
+        }
+        await this.validate_page_after_action(page);
         try {
-            const page = await this.get_current_page();
-            if (page?.goForward) {
-                await page.goForward({ timeout: 10000, waitUntil: 'load' });
-            }
+            await page.goForward({ timeout: 10000, waitUntil: 'load' });
+            await this._waitForStableNetwork(page);
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             this.logger.debug(`⏭️ Error during go_forward: ${error.message}`);
             // Verify page is still usable after navigation error
             if (error.message.toLowerCase().includes('timeout')) {
@@ -3151,22 +3761,33 @@ export class BrowserSession {
                 }
             }
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     /**
      * Refresh the current page
      */
     async refresh() {
+        const page = await this.get_current_page();
+        if (!page?.reload) {
+            return;
+        }
+        await this.validate_page_after_action(page);
         try {
-            const page = await this.get_current_page();
-            if (page?.reload) {
-                this.currentPageLoadingStatus = null;
-                await page.reload({ waitUntil: 'domcontentloaded' });
-                await this._waitForStableNetwork(page);
-            }
+            this.currentPageLoadingStatus = null;
+            await page.reload({ waitUntil: 'domcontentloaded' });
+            await this._waitForStableNetwork(page);
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             this.logger.debug(`🔄 Error during refresh: ${error.message}`);
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     // ==================== Element Waiting ====================
     /**
@@ -3177,7 +3798,13 @@ export class BrowserSession {
         if (!page) {
             throw new Error('No page available');
         }
-        await page.waitForSelector(selector, { state: 'visible', timeout });
+        await this.validate_page_after_action(page);
+        try {
+            await page.waitForSelector(selector, { state: 'visible', timeout });
+        }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     // ==================== Screenshots ====================
     /**
@@ -3191,15 +3818,17 @@ export class BrowserSession {
         if (!page) {
             throw new Error('No page available for screenshot');
         }
+        await this.validate_page_after_action(page);
         if (!this.browser_context) {
             throw new Error('Browser context is not set');
         }
         // Check if it's a new tab page
         const url = page.url();
+        const logUrl = BrowserSession._redact_url_for_logging(url);
         if (url === 'about:blank' ||
             url === 'chrome://newtab/' ||
             url === 'edge://newtab/') {
-            this.logger.warning(`▫️ Skipping screenshot of empty page: ${url}`);
+            this.logger.warning(`▫️ Skipping screenshot of empty page: ${logUrl}`);
             // Return a 4px placeholder
             return 'iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAYAAACp8Z5+AAAAD0lEQVQIHWP8//8/AxYMACgtBP9g8jqYAAAAAElFTkSuQmCC';
         }
@@ -3213,7 +3842,7 @@ export class BrowserSession {
         // Take screenshot using CDP for better performance
         let cdp_session = null;
         try {
-            this.logger.debug(`📸 Taking ${full_page ? 'full-page' : 'viewport'} PNG screenshot via CDP: ${url}`);
+            this.logger.debug(`📸 Taking ${full_page ? 'full-page' : 'viewport'} PNG screenshot via CDP: ${logUrl}`);
             // Create CDP session for the screenshot
             cdp_session = await this.get_or_create_cdp_session(page);
             // Capture screenshot via CDP
@@ -3234,17 +3863,17 @@ export class BrowserSession {
             const screenshot_response = await cdp_session.send('Page.captureScreenshot', screenshotParams);
             const screenshot_b64 = screenshot_response.data;
             if (!screenshot_b64) {
-                throw new Error(`CDP returned empty screenshot data for page ${url}`);
+                throw new Error(`CDP returned empty screenshot data for page ${logUrl}`);
             }
             return screenshot_b64;
         }
         catch (error) {
             const error_str = error.message || String(error);
             if (error_str.toLowerCase().includes('timeout')) {
-                this.logger.warning(`⏱️ Screenshot timed out on page ${url}: ${error_str}`);
+                this.logger.warning(`⏱️ Screenshot timed out on page ${logUrl}: ${error_str}`);
             }
             else {
-                this.logger.error(`❌ Screenshot failed on page ${url}: ${error_str}`);
+                this.logger.error(`❌ Screenshot failed on page ${logUrl}: ${error_str}`);
             }
             throw error;
         }
@@ -3257,6 +3886,7 @@ export class BrowserSession {
                     // Ignore detach errors
                 }
             }
+            await this.validate_page_after_action(page);
         }
     }
     // ==================== Event Listeners ====================
@@ -3324,6 +3954,16 @@ export class BrowserSession {
                     // Keep tab url fallback when page url is unavailable.
                 }
             }
+            const exposedTab = this._sanitize_tab_for_exposure({
+                page_id,
+                tab_id,
+                url: currentUrl,
+                title: tab.title || currentUrl,
+            });
+            if (exposedTab.url !== currentUrl) {
+                tabs_info.push(exposedTab);
+                continue;
+            }
             // Skip chrome:// pages and new tab pages
             const isNewTab = currentUrl === 'about:blank' ||
                 currentUrl.startsWith('chrome://newtab');
@@ -3359,7 +3999,7 @@ export class BrowserSession {
                 tabs_info.push({ page_id, tab_id, url: currentUrl, title });
             }
             catch (error) {
-                this.logger.debug(`⚠️ Failed to get tab info for tab #${page_id}: ${currentUrl} (using fallback title)`);
+                this.logger.debug(`⚠️ Failed to get tab info for tab #${page_id}: ${BrowserSession._redact_url_for_logging(currentUrl)} (using fallback title)`);
                 if (isNewTab) {
                     tabs_info.push({
                         page_id,
@@ -3415,22 +4055,28 @@ export class BrowserSession {
                 viewport_height: 0,
             };
         }
-        return await page.evaluate(() => {
-            return {
-                scroll_x: window.scrollX ||
-                    window.pageXOffset ||
-                    document.documentElement.scrollLeft ||
-                    0,
-                scroll_y: window.scrollY ||
-                    window.pageYOffset ||
-                    document.documentElement.scrollTop ||
-                    0,
-                page_width: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth || 0),
-                page_height: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight || 0),
-                viewport_width: window.innerWidth,
-                viewport_height: window.innerHeight,
-            };
-        });
+        await this.validate_page_after_action(page);
+        try {
+            return await page.evaluate(() => {
+                return {
+                    scroll_x: window.scrollX ||
+                        window.pageXOffset ||
+                        document.documentElement.scrollLeft ||
+                        0,
+                    scroll_y: window.scrollY ||
+                        window.pageYOffset ||
+                        document.documentElement.scrollTop ||
+                        0,
+                    page_width: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth || 0),
+                    page_height: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight || 0),
+                    viewport_width: window.innerWidth,
+                    viewport_height: window.innerHeight,
+                };
+            });
+        }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     /**
      * Get a summary of the current browser state
@@ -3469,6 +4115,10 @@ export class BrowserSession {
     async get_minimal_state_summary(include_recent_events = false) {
         try {
             const page = await this.get_current_page();
+            if (page) {
+                await this._assert_page_url_allowed_or_rollback(page);
+                await this._syncCurrentTabFromPage(page);
+            }
             const url = page ? page.url() : 'unknown';
             // Try to get title safely
             let title = 'Page Load Error';
@@ -3554,11 +4204,13 @@ export class BrowserSession {
         if (!page) {
             throw new Error('No current page available');
         }
+        await this.validate_page_after_action(page);
         const page_url = page.url();
+        const logPageUrl = BrowserSession._redact_url_for_logging(page_url);
         // Check for new tab or chrome:// pages - fast path
         const is_empty_page = this._is_new_tab_page(page_url) || page_url.startsWith('chrome://');
         if (is_empty_page) {
-            this.logger.debug(`⚡ Fast path for empty page: ${page_url}`);
+            this.logger.debug(`⚡ Fast path for empty page: ${logPageUrl}`);
             // Create minimal DOM state
             const minimal_element_tree = new DOMElementNode(false, null, 'body', '', {}, []);
             const tabs_info = await this.get_tabs_info();
@@ -3604,8 +4256,14 @@ export class BrowserSession {
             await this.remove_highlights();
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             this.logger.debug('Timeout removing highlights');
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
         // Check for PDF and auto-download if needed
         try {
             const pdf_path = await this._auto_download_pdf_if_needed(page);
@@ -3614,8 +4272,14 @@ export class BrowserSession {
             }
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             this.logger.debug(`PDF auto-download check failed: ${error.message}`);
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
         // DOM processing
         this.logger.debug('🌳 Starting DOM processing...');
         const dom_service = new DomService(page, this.logger);
@@ -3627,12 +4291,18 @@ export class BrowserSession {
             this.logger.debug('✅ DOM processing completed');
         }
         catch (error) {
-            this.logger.warning(`DOM processing timed out for ${page_url}`);
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
+            this.logger.warning(`DOM processing timed out for ${logPageUrl}`);
             this.logger.warning('🔄 Falling back to minimal DOM state...');
             // Create minimal DOM state for fallback
             const minimal_element_tree = new DOMElementNode(true, null, 'body', '/body', {}, []);
             content = new DOMState(minimal_element_tree, {});
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
         // Get tabs info
         this.logger.debug('📋 Getting tabs info...');
         const tabs_info = await this.get_tabs_info();
@@ -3645,7 +4315,13 @@ export class BrowserSession {
                 screenshot_b64 = await this.take_screenshot();
             }
             catch (error) {
-                this.logger.warning(`❌ Screenshot failed for ${page_url}: ${error.message}`);
+                if (error instanceof URLNotAllowedError) {
+                    throw error;
+                }
+                this.logger.warning(`❌ Screenshot failed for ${logPageUrl}: ${error.message}`);
+            }
+            finally {
+                await this.validate_page_after_action(page);
             }
         }
         // Get page info and scroll info
@@ -3673,26 +4349,42 @@ export class BrowserSession {
             this.logger.debug('✅ Scroll info completed');
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             this.logger.warning(`Failed to get scroll info: ${error.message}`);
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
         // Get title
         let title = 'Title unavailable';
         try {
+            await this.validate_page_after_action(page);
             const titlePromise = page.title();
             const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000));
             title = await Promise.race([titlePromise, timeoutPromise]);
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             // Keep default title
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
         // Check for errors
         const browser_errors = [];
         if (Object.keys(content.selector_map).length === 0) {
-            browser_errors.push(`DOM processing timed out for ${page_url} - using minimal state. Basic navigation still available.`);
+            browser_errors.push(`DOM processing timed out for ${logPageUrl} - using minimal state. Basic navigation still available.`);
         }
         // Check if PDF viewer
+        await this.validate_page_after_action(page);
         const is_pdf_viewer = await this._is_pdf_viewer(page);
+        await this.validate_page_after_action(page);
         const pendingNetworkRequests = await this._getPendingNetworkRequests(page);
+        await this.validate_page_after_action(page);
         const paginationButtons = DomService.detect_pagination_buttons(content.selector_map);
         const browser_state = new BrowserStateSummary(content, {
             url: page_url,
@@ -3713,6 +4405,7 @@ export class BrowserSession {
             closed_popup_messages: this._getClosedPopupMessagesSnapshot(),
         });
         this.logger.debug('✅ get_state_summary completed successfully');
+        await this.validate_page_after_action(page);
         return browser_state;
     }
     /**
@@ -3722,6 +4415,7 @@ export class BrowserSession {
         return (url === 'about:blank' ||
             url === 'about:newtab' ||
             url === 'chrome://newtab/' ||
+            url === 'chrome://newtab' ||
             url === 'chrome://new-tab-page/' ||
             url === 'chrome://new-tab-page');
     }
@@ -3747,10 +4441,16 @@ export class BrowserSession {
         // so keep parity with pattern matching default: https-only.
         return protocol.toLowerCase() === 'https:';
     }
+    _domainCollectionHasEntries(value) {
+        return Array.isArray(value)
+            ? value.length > 0
+            : value instanceof Set && value.size > 0;
+    }
     /**
      * Check if page is displaying a PDF
      */
     async _is_pdf_viewer(page) {
+        await this.validate_page_after_action(page);
         try {
             const url = page.url();
             if (url.endsWith('.pdf') || url.includes('.pdf?')) {
@@ -3764,8 +4464,14 @@ export class BrowserSession {
             return is_pdf;
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             return false;
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     /**
      * Auto-download PDF if detected and auto-download is enabled
@@ -3775,13 +4481,15 @@ export class BrowserSession {
         if (!downloadsPath || !this._autoDownloadPdfs) {
             return null;
         }
+        await this.validate_page_after_action(page);
         try {
             const is_pdf = await this._is_pdf_viewer(page);
             if (!is_pdf) {
                 return null;
             }
             const url = page.url();
-            this.logger.info(`📄 PDF detected: ${url}`);
+            const logUrl = BrowserSession._redact_url_for_logging(url);
+            this.logger.info(`📄 PDF detected: ${logUrl}`);
             let pdfFilename = path.basename(url.split('?')[0]);
             if (!pdfFilename || !pdfFilename.toLowerCase().endsWith('.pdf')) {
                 const parsed = new URL(url);
@@ -3794,50 +4502,58 @@ export class BrowserSession {
                 this.logger.debug(`📄 PDF already downloaded: ${pdfFilename}`);
                 return null;
             }
-            this.logger.info(`📄 Auto-downloading PDF from: ${url}`);
-            const downloadResult = await page.evaluate(async (pdfUrl) => {
-                try {
-                    const response = await fetch(pdfUrl, {
-                        cache: 'force-cache',
-                    });
-                    if (!response.ok) {
-                        throw new Error(`HTTP error! status: ${response.status}`);
+            this.logger.info(`📄 Auto-downloading PDF from: ${logUrl}`);
+            await this.validate_page_after_action(page);
+            let downloadResult = null;
+            try {
+                downloadResult = await page.evaluate(async (pdfUrl) => {
+                    try {
+                        const response = await fetch(pdfUrl, {
+                            cache: 'force-cache',
+                        });
+                        if (!response.ok) {
+                            throw new Error(`HTTP error! status: ${response.status}`);
+                        }
+                        const blob = await response.blob();
+                        const arrayBuffer = await blob.arrayBuffer();
+                        const uint8Array = new Uint8Array(arrayBuffer);
+                        const cacheHeader = response.headers.get('x-cache') || '';
+                        const fromCache = response.headers.has('age') ||
+                            cacheHeader.toLowerCase().includes('hit');
+                        return {
+                            data: Array.from(uint8Array),
+                            fromCache,
+                            responseSize: uint8Array.length,
+                        };
                     }
-                    const blob = await response.blob();
-                    const arrayBuffer = await blob.arrayBuffer();
-                    const uint8Array = new Uint8Array(arrayBuffer);
-                    const cacheHeader = response.headers.get('x-cache') || '';
-                    const fromCache = response.headers.has('age') ||
-                        cacheHeader.toLowerCase().includes('hit');
-                    return {
-                        data: Array.from(uint8Array),
-                        fromCache,
-                        responseSize: uint8Array.length,
-                    };
-                }
-                catch (error) {
-                    return {
-                        data: [],
-                        fromCache: false,
-                        responseSize: 0,
-                        error: error instanceof Error ? error.message : 'Unknown fetch error',
-                    };
-                }
-            }, url);
+                    catch (error) {
+                        return {
+                            data: [],
+                            fromCache: false,
+                            responseSize: 0,
+                            error: error instanceof Error ? error.message : 'Unknown fetch error',
+                        };
+                    }
+                }, url);
+            }
+            finally {
+                await this.validate_page_after_action(page);
+            }
             if (downloadResult?.error) {
-                this.logger.warning(`⚠️ Failed to auto-download PDF from ${url}: ${downloadResult.error}`);
+                this.logger.warning(`⚠️ Failed to auto-download PDF from ${logUrl}: ${downloadResult.error}`);
                 return null;
             }
             if (!downloadResult ||
                 !Array.isArray(downloadResult.data) ||
                 downloadResult.data.length === 0) {
-                this.logger.warning(`⚠️ No data received when downloading PDF from ${url}`);
+                this.logger.warning(`⚠️ No data received when downloading PDF from ${logUrl}`);
                 return null;
             }
-            await fs.promises.mkdir(downloadsPath, { recursive: true });
+            ensurePrivateDirectoryIfCreated(downloadsPath);
             const uniqueFilename = await BrowserSession.get_unique_filename(downloadsPath, pdfFilename);
             const downloadPath = path.join(downloadsPath, uniqueFilename);
-            await fs.promises.writeFile(downloadPath, Buffer.from(downloadResult.data));
+            await fs.promises.writeFile(downloadPath, Buffer.from(downloadResult.data), { mode: 0o600 });
+            chmodPrivateFileBestEffort(downloadPath);
             this.add_downloaded_file(downloadPath);
             const cacheStatus = downloadResult.fromCache
                 ? 'from cache'
@@ -3847,6 +4563,9 @@ export class BrowserSession {
             return downloadPath;
         }
         catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                throw error;
+            }
             this.logger.debug(`PDF detection failed: ${error.message}`);
             return null;
         }
@@ -3872,6 +4591,7 @@ export class BrowserSession {
         if (!page) {
             return null;
         }
+        await this.validate_page_after_action(page);
         try {
             // Use XPath to locate the element
             const element_handle = await page
@@ -3899,6 +4619,7 @@ export class BrowserSession {
         if (!page) {
             return null;
         }
+        await this.validate_page_after_action(page);
         try {
             // Use CSS selector to locate the element
             const element_handle = await page.locator(css_selector).elementHandle();
@@ -3927,6 +4648,7 @@ export class BrowserSession {
         if (!page) {
             return null;
         }
+        await this.validate_page_after_action(page);
         try {
             // Build selector: filter by element type and text
             const selector = element_type
@@ -4023,8 +4745,19 @@ export class BrowserSession {
         catch {
             return 'invalid_url';
         }
-        if (parsed.protocol === 'data:' || parsed.protocol === 'blob:') {
-            return null;
+        const allowedDomains = this.browser_profile.allowed_domains;
+        const hasAllowedDomains = this._domainCollectionHasEntries(allowedDomains);
+        const prohibitedDomains = this.browser_profile.prohibited_domains;
+        const hasProhibitedDomains = this._domainCollectionHasEntries(prohibitedDomains);
+        const hasDomainRestrictions = hasAllowedDomains || hasProhibitedDomains;
+        if (parsed.protocol === 'data:') {
+            return hasDomainRestrictions ? 'opaque_origin_blocked' : null;
+        }
+        if (parsed.protocol === 'blob:') {
+            if (parsed.origin && parsed.origin !== 'null') {
+                return this._get_url_access_denial_reason(parsed.origin);
+            }
+            return hasDomainRestrictions ? 'opaque_origin_blocked' : null;
         }
         if (!parsed.hostname) {
             return 'missing_host';
@@ -4034,50 +4767,44 @@ export class BrowserSession {
             this._is_ip_address_host(parsed.hostname)) {
             return 'ip_address_blocked';
         }
-        const allowedDomains = this.browser_profile.allowed_domains;
-        if (allowedDomains &&
-            ((Array.isArray(allowedDomains) && allowedDomains.length > 0) ||
-                (allowedDomains instanceof Set && allowedDomains.size > 0))) {
-            if (allowedDomains instanceof Set) {
-                if (this._setEntryMatchesUrl(allowedDomains, hostVariant, hostAlt, parsed.protocol)) {
-                    return null;
+        if (prohibitedDomains && hasProhibitedDomains) {
+            if (prohibitedDomains instanceof Set) {
+                if (this._setEntryMatchesUrl(prohibitedDomains, hostVariant, hostAlt, parsed.protocol)) {
+                    return 'in_prohibited_domains';
                 }
             }
             else {
-                for (const allowedDomain of allowedDomains) {
+                for (const prohibitedDomain of prohibitedDomains) {
                     try {
-                        if (match_url_with_domain_pattern(url, allowedDomain, true)) {
-                            return null;
+                        if (match_url_with_domain_pattern(url, prohibitedDomain, true)) {
+                            return 'in_prohibited_domains';
                         }
                     }
                     catch {
-                        this.logger.warning(`Invalid domain pattern: ${allowedDomain}`);
+                        this.logger.warning(`Invalid domain pattern: ${prohibitedDomain}`);
                     }
                 }
             }
-            return 'not_in_allowed_domains';
         }
-        const prohibitedDomains = this.browser_profile.prohibited_domains;
-        if (prohibitedDomains &&
-            ((Array.isArray(prohibitedDomains) && prohibitedDomains.length > 0) ||
-                (prohibitedDomains instanceof Set && prohibitedDomains.size > 0))) {
-            if (prohibitedDomains instanceof Set) {
-                if (this._setEntryMatchesUrl(prohibitedDomains, hostVariant, hostAlt, parsed.protocol)) {
-                    return 'in_prohibited_domains';
+        if (allowedDomains && hasAllowedDomains) {
+            if (allowedDomains instanceof Set) {
+                if (this._setEntryMatchesUrl(allowedDomains, hostVariant, hostAlt, parsed.protocol)) {
+                    return null;
                 }
             }
             else {
-                for (const prohibitedDomain of prohibitedDomains) {
+                for (const allowedDomain of allowedDomains) {
                     try {
-                        if (match_url_with_domain_pattern(url, prohibitedDomain, true)) {
-                            return 'in_prohibited_domains';
+                        if (match_url_with_domain_pattern(url, allowedDomain, true)) {
+                            return null;
                         }
                     }
                     catch {
-                        this.logger.warning(`Invalid domain pattern: ${prohibitedDomain}`);
+                        this.logger.warning(`Invalid domain pattern: ${allowedDomain}`);
                     }
                 }
             }
+            return 'not_in_allowed_domains';
         }
         return null;
     }
@@ -4090,25 +4817,150 @@ export class BrowserSession {
         }
         return JSON.stringify(value ?? null);
     }
+    _has_url_access_restrictions() {
+        return (this._domainCollectionHasEntries(this.browser_profile.allowed_domains) ||
+            this._domainCollectionHasEntries(this.browser_profile.prohibited_domains) ||
+            Boolean(this.browser_profile.block_ip_addresses));
+    }
+    _sanitize_tab_for_exposure(tab) {
+        if (!this._has_url_access_restrictions()) {
+            return { ...tab };
+        }
+        const denialReason = this._get_url_access_denial_reason(tab.url);
+        if (!denialReason) {
+            return { ...tab };
+        }
+        return {
+            ...tab,
+            url: 'about:blank',
+            title: 'blocked by domain policy',
+        };
+    }
     _assert_url_allowed(url) {
         const denialReason = this._get_url_access_denial_reason(url);
         if (!denialReason) {
             return;
         }
+        const safeUrl = BrowserSession._redact_url_for_logging(url);
         this._recordRecentEvent('navigation_blocked', {
-            url,
+            url: safeUrl,
             error_message: denialReason,
         });
         if (denialReason === 'not_in_allowed_domains') {
-            throw new URLNotAllowedError(`URL ${url} is not in allowed_domains. Current allowed_domains: ${this._formatDomainCollection(this.browser_profile.allowed_domains)}`);
+            throw new URLNotAllowedError(`URL ${safeUrl} is not in allowed_domains. Current allowed_domains: ${this._formatDomainCollection(this.browser_profile.allowed_domains)}`);
         }
         if (denialReason === 'in_prohibited_domains') {
-            throw new URLNotAllowedError(`URL ${url} is blocked by prohibited_domains. Current prohibited_domains: ${this._formatDomainCollection(this.browser_profile.prohibited_domains)}`);
+            throw new URLNotAllowedError(`URL ${safeUrl} is blocked by prohibited_domains. Current prohibited_domains: ${this._formatDomainCollection(this.browser_profile.prohibited_domains)}`);
         }
         if (denialReason === 'ip_address_blocked') {
-            throw new URLNotAllowedError(`URL ${url} is blocked because block_ip_addresses=true`);
+            throw new URLNotAllowedError(`URL ${safeUrl} is blocked because block_ip_addresses=true`);
+        }
+        if (denialReason === 'opaque_origin_blocked') {
+            throw new URLNotAllowedError(`URL ${safeUrl} is blocked because its origin cannot be validated against domain restrictions`);
+        }
+        throw new URLNotAllowedError(`URL ${safeUrl} is not allowed (${denialReason})`);
+    }
+    async _rollback_disallowed_navigation(page, blockedUrl, options = {}) {
+        this.logger.warning(`Blocked navigation reached disallowed URL ${BrowserSession._redact_url_for_logging(blockedUrl)}; resetting current tab to about:blank`);
+        try {
+            await page.goto('about:blank', { waitUntil: 'load', timeout: 5000 });
+        }
+        catch (rollbackError) {
+            this.logger.debug(`Failed to reset disallowed navigation to about:blank: ${rollbackError.message}`);
+        }
+        const currentUrl = typeof page.url === 'function' ? page.url() : 'about:blank';
+        if (this._is_new_tab_page(currentUrl)) {
+            this.currentUrl = 'about:blank';
+            this.currentTitle = 'about:blank';
+            const tab = this._tabs[this.currentTabIndex];
+            if (tab) {
+                tab.url = 'about:blank';
+                tab.title = 'about:blank';
+            }
+            this._syncSessionManagerFromTabs();
+            this.cachedBrowserState = null;
+            return;
+        }
+        if (options.replace_on_failure ?? true) {
+            await this._replace_disallowed_current_page(page, blockedUrl);
+        }
+    }
+    async _replace_disallowed_current_page(page, blockedUrl) {
+        const safeUrl = BrowserSession._redact_url_for_logging(blockedUrl);
+        let replacementPage = null;
+        const canCreateReplacement = typeof this.browser_context?.newPage === 'function';
+        if (canCreateReplacement) {
+            try {
+                replacementPage = await this.browser_context.newPage();
+                try {
+                    await replacementPage.goto('about:blank', {
+                        waitUntil: 'load',
+                        timeout: 5000,
+                    });
+                }
+                catch (error) {
+                    this.logger.debug(`Failed to initialize replacement blank tab after blocked navigation to ${safeUrl}: ${error.message}`);
+                }
+                const replacementUrl = typeof replacementPage.url === 'function'
+                    ? replacementPage.url()
+                    : 'about:blank';
+                if (!this._is_new_tab_page(replacementUrl)) {
+                    await replacementPage.close?.();
+                    replacementPage = null;
+                }
+            }
+            catch (error) {
+                this.logger.debug(`Failed to create replacement blank tab after blocked navigation to ${safeUrl}: ${error.message}`);
+                replacementPage = null;
+            }
+        }
+        try {
+            await page.close?.();
+        }
+        catch (error) {
+            this.logger.debug(`Failed to close blocked page after rollback failure: ${error.message}`);
+        }
+        this.currentUrl = 'about:blank';
+        this.currentTitle = 'about:blank';
+        const tab = this._tabs[this.currentTabIndex];
+        if (tab) {
+            tab.url = 'about:blank';
+            tab.title = 'about:blank';
+        }
+        if (this.human_current_page === page) {
+            this.human_current_page = replacementPage;
+        }
+        this._setActivePage(replacementPage);
+        this._syncSessionManagerFromTabs();
+        this.cachedBrowserState = null;
+    }
+    async _assert_page_url_allowed_or_rollback(page, options = {}) {
+        const currentUrl = typeof page.url === 'function' ? page.url() : 'about:blank';
+        try {
+            this._assert_url_allowed(currentUrl);
+        }
+        catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                await this._rollback_disallowed_navigation(page, currentUrl, options);
+            }
+            throw error;
+        }
+    }
+    async _get_disallowed_page_error_after_navigation_error(page, options = {}) {
+        if (!page) {
+            return null;
+        }
+        try {
+            await this._assert_page_url_allowed_or_rollback(page, options);
+            return null;
+        }
+        catch (error) {
+            if (error instanceof URLNotAllowedError) {
+                return error;
+            }
+            this.logger.debug(`Failed to inspect page URL after navigation error: ${error.message}`);
+            return null;
         }
-        throw new URLNotAllowedError(`URL ${url} is not allowed (${denialReason})`);
     }
     /**
      * Navigate helper with URL validation
@@ -4182,88 +5034,98 @@ export class BrowserSession {
         if (!element_handle) {
             throw new Error(`Element not found: ${JSON.stringify(element_node)}`);
         }
-        // Check if downloads are enabled
-        const downloads_path = this.browser_profile.downloads_path;
-        if (downloads_path) {
-            fs.mkdirSync(downloads_path, { recursive: true });
-            // Try to detect file download.
-            const download_promise = page.waitForEvent('download', {
-                timeout: 5000,
-            });
-            // Click failures should bubble to the caller.
-            try {
-                await element_handle.click();
-            }
-            catch (error) {
-                void download_promise.catch(() => undefined);
-                throw error;
-            }
-            let download;
-            try {
-                download = await download_promise;
+        const validateClickNavigation = async () => {
+            await this._waitForLoad(page, 5000);
+            await this._assert_page_url_allowed_or_rollback(page);
+            await this._syncCurrentTabFromPage(page);
+            if (this.historyStack[this.historyStack.length - 1] !== this.currentUrl) {
+                this.historyStack.push(this.currentUrl);
             }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                const isDownloadTimeout = error instanceof Error &&
-                    (error.name === 'TimeoutError' ||
-                        message.toLowerCase().includes('timeout'));
-                if (!isDownloadTimeout) {
+            this.cachedBrowserState = null;
+        };
+        try {
+            // Check if downloads are enabled
+            const downloads_path = this.browser_profile.downloads_path;
+            if (downloads_path) {
+                ensurePrivateDirectoryIfCreated(downloads_path);
+                // Try to detect file download.
+                const download_promise = page.waitForEvent('download', {
+                    timeout: 5000,
+                });
+                // Click failures should bubble to the caller.
+                try {
+                    await element_handle.click();
+                }
+                catch (error) {
+                    void download_promise.catch(() => undefined);
                     throw error;
                 }
-                this.logger.debug('No download triggered within timeout. Checking navigation...');
+                let download;
                 try {
-                    await page.waitForLoadState();
+                    download = await download_promise;
                 }
-                catch (e) {
-                    this.logger.warning(`Navigation check failed: ${e.message}`);
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    const isDownloadTimeout = error instanceof Error &&
+                        (error.name === 'TimeoutError' ||
+                            message.toLowerCase().includes('timeout'));
+                    if (!isDownloadTimeout) {
+                        throw error;
+                    }
+                    this.logger.debug('No download triggered within timeout. Checking navigation...');
+                    return null;
                 }
-                return null;
+                // Save the downloaded file.
+                const suggested_filename = download.suggestedFilename();
+                const unique_filename = await BrowserSession.get_unique_filename(downloads_path, suggested_filename);
+                const download_path = path.join(downloads_path, unique_filename);
+                const download_guid = uuid7str();
+                const download_url = typeof download.url === 'function'
+                    ? download.url()
+                    : (this.currentUrl ?? '');
+                await this._assert_download_url_allowed(download, download_url);
+                await this.event_bus.dispatch(new DownloadStartedEvent({
+                    guid: download_guid,
+                    url: download_url,
+                    suggested_filename,
+                    auto_download: false,
+                }));
+                await download.saveAs(download_path);
+                chmodPrivateFileBestEffort(download_path);
+                this.logger.info(`⬇️ Downloaded file to: ${download_path}`);
+                const stats = fs.existsSync(download_path)
+                    ? fs.statSync(download_path)
+                    : null;
+                await this.event_bus.dispatch(new DownloadProgressEvent({
+                    guid: download_guid,
+                    received_bytes: stats?.size ?? 0,
+                    total_bytes: stats?.size ?? 0,
+                    state: 'completed',
+                }));
+                const fileDownloadedResult = await this.event_bus.dispatch(new FileDownloadedEvent({
+                    guid: download_guid,
+                    url: download_url,
+                    path: download_path,
+                    file_name: unique_filename,
+                    file_size: stats?.size ?? 0,
+                    file_type: path.extname(unique_filename).replace('.', '') || null,
+                    mime_type: null,
+                    auto_download: false,
+                }));
+                if (fileDownloadedResult.handler_results.length === 0) {
+                    this.add_downloaded_file(download_path);
+                }
+                return download_path;
             }
-            // Save the downloaded file.
-            const suggested_filename = download.suggestedFilename();
-            const unique_filename = await BrowserSession.get_unique_filename(downloads_path, suggested_filename);
-            const download_path = path.join(downloads_path, unique_filename);
-            const download_guid = uuid7str();
-            const download_url = typeof download.url === 'function'
-                ? download.url()
-                : (this.currentUrl ?? '');
-            await this.event_bus.dispatch(new DownloadStartedEvent({
-                guid: download_guid,
-                url: download_url,
-                suggested_filename,
-                auto_download: false,
-            }));
-            await download.saveAs(download_path);
-            this.logger.info(`⬇️ Downloaded file to: ${download_path}`);
-            const stats = fs.existsSync(download_path)
-                ? fs.statSync(download_path)
-                : null;
-            await this.event_bus.dispatch(new DownloadProgressEvent({
-                guid: download_guid,
-                received_bytes: stats?.size ?? 0,
-                total_bytes: stats?.size ?? 0,
-                state: 'completed',
-            }));
-            const fileDownloadedResult = await this.event_bus.dispatch(new FileDownloadedEvent({
-                guid: download_guid,
-                url: download_url,
-                path: download_path,
-                file_name: unique_filename,
-                file_size: stats?.size ?? 0,
-                file_type: path.extname(unique_filename).replace('.', '') || null,
-                mime_type: null,
-                auto_download: false,
-            }));
-            if (fileDownloadedResult.handler_results.length === 0) {
-                this.add_downloaded_file(download_path);
+            else {
+                // No downloads path configured, just click
+                await element_handle.click();
             }
-            return download_path;
+            return null;
         }
-        else {
-            // No downloads path configured, just click
-            await element_handle.click();
+        finally {
+            await validateClickNavigation();
         }
-        return null;
     }
     /**
      * Remove all highlights from the current page
@@ -4309,6 +5171,9 @@ export class BrowserSession {
         catch (error) {
             this.logger.debug(`Failed to remove highlights: ${error.message}`);
         }
+        finally {
+            await this.validate_page_after_action(page);
+        }
     }
     // region - Trace Recording
     /**
@@ -4329,6 +5194,11 @@ export class BrowserSession {
      * Note: Currently optional as it may cause performance issues in some cases
      */
     async _startContextTracing() {
+        if (this.browser_profile.traces_dir &&
+            this._has_url_access_restrictions()) {
+            this.logger.warning('Skipping trace recording because domain restrictions are active and trace artifacts cannot be URL-filtered.');
+            return;
+        }
         if (this.browser_profile.traces_dir && this.browser_context) {
             try {
                 this.logger.debug(`📽️ Starting tracing (will save to: ${this.browser_profile.traces_dir})`);
@@ -4348,6 +5218,10 @@ export class BrowserSession {
      * Save browser trace recording
      */
     async _saveTraceRecording() {
+        if (this.browser_profile.traces_dir &&
+            this._has_url_access_restrictions()) {
+            return;
+        }
         if (this.browser_profile.traces_dir && this.browser_context) {
             try {
                 const tracesPath = this.browser_profile.traces_dir;
@@ -4362,8 +5236,10 @@ export class BrowserSession {
                     const traceFilename = `BrowserSession_${this.id}.zip`;
                     finalTracePath = path.join(tracesPath, traceFilename);
                 }
+                ensurePrivateDirectoryIfCreated(path.dirname(finalTracePath));
                 this.logger.info(`🎥 Saving browser_context trace to ${finalTracePath}...`);
                 await this.browser_context.tracing.stop({ path: finalTracePath });
+                chmodPrivateFileBestEffort(finalTracePath);
             }
             catch (error) {
                 this.logger.warning(`Failed to save trace recording: ${error.message}`);
@@ -4608,6 +5484,7 @@ export class BrowserSession {
      * @returns true if successful, false otherwise
      */
     async _forceClosePageViaCdp(pageUrl) {
+        const logPageUrl = BrowserSession._redact_url_for_logging(pageUrl);
         try {
             if (!this.browser_context) {
                 throw new Error('Browser context is not set up yet');
@@ -4644,7 +5521,7 @@ export class BrowserSession {
                     }
                     if (blockedTargetId) {
                         // Force close the target
-                        this.logger.warning(`🪓 Force-closing crashed page target_id=${blockedTargetId} via CDP: ${pageUrl.substring(0, 50)}...`);
+                        this.logger.warning(`🪓 Force-closing crashed page target_id=${blockedTargetId} via CDP: ${logPageUrl}`);
                         await Promise.race([
                             cdpSession.send('Target.closeTarget', {
                                 targetId: blockedTargetId,
@@ -4654,7 +5531,7 @@ export class BrowserSession {
                         return true;
                     }
                     else {
-                        this.logger.debug(`❌ Could not find CDP page target_id to force-close: ${pageUrl.substring(0, 50)} (concurrency issues?)`);
+                        this.logger.debug(`❌ Could not find CDP page target_id to force-close: ${logPageUrl} (concurrency issues?)`);
                         return false;
                     }
                 }
@@ -4693,8 +5570,14 @@ export class BrowserSession {
             return false;
         }
         const timeout = timeoutMs || this.browser_profile.default_navigation_timeout || 6000;
+        const logUrl = BrowserSession._redact_url_for_logging(url);
+        const denialReason = this._get_url_access_denial_reason(url);
+        if (denialReason) {
+            this.logger.warning(`Skipping recovery reopen for disallowed URL: ${denialReason}`);
+            return false;
+        }
         try {
-            this.logger.debug(`🔄 Attempting to reload URL that crashed: ${url.substring(0, 50)}`);
+            this.logger.debug(`🔄 Attempting to reload URL that crashed: ${logUrl}`);
             if (!this.browser_context) {
                 throw new Error('Browser context is not set');
             }
@@ -4717,31 +5600,55 @@ export class BrowserSession {
                 ]);
             }
             catch (error) {
-                this.logger.debug(`⚠️ Attempting to reload previously crashed URL ${url.substring(0, 50)} failed again: ${error.name}`);
+                this.logger.debug(`⚠️ Attempting to reload previously crashed URL ${logUrl} failed again: ${error.name}`);
+            }
+            try {
+                await this._assert_page_url_allowed_or_rollback(newPage, {
+                    replace_on_failure: false,
+                });
+            }
+            catch (error) {
+                if (error instanceof URLNotAllowedError) {
+                    this.logger.warning(`Skipping recovery reopen after redirect to disallowed URL: ${error.message}`);
+                    try {
+                        await newPage.close?.();
+                    }
+                    catch {
+                        // Ignore cleanup errors; the page was already reset best effort.
+                    }
+                    if (this.agent_current_page === newPage) {
+                        this.agent_current_page = null;
+                    }
+                    if (this.human_current_page === newPage) {
+                        this.human_current_page = null;
+                    }
+                    return false;
+                }
+                throw error;
             }
             // Wait a bit for any transient blocking to resolve
             await new Promise((resolve) => setTimeout(resolve, 1000));
             // Check if the reopened page is responsive
             const isResponsive = await this._isPageResponsive(newPage, 2.0);
             if (isResponsive) {
-                this.logger.info(`✅ Page recovered and is now responsive after reopening on: ${url.substring(0, 50)}`);
+                this.logger.info(`✅ Page recovered and is now responsive after reopening on: ${logUrl}`);
                 return true;
             }
             else {
-                this.logger.warning(`⚠️ Reopened page ${url.substring(0, 50)} is still unresponsive`);
+                this.logger.warning(`⚠️ Reopened page ${logUrl} is still unresponsive`);
                 // Close the unresponsive page before returning
                 try {
                     await this._forceClosePageViaCdp(newPage.url());
                 }
                 catch (error) {
-                    this.logger.error(`❌ Failed to close crashed page ${url.substring(0, 50)} via CDP: ${error.message} (something is very wrong or system is extremely overloaded)`);
+                    this.logger.error(`❌ Failed to close crashed page ${logUrl} via CDP: ${error.message} (something is very wrong or system is extremely overloaded)`);
                 }
                 this.agent_current_page = null; // Clear reference to closed page
                 return false;
             }
         }
         catch (error) {
-            this.logger.error(`❌ Retrying crashed page ${url.substring(0, 50)} failed: ${error.message}`);
+            this.logger.error(`❌ Retrying crashed page ${logUrl} failed: ${error.message}`);
             return false;
         }
     }
@@ -4750,7 +5657,7 @@ export class BrowserSession {
      * @param url - The original URL that failed
      */
     async _createBlankFallbackPage(url) {
-        this.logger.warning(`⚠️ Resetting to about:blank as fallback because browser is unable to load the original URL without crashing: ${url.substring(0, 50)}`);
+        this.logger.warning(`⚠️ Resetting to about:blank as fallback because browser is unable to load the original URL without crashing: ${BrowserSession._redact_url_for_logging(url)}`);
         // Close any existing broken page
         if (this.agent_current_page && !this.agent_current_page.isClosed()) {
             try {
@@ -4832,7 +5739,7 @@ export class BrowserSession {
                         !pageUrl.startsWith('edge://')) {
                         try {
                             await page.close();
-                            this.logger.debug(`🪓 Closed page because it has a known crash-causing URL: ${pageUrl.substring(0, 50)}`);
+                            this.logger.debug(`🪓 Closed page because it has a known crash-causing URL: ${BrowserSession._redact_url_for_logging(pageUrl)}`);
                         }
                         catch {
                             // Page might already be closed via CDP
@@ -4974,7 +5881,7 @@ export class BrowserSession {
         }
         // Ensure directory exists
         if (!fs.existsSync(userDataDir)) {
-            fs.mkdirSync(userDataDir, { recursive: true });
+            ensurePrivateDirectoryIfCreated(userDataDir);
             this.logger.debug(`Created user data directory: ${userDataDir}`);
         }
         return userDataDir;
@@ -5038,9 +5945,10 @@ export class BrowserSession {
      * Create a temporary user data directory
      */
     async _createTempUserDataDir() {
-        const osTempDir = os.tmpdir();
-        const tempDir = path.join(osTempDir, `browser-use-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-        fs.mkdirSync(tempDir, { recursive: true });
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'browser-use-user-data-dir-'));
+        if (process.platform !== 'win32') {
+            fs.chmodSync(tempDir, 0o700);
+        }
         return tempDir;
     }
     // endregion
@@ -5055,7 +5963,7 @@ export class BrowserSession {
         }
         // Listen for page events to track which page the user is viewing
         this.browser_context.on?.('page', (page) => {
-            this.logger.debug(`New page created: ${page.url?.() || 'about:blank'}`);
+            this.logger.debug(`New page created: ${BrowserSession._redact_url_for_logging(page.url?.() || 'about:blank')}`);
             // Note: 'visibilitychange' is not a standard Playwright page event
             // Visibility tracking would need to be implemented differently
             // (e.g., through page.evaluate polling or browser context events)
@@ -5076,7 +5984,7 @@ export class BrowserSession {
                 .evaluate?.(() => document.visibilityState === 'visible')
                 .then((isVisible) => {
                 if (isVisible) {
-                    this.logger.debug(`Tab became visible: ${page.url?.() || 'unknown'}`);
+                    this.logger.debug(`Tab became visible: ${BrowserSession._redact_url_for_logging(page.url?.() || 'unknown')}`);
                     this.human_current_page = page;
                 }
             })