chrome-devtools-mcp 0.18.0 → 0.19.0

package/build/src/third_party/index.js

@@ -2,34 +2,36 @@ import process$2 from 'node:process';
 import readline from 'node:readline';
 import * as WorkerThreads from 'node:worker_threads';
 import require$$2, { strictEqual, notStrictEqual } from 'assert';
-import require$$1$4, { resolve as resolve$2, dirname, normalize, join, relative, extname, basename } from 'path';
-import require$$0$7, { statSync, readdirSync, readFileSync, writeFile } from 'fs';
+import require$$0$4, { resolve as resolve$2, dirname, normalize, join, relative, extname, basename } from 'path';
+import require$$0$3, { statSync, readdirSync, readFileSync, writeFile } from 'fs';
 import require$$0$2, { format as format$5, inspect } from 'util';
 import require$$5, { fileURLToPath } from 'url';
 import { createRequire } from 'node:module';
 import fs, { readdirSync as readdirSync$1, readFileSync as readFileSync$1, accessSync, existsSync } from 'node:fs';
 import require$$1 from 'tty';
 import require$$0$1 from 'os';
+import require$$0$5 from 'child_process';
+import { PassThrough } from 'node:stream';
 import { mkdtemp, unlink, rename, readFile } from 'node:fs/promises';
 import os, { tmpdir } from 'node:os';
 import path$1, { join as join$1, dirname as dirname$1 } from 'node:path';
-import childProcess, { execSync, spawnSync, spawn } from 'node:child_process';
+import childProcess, { execSync, spawnSync, spawn as spawn$1 } from 'node:child_process';
 import { EventEmitter as EventEmitter$1 } from 'node:events';
 import * as http$1 from 'node:http';
 import * as https$1 from 'node:https';
 import { urlToHttpOptions, URL as URL$1 } from 'node:url';
-import require$$0$3 from 'http';
+import require$$0$6 from 'http';
 import require$$1$1 from 'https';
-import require$$0$4 from 'net';
+import require$$0$7 from 'net';
 import require$$1$2 from 'tls';
-import require$$0$5 from 'events';
-import require$$0$6 from 'buffer';
+import require$$0$8 from 'events';
+import require$$0$9 from 'buffer';
 import require$$1$3 from 'stream';
 import require$$3$3 from 'dns';
 import require$$2$1 from 'crypto';
 import 'node:assert';
-import { PassThrough } from 'node:stream';
-import require$$0$8 from 'zlib';
+import require$$0$a from 'zlib';
+import { generateReport as generateReport$1, navigation as navigation$1, snapshot as snapshot$1 } from './lighthouse-devtools-mcp-bundle.js';
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {
@@ -20966,7 +20968,7 @@ const ToolListChangedNotificationSchema = NotificationSchema.extend({
     method: literal('notifications/tools/list_changed'),
     params: NotificationsParamsSchema.optional()
 });
-object({
+const ListChangedOptionsBaseSchema = object({
     autoRefresh: boolean().default(true),
     debounceMs: number().int().nonnegative().default(300)
 });
@@ -36675,273 +36677,333 @@ class ExperimentalServerTasks {
     requestStream(request, resultSchema, options) {
         return this._server.requestStream(request, resultSchema, options);
     }
-    async getTask(taskId, options) {
-        return this._server.getTask({ taskId }, options);
-    }
-    async getTaskResult(taskId, resultSchema, options) {
-        return this._server.getTaskResult({ taskId }, resultSchema, options);
-    }
-    async listTasks(cursor, options) {
-        return this._server.listTasks(cursor ? { cursor } : undefined, options);
-    }
-    async cancelTask(taskId, options) {
-        return this._server.cancelTask({ taskId }, options);
-    }
-}
-
-function assertToolsCallTaskCapability(requests, method, entityName) {
-    if (!requests) {
-        throw new Error(`${entityName} does not support task creation (required for ${method})`);
-    }
-    switch (method) {
-        case 'tools/call':
-            if (!requests.tools?.call) {
-                throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
-            }
-            break;
-    }
-}
-function assertClientRequestTaskCapability(requests, method, entityName) {
-    if (!requests) {
-        throw new Error(`${entityName} does not support task creation (required for ${method})`);
-    }
-    switch (method) {
-        case 'sampling/createMessage':
-            if (!requests.sampling?.createMessage) {
-                throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-            }
-            break;
-        case 'elicitation/create':
-            if (!requests.elicitation?.create) {
-                throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
-            }
-            break;
-    }
-}
-
-class Server extends Protocol {
-    constructor(_serverInfo, options) {
-        super(options);
-        this._serverInfo = _serverInfo;
-        this._loggingLevels = new Map();
-        this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
-        this.isMessageIgnored = (level, sessionId) => {
-            const currentLevel = this._loggingLevels.get(sessionId);
-            return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
-        };
-        this._capabilities = options?.capabilities ?? {};
-        this._instructions = options?.instructions;
-        this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
-        this.setRequestHandler(InitializeRequestSchema, request => this._oninitialize(request));
-        this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
-        if (this._capabilities.logging) {
-            this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
-                const transportSessionId = extra.sessionId || extra.requestInfo?.headers['mcp-session-id'] || undefined;
-                const { level } = request.params;
-                const parseResult = LoggingLevelSchema.safeParse(level);
-                if (parseResult.success) {
-                    this._loggingLevels.set(transportSessionId, parseResult.data);
-                }
-                return {};
-            });
-        }
-    }
-    get experimental() {
-        if (!this._experimental) {
-            this._experimental = {
-                tasks: new ExperimentalServerTasks(this)
-            };
-        }
-        return this._experimental;
-    }
-    registerCapabilities(capabilities) {
-        if (this.transport) {
-            throw new Error('Cannot register capabilities after connecting to transport');
-        }
-        this._capabilities = mergeCapabilities(this._capabilities, capabilities);
-    }
-    setRequestHandler(requestSchema, handler) {
-        const shape = getObjectShape(requestSchema);
-        const methodSchema = shape?.method;
-        if (!methodSchema) {
-            throw new Error('Schema is missing a method literal');
-        }
-        let methodValue;
-        if (isZ4Schema(methodSchema)) {
-            const v4Schema = methodSchema;
-            const v4Def = v4Schema._zod?.def;
-            methodValue = v4Def?.value ?? v4Schema.value;
-        }
-        else {
-            const v3Schema = methodSchema;
-            const legacyDef = v3Schema._def;
-            methodValue = legacyDef?.value ?? v3Schema.value;
-        }
-        if (typeof methodValue !== 'string') {
-            throw new Error('Schema method literal must be a string');
-        }
-        const method = methodValue;
-        if (method === 'tools/call') {
-            const wrappedHandler = async (request, extra) => {
-                const validatedRequest = safeParse$1(CallToolRequestSchema, request);
-                if (!validatedRequest.success) {
-                    const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
-                }
-                const { params } = validatedRequest.data;
-                const result = await Promise.resolve(handler(request, extra));
-                if (params.task) {
-                    const taskValidationResult = safeParse$1(CreateTaskResultSchema, result);
-                    if (!taskValidationResult.success) {
-                        const errorMessage = taskValidationResult.error instanceof Error
-                            ? taskValidationResult.error.message
-                            : String(taskValidationResult.error);
-                        throw new McpError(ErrorCode$1.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-                    }
-                    return taskValidationResult.data;
-                }
-                const validationResult = safeParse$1(CallToolResultSchema, result);
-                if (!validationResult.success) {
-                    const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
-                }
-                return validationResult.data;
-            };
-            return super.setRequestHandler(requestSchema, wrappedHandler);
-        }
-        return super.setRequestHandler(requestSchema, handler);
-    }
-    assertCapabilityForMethod(method) {
-        switch (method) {
-            case 'sampling/createMessage':
-                if (!this._clientCapabilities?.sampling) {
-                    throw new Error(`Client does not support sampling (required for ${method})`);
-                }
-                break;
-            case 'elicitation/create':
-                if (!this._clientCapabilities?.elicitation) {
-                    throw new Error(`Client does not support elicitation (required for ${method})`);
-                }
-                break;
-            case 'roots/list':
-                if (!this._clientCapabilities?.roots) {
-                    throw new Error(`Client does not support listing roots (required for ${method})`);
-                }
-                break;
-        }
-    }
-    assertNotificationCapability(method) {
-        switch (method) {
-            case 'notifications/message':
-                if (!this._capabilities.logging) {
-                    throw new Error(`Server does not support logging (required for ${method})`);
-                }
-                break;
-            case 'notifications/resources/updated':
-            case 'notifications/resources/list_changed':
-                if (!this._capabilities.resources) {
-                    throw new Error(`Server does not support notifying about resources (required for ${method})`);
-                }
-                break;
-            case 'notifications/tools/list_changed':
-                if (!this._capabilities.tools) {
-                    throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
-                }
-                break;
-            case 'notifications/prompts/list_changed':
-                if (!this._capabilities.prompts) {
-                    throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
-                }
-                break;
-            case 'notifications/elicitation/complete':
-                if (!this._clientCapabilities?.elicitation?.url) {
-                    throw new Error(`Client does not support URL elicitation (required for ${method})`);
-                }
-                break;
-        }
-    }
-    assertRequestHandlerCapability(method) {
-        if (!this._capabilities) {
-            return;
-        }
-        switch (method) {
-            case 'completion/complete':
-                if (!this._capabilities.completions) {
-                    throw new Error(`Server does not support completions (required for ${method})`);
-                }
-                break;
-            case 'logging/setLevel':
-                if (!this._capabilities.logging) {
-                    throw new Error(`Server does not support logging (required for ${method})`);
-                }
-                break;
-            case 'prompts/get':
-            case 'prompts/list':
-                if (!this._capabilities.prompts) {
-                    throw new Error(`Server does not support prompts (required for ${method})`);
-                }
-                break;
-            case 'resources/list':
-            case 'resources/templates/list':
-            case 'resources/read':
-                if (!this._capabilities.resources) {
-                    throw new Error(`Server does not support resources (required for ${method})`);
-                }
-                break;
-            case 'tools/call':
-            case 'tools/list':
-                if (!this._capabilities.tools) {
-                    throw new Error(`Server does not support tools (required for ${method})`);
-                }
-                break;
-            case 'tasks/get':
-            case 'tasks/list':
-            case 'tasks/result':
-            case 'tasks/cancel':
-                if (!this._capabilities.tasks) {
-                    throw new Error(`Server does not support tasks capability (required for ${method})`);
-                }
-                break;
-        }
-    }
-    assertTaskCapability(method) {
-        assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, 'Client');
-    }
-    assertTaskHandlerCapability(method) {
-        if (!this._capabilities) {
-            return;
-        }
-        assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, 'Server');
-    }
-    async _oninitialize(request) {
-        const requestedVersion = request.params.protocolVersion;
-        this._clientCapabilities = request.params.capabilities;
-        this._clientVersion = request.params.clientInfo;
-        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
-        return {
-            protocolVersion,
-            capabilities: this.getCapabilities(),
-            serverInfo: this._serverInfo,
-            ...(this._instructions && { instructions: this._instructions })
-        };
-    }
-    getClientCapabilities() {
-        return this._clientCapabilities;
-    }
-    getClientVersion() {
-        return this._clientVersion;
-    }
-    getCapabilities() {
-        return this._capabilities;
-    }
-    async ping() {
-        return this.request({ method: 'ping' }, EmptyResultSchema);
-    }
-    async createMessage(params, options) {
-        if (params.tools || params.toolChoice) {
-            if (!this._clientCapabilities?.sampling?.tools) {
-                throw new Error('Client does not support sampling tools capability.');
-            }
+    createMessageStream(params, options) {
+        const clientCapabilities = this._server.getClientCapabilities();
+        if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+            throw new Error('Client does not support sampling tools capability.');
+        }
+        if (params.messages.length > 0) {
+            const lastMessage = params.messages[params.messages.length - 1];
+            const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+            const hasToolResults = lastContent.some(c => c.type === 'tool_result');
+            const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+            const previousContent = previousMessage
+                ? Array.isArray(previousMessage.content)
+                    ? previousMessage.content
+                    : [previousMessage.content]
+                : [];
+            const hasPreviousToolUse = previousContent.some(c => c.type === 'tool_use');
+            if (hasToolResults) {
+                if (lastContent.some(c => c.type !== 'tool_result')) {
+                    throw new Error('The last message must contain only tool_result content if any is present');
+                }
+                if (!hasPreviousToolUse) {
+                    throw new Error('tool_result blocks are not matching any tool_use from the previous message');
+                }
+            }
+            if (hasPreviousToolUse) {
+                const toolUseIds = new Set(previousContent.filter(c => c.type === 'tool_use').map(c => c.id));
+                const toolResultIds = new Set(lastContent.filter(c => c.type === 'tool_result').map(c => c.toolUseId));
+                if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every(id => toolResultIds.has(id))) {
+                    throw new Error('ids of tool_result blocks and tool_use blocks from previous message do not match');
+                }
+            }
+        }
+        return this.requestStream({
+            method: 'sampling/createMessage',
+            params
+        }, CreateMessageResultSchema, options);
+    }
+    elicitInputStream(params, options) {
+        const clientCapabilities = this._server.getClientCapabilities();
+        const mode = params.mode ?? 'form';
+        switch (mode) {
+            case 'url': {
+                if (!clientCapabilities?.elicitation?.url) {
+                    throw new Error('Client does not support url elicitation.');
+                }
+                break;
+            }
+            case 'form': {
+                if (!clientCapabilities?.elicitation?.form) {
+                    throw new Error('Client does not support form elicitation.');
+                }
+                break;
+            }
+        }
+        const normalizedParams = mode === 'form' && params.mode === undefined ? { ...params, mode: 'form' } : params;
+        return this.requestStream({
+            method: 'elicitation/create',
+            params: normalizedParams
+        }, ElicitResultSchema, options);
+    }
+    async getTask(taskId, options) {
+        return this._server.getTask({ taskId }, options);
+    }
+    async getTaskResult(taskId, resultSchema, options) {
+        return this._server.getTaskResult({ taskId }, resultSchema, options);
+    }
+    async listTasks(cursor, options) {
+        return this._server.listTasks(cursor ? { cursor } : undefined, options);
+    }
+    async cancelTask(taskId, options) {
+        return this._server.cancelTask({ taskId }, options);
+    }
+}
+
+function assertToolsCallTaskCapability(requests, method, entityName) {
+    if (!requests) {
+        throw new Error(`${entityName} does not support task creation (required for ${method})`);
+    }
+    switch (method) {
+        case 'tools/call':
+            if (!requests.tools?.call) {
+                throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+            }
+            break;
+    }
+}
+function assertClientRequestTaskCapability(requests, method, entityName) {
+    if (!requests) {
+        throw new Error(`${entityName} does not support task creation (required for ${method})`);
+    }
+    switch (method) {
+        case 'sampling/createMessage':
+            if (!requests.sampling?.createMessage) {
+                throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+            }
+            break;
+        case 'elicitation/create':
+            if (!requests.elicitation?.create) {
+                throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+            }
+            break;
+    }
+}
+
+class Server extends Protocol {
+    constructor(_serverInfo, options) {
+        super(options);
+        this._serverInfo = _serverInfo;
+        this._loggingLevels = new Map();
+        this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
+        this.isMessageIgnored = (level, sessionId) => {
+            const currentLevel = this._loggingLevels.get(sessionId);
+            return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
+        };
+        this._capabilities = options?.capabilities ?? {};
+        this._instructions = options?.instructions;
+        this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+        this.setRequestHandler(InitializeRequestSchema, request => this._oninitialize(request));
+        this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
+        if (this._capabilities.logging) {
+            this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
+                const transportSessionId = extra.sessionId || extra.requestInfo?.headers['mcp-session-id'] || undefined;
+                const { level } = request.params;
+                const parseResult = LoggingLevelSchema.safeParse(level);
+                if (parseResult.success) {
+                    this._loggingLevels.set(transportSessionId, parseResult.data);
+                }
+                return {};
+            });
+        }
+    }
+    get experimental() {
+        if (!this._experimental) {
+            this._experimental = {
+                tasks: new ExperimentalServerTasks(this)
+            };
+        }
+        return this._experimental;
+    }
+    registerCapabilities(capabilities) {
+        if (this.transport) {
+            throw new Error('Cannot register capabilities after connecting to transport');
+        }
+        this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+    }
+    setRequestHandler(requestSchema, handler) {
+        const shape = getObjectShape(requestSchema);
+        const methodSchema = shape?.method;
+        if (!methodSchema) {
+            throw new Error('Schema is missing a method literal');
+        }
+        let methodValue;
+        if (isZ4Schema(methodSchema)) {
+            const v4Schema = methodSchema;
+            const v4Def = v4Schema._zod?.def;
+            methodValue = v4Def?.value ?? v4Schema.value;
+        }
+        else {
+            const v3Schema = methodSchema;
+            const legacyDef = v3Schema._def;
+            methodValue = legacyDef?.value ?? v3Schema.value;
+        }
+        if (typeof methodValue !== 'string') {
+            throw new Error('Schema method literal must be a string');
+        }
+        const method = methodValue;
+        if (method === 'tools/call') {
+            const wrappedHandler = async (request, extra) => {
+                const validatedRequest = safeParse$1(CallToolRequestSchema, request);
+                if (!validatedRequest.success) {
+                    const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+                }
+                const { params } = validatedRequest.data;
+                const result = await Promise.resolve(handler(request, extra));
+                if (params.task) {
+                    const taskValidationResult = safeParse$1(CreateTaskResultSchema, result);
+                    if (!taskValidationResult.success) {
+                        const errorMessage = taskValidationResult.error instanceof Error
+                            ? taskValidationResult.error.message
+                            : String(taskValidationResult.error);
+                        throw new McpError(ErrorCode$1.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+                    }
+                    return taskValidationResult.data;
+                }
+                const validationResult = safeParse$1(CallToolResultSchema, result);
+                if (!validationResult.success) {
+                    const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+                }
+                return validationResult.data;
+            };
+            return super.setRequestHandler(requestSchema, wrappedHandler);
+        }
+        return super.setRequestHandler(requestSchema, handler);
+    }
+    assertCapabilityForMethod(method) {
+        switch (method) {
+            case 'sampling/createMessage':
+                if (!this._clientCapabilities?.sampling) {
+                    throw new Error(`Client does not support sampling (required for ${method})`);
+                }
+                break;
+            case 'elicitation/create':
+                if (!this._clientCapabilities?.elicitation) {
+                    throw new Error(`Client does not support elicitation (required for ${method})`);
+                }
+                break;
+            case 'roots/list':
+                if (!this._clientCapabilities?.roots) {
+                    throw new Error(`Client does not support listing roots (required for ${method})`);
+                }
+                break;
+        }
+    }
+    assertNotificationCapability(method) {
+        switch (method) {
+            case 'notifications/message':
+                if (!this._capabilities.logging) {
+                    throw new Error(`Server does not support logging (required for ${method})`);
+                }
+                break;
+            case 'notifications/resources/updated':
+            case 'notifications/resources/list_changed':
+                if (!this._capabilities.resources) {
+                    throw new Error(`Server does not support notifying about resources (required for ${method})`);
+                }
+                break;
+            case 'notifications/tools/list_changed':
+                if (!this._capabilities.tools) {
+                    throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
+                }
+                break;
+            case 'notifications/prompts/list_changed':
+                if (!this._capabilities.prompts) {
+                    throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
+                }
+                break;
+            case 'notifications/elicitation/complete':
+                if (!this._clientCapabilities?.elicitation?.url) {
+                    throw new Error(`Client does not support URL elicitation (required for ${method})`);
+                }
+                break;
+        }
+    }
+    assertRequestHandlerCapability(method) {
+        if (!this._capabilities) {
+            return;
+        }
+        switch (method) {
+            case 'completion/complete':
+                if (!this._capabilities.completions) {
+                    throw new Error(`Server does not support completions (required for ${method})`);
+                }
+                break;
+            case 'logging/setLevel':
+                if (!this._capabilities.logging) {
+                    throw new Error(`Server does not support logging (required for ${method})`);
+                }
+                break;
+            case 'prompts/get':
+            case 'prompts/list':
+                if (!this._capabilities.prompts) {
+                    throw new Error(`Server does not support prompts (required for ${method})`);
+                }
+                break;
+            case 'resources/list':
+            case 'resources/templates/list':
+            case 'resources/read':
+                if (!this._capabilities.resources) {
+                    throw new Error(`Server does not support resources (required for ${method})`);
+                }
+                break;
+            case 'tools/call':
+            case 'tools/list':
+                if (!this._capabilities.tools) {
+                    throw new Error(`Server does not support tools (required for ${method})`);
+                }
+                break;
+            case 'tasks/get':
+            case 'tasks/list':
+            case 'tasks/result':
+            case 'tasks/cancel':
+                if (!this._capabilities.tasks) {
+                    throw new Error(`Server does not support tasks capability (required for ${method})`);
+                }
+                break;
+        }
+    }
+    assertTaskCapability(method) {
+        assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, 'Client');
+    }
+    assertTaskHandlerCapability(method) {
+        if (!this._capabilities) {
+            return;
+        }
+        assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, 'Server');
+    }
+    async _oninitialize(request) {
+        const requestedVersion = request.params.protocolVersion;
+        this._clientCapabilities = request.params.capabilities;
+        this._clientVersion = request.params.clientInfo;
+        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
+        return {
+            protocolVersion,
+            capabilities: this.getCapabilities(),
+            serverInfo: this._serverInfo,
+            ...(this._instructions && { instructions: this._instructions })
+        };
+    }
+    getClientCapabilities() {
+        return this._clientCapabilities;
+    }
+    getClientVersion() {
+        return this._clientVersion;
+    }
+    getCapabilities() {
+        return this._capabilities;
+    }
+    async ping() {
+        return this.request({ method: 'ping' }, EmptyResultSchema);
+    }
+    async createMessage(params, options) {
+        if (params.tools || params.toolChoice) {
+            if (!this._clientCapabilities?.sampling?.tools) {
+                throw new Error('Client does not support sampling tools capability.');
+            }
         }
         if (params.messages.length > 0) {
             const lastMessage = params.messages[params.messages.length - 1];
@@ -37965,6 +38027,1238 @@ class StdioServerTransport {
     }
 }
 
+var crossSpawn = {exports: {}};
+
+var windows;
+var hasRequiredWindows;
+
+function requireWindows () {
+	if (hasRequiredWindows) return windows;
+	hasRequiredWindows = 1;
+	windows = isexe;
+	isexe.sync = sync;
+	var fs = require$$0$3;
+	function checkPathExt (path, options) {
+	  var pathext = options.pathExt !== undefined ?
+	    options.pathExt : process.env.PATHEXT;
+	  if (!pathext) {
+	    return true
+	  }
+	  pathext = pathext.split(';');
+	  if (pathext.indexOf('') !== -1) {
+	    return true
+	  }
+	  for (var i = 0; i < pathext.length; i++) {
+	    var p = pathext[i].toLowerCase();
+	    if (p && path.substr(-p.length).toLowerCase() === p) {
+	      return true
+	    }
+	  }
+	  return false
+	}
+	function checkStat (stat, path, options) {
+	  if (!stat.isSymbolicLink() && !stat.isFile()) {
+	    return false
+	  }
+	  return checkPathExt(path, options)
+	}
+	function isexe (path, options, cb) {
+	  fs.stat(path, function (er, stat) {
+	    cb(er, er ? false : checkStat(stat, path, options));
+	  });
+	}
+	function sync (path, options) {
+	  return checkStat(fs.statSync(path), path, options)
+	}
+	return windows;
+}
+
+var mode;
+var hasRequiredMode;
+
+function requireMode () {
+	if (hasRequiredMode) return mode;
+	hasRequiredMode = 1;
+	mode = isexe;
+	isexe.sync = sync;
+	var fs = require$$0$3;
+	function isexe (path, options, cb) {
+	  fs.stat(path, function (er, stat) {
+	    cb(er, er ? false : checkStat(stat, options));
+	  });
+	}
+	function sync (path, options) {
+	  return checkStat(fs.statSync(path), options)
+	}
+	function checkStat (stat, options) {
+	  return stat.isFile() && checkMode(stat, options)
+	}
+	function checkMode (stat, options) {
+	  var mod = stat.mode;
+	  var uid = stat.uid;
+	  var gid = stat.gid;
+	  var myUid = options.uid !== undefined ?
+	    options.uid : process.getuid && process.getuid();
+	  var myGid = options.gid !== undefined ?
+	    options.gid : process.getgid && process.getgid();
+	  var u = parseInt('100', 8);
+	  var g = parseInt('010', 8);
+	  var o = parseInt('001', 8);
+	  var ug = u | g;
+	  var ret = (mod & o) ||
+	    (mod & g) && gid === myGid ||
+	    (mod & u) && uid === myUid ||
+	    (mod & ug) && myUid === 0;
+	  return ret
+	}
+	return mode;
+}
+
+var isexe_1;
+var hasRequiredIsexe;
+
+function requireIsexe () {
+	if (hasRequiredIsexe) return isexe_1;
+	hasRequiredIsexe = 1;
+	var core;
+	if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
+	  core = requireWindows();
+	} else {
+	  core = requireMode();
+	}
+	isexe_1 = isexe;
+	isexe.sync = sync;
+	function isexe (path, options, cb) {
+	  if (typeof options === 'function') {
+	    cb = options;
+	    options = {};
+	  }
+	  if (!cb) {
+	    if (typeof Promise !== 'function') {
+	      throw new TypeError('callback not provided')
+	    }
+	    return new Promise(function (resolve, reject) {
+	      isexe(path, options || {}, function (er, is) {
+	        if (er) {
+	          reject(er);
+	        } else {
+	          resolve(is);
+	        }
+	      });
+	    })
+	  }
+	  core(path, options || {}, function (er, is) {
+	    if (er) {
+	      if (er.code === 'EACCES' || options && options.ignoreErrors) {
+	        er = null;
+	        is = false;
+	      }
+	    }
+	    cb(er, is);
+	  });
+	}
+	function sync (path, options) {
+	  try {
+	    return core.sync(path, options || {})
+	  } catch (er) {
+	    if (options && options.ignoreErrors || er.code === 'EACCES') {
+	      return false
+	    } else {
+	      throw er
+	    }
+	  }
+	}
+	return isexe_1;
+}
+
+var which_1;
+var hasRequiredWhich;
+
+function requireWhich () {
+	if (hasRequiredWhich) return which_1;
+	hasRequiredWhich = 1;
+	const isWindows = process.platform === 'win32' ||
+	    process.env.OSTYPE === 'cygwin' ||
+	    process.env.OSTYPE === 'msys';
+	const path = require$$0$4;
+	const COLON = isWindows ? ';' : ':';
+	const isexe = requireIsexe();
+	const getNotFoundError = (cmd) =>
+	  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' });
+	const getPathInfo = (cmd, opt) => {
+	  const colon = opt.colon || COLON;
+	  const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
+	    : (
+	      [
+	        ...(isWindows ? [process.cwd()] : []),
+	        ...(opt.path || process.env.PATH ||
+	           '').split(colon),
+	      ]
+	    );
+	  const pathExtExe = isWindows
+	    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
+	    : '';
+	  const pathExt = isWindows ? pathExtExe.split(colon) : [''];
+	  if (isWindows) {
+	    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
+	      pathExt.unshift('');
+	  }
+	  return {
+	    pathEnv,
+	    pathExt,
+	    pathExtExe,
+	  }
+	};
+	const which = (cmd, opt, cb) => {
+	  if (typeof opt === 'function') {
+	    cb = opt;
+	    opt = {};
+	  }
+	  if (!opt)
+	    opt = {};
+	  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+	  const found = [];
+	  const step = i => new Promise((resolve, reject) => {
+	    if (i === pathEnv.length)
+	      return opt.all && found.length ? resolve(found)
+	        : reject(getNotFoundError(cmd))
+	    const ppRaw = pathEnv[i];
+	    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+	    const pCmd = path.join(pathPart, cmd);
+	    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+	      : pCmd;
+	    resolve(subStep(p, i, 0));
+	  });
+	  const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+	    if (ii === pathExt.length)
+	      return resolve(step(i + 1))
+	    const ext = pathExt[ii];
+	    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+	      if (!er && is) {
+	        if (opt.all)
+	          found.push(p + ext);
+	        else
+	          return resolve(p + ext)
+	      }
+	      return resolve(subStep(p, i, ii + 1))
+	    });
+	  });
+	  return cb ? step(0).then(res => cb(null, res), cb) : step(0)
+	};
+	const whichSync = (cmd, opt) => {
+	  opt = opt || {};
+	  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+	  const found = [];
+	  for (let i = 0; i < pathEnv.length; i ++) {
+	    const ppRaw = pathEnv[i];
+	    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+	    const pCmd = path.join(pathPart, cmd);
+	    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+	      : pCmd;
+	    for (let j = 0; j < pathExt.length; j ++) {
+	      const cur = p + pathExt[j];
+	      try {
+	        const is = isexe.sync(cur, { pathExt: pathExtExe });
+	        if (is) {
+	          if (opt.all)
+	            found.push(cur);
+	          else
+	            return cur
+	        }
+	      } catch (ex) {}
+	    }
+	  }
+	  if (opt.all && found.length)
+	    return found
+	  if (opt.nothrow)
+	    return null
+	  throw getNotFoundError(cmd)
+	};
+	which_1 = which;
+	which.sync = whichSync;
+	return which_1;
+}
+
+var pathKey = {exports: {}};
+
+var hasRequiredPathKey;
+
+function requirePathKey () {
+	if (hasRequiredPathKey) return pathKey.exports;
+	hasRequiredPathKey = 1;
+	const pathKey$1 = (options = {}) => {
+		const environment = options.env || process.env;
+		const platform = options.platform || process.platform;
+		if (platform !== 'win32') {
+			return 'PATH';
+		}
+		return Object.keys(environment).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
+	};
+	pathKey.exports = pathKey$1;
+	pathKey.exports.default = pathKey$1;
+	return pathKey.exports;
+}
+
+var resolveCommand_1;
+var hasRequiredResolveCommand;
+
+function requireResolveCommand () {
+	if (hasRequiredResolveCommand) return resolveCommand_1;
+	hasRequiredResolveCommand = 1;
+	const path = require$$0$4;
+	const which = requireWhich();
+	const getPathKey = requirePathKey();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+	    const env = parsed.options.env || process.env;
+	    const cwd = process.cwd();
+	    const hasCustomCwd = parsed.options.cwd != null;
+	    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+	    if (shouldSwitchCwd) {
+	        try {
+	            process.chdir(parsed.options.cwd);
+	        } catch (err) {
+	        }
+	    }
+	    let resolved;
+	    try {
+	        resolved = which.sync(parsed.command, {
+	            path: env[getPathKey({ env })],
+	            pathExt: withoutPathExt ? path.delimiter : undefined,
+	        });
+	    } catch (e) {
+	    } finally {
+	        if (shouldSwitchCwd) {
+	            process.chdir(cwd);
+	        }
+	    }
+	    if (resolved) {
+	        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
+	    }
+	    return resolved;
+	}
+	function resolveCommand(parsed) {
+	    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	resolveCommand_1 = resolveCommand;
+	return resolveCommand_1;
+}
+
+var _escape = {};
+
+var hasRequired_escape;
+
+function require_escape () {
+	if (hasRequired_escape) return _escape;
+	hasRequired_escape = 1;
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+	    arg = arg.replace(metaCharsRegExp, '^$1');
+	    return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+	    arg = `${arg}`;
+	    arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+	    arg = arg.replace(/(?=(\\+?)?)\1$/, '$1$1');
+	    arg = `"${arg}"`;
+	    arg = arg.replace(metaCharsRegExp, '^$1');
+	    if (doubleEscapeMetaChars) {
+	        arg = arg.replace(metaCharsRegExp, '^$1');
+	    }
+	    return arg;
+	}
+	_escape.command = escapeCommand;
+	_escape.argument = escapeArgument;
+	return _escape;
+}
+
+var shebangRegex;
+var hasRequiredShebangRegex;
+
+function requireShebangRegex () {
+	if (hasRequiredShebangRegex) return shebangRegex;
+	hasRequiredShebangRegex = 1;
+	shebangRegex = /^#!(.*)/;
+	return shebangRegex;
+}
+
+var shebangCommand;
+var hasRequiredShebangCommand;
+
+function requireShebangCommand () {
+	if (hasRequiredShebangCommand) return shebangCommand;
+	hasRequiredShebangCommand = 1;
+	const shebangRegex = requireShebangRegex();
+	shebangCommand = (string = '') => {
+		const match = string.match(shebangRegex);
+		if (!match) {
+			return null;
+		}
+		const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
+		const binary = path.split('/').pop();
+		if (binary === 'env') {
+			return argument;
+		}
+		return argument ? `${binary} ${argument}` : binary;
+	};
+	return shebangCommand;
+}
+
+var readShebang_1;
+var hasRequiredReadShebang;
+
+function requireReadShebang () {
+	if (hasRequiredReadShebang) return readShebang_1;
+	hasRequiredReadShebang = 1;
+	const fs = require$$0$3;
+	const shebangCommand = requireShebangCommand();
+	function readShebang(command) {
+	    const size = 150;
+	    const buffer = Buffer.alloc(size);
+	    let fd;
+	    try {
+	        fd = fs.openSync(command, 'r');
+	        fs.readSync(fd, buffer, 0, size, 0);
+	        fs.closeSync(fd);
+	    } catch (e) {  }
+	    return shebangCommand(buffer.toString());
+	}
+	readShebang_1 = readShebang;
+	return readShebang_1;
+}
+
+var parse_1$1;
+var hasRequiredParse$1;
+
+function requireParse$1 () {
+	if (hasRequiredParse$1) return parse_1$1;
+	hasRequiredParse$1 = 1;
+	const path = require$$0$4;
+	const resolveCommand = requireResolveCommand();
+	const escape = require_escape();
+	const readShebang = requireReadShebang();
+	const isWin = process.platform === 'win32';
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+	    parsed.file = resolveCommand(parsed);
+	    const shebang = parsed.file && readShebang(parsed.file);
+	    if (shebang) {
+	        parsed.args.unshift(parsed.file);
+	        parsed.command = shebang;
+	        return resolveCommand(parsed);
+	    }
+	    return parsed.file;
+	}
+	function parseNonShell(parsed) {
+	    if (!isWin) {
+	        return parsed;
+	    }
+	    const commandFile = detectShebang(parsed);
+	    const needsShell = !isExecutableRegExp.test(commandFile);
+	    if (parsed.options.forceShell || needsShell) {
+	        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+	        parsed.command = path.normalize(parsed.command);
+	        parsed.command = escape.command(parsed.command);
+	        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+	        const shellCommand = [parsed.command].concat(parsed.args).join(' ');
+	        parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
+	        parsed.command = process.env.comspec || 'cmd.exe';
+	        parsed.options.windowsVerbatimArguments = true;
+	    }
+	    return parsed;
+	}
+	function parse(command, args, options) {
+	    if (args && !Array.isArray(args)) {
+	        options = args;
+	        args = null;
+	    }
+	    args = args ? args.slice(0) : [];
+	    options = Object.assign({}, options);
+	    const parsed = {
+	        command,
+	        args,
+	        options,
+	        file: undefined,
+	        original: {
+	            command,
+	            args,
+	        },
+	    };
+	    return options.shell ? parsed : parseNonShell(parsed);
+	}
+	parse_1$1 = parse;
+	return parse_1$1;
+}
+
+var enoent;
+var hasRequiredEnoent;
+
+function requireEnoent () {
+	if (hasRequiredEnoent) return enoent;
+	hasRequiredEnoent = 1;
+	const isWin = process.platform === 'win32';
+	function notFoundError(original, syscall) {
+	    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+	        code: 'ENOENT',
+	        errno: 'ENOENT',
+	        syscall: `${syscall} ${original.command}`,
+	        path: original.command,
+	        spawnargs: original.args,
+	    });
+	}
+	function hookChildProcess(cp, parsed) {
+	    if (!isWin) {
+	        return;
+	    }
+	    const originalEmit = cp.emit;
+	    cp.emit = function (name, arg1) {
+	        if (name === 'exit') {
+	            const err = verifyENOENT(arg1, parsed);
+	            if (err) {
+	                return originalEmit.call(cp, 'error', err);
+	            }
+	        }
+	        return originalEmit.apply(cp, arguments);
+	    };
+	}
+	function verifyENOENT(status, parsed) {
+	    if (isWin && status === 1 && !parsed.file) {
+	        return notFoundError(parsed.original, 'spawn');
+	    }
+	    return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+	    if (isWin && status === 1 && !parsed.file) {
+	        return notFoundError(parsed.original, 'spawnSync');
+	    }
+	    return null;
+	}
+	enoent = {
+	    hookChildProcess,
+	    verifyENOENT,
+	    verifyENOENTSync,
+	    notFoundError,
+	};
+	return enoent;
+}
+
+var hasRequiredCrossSpawn;
+
+function requireCrossSpawn () {
+	if (hasRequiredCrossSpawn) return crossSpawn.exports;
+	hasRequiredCrossSpawn = 1;
+	const cp = require$$0$5;
+	const parse = requireParse$1();
+	const enoent = requireEnoent();
+	function spawn(command, args, options) {
+	    const parsed = parse(command, args, options);
+	    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+	    enoent.hookChildProcess(spawned, parsed);
+	    return spawned;
+	}
+	function spawnSync(command, args, options) {
+	    const parsed = parse(command, args, options);
+	    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+	    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+	    return result;
+	}
+	crossSpawn.exports = spawn;
+	crossSpawn.exports.spawn = spawn;
+	crossSpawn.exports.sync = spawnSync;
+	crossSpawn.exports._parse = parse;
+	crossSpawn.exports._enoent = enoent;
+	return crossSpawn.exports;
+}
+
+var crossSpawnExports = requireCrossSpawn();
+var spawn = /*@__PURE__*/getDefaultExportFromCjs(crossSpawnExports);
+
+const DEFAULT_INHERITED_ENV_VARS = process$2.platform === 'win32'
+    ? [
+        'APPDATA',
+        'HOMEDRIVE',
+        'HOMEPATH',
+        'LOCALAPPDATA',
+        'PATH',
+        'PROCESSOR_ARCHITECTURE',
+        'SYSTEMDRIVE',
+        'SYSTEMROOT',
+        'TEMP',
+        'USERNAME',
+        'USERPROFILE',
+        'PROGRAMFILES'
+    ]
+    :
+        ['HOME', 'LOGNAME', 'PATH', 'SHELL', 'TERM', 'USER'];
+function getDefaultEnvironment() {
+    const env = {};
+    for (const key of DEFAULT_INHERITED_ENV_VARS) {
+        const value = process$2.env[key];
+        if (value === undefined) {
+            continue;
+        }
+        if (value.startsWith('()')) {
+            continue;
+        }
+        env[key] = value;
+    }
+    return env;
+}
+class StdioClientTransport {
+    constructor(server) {
+        this._readBuffer = new ReadBuffer();
+        this._stderrStream = null;
+        this._serverParams = server;
+        if (server.stderr === 'pipe' || server.stderr === 'overlapped') {
+            this._stderrStream = new PassThrough();
+        }
+    }
+    async start() {
+        if (this._process) {
+            throw new Error('StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.');
+        }
+        return new Promise((resolve, reject) => {
+            this._process = spawn(this._serverParams.command, this._serverParams.args ?? [], {
+                env: {
+                    ...getDefaultEnvironment(),
+                    ...this._serverParams.env
+                },
+                stdio: ['pipe', 'pipe', this._serverParams.stderr ?? 'inherit'],
+                shell: false,
+                windowsHide: process$2.platform === 'win32' && isElectron(),
+                cwd: this._serverParams.cwd
+            });
+            this._process.on('error', error => {
+                reject(error);
+                this.onerror?.(error);
+            });
+            this._process.on('spawn', () => {
+                resolve();
+            });
+            this._process.on('close', _code => {
+                this._process = undefined;
+                this.onclose?.();
+            });
+            this._process.stdin?.on('error', error => {
+                this.onerror?.(error);
+            });
+            this._process.stdout?.on('data', chunk => {
+                this._readBuffer.append(chunk);
+                this.processReadBuffer();
+            });
+            this._process.stdout?.on('error', error => {
+                this.onerror?.(error);
+            });
+            if (this._stderrStream && this._process.stderr) {
+                this._process.stderr.pipe(this._stderrStream);
+            }
+        });
+    }
+    get stderr() {
+        if (this._stderrStream) {
+            return this._stderrStream;
+        }
+        return this._process?.stderr ?? null;
+    }
+    get pid() {
+        return this._process?.pid ?? null;
+    }
+    processReadBuffer() {
+        while (true) {
+            try {
+                const message = this._readBuffer.readMessage();
+                if (message === null) {
+                    break;
+                }
+                this.onmessage?.(message);
+            }
+            catch (error) {
+                this.onerror?.(error);
+            }
+        }
+    }
+    async close() {
+        if (this._process) {
+            const processToClose = this._process;
+            this._process = undefined;
+            const closePromise = new Promise(resolve => {
+                processToClose.once('close', () => {
+                    resolve();
+                });
+            });
+            try {
+                processToClose.stdin?.end();
+            }
+            catch {
+            }
+            await Promise.race([closePromise, new Promise(resolve => setTimeout(resolve, 2000).unref())]);
+            if (processToClose.exitCode === null) {
+                try {
+                    processToClose.kill('SIGTERM');
+                }
+                catch {
+                }
+                await Promise.race([closePromise, new Promise(resolve => setTimeout(resolve, 2000).unref())]);
+            }
+            if (processToClose.exitCode === null) {
+                try {
+                    processToClose.kill('SIGKILL');
+                }
+                catch {
+                }
+            }
+        }
+        this._readBuffer.clear();
+    }
+    send(message) {
+        return new Promise(resolve => {
+            if (!this._process?.stdin) {
+                throw new Error('Not connected');
+            }
+            const json = serializeMessage(message);
+            if (this._process.stdin.write(json)) {
+                resolve();
+            }
+            else {
+                this._process.stdin.once('drain', resolve);
+            }
+        });
+    }
+}
+function isElectron() {
+    return 'type' in process$2;
+}
+
+class ExperimentalClientTasks {
+    constructor(_client) {
+        this._client = _client;
+    }
+    async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+        const clientInternal = this._client;
+        const optionsWithTask = {
+            ...options,
+            task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : undefined)
+        };
+        const stream = clientInternal.requestStream({ method: 'tools/call', params }, resultSchema, optionsWithTask);
+        const validator = clientInternal.getToolOutputValidator(params.name);
+        for await (const message of stream) {
+            if (message.type === 'result' && validator) {
+                const result = message.result;
+                if (!result.structuredContent && !result.isError) {
+                    yield {
+                        type: 'error',
+                        error: new McpError(ErrorCode$1.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+                    };
+                    return;
+                }
+                if (result.structuredContent) {
+                    try {
+                        const validationResult = validator(result.structuredContent);
+                        if (!validationResult.valid) {
+                            yield {
+                                type: 'error',
+                                error: new McpError(ErrorCode$1.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+                            };
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        if (error instanceof McpError) {
+                            yield { type: 'error', error };
+                            return;
+                        }
+                        yield {
+                            type: 'error',
+                            error: new McpError(ErrorCode$1.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`)
+                        };
+                        return;
+                    }
+                }
+            }
+            yield message;
+        }
+    }
+    async getTask(taskId, options) {
+        return this._client.getTask({ taskId }, options);
+    }
+    async getTaskResult(taskId, resultSchema, options) {
+        return this._client.getTaskResult({ taskId }, resultSchema, options);
+    }
+    async listTasks(cursor, options) {
+        return this._client.listTasks(cursor ? { cursor } : undefined, options);
+    }
+    async cancelTask(taskId, options) {
+        return this._client.cancelTask({ taskId }, options);
+    }
+    requestStream(request, resultSchema, options) {
+        return this._client.requestStream(request, resultSchema, options);
+    }
+}
+
+function applyElicitationDefaults(schema, data) {
+    if (!schema || data === null || typeof data !== 'object')
+        return;
+    if (schema.type === 'object' && schema.properties && typeof schema.properties === 'object') {
+        const obj = data;
+        const props = schema.properties;
+        for (const key of Object.keys(props)) {
+            const propSchema = props[key];
+            if (obj[key] === undefined && Object.prototype.hasOwnProperty.call(propSchema, 'default')) {
+                obj[key] = propSchema.default;
+            }
+            if (obj[key] !== undefined) {
+                applyElicitationDefaults(propSchema, obj[key]);
+            }
+        }
+    }
+    if (Array.isArray(schema.anyOf)) {
+        for (const sub of schema.anyOf) {
+            if (typeof sub !== 'boolean') {
+                applyElicitationDefaults(sub, data);
+            }
+        }
+    }
+    if (Array.isArray(schema.oneOf)) {
+        for (const sub of schema.oneOf) {
+            if (typeof sub !== 'boolean') {
+                applyElicitationDefaults(sub, data);
+            }
+        }
+    }
+}
+function getSupportedElicitationModes(capabilities) {
+    if (!capabilities) {
+        return { supportsFormMode: false, supportsUrlMode: false };
+    }
+    const hasFormCapability = capabilities.form !== undefined;
+    const hasUrlCapability = capabilities.url !== undefined;
+    const supportsFormMode = hasFormCapability || (!hasFormCapability && !hasUrlCapability);
+    const supportsUrlMode = hasUrlCapability;
+    return { supportsFormMode, supportsUrlMode };
+}
+let Client$1 = class Client extends Protocol {
+    constructor(_clientInfo, options) {
+        super(options);
+        this._clientInfo = _clientInfo;
+        this._cachedToolOutputValidators = new Map();
+        this._cachedKnownTaskTools = new Set();
+        this._cachedRequiredTaskTools = new Set();
+        this._listChangedDebounceTimers = new Map();
+        this._capabilities = options?.capabilities ?? {};
+        this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+        if (options?.listChanged) {
+            this._pendingListChangedConfig = options.listChanged;
+        }
+    }
+    _setupListChangedHandlers(config) {
+        if (config.tools && this._serverCapabilities?.tools?.listChanged) {
+            this._setupListChangedHandler('tools', ToolListChangedNotificationSchema, config.tools, async () => {
+                const result = await this.listTools();
+                return result.tools;
+            });
+        }
+        if (config.prompts && this._serverCapabilities?.prompts?.listChanged) {
+            this._setupListChangedHandler('prompts', PromptListChangedNotificationSchema, config.prompts, async () => {
+                const result = await this.listPrompts();
+                return result.prompts;
+            });
+        }
+        if (config.resources && this._serverCapabilities?.resources?.listChanged) {
+            this._setupListChangedHandler('resources', ResourceListChangedNotificationSchema, config.resources, async () => {
+                const result = await this.listResources();
+                return result.resources;
+            });
+        }
+    }
+    get experimental() {
+        if (!this._experimental) {
+            this._experimental = {
+                tasks: new ExperimentalClientTasks(this)
+            };
+        }
+        return this._experimental;
+    }
+    registerCapabilities(capabilities) {
+        if (this.transport) {
+            throw new Error('Cannot register capabilities after connecting to transport');
+        }
+        this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+    }
+    setRequestHandler(requestSchema, handler) {
+        const shape = getObjectShape(requestSchema);
+        const methodSchema = shape?.method;
+        if (!methodSchema) {
+            throw new Error('Schema is missing a method literal');
+        }
+        let methodValue;
+        if (isZ4Schema(methodSchema)) {
+            const v4Schema = methodSchema;
+            const v4Def = v4Schema._zod?.def;
+            methodValue = v4Def?.value ?? v4Schema.value;
+        }
+        else {
+            const v3Schema = methodSchema;
+            const legacyDef = v3Schema._def;
+            methodValue = legacyDef?.value ?? v3Schema.value;
+        }
+        if (typeof methodValue !== 'string') {
+            throw new Error('Schema method literal must be a string');
+        }
+        const method = methodValue;
+        if (method === 'elicitation/create') {
+            const wrappedHandler = async (request, extra) => {
+                const validatedRequest = safeParse$1(ElicitRequestSchema, request);
+                if (!validatedRequest.success) {
+                    const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
+                }
+                const { params } = validatedRequest.data;
+                params.mode = params.mode ?? 'form';
+                const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
+                if (params.mode === 'form' && !supportsFormMode) {
+                    throw new McpError(ErrorCode$1.InvalidParams, 'Client does not support form-mode elicitation requests');
+                }
+                if (params.mode === 'url' && !supportsUrlMode) {
+                    throw new McpError(ErrorCode$1.InvalidParams, 'Client does not support URL-mode elicitation requests');
+                }
+                const result = await Promise.resolve(handler(request, extra));
+                if (params.task) {
+                    const taskValidationResult = safeParse$1(CreateTaskResultSchema, result);
+                    if (!taskValidationResult.success) {
+                        const errorMessage = taskValidationResult.error instanceof Error
+                            ? taskValidationResult.error.message
+                            : String(taskValidationResult.error);
+                        throw new McpError(ErrorCode$1.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+                    }
+                    return taskValidationResult.data;
+                }
+                const validationResult = safeParse$1(ElicitResultSchema, result);
+                if (!validationResult.success) {
+                    const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
+                }
+                const validatedResult = validationResult.data;
+                const requestedSchema = params.mode === 'form' ? params.requestedSchema : undefined;
+                if (params.mode === 'form' && validatedResult.action === 'accept' && validatedResult.content && requestedSchema) {
+                    if (this._capabilities.elicitation?.form?.applyDefaults) {
+                        try {
+                            applyElicitationDefaults(requestedSchema, validatedResult.content);
+                        }
+                        catch {
+                        }
+                    }
+                }
+                return validatedResult;
+            };
+            return super.setRequestHandler(requestSchema, wrappedHandler);
+        }
+        if (method === 'sampling/createMessage') {
+            const wrappedHandler = async (request, extra) => {
+                const validatedRequest = safeParse$1(CreateMessageRequestSchema, request);
+                if (!validatedRequest.success) {
+                    const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid sampling request: ${errorMessage}`);
+                }
+                const { params } = validatedRequest.data;
+                const result = await Promise.resolve(handler(request, extra));
+                if (params.task) {
+                    const taskValidationResult = safeParse$1(CreateTaskResultSchema, result);
+                    if (!taskValidationResult.success) {
+                        const errorMessage = taskValidationResult.error instanceof Error
+                            ? taskValidationResult.error.message
+                            : String(taskValidationResult.error);
+                        throw new McpError(ErrorCode$1.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+                    }
+                    return taskValidationResult.data;
+                }
+                const hasTools = params.tools || params.toolChoice;
+                const resultSchema = hasTools ? CreateMessageResultWithToolsSchema : CreateMessageResultSchema;
+                const validationResult = safeParse$1(resultSchema, result);
+                if (!validationResult.success) {
+                    const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+                    throw new McpError(ErrorCode$1.InvalidParams, `Invalid sampling result: ${errorMessage}`);
+                }
+                return validationResult.data;
+            };
+            return super.setRequestHandler(requestSchema, wrappedHandler);
+        }
+        return super.setRequestHandler(requestSchema, handler);
+    }
+    assertCapability(capability, method) {
+        if (!this._serverCapabilities?.[capability]) {
+            throw new Error(`Server does not support ${capability} (required for ${method})`);
+        }
+    }
+    async connect(transport, options) {
+        await super.connect(transport);
+        if (transport.sessionId !== undefined) {
+            return;
+        }
+        try {
+            const result = await this.request({
+                method: 'initialize',
+                params: {
+                    protocolVersion: LATEST_PROTOCOL_VERSION,
+                    capabilities: this._capabilities,
+                    clientInfo: this._clientInfo
+                }
+            }, InitializeResultSchema, options);
+            if (result === undefined) {
+                throw new Error(`Server sent invalid initialize result: ${result}`);
+            }
+            if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+                throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+            }
+            this._serverCapabilities = result.capabilities;
+            this._serverVersion = result.serverInfo;
+            if (transport.setProtocolVersion) {
+                transport.setProtocolVersion(result.protocolVersion);
+            }
+            this._instructions = result.instructions;
+            await this.notification({
+                method: 'notifications/initialized'
+            });
+            if (this._pendingListChangedConfig) {
+                this._setupListChangedHandlers(this._pendingListChangedConfig);
+                this._pendingListChangedConfig = undefined;
+            }
+        }
+        catch (error) {
+            void this.close();
+            throw error;
+        }
+    }
+    getServerCapabilities() {
+        return this._serverCapabilities;
+    }
+    getServerVersion() {
+        return this._serverVersion;
+    }
+    getInstructions() {
+        return this._instructions;
+    }
+    assertCapabilityForMethod(method) {
+        switch (method) {
+            case 'logging/setLevel':
+                if (!this._serverCapabilities?.logging) {
+                    throw new Error(`Server does not support logging (required for ${method})`);
+                }
+                break;
+            case 'prompts/get':
+            case 'prompts/list':
+                if (!this._serverCapabilities?.prompts) {
+                    throw new Error(`Server does not support prompts (required for ${method})`);
+                }
+                break;
+            case 'resources/list':
+            case 'resources/templates/list':
+            case 'resources/read':
+            case 'resources/subscribe':
+            case 'resources/unsubscribe':
+                if (!this._serverCapabilities?.resources) {
+                    throw new Error(`Server does not support resources (required for ${method})`);
+                }
+                if (method === 'resources/subscribe' && !this._serverCapabilities.resources.subscribe) {
+                    throw new Error(`Server does not support resource subscriptions (required for ${method})`);
+                }
+                break;
+            case 'tools/call':
+            case 'tools/list':
+                if (!this._serverCapabilities?.tools) {
+                    throw new Error(`Server does not support tools (required for ${method})`);
+                }
+                break;
+            case 'completion/complete':
+                if (!this._serverCapabilities?.completions) {
+                    throw new Error(`Server does not support completions (required for ${method})`);
+                }
+                break;
+        }
+    }
+    assertNotificationCapability(method) {
+        switch (method) {
+            case 'notifications/roots/list_changed':
+                if (!this._capabilities.roots?.listChanged) {
+                    throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+                }
+                break;
+        }
+    }
+    assertRequestHandlerCapability(method) {
+        if (!this._capabilities) {
+            return;
+        }
+        switch (method) {
+            case 'sampling/createMessage':
+                if (!this._capabilities.sampling) {
+                    throw new Error(`Client does not support sampling capability (required for ${method})`);
+                }
+                break;
+            case 'elicitation/create':
+                if (!this._capabilities.elicitation) {
+                    throw new Error(`Client does not support elicitation capability (required for ${method})`);
+                }
+                break;
+            case 'roots/list':
+                if (!this._capabilities.roots) {
+                    throw new Error(`Client does not support roots capability (required for ${method})`);
+                }
+                break;
+            case 'tasks/get':
+            case 'tasks/list':
+            case 'tasks/result':
+            case 'tasks/cancel':
+                if (!this._capabilities.tasks) {
+                    throw new Error(`Client does not support tasks capability (required for ${method})`);
+                }
+                break;
+        }
+    }
+    assertTaskCapability(method) {
+        assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, 'Server');
+    }
+    assertTaskHandlerCapability(method) {
+        if (!this._capabilities) {
+            return;
+        }
+        assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, 'Client');
+    }
+    async ping(options) {
+        return this.request({ method: 'ping' }, EmptyResultSchema, options);
+    }
+    async complete(params, options) {
+        return this.request({ method: 'completion/complete', params }, CompleteResultSchema, options);
+    }
+    async setLoggingLevel(level, options) {
+        return this.request({ method: 'logging/setLevel', params: { level } }, EmptyResultSchema, options);
+    }
+    async getPrompt(params, options) {
+        return this.request({ method: 'prompts/get', params }, GetPromptResultSchema, options);
+    }
+    async listPrompts(params, options) {
+        return this.request({ method: 'prompts/list', params }, ListPromptsResultSchema, options);
+    }
+    async listResources(params, options) {
+        return this.request({ method: 'resources/list', params }, ListResourcesResultSchema, options);
+    }
+    async listResourceTemplates(params, options) {
+        return this.request({ method: 'resources/templates/list', params }, ListResourceTemplatesResultSchema, options);
+    }
+    async readResource(params, options) {
+        return this.request({ method: 'resources/read', params }, ReadResourceResultSchema, options);
+    }
+    async subscribeResource(params, options) {
+        return this.request({ method: 'resources/subscribe', params }, EmptyResultSchema, options);
+    }
+    async unsubscribeResource(params, options) {
+        return this.request({ method: 'resources/unsubscribe', params }, EmptyResultSchema, options);
+    }
+    async callTool(params, resultSchema = CallToolResultSchema, options) {
+        if (this.isToolTaskRequired(params.name)) {
+            throw new McpError(ErrorCode$1.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
+        }
+        const result = await this.request({ method: 'tools/call', params }, resultSchema, options);
+        const validator = this.getToolOutputValidator(params.name);
+        if (validator) {
+            if (!result.structuredContent && !result.isError) {
+                throw new McpError(ErrorCode$1.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`);
+            }
+            if (result.structuredContent) {
+                try {
+                    const validationResult = validator(result.structuredContent);
+                    if (!validationResult.valid) {
+                        throw new McpError(ErrorCode$1.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof McpError) {
+                        throw error;
+                    }
+                    throw new McpError(ErrorCode$1.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        return result;
+    }
+    isToolTask(toolName) {
+        if (!this._serverCapabilities?.tasks?.requests?.tools?.call) {
+            return false;
+        }
+        return this._cachedKnownTaskTools.has(toolName);
+    }
+    isToolTaskRequired(toolName) {
+        return this._cachedRequiredTaskTools.has(toolName);
+    }
+    cacheToolMetadata(tools) {
+        this._cachedToolOutputValidators.clear();
+        this._cachedKnownTaskTools.clear();
+        this._cachedRequiredTaskTools.clear();
+        for (const tool of tools) {
+            if (tool.outputSchema) {
+                const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
+                this._cachedToolOutputValidators.set(tool.name, toolValidator);
+            }
+            const taskSupport = tool.execution?.taskSupport;
+            if (taskSupport === 'required' || taskSupport === 'optional') {
+                this._cachedKnownTaskTools.add(tool.name);
+            }
+            if (taskSupport === 'required') {
+                this._cachedRequiredTaskTools.add(tool.name);
+            }
+        }
+    }
+    getToolOutputValidator(toolName) {
+        return this._cachedToolOutputValidators.get(toolName);
+    }
+    async listTools(params, options) {
+        const result = await this.request({ method: 'tools/list', params }, ListToolsResultSchema, options);
+        this.cacheToolMetadata(result.tools);
+        return result;
+    }
+    _setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+        const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+        if (!parseResult.success) {
+            throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+        }
+        if (typeof options.onChanged !== 'function') {
+            throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+        }
+        const { autoRefresh, debounceMs } = parseResult.data;
+        const { onChanged } = options;
+        const refresh = async () => {
+            if (!autoRefresh) {
+                onChanged(null, null);
+                return;
+            }
+            try {
+                const items = await fetcher();
+                onChanged(null, items);
+            }
+            catch (e) {
+                const error = e instanceof Error ? e : new Error(String(e));
+                onChanged(error, null);
+            }
+        };
+        const handler = () => {
+            if (debounceMs) {
+                const existingTimer = this._listChangedDebounceTimers.get(listType);
+                if (existingTimer) {
+                    clearTimeout(existingTimer);
+                }
+                const timer = setTimeout(refresh, debounceMs);
+                this._listChangedDebounceTimers.set(listType, timer);
+            }
+            else {
+                refresh();
+            }
+        };
+        this.setNotificationHandler(notificationSchema, handler);
+    }
+    async sendRootsListChanged() {
+        return this.notification({ method: 'notifications/roots/list_changed' });
+    }
+};
+
 /**
                                Apache License
                          Version 2.0, January 2004
@@ -40599,7 +41893,7 @@ function mergeUint8Arrays(items) {
  * Copyright 2025 Google Inc.
  * SPDX-License-Identifier: Apache-2.0
  */
-const packageVersion = '24.37.5';
+const packageVersion = '24.38.0';
 
 /**
  * @license
@@ -52249,7 +53543,7 @@ class CdpPage extends Page {
                 partitionKey: cookie.partitionKey
                     ? cookie.partitionKey.topLevelSite
                     : undefined,
-                sameParty: cookie.sameParty ?? false,
+                sameParty: false,
             };
         });
     }
@@ -52863,7 +54157,7 @@ class CdpBrowserContext extends BrowserContext {
                         hasCrossSiteAncestor: cookie.partitionKey.hasCrossSiteAncestor,
                     }
                     : undefined,
-                sameParty: cookie.sameParty ?? false,
+                sameParty: false,
             };
         });
     }
@@ -55541,9 +56835,9 @@ class Puppeteer {
  * SPDX-License-Identifier: Apache-2.0
  */
 const PUPPETEER_REVISIONS = Object.freeze({
-    chrome: '145.0.7632.77',
-    'chrome-headless-shell': '145.0.7632.77',
-    firefox: 'stable_147.0.4',
+    chrome: '146.0.7680.31',
+    'chrome-headless-shell': '146.0.7680.31',
+    firefox: 'stable_148.0',
 });
 
 /**
@@ -58860,7 +60154,7 @@ function requireHelpers$2 () {
 	};
 	Object.defineProperty(helpers$4, "__esModule", { value: true });
 	helpers$4.req = helpers$4.json = helpers$4.toBuffer = void 0;
-	const http = __importStar(require$$0$3);
+	const http = __importStar(require$$0$6);
 	const https = __importStar(require$$1$1);
 	async function toBuffer(stream) {
 	    let length = 0;
@@ -58935,8 +60229,8 @@ function requireDist$b () {
 		};
 		Object.defineProperty(exports$1, "__esModule", { value: true });
 		exports$1.Agent = void 0;
-		const net = __importStar(require$$0$4);
-		const http = __importStar(require$$0$3);
+		const net = __importStar(require$$0$7);
+		const http = __importStar(require$$0$6);
 		const https_1 = require$$1$1;
 		__exportStar(requireHelpers$2(), exports$1);
 		const INTERNAL = Symbol('AgentBaseInternalState');
@@ -59167,10 +60461,10 @@ function requireDist$a () {
 	};
 	Object.defineProperty(dist$9, "__esModule", { value: true });
 	dist$9.HttpProxyAgent = void 0;
-	const net = __importStar(require$$0$4);
+	const net = __importStar(require$$0$7);
 	const tls = __importStar(require$$1$2);
 	const debug_1 = __importDefault(requireSrc());
-	const events_1 = require$$0$5;
+	const events_1 = require$$0$8;
 	const agent_base_1 = requireDist$b();
 	const url_1 = require$$5;
 	const debug = (0, debug_1.default)('http-proxy-agent');
@@ -59410,7 +60704,7 @@ function requireDist$9 () {
 	};
 	Object.defineProperty(dist$8, "__esModule", { value: true });
 	dist$8.HttpsProxyAgent = void 0;
-	const net = __importStar(require$$0$4);
+	const net = __importStar(require$$0$7);
 	const tls = __importStar(require$$1$2);
 	const assert_1 = __importDefault(require$$2);
 	const debug_1 = __importDefault(requireSrc());
@@ -59543,7 +60837,7 @@ function requireUtils$1 () {
 	if (hasRequiredUtils$1) return utils$1;
 	hasRequiredUtils$1 = 1;
 	Object.defineProperty(utils$1, "__esModule", { value: true });
-	const buffer_1 = require$$0$6;
+	const buffer_1 = require$$0$9;
 	const ERRORS = {
 	    INVALID_ENCODING: 'Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.',
 	    INVALID_SMARTBUFFER_SIZE: 'Invalid size provided. Size must be a valid integer greater than zero.',
@@ -61415,7 +62709,7 @@ function requireHelpers () {
 	const constants_1 = requireConstants$3();
 	const stream = require$$1$3;
 	const ip_address_1 = requireIpAddress();
-	const net = require$$0$4;
+	const net = require$$0$7;
 	function validateSocksClientOptions(options, acceptedCommands = ['connect', 'bind', 'associate']) {
 	    if (!constants_1.SocksCommand[options.command]) {
 	        throw new util_1.SocksClientError(constants_1.ERRORS.InvalidSocksCommand, options);
@@ -61602,8 +62896,8 @@ function requireSocksclient () {
 		};
 		Object.defineProperty(exports$1, "__esModule", { value: true });
 		exports$1.SocksClientError = exports$1.SocksClient = void 0;
-		const events_1 = require$$0$5;
-		const net = require$$0$4;
+		const events_1 = require$$0$8;
+		const net = require$$0$7;
 		const smart_buffer_1 = requireSmartbuffer();
 		const constants_1 = requireConstants$3();
 		const helpers_1 = requireHelpers();
@@ -62269,7 +63563,7 @@ function requireDist$8 () {
 	const agent_base_1 = requireDist$b();
 	const debug_1 = __importDefault(requireSrc());
 	const dns = __importStar(require$$3$3);
-	const net = __importStar(require$$0$4);
+	const net = __importStar(require$$0$7);
 	const tls = __importStar(require$$1$2);
 	const url_1 = require$$5;
 	const debug = (0, debug_1.default)('socks-proxy-agent');
@@ -62616,7 +63910,7 @@ function requireFile () {
 	Object.defineProperty(file, "__esModule", { value: true });
 	file.file = void 0;
 	const debug_1 = __importDefault(requireSrc());
-	const fs_1 = require$$0$7;
+	const fs_1 = require$$0$3;
 	const notfound_1 = __importDefault(requireNotfound());
 	const notmodified_1 = __importDefault(requireNotmodified());
 	const url_1 = require$$5;
@@ -62728,7 +64022,7 @@ function requireFtpContext () {
 	hasRequiredFtpContext = 1;
 	Object.defineProperty(FtpContext, "__esModule", { value: true });
 	FtpContext.FTPContext = FtpContext.FTPError = void 0;
-	const net_1 = require$$0$4;
+	const net_1 = require$$0$7;
 	const parseControlResponse_1 = requireParseControlResponse();
 	class FTPError extends Error {
 	    constructor(res) {
@@ -63773,8 +65067,8 @@ function requireClient () {
 	hasRequiredClient = 1;
 	Object.defineProperty(Client, "__esModule", { value: true });
 	Client.Client = void 0;
-	const fs_1 = require$$0$7;
-	const path_1 = require$$1$4;
+	const fs_1 = require$$0$3;
+	const path_1 = require$$0$4;
 	const tls_1 = require$$1$2;
 	const util_1 = require$$0$2;
 	const FtpContext_1 = requireFtpContext();
@@ -64169,6 +65463,12 @@ function requireClient () {
 	    async _downloadFromWorkingDir(localDirPath) {
 	        await ensureLocalDirectory(localDirPath);
 	        for (const file of await this.list()) {
+	            const hasInvalidName = !file.name || (0, path_1.basename)(file.name) !== file.name;
+	            if (hasInvalidName) {
+	                const safeName = JSON.stringify(file.name);
+	                this.ftp.log(`Invalid filename from server listing, will skip file. (${safeName})`);
+	                continue;
+	            }
 	            const localPath = (0, path_1.join)(localDirPath, file.name);
 	            if (file.isDirectory) {
 	                await this.cd(file.name);
@@ -64332,7 +65632,7 @@ function requireFtp () {
 	ftp.ftp = void 0;
 	const basic_ftp_1 = requireDist$6();
 	const stream_1 = require$$1$3;
-	const path_1 = require$$1$4;
+	const path_1 = require$$0$4;
 	const debug_1 = __importDefault(requireSrc());
 	const notfound_1 = __importDefault(requireNotfound());
 	const notmodified_1 = __importDefault(requireNotmodified());
@@ -64419,7 +65719,7 @@ function requireHttpError () {
 	if (hasRequiredHttpError) return httpError;
 	hasRequiredHttpError = 1;
 	Object.defineProperty(httpError, "__esModule", { value: true });
-	const http_1 = require$$0$3;
+	const http_1 = require$$0$6;
 	class HTTPError extends Error {
 	    constructor(statusCode, message = http_1.STATUS_CODES[statusCode]) {
 	        super(message);
@@ -64442,9 +65742,9 @@ function requireHttp () {
 		};
 		Object.defineProperty(exports$1, "__esModule", { value: true });
 		exports$1.http = void 0;
-		const http_1 = __importDefault(require$$0$3);
+		const http_1 = __importDefault(require$$0$6);
 		const https_1 = __importDefault(require$$1$1);
-		const events_1 = require$$0$5;
+		const events_1 = require$$0$8;
 		const debug_1 = __importDefault(requireSrc());
 		const http_error_1 = __importDefault(requireHttpError());
 		const notfound_1 = __importDefault(requireNotfound());
@@ -81470,7 +82770,7 @@ function requireMyIpAddress () {
 	};
 	Object.defineProperty(myIpAddress, "__esModule", { value: true });
 	const ip_1 = requireIp();
-	const net_1 = __importDefault(require$$0$4);
+	const net_1 = __importDefault(require$$0$7);
 	async function myIpAddress$1() {
 	    return new Promise((resolve, reject) => {
 	        const socket = net_1.default.connect({ host: '8.8.8.8', port: 53 });
@@ -83349,7 +84649,7 @@ function requireEmscriptenModule_WASM_RELEASE_SYNC () {
 		        a.ready = new Promise(function (b, c) { m = b; n = c; });
 		        var p = Object.assign({}, a), t = "./this.program", u = "object" == typeof window, v = "function" == typeof importScripts, w = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, x = "", y, z, A;
 		        if (w) {
-		            var fs = require$$0$7, B = require$$1$4;
+		            var fs = require$$0$3, B = require$$0$4;
 		            x = v ? B.dirname(x) + "/" : __dirname + "/";
 		            y = (b, c) => { var d = C(b); if (d)
 		                return c ? d : d.toString(); b = b.startsWith("file://") ? new URL(b) : B.normalize(b); return fs.readFileSync(b, c ? void 0 : "utf8"); };
@@ -84038,10 +85338,10 @@ function requireDist$1 () {
 	};
 	Object.defineProperty(dist$6, "__esModule", { value: true });
 	dist$6.PacProxyAgent = void 0;
-	const net = __importStar(require$$0$4);
+	const net = __importStar(require$$0$7);
 	const tls = __importStar(require$$1$2);
 	const crypto = __importStar(require$$2$1);
-	const events_1 = require$$0$5;
+	const events_1 = require$$0$8;
 	const debug_1 = __importDefault(requireSrc());
 	const url_1 = require$$5;
 	const agent_base_1 = requireDist$b();
@@ -84241,7 +85541,7 @@ function requireDist () {
 		};
 		Object.defineProperty(exports$1, "__esModule", { value: true });
 		exports$1.ProxyAgent = exports$1.proxies = void 0;
-		const http = __importStar(require$$0$3);
+		const http = __importStar(require$$0$6);
 		const https = __importStar(require$$1$1);
 		const url_1 = require$$5;
 		const lru_cache_1 = __importDefault(/*@__PURE__*/ requireLruCache());
@@ -86170,7 +87470,7 @@ var hasRequiredPermessageDeflate;
 function requirePermessageDeflate () {
 	if (hasRequiredPermessageDeflate) return permessageDeflate;
 	hasRequiredPermessageDeflate = 1;
-	const zlib = require$$0$8;
+	const zlib = require$$0$a;
 	const bufferUtil = requireBufferUtil();
 	const Limiter = requireLimiter();
 	const { kStatusCode } = requireConstants();
@@ -86495,7 +87795,7 @@ var hasRequiredValidation;
 function requireValidation () {
 	if (hasRequiredValidation) return validation.exports;
 	hasRequiredValidation = 1;
-	const { isUtf8 } = require$$0$6;
+	const { isUtf8 } = require$$0$9;
 	const { hasBlob } = requireConstants();
 	const tokenChars = [
 	  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -87792,10 +89092,10 @@ var hasRequiredWebsocket;
 function requireWebsocket () {
 	if (hasRequiredWebsocket) return websocket;
 	hasRequiredWebsocket = 1;
-	const EventEmitter = require$$0$5;
+	const EventEmitter = require$$0$8;
 	const https = require$$1$1;
-	const http = require$$0$3;
-	const net = require$$0$4;
+	const http = require$$0$6;
+	const net = require$$0$7;
 	const tls = require$$1$2;
 	const { randomBytes, createHash } = require$$2$1;
 	const { Duplex, Readable } = require$$1$3;
@@ -88759,8 +90059,8 @@ var hasRequiredWebsocketServer;
 function requireWebsocketServer () {
 	if (hasRequiredWebsocketServer) return websocketServer;
 	hasRequiredWebsocketServer = 1;
-	const EventEmitter = require$$0$5;
-	const http = require$$0$3;
+	const EventEmitter = require$$0$8;
+	const http = require$$0$6;
 	const { Duplex } = require$$1$3;
 	const { createHash } = require$$2$1;
 	const extension = requireExtension();
@@ -89603,6 +90903,7 @@ class ChromeLauncher extends BrowserLauncher {
             'MediaRouter',
             'OptimizationHints',
             'RenderDocument',
+            'PartitionAllocSchedulerLoopQuarantineTaskControlledPurge',
             ...(turnOnExperimentalFeaturesForTesting
                 ? []
                 : [
@@ -90104,7 +91405,7 @@ let ScreenRecorder = (() => {
             if (path) {
                 fs.mkdirSync(dirname$1(path), { recursive: overwrite });
             }
-            this.#process = spawn(ffmpegPath,
+            this.#process = spawn$1(ffmpegPath,
             [
                 ['-loglevel', 'error'],
                 ['-avioflags', 'direct'],
@@ -90295,6 +91596,8 @@ var ExperimentName;
     ExperimentName["USE_SOURCE_MAP_SCOPES"] = "use-source-map-scopes";
     ExperimentName["TIMELINE_SHOW_POST_MESSAGE_EVENTS"] = "timeline-show-postmessage-events";
     ExperimentName["TIMELINE_DEBUG_MODE"] = "timeline-debug-mode";
+    ExperimentName["DURABLE_MESSAGES"] = "durable-messages";
+    ExperimentName["JPEG_XL"] = "jpeg-xl";
 })(ExperimentName || (ExperimentName = {}));
 
 function getChromeVersion() { return ''; }const hostConfig = {};
@@ -90313,7 +91616,7 @@ function registerAppProvider(registration) {
 }
 function getRegisteredAppProviders() {
     return registeredAppProvider
-        .filter(provider => Runtime.isDescriptorEnabled({ experiment: undefined, condition: provider.condition }))
+        .filter(provider => Runtime.isDescriptorEnabled({ condition: provider.condition }))
         .sort((firstProvider, secondProvider) => {
         const order1 = firstProvider.order || 0;
         const order2 = secondProvider.order || 0;
@@ -93273,7 +94576,7 @@ class Legacy {
     }
     toProtocolRGBA() {
         const rgba = this.canonicalRGBA();
-        const result = { r: rgba[0], g: rgba[1], b: rgba[2], a: undefined };
+        const result = { r: rgba[0], g: rgba[1], b: rgba[2] };
         if (rgba[3] !== 1) {
             result.a = rgba[3];
         }
@@ -93513,7 +94816,7 @@ class Generator {
     #alphaSpace;
     #colors = new Map();
     constructor(hueSpace, satSpace, lightnessSpace, alphaSpace) {
-        this.#hueSpace = hueSpace || { min: 0, max: 360, count: undefined };
+        this.#hueSpace = hueSpace || { min: 0, max: 360 };
         this.#satSpace = satSpace || 67;
         this.#lightnessSpace = lightnessSpace || 80;
         this.#alphaSpace = alphaSpace || 1;
@@ -96140,11 +97443,21 @@ async function fileToString(file) {
     const str = new TextDecoder('utf-8').decode(arrayBuffer);
     return str;
 }
-async function decompress(gzippedBuffer) {
+async function decompress(gzippedBuffer, charset = 'utf-8') {
     const buffer = await gzipCodec(gzippedBuffer, new DecompressionStream('gzip'));
-    const str = new TextDecoder('utf-8').decode(buffer);
+    const str = new TextDecoder(charset).decode(buffer);
     return str;
 }
+async function decompressDeflate(buffer, charset = 'utf-8') {
+    let decompressedBuffer;
+    try {
+        decompressedBuffer = await gzipCodec(buffer, new DecompressionStream('deflate'));
+    }
+    catch {
+        decompressedBuffer = await gzipCodec(buffer, new DecompressionStream('deflate-raw'));
+    }
+    return new TextDecoder(charset).decode(decompressedBuffer);
+}
 async function compress(str) {
     const encoded = new TextEncoder().encode(str);
     const buffer = await gzipCodec(encoded, new CompressionStream('gzip'));
@@ -96187,6 +97500,7 @@ var Gzip = /*#__PURE__*/Object.freeze({
 	compressStream: compressStream,
 	createMonitoredStream: createMonitoredStream,
 	decompress: decompress,
+	decompressDeflate: decompressDeflate,
 	decompressStream: decompressStream,
 	fileToString: fileToString,
 	isGzip: isGzip
@@ -96724,7 +98038,7 @@ var ParsedURL$1 = /*#__PURE__*/Object.freeze({
 class Progress {
     totalWork = 0;
     worked = 0;
-    title = undefined;
+    title;
     canceled = false;
     done = false;
 }
@@ -98060,7 +99374,7 @@ class VersionController {
     static GLOBAL_VERSION_SETTING_NAME = 'inspectorVersion';
     static SYNCED_VERSION_SETTING_NAME = 'syncedInspectorVersion';
     static LOCAL_VERSION_SETTING_NAME = 'localInspectorVersion';
-    static CURRENT_VERSION = 40;
+    static CURRENT_VERSION = 41;
     #settings;
     #globalVersionSetting;
     #syncedVersionSetting;
@@ -98631,6 +99945,24 @@ class VersionController {
             this.#settings.globalStorage.remove(PREFERRED_NETWORK_COND_SETTING);
         }
     }
+    updateVersionFrom40To41() {
+        if (this.#settings.syncedStorage.has('hide-network-messages')) {
+            const oldNetworkSetting = this.#settings.createSetting('hide-network-messages', false, "Synced" );
+            if (!this.#settings.syncedStorage.has('network-messages')) {
+                const newNetworkSetting = this.#settings.createSetting('network-messages', true, "Synced" );
+                newNetworkSetting.set(!oldNetworkSetting.get());
+            }
+            this.#removeSetting(oldNetworkSetting);
+        }
+        if (this.#settings.syncedStorage.has('frame-viewer-hide-chrome-window')) {
+            const oldChromeFrameSetting = this.#settings.createSetting('frame-viewer-hide-chrome-window', false, "Synced" );
+            if (!this.#settings.syncedStorage.has('frame-viewer-chrome-window')) {
+                const newChromeFrameSetting = this.#settings.createSetting('frame-viewer-chrome-window', true, "Synced" );
+                newChromeFrameSetting.set(!oldChromeFrameSetting.get());
+            }
+            this.#removeSetting(oldChromeFrameSetting);
+        }
+    }
     migrateSettingsFromLocalStorage() {
         const localSettings = new Set([
             'advancedSearchConfig',
@@ -99219,6 +100551,8 @@ const UIStrings$18 = {
     enableLocalFonts: 'Enable local fonts',
     disableAvifFormat: 'Disable `AVIF` format',
     enableAvifFormat: 'Enable `AVIF` format',
+    disableJpegXlFormat: 'Disable `JPEG XL` format',
+    enableJpegXlFormat: 'Enable `JPEG XL` format',
     disableWebpFormat: 'Disable `WebP` format',
     enableWebpFormat: 'Enable `WebP` format',
     customFormatters: 'Custom formatters',
@@ -99887,6 +101221,23 @@ registerSettingExtension({
     ],
     defaultValue: false,
 });
+registerSettingExtension({
+    category: "RENDERING" ,
+    settingName: 'jpeg-xl-format-disabled',
+    settingType: "boolean" ,
+    storageType: "Session" ,
+    options: [
+        {
+            value: true,
+            title: i18nLazyString$f(UIStrings$18.disableJpegXlFormat),
+        },
+        {
+            value: false,
+            title: i18nLazyString$f(UIStrings$18.enableJpegXlFormat),
+        },
+    ],
+    defaultValue: false,
+});
 registerSettingExtension({
     category: "RENDERING" ,
     settingName: 'webp-format-disabled',
@@ -100489,21 +101840,11 @@ class InspectorFrontendHostStub {
             streamWrite(streamId, text);
             callback({
                 statusCode: 200,
-                headers: undefined,
-                messageOverride: undefined,
-                netError: undefined,
-                netErrorName: undefined,
-                urlValid: undefined,
             });
         })
             .catch(function () {
             callback({
                 statusCode: 404,
-                headers: undefined,
-                messageOverride: undefined,
-                netError: undefined,
-                netErrorName: undefined,
-                urlValid: undefined,
             });
         });
     }
@@ -101041,7 +102382,7 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerEnum("Audits.PropertyRuleIssueReason", { InvalidSyntax: "InvalidSyntax", InvalidInitialValue: "InvalidInitialValue", InvalidInherits: "InvalidInherits", InvalidName: "InvalidName" });
     inspectorBackend.registerEnum("Audits.UserReidentificationIssueType", { BlockedFrameNavigation: "BlockedFrameNavigation", BlockedSubresource: "BlockedSubresource", NoisedCanvasReadback: "NoisedCanvasReadback" });
     inspectorBackend.registerEnum("Audits.PermissionElementIssueType", { InvalidType: "InvalidType", FencedFrameDisallowed: "FencedFrameDisallowed", CspFrameAncestorsMissing: "CspFrameAncestorsMissing", PermissionsPolicyBlocked: "PermissionsPolicyBlocked", PaddingRightUnsupported: "PaddingRightUnsupported", PaddingBottomUnsupported: "PaddingBottomUnsupported", InsetBoxShadowUnsupported: "InsetBoxShadowUnsupported", RequestInProgress: "RequestInProgress", UntrustedEvent: "UntrustedEvent", RegistrationFailed: "RegistrationFailed", TypeNotSupported: "TypeNotSupported", InvalidTypeActivation: "InvalidTypeActivation", SecurityChecksFailed: "SecurityChecksFailed", ActivationDisabled: "ActivationDisabled", GeolocationDeprecated: "GeolocationDeprecated", InvalidDisplayStyle: "InvalidDisplayStyle", NonOpaqueColor: "NonOpaqueColor", LowContrast: "LowContrast", FontSizeTooSmall: "FontSizeTooSmall", FontSizeTooLarge: "FontSizeTooLarge", InvalidSizeValue: "InvalidSizeValue" });
-    inspectorBackend.registerEnum("Audits.InspectorIssueCode", { CookieIssue: "CookieIssue", MixedContentIssue: "MixedContentIssue", BlockedByResponseIssue: "BlockedByResponseIssue", HeavyAdIssue: "HeavyAdIssue", ContentSecurityPolicyIssue: "ContentSecurityPolicyIssue", SharedArrayBufferIssue: "SharedArrayBufferIssue", LowTextContrastIssue: "LowTextContrastIssue", CorsIssue: "CorsIssue", AttributionReportingIssue: "AttributionReportingIssue", QuirksModeIssue: "QuirksModeIssue", PartitioningBlobURLIssue: "PartitioningBlobURLIssue", NavigatorUserAgentIssue: "NavigatorUserAgentIssue", GenericIssue: "GenericIssue", DeprecationIssue: "DeprecationIssue", ClientHintIssue: "ClientHintIssue", FederatedAuthRequestIssue: "FederatedAuthRequestIssue", BounceTrackingIssue: "BounceTrackingIssue", CookieDeprecationMetadataIssue: "CookieDeprecationMetadataIssue", StylesheetLoadingIssue: "StylesheetLoadingIssue", FederatedAuthUserInfoRequestIssue: "FederatedAuthUserInfoRequestIssue", PropertyRuleIssue: "PropertyRuleIssue", SharedDictionaryIssue: "SharedDictionaryIssue", ElementAccessibilityIssue: "ElementAccessibilityIssue", SRIMessageSignatureIssue: "SRIMessageSignatureIssue", UnencodedDigestIssue: "UnencodedDigestIssue", ConnectionAllowlistIssue: "ConnectionAllowlistIssue", UserReidentificationIssue: "UserReidentificationIssue", PermissionElementIssue: "PermissionElementIssue", PerformanceIssue: "PerformanceIssue" });
+    inspectorBackend.registerEnum("Audits.InspectorIssueCode", { CookieIssue: "CookieIssue", MixedContentIssue: "MixedContentIssue", BlockedByResponseIssue: "BlockedByResponseIssue", HeavyAdIssue: "HeavyAdIssue", ContentSecurityPolicyIssue: "ContentSecurityPolicyIssue", SharedArrayBufferIssue: "SharedArrayBufferIssue", LowTextContrastIssue: "LowTextContrastIssue", CorsIssue: "CorsIssue", AttributionReportingIssue: "AttributionReportingIssue", QuirksModeIssue: "QuirksModeIssue", PartitioningBlobURLIssue: "PartitioningBlobURLIssue", NavigatorUserAgentIssue: "NavigatorUserAgentIssue", GenericIssue: "GenericIssue", DeprecationIssue: "DeprecationIssue", ClientHintIssue: "ClientHintIssue", FederatedAuthRequestIssue: "FederatedAuthRequestIssue", BounceTrackingIssue: "BounceTrackingIssue", CookieDeprecationMetadataIssue: "CookieDeprecationMetadataIssue", StylesheetLoadingIssue: "StylesheetLoadingIssue", FederatedAuthUserInfoRequestIssue: "FederatedAuthUserInfoRequestIssue", PropertyRuleIssue: "PropertyRuleIssue", SharedDictionaryIssue: "SharedDictionaryIssue", ElementAccessibilityIssue: "ElementAccessibilityIssue", SRIMessageSignatureIssue: "SRIMessageSignatureIssue", UnencodedDigestIssue: "UnencodedDigestIssue", ConnectionAllowlistIssue: "ConnectionAllowlistIssue", UserReidentificationIssue: "UserReidentificationIssue", PermissionElementIssue: "PermissionElementIssue", PerformanceIssue: "PerformanceIssue", SelectivePermissionsInterventionIssue: "SelectivePermissionsInterventionIssue" });
     inspectorBackend.registerEvent("Audits.issueAdded", ["issue"]);
     inspectorBackend.registerEnum("Audits.GetEncodedResponseRequestEncoding", { Webp: "webp", Jpeg: "jpeg", Png: "png" });
     inspectorBackend.registerCommand("Audits.getEncodedResponse", [{ "name": "requestId", "type": "string", "optional": false, "description": "Identifier of the network request to get content for.", "typeRef": "Network.RequestId" }, { "name": "encoding", "type": "string", "optional": false, "description": "The encoding to use.", "typeRef": "Audits.GetEncodedResponseRequestEncoding" }, { "name": "quality", "type": "number", "optional": true, "description": "The quality of the encoding (0-1). (defaults to 1)", "typeRef": null }, { "name": "sizeOnly", "type": "boolean", "optional": true, "description": "Whether to only return the size information (defaults to false).", "typeRef": null }], ["body", "originalSize", "encodedSize"], "Returns the response body and size if it were re-encoded with the specified settings. Only applies to images.");
@@ -101084,7 +102425,10 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerType("Audits.PropertyRuleIssueDetails", [{ "name": "sourceCodeLocation", "type": "object", "optional": false, "description": "Source code position of the property rule.", "typeRef": "Audits.SourceCodeLocation" }, { "name": "propertyRuleIssueReason", "type": "string", "optional": false, "description": "Reason why the property rule was discarded.", "typeRef": "Audits.PropertyRuleIssueReason" }, { "name": "propertyValue", "type": "string", "optional": true, "description": "The value of the property rule property that failed to parse", "typeRef": null }]);
     inspectorBackend.registerType("Audits.UserReidentificationIssueDetails", [{ "name": "type", "type": "string", "optional": false, "description": "", "typeRef": "Audits.UserReidentificationIssueType" }, { "name": "request", "type": "object", "optional": true, "description": "Applies to BlockedFrameNavigation and BlockedSubresource issue types.", "typeRef": "Audits.AffectedRequest" }, { "name": "sourceCodeLocation", "type": "object", "optional": true, "description": "Applies to NoisedCanvasReadback issue type.", "typeRef": "Audits.SourceCodeLocation" }]);
     inspectorBackend.registerType("Audits.PermissionElementIssueDetails", [{ "name": "issueType", "type": "string", "optional": false, "description": "", "typeRef": "Audits.PermissionElementIssueType" }, { "name": "type", "type": "string", "optional": true, "description": "The value of the type attribute.", "typeRef": null }, { "name": "nodeId", "type": "number", "optional": true, "description": "The node ID of the <permission> element.", "typeRef": "DOM.BackendNodeId" }, { "name": "isWarning", "type": "boolean", "optional": true, "description": "True if the issue is a warning, false if it is an error.", "typeRef": null }, { "name": "permissionName", "type": "string", "optional": true, "description": "Fields for message construction: Used for messages that reference a specific permission name", "typeRef": null }, { "name": "occluderNodeInfo", "type": "string", "optional": true, "description": "Used for messages about occlusion", "typeRef": null }, { "name": "occluderParentNodeInfo", "type": "string", "optional": true, "description": "Used for messages about occluder's parent", "typeRef": null }, { "name": "disableReason", "type": "string", "optional": true, "description": "Used for messages about activation disabled reason", "typeRef": null }]);
-    inspectorBackend.registerType("Audits.InspectorIssueDetails", [{ "name": "cookieIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.CookieIssueDetails" }, { "name": "mixedContentIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.MixedContentIssueDetails" }, { "name": "blockedByResponseIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.BlockedByResponseIssueDetails" }, { "name": "heavyAdIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.HeavyAdIssueDetails" }, { "name": "contentSecurityPolicyIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ContentSecurityPolicyIssueDetails" }, { "name": "sharedArrayBufferIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.SharedArrayBufferIssueDetails" }, { "name": "lowTextContrastIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.LowTextContrastIssueDetails" }, { "name": "corsIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.CorsIssueDetails" }, { "name": "attributionReportingIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.AttributionReportingIssueDetails" }, { "name": "quirksModeIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.QuirksModeIssueDetails" }, { "name": "partitioningBlobURLIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PartitioningBlobURLIssueDetails" }, { "name": "navigatorUserAgentIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.NavigatorUserAgentIssueDetails" }, { "name": "genericIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.GenericIssueDetails" }, { "name": "deprecationIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.DeprecationIssueDetails" }, { "name": "clientHintIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ClientHintIssueDetails" }, { "name": "federatedAuthRequestIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.FederatedAuthRequestIssueDetails" }, { "name": "bounceTrackingIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.BounceTrackingIssueDetails" }, { "name": "cookieDeprecationMetadataIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.CookieDeprecationMetadataIssueDetails" }, { "name": "stylesheetLoadingIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.StylesheetLoadingIssueDetails" }, { "name": "propertyRuleIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PropertyRuleIssueDetails" }, { "name": "federatedAuthUserInfoRequestIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.FederatedAuthUserInfoRequestIssueDetails" }, { "name": "sharedDictionaryIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.SharedDictionaryIssueDetails" }, { "name": "elementAccessibilityIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ElementAccessibilityIssueDetails" }, { "name": "sriMessageSignatureIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.SRIMessageSignatureIssueDetails" }, { "name": "unencodedDigestIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.UnencodedDigestIssueDetails" }, { "name": "connectionAllowlistIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ConnectionAllowlistIssueDetails" }, { "name": "userReidentificationIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.UserReidentificationIssueDetails" }, { "name": "permissionElementIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PermissionElementIssueDetails" }, { "name": "performanceIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PerformanceIssueDetails" }]);
+    inspectorBackend.registerType("Audits.AdScriptIdentifier", [{ "name": "scriptId", "type": "string", "optional": false, "description": "The script's v8 identifier.", "typeRef": "Runtime.ScriptId" }, { "name": "debuggerId", "type": "string", "optional": false, "description": "v8's debugging id for the v8::Context.", "typeRef": "Runtime.UniqueDebuggerId" }, { "name": "name", "type": "string", "optional": false, "description": "The script's url (or generated name based on id if inline script).", "typeRef": null }]);
+    inspectorBackend.registerType("Audits.AdAncestry", [{ "name": "adAncestryChain", "type": "array", "optional": false, "description": "The ad-script in the stack when the offending script was loaded. This is recursive down to the root script that was tagged due to the filterlist rule.", "typeRef": "Audits.AdScriptIdentifier" }, { "name": "rootScriptFilterlistRule", "type": "string", "optional": true, "description": "The filterlist rule that caused the root (last) script in `adAncestry` to be ad-tagged.", "typeRef": null }]);
+    inspectorBackend.registerType("Audits.SelectivePermissionsInterventionIssueDetails", [{ "name": "apiName", "type": "string", "optional": false, "description": "Which API was intervened on.", "typeRef": null }, { "name": "adAncestry", "type": "object", "optional": false, "description": "Why the ad script using the API is considered an ad.", "typeRef": "Audits.AdAncestry" }, { "name": "stackTrace", "type": "object", "optional": true, "description": "The stack trace at the time of the intervention.", "typeRef": "Runtime.StackTrace" }]);
+    inspectorBackend.registerType("Audits.InspectorIssueDetails", [{ "name": "cookieIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.CookieIssueDetails" }, { "name": "mixedContentIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.MixedContentIssueDetails" }, { "name": "blockedByResponseIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.BlockedByResponseIssueDetails" }, { "name": "heavyAdIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.HeavyAdIssueDetails" }, { "name": "contentSecurityPolicyIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ContentSecurityPolicyIssueDetails" }, { "name": "sharedArrayBufferIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.SharedArrayBufferIssueDetails" }, { "name": "lowTextContrastIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.LowTextContrastIssueDetails" }, { "name": "corsIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.CorsIssueDetails" }, { "name": "attributionReportingIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.AttributionReportingIssueDetails" }, { "name": "quirksModeIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.QuirksModeIssueDetails" }, { "name": "partitioningBlobURLIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PartitioningBlobURLIssueDetails" }, { "name": "navigatorUserAgentIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.NavigatorUserAgentIssueDetails" }, { "name": "genericIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.GenericIssueDetails" }, { "name": "deprecationIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.DeprecationIssueDetails" }, { "name": "clientHintIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ClientHintIssueDetails" }, { "name": "federatedAuthRequestIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.FederatedAuthRequestIssueDetails" }, { "name": "bounceTrackingIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.BounceTrackingIssueDetails" }, { "name": "cookieDeprecationMetadataIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.CookieDeprecationMetadataIssueDetails" }, { "name": "stylesheetLoadingIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.StylesheetLoadingIssueDetails" }, { "name": "propertyRuleIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PropertyRuleIssueDetails" }, { "name": "federatedAuthUserInfoRequestIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.FederatedAuthUserInfoRequestIssueDetails" }, { "name": "sharedDictionaryIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.SharedDictionaryIssueDetails" }, { "name": "elementAccessibilityIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ElementAccessibilityIssueDetails" }, { "name": "sriMessageSignatureIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.SRIMessageSignatureIssueDetails" }, { "name": "unencodedDigestIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.UnencodedDigestIssueDetails" }, { "name": "connectionAllowlistIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.ConnectionAllowlistIssueDetails" }, { "name": "userReidentificationIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.UserReidentificationIssueDetails" }, { "name": "permissionElementIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PermissionElementIssueDetails" }, { "name": "performanceIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.PerformanceIssueDetails" }, { "name": "selectivePermissionsInterventionIssueDetails", "type": "object", "optional": true, "description": "", "typeRef": "Audits.SelectivePermissionsInterventionIssueDetails" }]);
     inspectorBackend.registerType("Audits.InspectorIssue", [{ "name": "code", "type": "string", "optional": false, "description": "", "typeRef": "Audits.InspectorIssueCode" }, { "name": "details", "type": "object", "optional": false, "description": "", "typeRef": "Audits.InspectorIssueDetails" }, { "name": "issueId", "type": "string", "optional": true, "description": "A unique id for this issue. May be omitted if no other entity (e.g. exception, CDP message, etc.) is referencing this issue.", "typeRef": "Audits.IssueId" }]);
     inspectorBackend.registerEnum("Autofill.FillingStrategy", { AutocompleteAttribute: "autocompleteAttribute", AutofillInferred: "autofillInferred" });
     inspectorBackend.registerEvent("Autofill.addressFormFilled", ["filledFields", "addressUi"]);
@@ -101295,6 +102639,7 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerEvent("DOM.pseudoElementAdded", ["parentId", "pseudoElement"]);
     inspectorBackend.registerEvent("DOM.topLayerElementsUpdated", []);
     inspectorBackend.registerEvent("DOM.scrollableFlagUpdated", ["nodeId", "isScrollable"]);
+    inspectorBackend.registerEvent("DOM.adRelatedStateUpdated", ["nodeId", "isAdRelated"]);
     inspectorBackend.registerEvent("DOM.affectedByStartingStylesFlagUpdated", ["nodeId", "affectedByStartingStyles"]);
     inspectorBackend.registerEvent("DOM.pseudoElementRemoved", ["parentId", "pseudoElementId"]);
     inspectorBackend.registerEvent("DOM.setChildNodes", ["parentId", "nodes"]);
@@ -101356,7 +102701,7 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerCommand("DOM.getAnchorElement", [{ "name": "nodeId", "type": "number", "optional": false, "description": "Id of the positioned element from which to find the anchor.", "typeRef": "DOM.NodeId" }, { "name": "anchorSpecifier", "type": "string", "optional": true, "description": "An optional anchor specifier, as defined in https://www.w3.org/TR/css-anchor-position-1/#anchor-specifier. If not provided, it will return the implicit anchor element for the given positioned element.", "typeRef": null }], ["nodeId"], "Returns the target anchor element of the given anchor query according to https://www.w3.org/TR/css-anchor-position-1/#target.");
     inspectorBackend.registerCommand("DOM.forceShowPopover", [{ "name": "nodeId", "type": "number", "optional": false, "description": "Id of the popover HTMLElement", "typeRef": "DOM.NodeId" }, { "name": "enable", "type": "boolean", "optional": false, "description": "If true, opens the popover and keeps it open. If false, closes the popover if it was previously force-opened.", "typeRef": null }], ["nodeIds"], "When enabling, this API force-opens the popover identified by nodeId and keeps it open until disabled.");
     inspectorBackend.registerType("DOM.BackendNode", [{ "name": "nodeType", "type": "number", "optional": false, "description": "`Node`'s nodeType.", "typeRef": null }, { "name": "nodeName", "type": "string", "optional": false, "description": "`Node`'s nodeName.", "typeRef": null }, { "name": "backendNodeId", "type": "number", "optional": false, "description": "", "typeRef": "DOM.BackendNodeId" }]);
-    inspectorBackend.registerType("DOM.Node", [{ "name": "nodeId", "type": "number", "optional": false, "description": "Node identifier that is passed into the rest of the DOM messages as the `nodeId`. Backend will only push node with given `id` once. It is aware of all requested nodes and will only fire DOM events for nodes known to the client.", "typeRef": "DOM.NodeId" }, { "name": "parentId", "type": "number", "optional": true, "description": "The id of the parent node if any.", "typeRef": "DOM.NodeId" }, { "name": "backendNodeId", "type": "number", "optional": false, "description": "The BackendNodeId for this node.", "typeRef": "DOM.BackendNodeId" }, { "name": "nodeType", "type": "number", "optional": false, "description": "`Node`'s nodeType.", "typeRef": null }, { "name": "nodeName", "type": "string", "optional": false, "description": "`Node`'s nodeName.", "typeRef": null }, { "name": "localName", "type": "string", "optional": false, "description": "`Node`'s localName.", "typeRef": null }, { "name": "nodeValue", "type": "string", "optional": false, "description": "`Node`'s nodeValue.", "typeRef": null }, { "name": "childNodeCount", "type": "number", "optional": true, "description": "Child count for `Container` nodes.", "typeRef": null }, { "name": "children", "type": "array", "optional": true, "description": "Child nodes of this node when requested with children.", "typeRef": "DOM.Node" }, { "name": "attributes", "type": "array", "optional": true, "description": "Attributes of the `Element` node in the form of flat array `[name1, value1, name2, value2]`.", "typeRef": "string" }, { "name": "documentURL", "type": "string", "optional": true, "description": "Document URL that `Document` or `FrameOwner` node points to.", "typeRef": null }, { "name": "baseURL", "type": "string", "optional": true, "description": "Base URL that `Document` or `FrameOwner` node uses for URL completion.", "typeRef": null }, { "name": "publicId", "type": "string", "optional": true, "description": "`DocumentType`'s publicId.", "typeRef": null }, { "name": "systemId", "type": "string", "optional": true, "description": "`DocumentType`'s systemId.", "typeRef": null }, { "name": "internalSubset", "type": "string", "optional": true, "description": "`DocumentType`'s internalSubset.", "typeRef": null }, { "name": "xmlVersion", "type": "string", "optional": true, "description": "`Document`'s XML version in case of XML documents.", "typeRef": null }, { "name": "name", "type": "string", "optional": true, "description": "`Attr`'s name.", "typeRef": null }, { "name": "value", "type": "string", "optional": true, "description": "`Attr`'s value.", "typeRef": null }, { "name": "pseudoType", "type": "string", "optional": true, "description": "Pseudo element type for this node.", "typeRef": "DOM.PseudoType" }, { "name": "pseudoIdentifier", "type": "string", "optional": true, "description": "Pseudo element identifier for this node. Only present if there is a valid pseudoType.", "typeRef": null }, { "name": "shadowRootType", "type": "string", "optional": true, "description": "Shadow root type.", "typeRef": "DOM.ShadowRootType" }, { "name": "frameId", "type": "string", "optional": true, "description": "Frame ID for frame owner elements.", "typeRef": "Page.FrameId" }, { "name": "contentDocument", "type": "object", "optional": true, "description": "Content document for frame owner elements.", "typeRef": "DOM.Node" }, { "name": "shadowRoots", "type": "array", "optional": true, "description": "Shadow root list for given element host.", "typeRef": "DOM.Node" }, { "name": "templateContent", "type": "object", "optional": true, "description": "Content document fragment for template elements.", "typeRef": "DOM.Node" }, { "name": "pseudoElements", "type": "array", "optional": true, "description": "Pseudo elements associated with this node.", "typeRef": "DOM.Node" }, { "name": "importedDocument", "type": "object", "optional": true, "description": "Deprecated, as the HTML Imports API has been removed (crbug.com/937746). This property used to return the imported document for the HTMLImport links. The property is always undefined now.", "typeRef": "DOM.Node" }, { "name": "distributedNodes", "type": "array", "optional": true, "description": "Distributed nodes for given insertion point.", "typeRef": "DOM.BackendNode" }, { "name": "isSVG", "type": "boolean", "optional": true, "description": "Whether the node is SVG.", "typeRef": null }, { "name": "compatibilityMode", "type": "string", "optional": true, "description": "", "typeRef": "DOM.CompatibilityMode" }, { "name": "assignedSlot", "type": "object", "optional": true, "description": "", "typeRef": "DOM.BackendNode" }, { "name": "isScrollable", "type": "boolean", "optional": true, "description": "", "typeRef": null }, { "name": "affectedByStartingStyles", "type": "boolean", "optional": true, "description": "", "typeRef": null }, { "name": "adoptedStyleSheets", "type": "array", "optional": true, "description": "", "typeRef": "DOM.StyleSheetId" }]);
+    inspectorBackend.registerType("DOM.Node", [{ "name": "nodeId", "type": "number", "optional": false, "description": "Node identifier that is passed into the rest of the DOM messages as the `nodeId`. Backend will only push node with given `id` once. It is aware of all requested nodes and will only fire DOM events for nodes known to the client.", "typeRef": "DOM.NodeId" }, { "name": "parentId", "type": "number", "optional": true, "description": "The id of the parent node if any.", "typeRef": "DOM.NodeId" }, { "name": "backendNodeId", "type": "number", "optional": false, "description": "The BackendNodeId for this node.", "typeRef": "DOM.BackendNodeId" }, { "name": "nodeType", "type": "number", "optional": false, "description": "`Node`'s nodeType.", "typeRef": null }, { "name": "nodeName", "type": "string", "optional": false, "description": "`Node`'s nodeName.", "typeRef": null }, { "name": "localName", "type": "string", "optional": false, "description": "`Node`'s localName.", "typeRef": null }, { "name": "nodeValue", "type": "string", "optional": false, "description": "`Node`'s nodeValue.", "typeRef": null }, { "name": "childNodeCount", "type": "number", "optional": true, "description": "Child count for `Container` nodes.", "typeRef": null }, { "name": "children", "type": "array", "optional": true, "description": "Child nodes of this node when requested with children.", "typeRef": "DOM.Node" }, { "name": "attributes", "type": "array", "optional": true, "description": "Attributes of the `Element` node in the form of flat array `[name1, value1, name2, value2]`.", "typeRef": "string" }, { "name": "documentURL", "type": "string", "optional": true, "description": "Document URL that `Document` or `FrameOwner` node points to.", "typeRef": null }, { "name": "baseURL", "type": "string", "optional": true, "description": "Base URL that `Document` or `FrameOwner` node uses for URL completion.", "typeRef": null }, { "name": "publicId", "type": "string", "optional": true, "description": "`DocumentType`'s publicId.", "typeRef": null }, { "name": "systemId", "type": "string", "optional": true, "description": "`DocumentType`'s systemId.", "typeRef": null }, { "name": "internalSubset", "type": "string", "optional": true, "description": "`DocumentType`'s internalSubset.", "typeRef": null }, { "name": "xmlVersion", "type": "string", "optional": true, "description": "`Document`'s XML version in case of XML documents.", "typeRef": null }, { "name": "name", "type": "string", "optional": true, "description": "`Attr`'s name.", "typeRef": null }, { "name": "value", "type": "string", "optional": true, "description": "`Attr`'s value.", "typeRef": null }, { "name": "pseudoType", "type": "string", "optional": true, "description": "Pseudo element type for this node.", "typeRef": "DOM.PseudoType" }, { "name": "pseudoIdentifier", "type": "string", "optional": true, "description": "Pseudo element identifier for this node. Only present if there is a valid pseudoType.", "typeRef": null }, { "name": "shadowRootType", "type": "string", "optional": true, "description": "Shadow root type.", "typeRef": "DOM.ShadowRootType" }, { "name": "frameId", "type": "string", "optional": true, "description": "Frame ID for frame owner elements.", "typeRef": "Page.FrameId" }, { "name": "contentDocument", "type": "object", "optional": true, "description": "Content document for frame owner elements.", "typeRef": "DOM.Node" }, { "name": "shadowRoots", "type": "array", "optional": true, "description": "Shadow root list for given element host.", "typeRef": "DOM.Node" }, { "name": "templateContent", "type": "object", "optional": true, "description": "Content document fragment for template elements.", "typeRef": "DOM.Node" }, { "name": "pseudoElements", "type": "array", "optional": true, "description": "Pseudo elements associated with this node.", "typeRef": "DOM.Node" }, { "name": "importedDocument", "type": "object", "optional": true, "description": "Deprecated, as the HTML Imports API has been removed (crbug.com/937746). This property used to return the imported document for the HTMLImport links. The property is always undefined now.", "typeRef": "DOM.Node" }, { "name": "distributedNodes", "type": "array", "optional": true, "description": "Distributed nodes for given insertion point.", "typeRef": "DOM.BackendNode" }, { "name": "isSVG", "type": "boolean", "optional": true, "description": "Whether the node is SVG.", "typeRef": null }, { "name": "compatibilityMode", "type": "string", "optional": true, "description": "", "typeRef": "DOM.CompatibilityMode" }, { "name": "assignedSlot", "type": "object", "optional": true, "description": "", "typeRef": "DOM.BackendNode" }, { "name": "isScrollable", "type": "boolean", "optional": true, "description": "", "typeRef": null }, { "name": "affectedByStartingStyles", "type": "boolean", "optional": true, "description": "", "typeRef": null }, { "name": "adoptedStyleSheets", "type": "array", "optional": true, "description": "", "typeRef": "DOM.StyleSheetId" }, { "name": "isAdRelated", "type": "boolean", "optional": true, "description": "", "typeRef": null }]);
     inspectorBackend.registerType("DOM.DetachedElementInfo", [{ "name": "treeNode", "type": "object", "optional": false, "description": "", "typeRef": "DOM.Node" }, { "name": "retainedNodeIds", "type": "array", "optional": false, "description": "", "typeRef": "DOM.NodeId" }]);
     inspectorBackend.registerType("DOM.RGBA", [{ "name": "r", "type": "number", "optional": false, "description": "The red component, in the [0-255] range.", "typeRef": null }, { "name": "g", "type": "number", "optional": false, "description": "The green component, in the [0-255] range.", "typeRef": null }, { "name": "b", "type": "number", "optional": false, "description": "The blue component, in the [0-255] range.", "typeRef": null }, { "name": "a", "type": "number", "optional": true, "description": "The alpha component, in the [0-1] range (default: 1).", "typeRef": null }]);
     inspectorBackend.registerType("DOM.Quad", [{ "name": "Quad", "type": "array", "optional": false, "description": "An array of quad vertices, x immediately followed by y for each point, points clock-wise.", "typeRef": "number" }]);
@@ -101422,8 +102767,9 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerEnum("Emulation.SensorType", { AbsoluteOrientation: "absolute-orientation", Accelerometer: "accelerometer", AmbientLight: "ambient-light", Gravity: "gravity", Gyroscope: "gyroscope", LinearAcceleration: "linear-acceleration", Magnetometer: "magnetometer", RelativeOrientation: "relative-orientation" });
     inspectorBackend.registerEnum("Emulation.PressureSource", { Cpu: "cpu" });
     inspectorBackend.registerEnum("Emulation.PressureState", { Nominal: "nominal", Fair: "fair", Serious: "serious", Critical: "critical" });
-    inspectorBackend.registerEnum("Emulation.DisabledImageType", { Avif: "avif", Webp: "webp" });
+    inspectorBackend.registerEnum("Emulation.DisabledImageType", { Avif: "avif", Jxl: "jxl", Webp: "webp" });
     inspectorBackend.registerEvent("Emulation.virtualTimeBudgetExpired", []);
+    inspectorBackend.registerEvent("Emulation.screenOrientationLockChanged", ["locked", "orientation"]);
     inspectorBackend.registerCommand("Emulation.canEmulate", [], ["result"], "Tells whether emulation is supported.");
     inspectorBackend.registerCommand("Emulation.clearDeviceMetricsOverride", [], [], "Clears the overridden device metrics.");
     inspectorBackend.registerCommand("Emulation.clearGeolocationOverride", [], [], "Clears the overridden Geolocation Position and Error.");
@@ -101433,7 +102779,8 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerCommand("Emulation.setCPUThrottlingRate", [{ "name": "rate", "type": "number", "optional": false, "description": "Throttling rate as a slowdown factor (1 is no throttle, 2 is 2x slowdown, etc).", "typeRef": null }], [], "Enables CPU throttling to emulate slow CPUs.");
     inspectorBackend.registerCommand("Emulation.setDefaultBackgroundColorOverride", [{ "name": "color", "type": "object", "optional": true, "description": "RGBA of the default background color. If not specified, any existing override will be cleared.", "typeRef": "DOM.RGBA" }], [], "Sets or clears an override of the default background color of the frame. This override is used if the content does not specify one.");
     inspectorBackend.registerCommand("Emulation.setSafeAreaInsetsOverride", [{ "name": "insets", "type": "object", "optional": false, "description": "", "typeRef": "Emulation.SafeAreaInsets" }], [], "Overrides the values for env(safe-area-inset-*) and env(safe-area-max-inset-*). Unset values will cause the respective variables to be undefined, even if previously overridden.");
-    inspectorBackend.registerCommand("Emulation.setDeviceMetricsOverride", [{ "name": "width", "type": "number", "optional": false, "description": "Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null }, { "name": "height", "type": "number", "optional": false, "description": "Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null }, { "name": "deviceScaleFactor", "type": "number", "optional": false, "description": "Overriding device scale factor value. 0 disables the override.", "typeRef": null }, { "name": "mobile", "type": "boolean", "optional": false, "description": "Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more.", "typeRef": null }, { "name": "scale", "type": "number", "optional": true, "description": "Scale to apply to resulting view image.", "typeRef": null }, { "name": "screenWidth", "type": "number", "optional": true, "description": "Overriding screen width value in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "screenHeight", "type": "number", "optional": true, "description": "Overriding screen height value in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "positionX", "type": "number", "optional": true, "description": "Overriding view X position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "positionY", "type": "number", "optional": true, "description": "Overriding view Y position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "dontSetVisibleSize", "type": "boolean", "optional": true, "description": "Do not set visible view size, rely upon explicit setVisibleSize call.", "typeRef": null }, { "name": "screenOrientation", "type": "object", "optional": true, "description": "Screen orientation override.", "typeRef": "Emulation.ScreenOrientation" }, { "name": "viewport", "type": "object", "optional": true, "description": "If set, the visible area of the page will be overridden to this viewport. This viewport change is not observed by the page, e.g. viewport-relative elements do not change positions.", "typeRef": "Page.Viewport" }, { "name": "displayFeature", "type": "object", "optional": true, "description": "If set, the display feature of a multi-segment screen. If not set, multi-segment support is turned-off. Deprecated, use Emulation.setDisplayFeaturesOverride.", "typeRef": "Emulation.DisplayFeature" }, { "name": "devicePosture", "type": "object", "optional": true, "description": "If set, the posture of a foldable device. If not set the posture is set to continuous. Deprecated, use Emulation.setDevicePostureOverride.", "typeRef": "Emulation.DevicePosture" }], [], "Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and \"device-width\"/\"device-height\"-related CSS media query results).");
+    inspectorBackend.registerEnum("Emulation.SetDeviceMetricsOverrideRequestScrollbarType", { Overlay: "overlay", Default: "default" });
+    inspectorBackend.registerCommand("Emulation.setDeviceMetricsOverride", [{ "name": "width", "type": "number", "optional": false, "description": "Overriding width value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null }, { "name": "height", "type": "number", "optional": false, "description": "Overriding height value in pixels (minimum 0, maximum 10000000). 0 disables the override.", "typeRef": null }, { "name": "deviceScaleFactor", "type": "number", "optional": false, "description": "Overriding device scale factor value. 0 disables the override.", "typeRef": null }, { "name": "mobile", "type": "boolean", "optional": false, "description": "Whether to emulate mobile device. This includes viewport meta tag, overlay scrollbars, text autosizing and more.", "typeRef": null }, { "name": "scale", "type": "number", "optional": true, "description": "Scale to apply to resulting view image.", "typeRef": null }, { "name": "screenWidth", "type": "number", "optional": true, "description": "Overriding screen width value in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "screenHeight", "type": "number", "optional": true, "description": "Overriding screen height value in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "positionX", "type": "number", "optional": true, "description": "Overriding view X position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "positionY", "type": "number", "optional": true, "description": "Overriding view Y position on screen in pixels (minimum 0, maximum 10000000).", "typeRef": null }, { "name": "dontSetVisibleSize", "type": "boolean", "optional": true, "description": "Do not set visible view size, rely upon explicit setVisibleSize call.", "typeRef": null }, { "name": "screenOrientation", "type": "object", "optional": true, "description": "Screen orientation override.", "typeRef": "Emulation.ScreenOrientation" }, { "name": "viewport", "type": "object", "optional": true, "description": "If set, the visible area of the page will be overridden to this viewport. This viewport change is not observed by the page, e.g. viewport-relative elements do not change positions.", "typeRef": "Page.Viewport" }, { "name": "displayFeature", "type": "object", "optional": true, "description": "If set, the display feature of a multi-segment screen. If not set, multi-segment support is turned-off. Deprecated, use Emulation.setDisplayFeaturesOverride.", "typeRef": "Emulation.DisplayFeature" }, { "name": "devicePosture", "type": "object", "optional": true, "description": "If set, the posture of a foldable device. If not set the posture is set to continuous. Deprecated, use Emulation.setDevicePostureOverride.", "typeRef": "Emulation.DevicePosture" }, { "name": "scrollbarType", "type": "string", "optional": true, "description": "Scrollbar type. Default: `default`.", "typeRef": "Emulation.SetDeviceMetricsOverrideRequestScrollbarType" }], [], "Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and \"device-width\"/\"device-height\"-related CSS media query results).");
     inspectorBackend.registerCommand("Emulation.setDevicePostureOverride", [{ "name": "posture", "type": "object", "optional": false, "description": "", "typeRef": "Emulation.DevicePosture" }], [], "Start reporting the given posture value to the Device Posture API. This override can also be set in setDeviceMetricsOverride().");
     inspectorBackend.registerCommand("Emulation.clearDevicePostureOverride", [], [], "Clears a device posture override set with either setDeviceMetricsOverride() or setDevicePostureOverride() and starts using posture information from the platform again. Does nothing if no override is set.");
     inspectorBackend.registerCommand("Emulation.setDisplayFeaturesOverride", [{ "name": "features", "type": "array", "optional": false, "description": "", "typeRef": "Emulation.DisplayFeature" }], [], "Start using the given display features to pupulate the Viewport Segments API. This override can also be set in setDeviceMetricsOverride().");
@@ -101472,6 +102819,7 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerCommand("Emulation.getScreenInfos", [], ["screenInfos"], "Returns device's screen configuration. In headful mode, the physical screens configuration is returned, whereas in headless mode, a virtual headless screen configuration is provided instead.");
     inspectorBackend.registerCommand("Emulation.addScreen", [{ "name": "left", "type": "number", "optional": false, "description": "Offset of the left edge of the screen in pixels.", "typeRef": null }, { "name": "top", "type": "number", "optional": false, "description": "Offset of the top edge of the screen in pixels.", "typeRef": null }, { "name": "width", "type": "number", "optional": false, "description": "The width of the screen in pixels.", "typeRef": null }, { "name": "height", "type": "number", "optional": false, "description": "The height of the screen in pixels.", "typeRef": null }, { "name": "workAreaInsets", "type": "object", "optional": true, "description": "Specifies the screen's work area. Default is entire screen.", "typeRef": "Emulation.WorkAreaInsets" }, { "name": "devicePixelRatio", "type": "number", "optional": true, "description": "Specifies the screen's device pixel ratio. Default is 1.", "typeRef": null }, { "name": "rotation", "type": "number", "optional": true, "description": "Specifies the screen's rotation angle. Available values are 0, 90, 180 and 270. Default is 0.", "typeRef": null }, { "name": "colorDepth", "type": "number", "optional": true, "description": "Specifies the screen's color depth in bits. Default is 24.", "typeRef": null }, { "name": "label", "type": "string", "optional": true, "description": "Specifies the descriptive label for the screen. Default is none.", "typeRef": null }, { "name": "isInternal", "type": "boolean", "optional": true, "description": "Indicates whether the screen is internal to the device or external, attached to the device. Default is false.", "typeRef": null }], ["screenInfo"], "Add a new screen to the device. Only supported in headless mode.");
     inspectorBackend.registerCommand("Emulation.removeScreen", [{ "name": "screenId", "type": "string", "optional": false, "description": "", "typeRef": "Emulation.ScreenId" }], [], "Remove screen from the device. Only supported in headless mode.");
+    inspectorBackend.registerCommand("Emulation.setPrimaryScreen", [{ "name": "screenId", "type": "string", "optional": false, "description": "", "typeRef": "Emulation.ScreenId" }], [], "Set primary screen. Only supported in headless mode. Note that this changes the coordinate system origin to the top-left of the new primary screen, updating the bounds and work areas of all existing screens accordingly.");
     inspectorBackend.registerType("Emulation.SafeAreaInsets", [{ "name": "top", "type": "number", "optional": true, "description": "Overrides safe-area-inset-top.", "typeRef": null }, { "name": "topMax", "type": "number", "optional": true, "description": "Overrides safe-area-max-inset-top.", "typeRef": null }, { "name": "left", "type": "number", "optional": true, "description": "Overrides safe-area-inset-left.", "typeRef": null }, { "name": "leftMax", "type": "number", "optional": true, "description": "Overrides safe-area-max-inset-left.", "typeRef": null }, { "name": "bottom", "type": "number", "optional": true, "description": "Overrides safe-area-inset-bottom.", "typeRef": null }, { "name": "bottomMax", "type": "number", "optional": true, "description": "Overrides safe-area-max-inset-bottom.", "typeRef": null }, { "name": "right", "type": "number", "optional": true, "description": "Overrides safe-area-inset-right.", "typeRef": null }, { "name": "rightMax", "type": "number", "optional": true, "description": "Overrides safe-area-max-inset-right.", "typeRef": null }]);
     inspectorBackend.registerType("Emulation.ScreenOrientation", [{ "name": "type", "type": "string", "optional": false, "description": "Orientation type.", "typeRef": null }, { "name": "angle", "type": "number", "optional": false, "description": "Orientation angle.", "typeRef": null }]);
     inspectorBackend.registerType("Emulation.DisplayFeature", [{ "name": "orientation", "type": "string", "optional": false, "description": "Orientation of a display feature in relation to screen", "typeRef": null }, { "name": "offset", "type": "number", "optional": false, "description": "The offset from the screen origin in either the x (for vertical orientation) or y (for horizontal orientation) direction.", "typeRef": null }, { "name": "maskLength", "type": "number", "optional": false, "description": "A display feature may mask content such that it is not physically displayed - this length along with the offset describes this area. A display feature that only splits content will have a 0 mask_length.", "typeRef": null }]);
@@ -101493,11 +102841,13 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerEnum("Extensions.StorageArea", { Session: "session", Local: "local", Sync: "sync", Managed: "managed" });
     inspectorBackend.registerCommand("Extensions.triggerAction", [{ "name": "id", "type": "string", "optional": false, "description": "Extension id.", "typeRef": null }, { "name": "targetId", "type": "string", "optional": false, "description": "A tab target ID to trigger the default extension action on.", "typeRef": null }], [], "Runs an extension default action. Available if the client is connected using the --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging flag is set.");
     inspectorBackend.registerCommand("Extensions.loadUnpacked", [{ "name": "path", "type": "string", "optional": false, "description": "Absolute file path.", "typeRef": null }, { "name": "enableInIncognito", "type": "boolean", "optional": true, "description": "Enable the extension in incognito", "typeRef": null }], ["id"], "Installs an unpacked extension from the filesystem similar to --load-extension CLI flags. Returns extension ID once the extension has been installed. Available if the client is connected using the --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging flag is set.");
+    inspectorBackend.registerCommand("Extensions.getExtensions", [], ["extensions"], "Gets a list of all unpacked extensions. Available if the client is connected using the --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging flag is set.");
     inspectorBackend.registerCommand("Extensions.uninstall", [{ "name": "id", "type": "string", "optional": false, "description": "Extension id.", "typeRef": null }], [], "Uninstalls an unpacked extension (others not supported) from the profile. Available if the client is connected using the --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging.");
     inspectorBackend.registerCommand("Extensions.getStorageItems", [{ "name": "id", "type": "string", "optional": false, "description": "ID of extension.", "typeRef": null }, { "name": "storageArea", "type": "string", "optional": false, "description": "StorageArea to retrieve data from.", "typeRef": "Extensions.StorageArea" }, { "name": "keys", "type": "array", "optional": true, "description": "Keys to retrieve.", "typeRef": "string" }], ["data"], "Gets data from extension storage in the given `storageArea`. If `keys` is specified, these are used to filter the result.");
     inspectorBackend.registerCommand("Extensions.removeStorageItems", [{ "name": "id", "type": "string", "optional": false, "description": "ID of extension.", "typeRef": null }, { "name": "storageArea", "type": "string", "optional": false, "description": "StorageArea to remove data from.", "typeRef": "Extensions.StorageArea" }, { "name": "keys", "type": "array", "optional": false, "description": "Keys to remove.", "typeRef": "string" }], [], "Removes `keys` from extension storage in the given `storageArea`.");
     inspectorBackend.registerCommand("Extensions.clearStorageItems", [{ "name": "id", "type": "string", "optional": false, "description": "ID of extension.", "typeRef": null }, { "name": "storageArea", "type": "string", "optional": false, "description": "StorageArea to remove data from.", "typeRef": "Extensions.StorageArea" }], [], "Clears extension storage in the given `storageArea`.");
     inspectorBackend.registerCommand("Extensions.setStorageItems", [{ "name": "id", "type": "string", "optional": false, "description": "ID of extension.", "typeRef": null }, { "name": "storageArea", "type": "string", "optional": false, "description": "StorageArea to set data in.", "typeRef": "Extensions.StorageArea" }, { "name": "values", "type": "object", "optional": false, "description": "Values to set.", "typeRef": null }], [], "Sets `values` in extension storage in the given `storageArea`. The provided `values` will be merged with existing values in the storage area.");
+    inspectorBackend.registerType("Extensions.ExtensionInfo", [{ "name": "id", "type": "string", "optional": false, "description": "Extension id.", "typeRef": null }, { "name": "name", "type": "string", "optional": false, "description": "Extension name.", "typeRef": null }, { "name": "version", "type": "string", "optional": false, "description": "Extension version.", "typeRef": null }, { "name": "path", "type": "string", "optional": false, "description": "The path from which the extension was loaded.", "typeRef": null }, { "name": "enabled", "type": "boolean", "optional": false, "description": "Extension enabled status.", "typeRef": null }]);
     inspectorBackend.registerEnum("FedCm.LoginState", { SignIn: "SignIn", SignUp: "SignUp" });
     inspectorBackend.registerEnum("FedCm.DialogType", { AccountChooser: "AccountChooser", AutoReauthn: "AutoReauthn", ConfirmIdpLogin: "ConfirmIdpLogin", Error: "Error" });
     inspectorBackend.registerEnum("FedCm.DialogButton", { ConfirmIdpLoginContinue: "ConfirmIdpLoginContinue", ErrorGotIt: "ErrorGotIt", ErrorMoreDetails: "ErrorMoreDetails" });
@@ -101820,8 +103170,9 @@ function registerCommands(inspectorBackend) {
     inspectorBackend.registerType("Network.DeviceBoundSessionUrlRule", [{ "name": "ruleType", "type": "string", "optional": false, "description": "See comments on `net::device_bound_sessions::SessionInclusionRules::UrlRule::rule_type`.", "typeRef": null }, { "name": "hostPattern", "type": "string", "optional": false, "description": "See comments on `net::device_bound_sessions::SessionInclusionRules::UrlRule::host_pattern`.", "typeRef": null }, { "name": "pathPrefix", "type": "string", "optional": false, "description": "See comments on `net::device_bound_sessions::SessionInclusionRules::UrlRule::path_prefix`.", "typeRef": null }]);
     inspectorBackend.registerType("Network.DeviceBoundSessionInclusionRules", [{ "name": "origin", "type": "string", "optional": false, "description": "See comments on `net::device_bound_sessions::SessionInclusionRules::origin_`.", "typeRef": null }, { "name": "includeSite", "type": "boolean", "optional": false, "description": "Whether the whole site is included. See comments on `net::device_bound_sessions::SessionInclusionRules::include_site_` for more details; this boolean is true if that value is populated.", "typeRef": null }, { "name": "urlRules", "type": "array", "optional": false, "description": "See comments on `net::device_bound_sessions::SessionInclusionRules::url_rules_`.", "typeRef": "Network.DeviceBoundSessionUrlRule" }]);
     inspectorBackend.registerType("Network.DeviceBoundSession", [{ "name": "key", "type": "object", "optional": false, "description": "The site and session ID of the session.", "typeRef": "Network.DeviceBoundSessionKey" }, { "name": "refreshUrl", "type": "string", "optional": false, "description": "See comments on `net::device_bound_sessions::Session::refresh_url_`.", "typeRef": null }, { "name": "inclusionRules", "type": "object", "optional": false, "description": "See comments on `net::device_bound_sessions::Session::inclusion_rules_`.", "typeRef": "Network.DeviceBoundSessionInclusionRules" }, { "name": "cookieCravings", "type": "array", "optional": false, "description": "See comments on `net::device_bound_sessions::Session::cookie_cravings_`.", "typeRef": "Network.DeviceBoundSessionCookieCraving" }, { "name": "expiryDate", "type": "number", "optional": false, "description": "See comments on `net::device_bound_sessions::Session::expiry_date_`.", "typeRef": "Network.TimeSinceEpoch" }, { "name": "cachedChallenge", "type": "string", "optional": true, "description": "See comments on `net::device_bound_sessions::Session::cached_challenge__`.", "typeRef": null }, { "name": "allowedRefreshInitiators", "type": "array", "optional": false, "description": "See comments on `net::device_bound_sessions::Session::allowed_refresh_initiators_`.", "typeRef": "string" }]);
-    inspectorBackend.registerType("Network.CreationEventDetails", [{ "name": "fetchResult", "type": "string", "optional": false, "description": "The result of the fetch attempt.", "typeRef": "Network.DeviceBoundSessionFetchResult" }, { "name": "newSession", "type": "object", "optional": true, "description": "The session if there was a newly created session. This is populated for all successful creation events.", "typeRef": "Network.DeviceBoundSession" }]);
-    inspectorBackend.registerType("Network.RefreshEventDetails", [{ "name": "refreshResult", "type": "string", "optional": false, "description": "The result of a refresh.", "typeRef": null }, { "name": "fetchResult", "type": "string", "optional": true, "description": "If there was a fetch attempt, the result of that.", "typeRef": "Network.DeviceBoundSessionFetchResult" }, { "name": "newSession", "type": "object", "optional": true, "description": "The session display if there was a newly created session. This is populated for any refresh event that modifies the session config.", "typeRef": "Network.DeviceBoundSession" }, { "name": "wasFullyProactiveRefresh", "type": "boolean", "optional": false, "description": "See comments on `net::device_bound_sessions::RefreshEventResult::was_fully_proactive_refresh`.", "typeRef": null }]);
+    inspectorBackend.registerType("Network.DeviceBoundSessionFailedRequest", [{ "name": "requestUrl", "type": "string", "optional": false, "description": "The failed request URL.", "typeRef": null }, { "name": "netError", "type": "string", "optional": true, "description": "The net error of the response if it was not OK.", "typeRef": null }, { "name": "responseError", "type": "number", "optional": true, "description": "The response code if the net error was OK and the response code was not 200.", "typeRef": null }, { "name": "responseErrorBody", "type": "string", "optional": true, "description": "The body of the response if the net error was OK, the response code was not 200, and the response body was not empty.", "typeRef": null }]);
+    inspectorBackend.registerType("Network.CreationEventDetails", [{ "name": "fetchResult", "type": "string", "optional": false, "description": "The result of the fetch attempt.", "typeRef": "Network.DeviceBoundSessionFetchResult" }, { "name": "newSession", "type": "object", "optional": true, "description": "The session if there was a newly created session. This is populated for all successful creation events.", "typeRef": "Network.DeviceBoundSession" }, { "name": "failedRequest", "type": "object", "optional": true, "description": "Details about a failed device bound session network request if there was one.", "typeRef": "Network.DeviceBoundSessionFailedRequest" }]);
+    inspectorBackend.registerType("Network.RefreshEventDetails", [{ "name": "refreshResult", "type": "string", "optional": false, "description": "The result of a refresh.", "typeRef": null }, { "name": "fetchResult", "type": "string", "optional": true, "description": "If there was a fetch attempt, the result of that.", "typeRef": "Network.DeviceBoundSessionFetchResult" }, { "name": "newSession", "type": "object", "optional": true, "description": "The session display if there was a newly created session. This is populated for any refresh event that modifies the session config.", "typeRef": "Network.DeviceBoundSession" }, { "name": "wasFullyProactiveRefresh", "type": "boolean", "optional": false, "description": "See comments on `net::device_bound_sessions::RefreshEventResult::was_fully_proactive_refresh`.", "typeRef": null }, { "name": "failedRequest", "type": "object", "optional": true, "description": "Details about a failed device bound session network request if there was one.", "typeRef": "Network.DeviceBoundSessionFailedRequest" }]);
     inspectorBackend.registerType("Network.TerminationEventDetails", [{ "name": "deletionReason", "type": "string", "optional": false, "description": "The reason for a session being deleted.", "typeRef": null }]);
     inspectorBackend.registerType("Network.ChallengeEventDetails", [{ "name": "challengeResult", "type": "string", "optional": false, "description": "The result of a challenge.", "typeRef": null }, { "name": "challenge", "type": "string", "optional": false, "description": "The challenge set.", "typeRef": null }]);
     inspectorBackend.registerType("Network.LoadNetworkResourcePageResult", [{ "name": "success", "type": "boolean", "optional": false, "description": "", "typeRef": null }, { "name": "netError", "type": "number", "optional": true, "description": "Optional values used for error reporting.", "typeRef": null }, { "name": "netErrorName", "type": "string", "optional": true, "description": "", "typeRef": null }, { "name": "httpStatusCode", "type": "number", "optional": true, "description": "", "typeRef": null }, { "name": "stream", "type": "string", "optional": true, "description": "If successful, one of the following two fields holds the result.", "typeRef": "IO.StreamHandle" }, { "name": "headers", "type": "object", "optional": true, "description": "Response headers.", "typeRef": "Network.Headers" }]);
@@ -102857,6 +104208,9 @@ class TargetBase {
     registerDOMStorageDispatcher(dispatcher) {
         this.registerDispatcher('DOMStorage', dispatcher);
     }
+    registerEmulationDispatcher(dispatcher) {
+        this.registerDispatcher('Emulation', dispatcher);
+    }
     registerFetchDispatcher(dispatcher) {
         this.registerDispatcher('Fetch', dispatcher);
     }
@@ -105375,7 +106729,9 @@ var DevtoolsExperiments;
     DevtoolsExperiments[DevtoolsExperiments["use-source-map-scopes"] = 76] = "use-source-map-scopes";
     DevtoolsExperiments[DevtoolsExperiments["timeline-show-postmessage-events"] = 86] = "timeline-show-postmessage-events";
     DevtoolsExperiments[DevtoolsExperiments["timeline-debug-mode"] = 93] = "timeline-debug-mode";
-    DevtoolsExperiments[DevtoolsExperiments["MAX_VALUE"] = 110] = "MAX_VALUE";
+    DevtoolsExperiments[DevtoolsExperiments["durable-messages"] = 110] = "durable-messages";
+    DevtoolsExperiments[DevtoolsExperiments["jpeg-xl"] = 111] = "jpeg-xl";
+    DevtoolsExperiments[DevtoolsExperiments["MAX_VALUE"] = 112] = "MAX_VALUE";
 })(DevtoolsExperiments || (DevtoolsExperiments = {}));
 var IssueExpanded;
 (function (IssueExpanded) {
@@ -107400,6 +108756,20 @@ const generatedProperties = [
         ],
         "name": "column-rule-inset"
     },
+    {
+        "longhands": [
+            "column-rule-edge-inset-end",
+            "column-rule-interior-inset-end"
+        ],
+        "name": "column-rule-inset-end"
+    },
+    {
+        "longhands": [
+            "column-rule-edge-inset-start",
+            "column-rule-interior-inset-start"
+        ],
+        "name": "column-rule-inset-start"
+    },
     {
         "longhands": [
             "column-rule-interior-inset-start",
@@ -109447,6 +110817,20 @@ const generatedProperties = [
         ],
         "name": "row-rule-inset"
     },
+    {
+        "longhands": [
+            "row-rule-edge-inset-end",
+            "row-rule-interior-inset-end"
+        ],
+        "name": "row-rule-inset-end"
+    },
+    {
+        "longhands": [
+            "row-rule-edge-inset-start",
+            "row-rule-interior-inset-start"
+        ],
+        "name": "row-rule-inset-start"
+    },
     {
         "longhands": [
             "row-rule-interior-inset-start",
@@ -109568,6 +110952,24 @@ const generatedProperties = [
         ],
         "name": "rule-inset"
     },
+    {
+        "longhands": [
+            "column-rule-edge-inset-end",
+            "column-rule-interior-inset-end",
+            "row-rule-edge-inset-end",
+            "row-rule-interior-inset-end"
+        ],
+        "name": "rule-inset-end"
+    },
+    {
+        "longhands": [
+            "column-rule-edge-inset-start",
+            "column-rule-interior-inset-start",
+            "row-rule-edge-inset-start",
+            "row-rule-interior-inset-start"
+        ],
+        "name": "rule-inset-start"
+    },
     {
         "longhands": [
             "row-rule-interior-inset-start",
@@ -114586,6 +115988,23 @@ const extraPropertyValues = new Map([
     ['-webkit-transform-origin-x', new Set(['left', 'right', 'center'])],
     ['-webkit-transform-origin-y', new Set(['top', 'bottom', 'center'])],
     ['width', new Set(['-webkit-fill-available', 'stretch'])],
+    [
+        'animation-trigger',
+        new Set([
+            'play',
+            'pause',
+            'play-once',
+            'play-alternate',
+            'play-forwards',
+            'play-backwards',
+            'play-pause',
+            'replay',
+        ]),
+    ],
+    ['timeline-trigger-activation-range-start', new Set(['normal'])],
+    ['timeline-trigger-activation-range-end', new Set(['normal'])],
+    ['timeline-trigger-active-range-start', new Set(['normal'])],
+    ['timeline-trigger-active-range-end', new Set(['normal'])],
     ['contain-intrinsic-width', new Set(['auto none', 'auto 100px'])],
     ['contain-intrinsic-height', new Set(['auto none', 'auto 100px'])],
     ['contain-intrinsic-size', new Set(['auto none', 'auto 100px'])],
@@ -116826,6 +118245,32 @@ class CSSProperty extends ObjectWrapper {
     getLonghandProperties() {
         return this.#longhandProperties;
     }
+    ignoreErrors() {
+        function hasUnknownVendorPrefix(string) {
+            return !string.startsWith('-webkit-') && /^[-_][\w\d]+-\w/.test(string);
+        }
+        const name = this.name.toLowerCase();
+        if (name.charAt(0) === '_') {
+            return true;
+        }
+        if (name === 'filter') {
+            return true;
+        }
+        if (name.startsWith('scrollbar-')) {
+            return true;
+        }
+        if (hasUnknownVendorPrefix(name)) {
+            return true;
+        }
+        const value = this.value.toLowerCase();
+        if (value.endsWith('\\9')) {
+            return true;
+        }
+        if (hasUnknownVendorPrefix(value)) {
+            return true;
+        }
+        return false;
+    }
 }
 
 // Copyright 2021 The Chromium Authors
@@ -117504,7 +118949,7 @@ class CSSStyleRule extends CSSRule {
         const dummyPayload = {
             selectorList: {
                 text: '',
-                selectors: [{ text: selectorText, value: undefined }],
+                selectors: [{ text: selectorText }],
             },
             style: {
                 styleSheetId: '0',
@@ -117588,7 +119033,6 @@ class CSSPropertyRule extends CSSRule {
             origin: payload.origin,
             style: payload.style,
             header: styleSheetHeaderForRule(cssModel, payload),
-            originTreeScopeNodeId: undefined,
         });
         this.#name = new CSSValue(payload.propertyName);
     }
@@ -117625,7 +119069,6 @@ class CSSAtRule extends CSSRule {
             origin: payload.origin,
             style: payload.style,
             header: styleSheetHeaderForRule(cssModel, payload),
-            originTreeScopeNodeId: undefined
         });
         this.#name = payload.name ? new CSSValue(payload.name) : null;
         this.#type = payload.type;
@@ -117664,7 +119107,6 @@ class CSSKeyframeRule extends CSSRule {
             origin: payload.origin,
             style: payload.style,
             header: styleSheetHeaderForRule(cssModel, payload),
-            originTreeScopeNodeId: undefined
         });
         this.reinitializeKey(payload.keyText);
         this.#parentRuleName = parentRuleName;
@@ -117713,7 +119155,6 @@ class CSSPositionTryRule extends CSSRule {
             origin: payload.origin,
             style: payload.style,
             header: styleSheetHeaderForRule(cssModel, payload),
-            originTreeScopeNodeId: undefined
         });
         this.#name = new CSSValue(payload.name);
         this.#active = payload.active;
@@ -117734,7 +119175,6 @@ class CSSFunctionRule extends CSSRule {
             origin: payload.origin,
             style: { cssProperties: [], shorthandEntries: [] },
             header: styleSheetHeaderForRule(cssModel, payload),
-            originTreeScopeNodeId: undefined
         });
         this.#name = new CSSValue(payload.name);
         this.#parameters = payload.parameters.map(({ name }) => name);
@@ -119663,7 +121103,6 @@ class CookieModel extends SDKModel {
         this.#cookieToBlockedReasons.clear();
         await Promise.all(cookies.map(cookie => networkAgent.invoke_deleteCookies({
             name: cookie.name(),
-            url: undefined,
             domain: cookie.domain(),
             path: cookie.path(),
             partitionKey: cookie.partitionKey(),
@@ -121439,6 +122878,9 @@ class NetworkRequest extends ObjectWrapper {
     requestContentType() {
         return this.requestHeaderValue('Content-Type');
     }
+    requestContentEncoding() {
+        return this.requestHeaderValue('Content-Encoding');
+    }
     hasErrorStatusCode() {
         return this.statusCode >= 400;
     }
@@ -122345,13 +123787,44 @@ class NetworkManager extends SDKModel {
             return null;
         }
         try {
-            const { postData } = await manager.#networkAgent.invoke_getRequestPostData({ requestId });
+            const { postData, base64Encoded } = await manager.#networkAgent.invoke_getRequestPostData({ requestId });
+            if (base64Encoded && postData) {
+                const binaryString = window.atob(postData);
+                const bytes = new Uint8Array(binaryString.length);
+                for (let i = 0; i < binaryString.length; i++) {
+                    bytes[i] = binaryString.charCodeAt(i);
+                }
+                const requestContentType = request.requestContentType();
+                const charset = requestContentType ? parseContentType(requestContentType).charset ?? 'utf-8' : 'utf-8';
+                const contentEncoding = request.requestContentEncoding()?.toLowerCase();
+                if (contentEncoding) {
+                    const decompressed = await NetworkManager.#tryDecompressBody(bytes.buffer, contentEncoding, charset);
+                    if (decompressed !== null) {
+                        return decompressed;
+                    }
+                }
+                return new TextDecoder(charset).decode(bytes);
+            }
             return postData;
         }
         catch (e) {
             return e.message;
         }
     }
+    static async #tryDecompressBody(buffer, encoding, charset) {
+        try {
+            if (encoding.includes('gzip') && isGzip(buffer)) {
+                return await decompress(buffer, charset);
+            }
+            if (encoding.includes('deflate')) {
+                return await decompressDeflate(buffer, charset);
+            }
+        }
+        catch (e) {
+            console.warn('Failed to decompress request body:', e);
+        }
+        return null;
+    }
     static connectionType(conditions) {
         if (!conditions.download && !conditions.upload) {
             return "none" ;
@@ -122536,7 +124009,8 @@ class NetworkDispatcher {
     updateNetworkRequestWithRequest(networkRequest, request) {
         networkRequest.requestMethod = request.method;
         networkRequest.setRequestHeaders(this.headersMapToHeadersArray(request.headers));
-        networkRequest.setRequestFormData(Boolean(request.hasPostData), request.postData || null);
+        const isCompressed = Boolean(networkRequest.requestContentEncoding());
+        networkRequest.setRequestFormData(Boolean(request.hasPostData), isCompressed ? null : (request.postData || null));
         networkRequest.setInitialPriority(request.initialPriority);
         networkRequest.mixedContentType = request.mixedContentType || "none" ;
         networkRequest.setReferrerPolicy(request.referrerPolicy);
@@ -124213,7 +125687,13 @@ class PageResourceLoader extends ObjectWrapper {
             throw new Error('Invalid initiator');
         }
         const key = PageResourceLoader.makeKey(url, initiator);
-        const pageResource = { success: null, size: null, duration: null, errorMessage: undefined, url, initiator };
+        const pageResource = {
+            success: null,
+            size: null,
+            duration: null,
+            url,
+            initiator,
+        };
         this.#pageResources.set(key, pageResource);
         this.dispatchEventToListeners("Update" );
         const startTime = performance.now();
@@ -124269,7 +125749,10 @@ class PageResourceLoader extends ObjectWrapper {
                         return {
                             success: false,
                             content: '',
-                            errorDescription: { statusCode: 0, netError: undefined, netErrorName: undefined, message: e.message, urlValid: undefined }
+                            errorDescription: {
+                                statusCode: 0,
+                                message: e.message,
+                            }
                         };
                     }
                 }
@@ -124327,7 +125810,6 @@ class PageResourceLoader extends ObjectWrapper {
                     netErrorName: resource.netErrorName,
                     message: netErrorToMessage(resource.netError, resource.httpStatusCode, resource.netErrorName) ||
                         '',
-                    urlValid: undefined,
                 },
             };
         }
@@ -125070,6 +126552,9 @@ var formatter = /*#__PURE__*/Object.freeze({
 // Copyright 2023 The Chromium Authors
 const scopeTrees = new WeakMap();
 function scopeTreeForScript(script) {
+    if (script.isWasm()) {
+        return Promise.resolve(null);
+    }
     let promise = scopeTrees.get(script);
     if (promise === undefined) {
         promise = script.requestContentData().then(content => {
@@ -125811,7 +127296,6 @@ class SourceMap {
                 sourceURL: this.sourceURLs()[callsite.sourceIndex],
                 sourceLineNumber: callsite.line,
                 sourceColumnNumber: callsite.column,
-                name: undefined,
             };
         }
         const mappings = this.mappings();
@@ -126390,7 +127874,6 @@ class SourceMapManager extends ObjectWrapper {
         let clientData = {
             relativeSourceURL,
             relativeSourceMapURL,
-            sourceMap: undefined,
             sourceMapPromise: Promise.resolve(undefined),
         };
         if (this.#isEnabled) {
@@ -129031,7 +130514,8 @@ class RuntimeModel extends SDKModel {
             }
         }
         if (object.isNode()) {
-            void reveal(object).then(object.release.bind(object));
+            const omitFocus = hints !== null && typeof hints === 'object' && 'omitFocus' in hints && Boolean(hints.omitFocus);
+            void reveal(object, omitFocus).then(object.release.bind(object));
             return;
         }
         if (object.type === 'function') {
@@ -129365,6 +130849,7 @@ var DOMNodeEvents;
 (function (DOMNodeEvents) {
     DOMNodeEvents["TOP_LAYER_INDEX_CHANGED"] = "TopLayerIndexChanged";
     DOMNodeEvents["SCROLLABLE_FLAG_UPDATED"] = "ScrollableFlagUpdated";
+    DOMNodeEvents["AD_RELATED_STATE_UPDATED"] = "AdRelatedStateUpdated";
     DOMNodeEvents["GRID_OVERLAY_STATE_CHANGED"] = "GridOverlayStateChanged";
     DOMNodeEvents["FLEX_CONTAINER_OVERLAY_STATE_CHANGED"] = "FlexContainerOverlayStateChanged";
     DOMNodeEvents["SCROLL_SNAP_OVERLAY_STATE_CHANGED"] = "ScrollSnapOverlayStateChanged";
@@ -129419,6 +130904,7 @@ class DOMNode extends ObjectWrapper {
     #retainedNodes;
     #adoptedStyleSheets = [];
     #topLayerIndex = -1;
+    #isAdRelatedInternal = false;
     constructor(domModel) {
         super();
         this.#domModel = domModel;
@@ -129499,6 +130985,9 @@ class DOMNode extends ObjectWrapper {
             this.setChildrenPayload(payload.children);
         }
         this.setPseudoElements(payload.pseudoElements);
+        if (payload.isAdRelated) {
+            this.#isAdRelatedInternal = true;
+        }
         if (this.#nodeType === Node.ELEMENT_NODE) {
             if (this.ownerDocument && !this.ownerDocument.documentElement && this.#nodeName === 'HTML') {
                 this.ownerDocument.documentElement = this;
@@ -129532,7 +131021,7 @@ class DOMNode extends ObjectWrapper {
     topLayerIndex() {
         return this.#topLayerIndex;
     }
-    isAdFrameNode() {
+    isAdRelatedNode() {
         if (this.isIframe() && this.#frameOwnerFrameId) {
             const frame = FrameManager.instance().getFrame(this.#frameOwnerFrameId);
             if (!frame) {
@@ -129540,7 +131029,7 @@ class DOMNode extends ObjectWrapper {
             }
             return frame.adFrameType() !== "none" ;
         }
-        return false;
+        return this.#isAdRelatedInternal;
     }
     isRootNode() {
         if (this.nodeType() === Node.ELEMENT_NODE && this.nodeName() === 'HTML') {
@@ -129603,6 +131092,10 @@ class DOMNode extends ObjectWrapper {
             this.ownerDocument?.documentElement?.setIsScrollable(isScrollable);
         }
     }
+    setIsAdRelated(isAdRelated) {
+        this.#isAdRelatedInternal = isAdRelated;
+        this.dispatchEventToListeners(DOMNodeEvents.AD_RELATED_STATE_UPDATED);
+    }
     setAffectedByStartingStyles(affectedByStartingStyles) {
         this.#affectedByStartingStyles = affectedByStartingStyles;
     }
@@ -130148,13 +131641,17 @@ class DOMNode extends ObjectWrapper {
         return null;
     }
     highlight(mode) {
-        this.#domModel.overlayModel().highlightInOverlay({ node: this, selectorList: undefined }, mode);
+        this.#domModel.overlayModel().highlightInOverlay({ node: this }, mode);
     }
     highlightForTwoSeconds() {
-        this.#domModel.overlayModel().highlightInOverlayForTwoSeconds({ node: this, selectorList: undefined });
+        this.#domModel.overlayModel().highlightInOverlayForTwoSeconds({ node: this });
     }
     async resolveToObject(objectGroup, executionContextId) {
-        const { object } = await this.#agent.invoke_resolveNode({ nodeId: this.id, backendNodeId: undefined, executionContextId, objectGroup });
+        const { object } = await this.#agent.invoke_resolveNode({
+            nodeId: this.id,
+            executionContextId,
+            objectGroup,
+        });
         return object && this.#domModel.runtimeModelInternal.createRemoteObject(object) || null;
     }
     async boxModel() {
@@ -130688,6 +132185,13 @@ class DOMModel extends SDKModel {
         }
         node.setIsScrollable(isScrollable);
     }
+    adRelatedStateUpdated(nodeId, isAdRelated) {
+        const node = this.nodeForId(nodeId);
+        if (!node || node.isAdRelatedNode() === isAdRelated) {
+            return;
+        }
+        node.setIsAdRelated(isAdRelated);
+    }
     affectedByStartingStylesFlagUpdated(nodeId, affectedByStartingStyles) {
         const node = this.nodeForId(nodeId);
         if (!node || node.affectedByStartingStyles() === affectedByStartingStyles) {
@@ -130971,6 +132475,9 @@ class DOMDispatcher {
     affectedByStartingStylesFlagUpdated({ nodeId, affectedByStartingStyles }) {
         this.#domModel.affectedByStartingStylesFlagUpdated(nodeId, affectedByStartingStyles);
     }
+    adRelatedStateUpdated({ nodeId, isAdRelated }) {
+        this.#domModel.adRelatedStateUpdated(nodeId, isAdRelated);
+    }
 }
 let domModelUndoStackInstance = null;
 class DOMModelUndoStack {
@@ -131766,9 +133273,7 @@ class ResourceTreeFrame {
     #childFrames = new Set();
     resourcesMap = new Map();
     backForwardCacheDetails = {
-        restoredFromCache: undefined,
         explanations: [],
-        explanationsTree: undefined,
     };
     constructor(model, parentFrame, frameId, payload, creationStackTrace) {
         this.#model = model;
@@ -131827,9 +133332,7 @@ class ResourceTreeFrame {
         this.#crossOriginIsolatedContextType = framePayload.crossOriginIsolatedContextType;
         this.#gatedAPIFeatures = framePayload.gatedAPIFeatures;
         this.backForwardCacheDetails = {
-            restoredFromCache: undefined,
             explanations: [],
-            explanationsTree: undefined,
         };
         const mainResource = this.resourcesMap.get(this.#url);
         this.resourcesMap.clear();
@@ -135552,10 +137055,14 @@ class EmulationModel extends SDKModel {
     #touchEmulationAllowed;
     #customTouchEnabled;
     #touchConfiguration;
+    #screenOrientationLocked;
+    #lockedOrientation;
     constructor(target) {
         super(target);
         this.#emulationAgent = target.emulationAgent();
         this.#deviceOrientationAgent = target.deviceOrientationAgent();
+        this.#screenOrientationLocked = false;
+        this.#lockedOrientation = null;
         this.#cssModel = target.model(CSSModel);
         this.#overlayModel = target.model(OverlayModel);
         if (this.#overlayModel) {
@@ -135678,20 +137185,25 @@ class EmulationModel extends SDKModel {
             this.setLocalFontsDisabled(localFontsDisabledSetting.get());
         }
         const avifFormatDisabledSetting = Settings.instance().moduleSetting('avif-format-disabled');
+        const jpegXlFormatDisabledSetting = Settings.instance().moduleSetting('jpeg-xl-format-disabled');
         const webpFormatDisabledSetting = Settings.instance().moduleSetting('webp-format-disabled');
         const updateDisabledImageFormats = () => {
             const types = [];
             if (avifFormatDisabledSetting.get()) {
                 types.push("avif" );
             }
+            if (jpegXlFormatDisabledSetting.get()) {
+                types.push("jxl" );
+            }
             if (webpFormatDisabledSetting.get()) {
                 types.push("webp" );
             }
             this.setDisabledImageTypes(types);
         };
         avifFormatDisabledSetting.addChangeListener(updateDisabledImageFormats);
+        jpegXlFormatDisabledSetting.addChangeListener(updateDisabledImageFormats);
         webpFormatDisabledSetting.addChangeListener(updateDisabledImageFormats);
-        if (avifFormatDisabledSetting.get() || webpFormatDisabledSetting.get()) {
+        if (avifFormatDisabledSetting.get() || jpegXlFormatDisabledSetting.get() || webpFormatDisabledSetting.get()) {
             updateDisabledImageFormats();
         }
         this.#cpuPressureEnabled = false;
@@ -135703,6 +137215,7 @@ class EmulationModel extends SDKModel {
             enabled: false,
             configuration: "mobile" ,
         };
+        target.registerEmulationDispatcher(this);
     }
     setTouchEmulationAllowed(touchEmulationAllowed) {
         this.#touchEmulationAllowed = touchEmulationAllowed;
@@ -135917,6 +137430,19 @@ class EmulationModel extends SDKModel {
         ];
         return await this.emulateCSSMedia(type, features);
     }
+    virtualTimeBudgetExpired() {
+    }
+    screenOrientationLockChanged(event) {
+        this.#screenOrientationLocked = event.locked;
+        this.#lockedOrientation = event.orientation ?? null;
+        this.dispatchEventToListeners("ScreenOrientationLockChanged" , { locked: event.locked, orientation: event.orientation ?? null });
+    }
+    isScreenOrientationLocked() {
+        return this.#screenOrientationLocked;
+    }
+    lockedOrientation() {
+        return this.#lockedOrientation;
+    }
 }
 SDKModel.register(EmulationModel, { capabilities: 256 , autostart: true });
 
@@ -136503,6 +138029,18 @@ class PreloadingModel extends SDKModel {
         TargetManager.instance().removeModelListener(ResourceTreeModel, Events$6.PrimaryPageChanged, this.onPrimaryPageChanged, this);
         void this.agent.invoke_disable();
     }
+    reset() {
+        this.documents.clear();
+        this.loaderIds = [];
+        this.targetJustAttached = true;
+        this.dispatchEventToListeners("ModelUpdated" );
+    }
+    maybeInferLoaderId(loaderId) {
+        if (this.currentLoaderId() === null) {
+            this.loaderIds = [loaderId];
+            this.targetJustAttached = false;
+        }
+    }
     ensureDocumentPreloadingData(loaderId) {
         if (this.documents.get(loaderId) === undefined) {
             this.documents.set(loaderId, new DocumentPreloadingData());
@@ -136615,10 +138153,7 @@ class PreloadingModel extends SDKModel {
     onRuleSetUpdated(event) {
         const ruleSet = event.ruleSet;
         const loaderId = ruleSet.loaderId;
-        if (this.currentLoaderId() === null) {
-            this.loaderIds = [loaderId];
-            this.targetJustAttached = false;
-        }
+        this.maybeInferLoaderId(loaderId);
         this.ensureDocumentPreloadingData(loaderId);
         this.documents.get(loaderId)?.ruleSets.upsert(ruleSet);
         this.dispatchEventToListeners("ModelUpdated" );
@@ -141283,9 +142818,9 @@ class DebuggerLanguagePluginManager {
         try {
             const object = await plugin.evaluate(expression, location, this.stopIdForCallFrame(callFrame));
             if (object) {
-                return { object: await wrapRemoteObject(callFrame, object, plugin), exceptionDetails: undefined };
+                return { object: await wrapRemoteObject(callFrame, object, plugin) };
             }
-            return { object: new LocalJSONObject(undefined), exceptionDetails: undefined };
+            return { object: new LocalJSONObject(undefined) };
         }
         catch (error) {
             if (error instanceof FormattingError) {
@@ -141530,14 +143065,12 @@ class DebuggerLanguagePluginManager {
             if (uiLocation) {
                 return {
                     uiSourceCode: uiLocation.uiSourceCode,
-                    url: undefined,
                     name,
                     line: uiLocation.lineNumber,
                     column: uiLocation.columnNumber ?? -1,
                 };
             }
             return {
-                uiSourceCode: undefined,
                 url: fallback.url,
                 name: fallback.functionName,
                 line: fallback.lineNumber,
@@ -145481,10 +147014,7 @@ function makeZeroBasedCallFrame(callFrame) {
 }
 function getRawLineAndColumnNumbersForEvent(event) {
     if (!event.args?.data) {
-        return {
-            lineNumber: undefined,
-            columnNumber: undefined,
-        };
+        return {};
     }
     let lineNumber = undefined;
     let columnNumber = undefined;
@@ -156461,13 +157991,13 @@ var NetworkDependencyTree = /*#__PURE__*/Object.freeze({
 
 // Copyright 2024 The Chromium Authors
 const UIStrings$w = {
-    title: 'Render blocking requests',
+    title: 'Render-blocking requests',
     description: 'Requests are blocking the page\'s initial render, which may delay LCP. ' +
         '[Deferring or inlining](https://developer.chrome.com/docs/performance/insights/render-blocking) ' +
         'can move these network requests out of the critical path.',
     renderBlockingRequest: 'Request',
     duration: 'Duration',
-    noRenderBlocking: 'No render blocking requests for this navigation',
+    noRenderBlocking: 'No render-blocking requests for this navigation',
 };
 const str_$v = registerUIStrings('models/trace/insights/RenderBlocking.ts', UIStrings$w);
 const i18nString$h = getLocalizedString.bind(undefined, str_$v);
@@ -159586,11 +161116,7 @@ function createLanternRequest(parsedTrace, workerThreads, request) {
         priority: request.args.data.priority,
         frameId: request.args.data.frame,
         fromWorker,
-        serverResponseTime: request.args.data.lrServerResponseTime ?? undefined,
-        redirects: undefined,
-        redirectSource: undefined,
-        redirectDestination: undefined,
-        initiatorRequest: undefined,
+        serverResponseTime: request.args.data.lrServerResponseTime,
     };
 }
 function chooseInitiatorRequest(request, requestsByURL) {
@@ -160867,7 +162393,8 @@ class Prototypes {
         const settings = Settings.instance();
         const aiAnnotations = settings.createSetting('greendev-ai-annotations-enabled', false, "Local" );
         const copyToGemini = settings.createSetting('greendev-copy-to-gemini-enabled', false, "Local" );
-        return { aiAnnotations, copyToGemini };
+        const breakpointDebuggerAgent = settings.createSetting('greendev-breakpoint-debugger-agent-enabled', false, "Local" );
+        return { aiAnnotations, copyToGemini, breakpointDebuggerAgent };
     }
 }
 
@@ -162306,6 +163833,7 @@ class DeviceModeModel extends ObjectWrapper {
     #emulationModel;
     #onModelAvailable;
     #outlineRect;
+    #screenOrientationLocked;
     constructor() {
         super();
         this.#screenRect = new Rect(0, 0, 1, 1);
@@ -162354,6 +163882,7 @@ class DeviceModeModel extends ObjectWrapper {
         this.#touchMobile = false;
         this.#emulationModel = null;
         this.#onModelAvailable = null;
+        this.#screenOrientationLocked = false;
         TargetManager.instance().observeModels(EmulationModel, this);
     }
     static instance(opts) {
@@ -162576,6 +164105,7 @@ class DeviceModeModel extends ObjectWrapper {
                 this.#onModelAvailable = null;
                 callback();
             }
+            emulationModel.addEventListener("ScreenOrientationLockChanged" , this.onScreenOrientationLockChanged, this);
             const resourceTreeModel = emulationModel.target().model(ResourceTreeModel);
             if (resourceTreeModel) {
                 resourceTreeModel.addEventListener(Events$6.FrameResized, this.onFrameChange, this);
@@ -162588,7 +164118,10 @@ class DeviceModeModel extends ObjectWrapper {
     }
     modelRemoved(emulationModel) {
         if (this.#emulationModel === emulationModel) {
+            emulationModel.removeEventListener("ScreenOrientationLockChanged" , this.onScreenOrientationLockChanged, this);
             this.#emulationModel = null;
+            this.#screenOrientationLocked = false;
+            this.dispatchEventToListeners("Updated" );
         }
     }
     inspectedURL() {
@@ -162601,6 +164134,36 @@ class DeviceModeModel extends ObjectWrapper {
         }
         this.showHingeIfApplicable(overlayModel);
     }
+    onScreenOrientationLockChanged(event) {
+        this.#screenOrientationLocked = event.data.locked;
+        if (event.data.locked && event.data.orientation) {
+            this.applyOrientationLock(event.data.orientation);
+        }
+        this.dispatchEventToListeners("Updated" );
+    }
+    applyOrientationLock(orientation) {
+        const wantsLandscape = orientation.type === "landscapePrimary"  ||
+            orientation.type === "landscapeSecondary" ;
+        if (this.#type === Type.Device && this.#device && this.#mode) {
+            const isCurrentlyLandscape = this.#mode.orientation === Horizontal || this.#mode.orientation === HorizontalSpanned;
+            if (wantsLandscape !== isCurrentlyLandscape) {
+                const rotationPartner = this.#device.getRotationPartner(this.#mode);
+                if (rotationPartner) {
+                    this.emulate(this.#type, this.#device, rotationPartner);
+                }
+            }
+        }
+        else if (this.#type === Type.Responsive) {
+            const appliedSize = this.appliedDeviceSize();
+            const isCurrentlyLandscape = appliedSize.width > appliedSize.height;
+            if (wantsLandscape !== isCurrentlyLandscape) {
+                this.setSizeAndScaleToFit(appliedSize.height, appliedSize.width);
+            }
+        }
+    }
+    isScreenOrientationLocked() {
+        return this.#screenOrientationLocked;
+    }
     scaleSettingChanged() {
         this.calculateAndEmulate(false);
     }
@@ -162785,9 +164348,6 @@ class DeviceModeModel extends ObjectWrapper {
                 positionX,
                 positionY,
                 dontSetVisibleSize: true,
-                displayFeature: undefined,
-                devicePosture: undefined,
-                screenOrientation: undefined,
             };
             if (displayFeature) {
                 metrics.displayFeature = displayFeature;
@@ -163940,7 +165500,6 @@ class NetworkLog extends ObjectWrapper {
         initiatorInfo = {
             info: null,
             chain: null,
-            request: undefined,
         };
         this.#initiatorData.set(request, initiatorInfo);
         return initiatorInfo;
@@ -165359,7 +166918,7 @@ Status code: ${statusCode}
 MIME Type: ${mimeType}
 Protocol: ${protocol}
 ${priorityLines.join('\n')}
-Render blocking: ${renderBlocking ? 'Yes' : 'No'}
+Render-blocking: ${renderBlocking ? 'Yes' : 'No'}
 From a service worker: ${fromServiceWorker ? 'Yes' : 'No'}
 Initiators (root request to the request that directly loaded this one): ${initiatorUrls.join(', ') || 'none'}
 ${NetworkRequestFormatter.formatHeaders('Response headers', responseHeaders ?? [], true)}`;
@@ -165688,8 +167247,8 @@ class PerformanceInsightFormatter {
                 return [{ title: 'How do I optimize my network dependency tree?' }];
             case 'RenderBlocking':
                 return [
-                    { title: 'Show me the most impactful render blocking requests that I should focus on' },
-                    { title: 'How can I reduce the number of render blocking requests?' }
+                    { title: 'Show me the most impactful render-blocking requests that I should focus on' },
+                    { title: 'How can I reduce the number of render-blocking requests?' }
                 ];
             case 'SlowCSSSelector':
                 return [{ title: 'How can I optimize my CSS to increase the performance of CSS selectors?' }];
@@ -166092,9 +167651,9 @@ ${requestSummary}`;
     formatRenderBlockingInsight(insight) {
         const requestSummary = this.#traceFormatter.formatNetworkRequests(insight.renderBlockingRequests);
         if (requestSummary.length === 0) {
-            return 'There are no network requests that are render blocking.';
+            return 'There are no network requests that are render-blocking.';
         }
-        return `Here is a list of the network requests that were render blocking on this page and their duration:
+        return `Here is a list of the network requests that were render-blocking on this page and their duration:
 
 ${requestSummary}`;
     }
@@ -166371,7 +167930,7 @@ It is important that all of these checks pass to minimize the delay between the
    3. The maximum of 4 preconnects should be respected.
 - Opportunities to add [preconnect] for a faster loading experience.`;
             case 'RenderBlocking':
-                return 'This insight identifies network requests that were render blocking. Render blocking requests are impactful because they are deemed critical to the page and therefore the browser stops rendering the page until it has dealt with these resources. For this insight make sure you fully inspect the details of each render blocking network request and prioritize your suggestions to the user based on the impact of each render blocking request.';
+                return 'This insight identifies network requests that were render-blocking. Render-blocking requests are impactful because they are deemed critical to the page and therefore the browser stops rendering the page until it has dealt with these resources. For this insight make sure you fully inspect the details of each render-blocking network request and prioritize your suggestions to the user based on the impact of each render-blocking request.';
             case 'SlowCSSSelector':
                 return `This insight identifies CSS selectors that are slowing down your page's rendering performance.`;
             case 'ThirdParties':
@@ -170109,6 +171668,10 @@ const UIStrings$g = {
     InsecurePrivateNetworkSubresourceRequest: "The website requested a subresource from a network that it could only access because of its users' privileged network position. These requests expose non-public devices and servers to the internet, increasing the risk of a cross-site request forgery (CSRF) attack, and/or information leakage. To mitigate these risks, Chrome deprecates requests to non-public subresources when initiated from non-secure contexts, and will start blocking them.",
     InterestGroupDailyUpdateUrl: "The `dailyUpdateUrl` field of `InterestGroups` passed to `joinAdInterestGroup()` has been renamed to `updateUrl`, to more accurately reflect its behavior.",
     IntlV8BreakIterator: "`Intl.v8BreakIterator` is deprecated. Please use `Intl.Segmenter` instead.",
+    LanguageModel_InputQuota: "LanguageModel.inputQuota is deprecated. Please use LanguageModel.contextWindow instead. This alias is only available in extensions.",
+    LanguageModel_InputUsage: "LanguageModel.inputUsage is deprecated. Please use LanguageModel.contextUsage instead. This alias is only available in extensions.",
+    LanguageModel_MeasureInputUsage: "LanguageModel.measureInputUsage() is deprecated. Please use LanguageModel.measureContextUsage() instead. This alias is only available in extensions.",
+    LanguageModel_OnQuotaOverflow: "LanguageModel.onquotaoverflow is deprecated. Please use LanguageModel.oncontextoverflow instead. The LanguageModel.onquotaoverflow alias is only available in extensions.",
     LanguageModelParams: "LanguageModel.params() is deprecated and now only available in extension contexts. The topK and temperature related fields within its result are also deprecated.",
     LanguageModelTemperature: "The 'temperature' parameter/attribute for LanguageModel is deprecated. It is only functional within extensions and may be removed in the future.",
     LanguageModelTopK: "The 'topK' parameter/attribute for LanguageModel is deprecated. It is only functional within extensions and may be removed in the future.",
@@ -170199,6 +171762,18 @@ const DEPRECATIONS_METADATA = {
     "LanguageModelTopK": {
         "chromeStatusFeature": 5134603979063296
     },
+    "LanguageModel_InputQuota": {
+        "chromeStatusFeature": 5134603979063296
+    },
+    "LanguageModel_InputUsage": {
+        "chromeStatusFeature": 5134603979063296
+    },
+    "LanguageModel_MeasureInputUsage": {
+        "chromeStatusFeature": 5134603979063296
+    },
+    "LanguageModel_OnQuotaOverflow": {
+        "chromeStatusFeature": 5134603979063296
+    },
     "LocalCSSFileExtensionRejected": {
         "milestone": 64
     },
@@ -172867,4 +174442,13 @@ var mcp = /*#__PURE__*/Object.freeze({
 	createIssuesFromProtocolIssue: createIssuesFromProtocolIssue
 });
 
-export { Browser as BrowserEnum, CDPSessionEvent, mcp as DevTools, KnownDevices, Locator, McpServer, PipeTransport, PredefinedNetworkConditions, SetLevelRequestSchema, StdioServerTransport, debug$2 as debug, detectBrowserPlatform, hideBin, puppeteer, resolveDefaultUserDataDir, Yargs as yargs, z as zod };
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const snapshot = snapshot$1;
+const navigation = navigation$1;
+const generateReport = generateReport$1;
+
+export { Browser as BrowserEnum, CDPSessionEvent, Client$1 as Client, mcp as DevTools, KnownDevices, Locator, McpServer, PipeTransport, PredefinedNetworkConditions, SetLevelRequestSchema, StdioClientTransport, StdioServerTransport, debug$2 as debug, detectBrowserPlatform, generateReport, hideBin, navigation, puppeteer, resolveDefaultUserDataDir, snapshot, Yargs as yargs, z as zod };