chrome-devtools-mcp 0.10.1 → 0.11.0

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/node/HostRuntime.js

@@ -0,0 +1,72 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as WorkerThreads from 'node:worker_threads';
+class NodeWorkerScope {
+    postMessage(message) {
+        WorkerThreads.parentPort?.postMessage(message);
+    }
+    set onmessage(listener) {
+        WorkerThreads.parentPort?.on('message', data => {
+            listener({ data });
+        });
+    }
+}
+class NodeWorker {
+    #workerPromise;
+    #disposed = false;
+    #rejectWorkerPromise;
+    constructor(url) {
+        this.#workerPromise = new Promise((resolve, reject) => {
+            this.#rejectWorkerPromise = reject;
+            const worker = new WorkerThreads.Worker(new URL(url));
+            worker.once('message', (message) => {
+                if (message === 'workerReady') {
+                    resolve(worker);
+                }
+            });
+            worker.on('error', reject);
+        });
+    }
+    postMessage(message) {
+        void this.#workerPromise.then(worker => {
+            if (!this.#disposed) {
+                worker.postMessage(message);
+            }
+        });
+    }
+    dispose() {
+        this.#disposed = true;
+        void this.#workerPromise.then(worker => worker.terminate());
+    }
+    terminate(immediately) {
+        if (immediately) {
+            this.#rejectWorkerPromise?.(new Error('Worker terminated'));
+        }
+        this.dispose();
+    }
+    set onmessage(listener) {
+        void this.#workerPromise.then(worker => {
+            worker.on('message', data => {
+                if (!this.#disposed) {
+                    listener({ data });
+                }
+            });
+        });
+    }
+    set onerror(listener) {
+        void this.#workerPromise.then(worker => {
+            worker.on('error', (error) => {
+                if (!this.#disposed) {
+                    listener({ type: 'error', ...error });
+                }
+            });
+        });
+    }
+}
+export const HOST_RUNTIME = {
+    createWorker(url) {
+        return new NodeWorker(url);
+    },
+    workerScope: new NodeWorkerScope(),
+};

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/node/node.js

@@ -0,0 +1,5 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as HostRuntime from './HostRuntime.js';
+export { HostRuntime };

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/platform.js

@@ -6,7 +6,7 @@ import * as Brand from './Brand.js';
 import * as Constructor from './Constructor.js';
 import * as DateUtilities from './DateUtilities.js';
 import * as DevToolsPath from './DevToolsPath.js';
-import * as DOMUtilities from './DOMUtilities.js';
+import * as HostRuntime from './HostRuntime.js';
 import * as KeyboardUtilities from './KeyboardUtilities.js';
 import * as MapUtilities from './MapUtilities.js';
 import * as MimeType from './MimeType.js';
@@ -23,4 +23,4 @@ import * as UserVisibleError from './UserVisibleError.js';
  * error).
  */
 export { assertNever, assertNotNullOrUndefined, assertUnhandled } from './TypescriptUtilities.js';
-export { ArrayUtilities, Brand, Constructor, DateUtilities, DevToolsPath, DOMUtilities, KeyboardUtilities, MapUtilities, MimeType, NumberUtilities, StringUtilities, Timing, TypedArrayUtilities, TypeScriptUtilities, UIString, UserVisibleError, };
+export { ArrayUtilities, Brand, Constructor, DateUtilities, DevToolsPath, HostRuntime, KeyboardUtilities, MapUtilities, MimeType, NumberUtilities, StringUtilities, Timing, TypedArrayUtilities, TypeScriptUtilities, UIString, UserVisibleError, };

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/DevToolsCDPConnection.js

@@ -0,0 +1,138 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { CDPErrorStatus } from './CDPConnection.js';
+import { InspectorBackend, test } from './InspectorBackend.js';
+const LongPollingMethods = new Set(['CSS.takeComputedStyleUpdates']);
+export class DevToolsCDPConnection {
+    #transport;
+    #lastMessageId = 1;
+    #pendingResponsesCount = 0;
+    #pendingLongPollingMessageIds = new Set();
+    #pendingScripts = [];
+    #callbacks = new Map();
+    #observers = new Set();
+    constructor(transport) {
+        this.#transport = transport;
+        test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
+        test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
+        this.#transport.setOnMessage(this.onMessage.bind(this));
+        this.#transport.setOnDisconnect(reason => {
+            this.#observers.forEach(observer => observer.onDisconnect(reason));
+        });
+    }
+    observe(observer) {
+        this.#observers.add(observer);
+    }
+    unobserve(observer) {
+        this.#observers.delete(observer);
+    }
+    send(method, params, sessionId) {
+        const messageId = ++this.#lastMessageId;
+        const messageObject = {
+            id: messageId,
+            method,
+        };
+        if (params) {
+            messageObject.params = params;
+        }
+        if (sessionId) {
+            messageObject.sessionId = sessionId;
+        }
+        if (test.dumpProtocol) {
+            test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
+        }
+        if (test.onMessageSent) {
+            const domain = method.split('.')[0];
+            const paramsObject = JSON.parse(JSON.stringify(params || {}));
+            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId });
+        }
+        ++this.#pendingResponsesCount;
+        if (LongPollingMethods.has(method)) {
+            this.#pendingLongPollingMessageIds.add(messageId);
+        }
+        return new Promise(resolve => {
+            this.#callbacks.set(messageId, { resolve, method, sessionId });
+            this.#transport.sendRawMessage(JSON.stringify(messageObject));
+        });
+    }
+    resolvePendingCalls(sessionId) {
+        for (const { resolve, method, sessionId: callbackSessionId } of this.#callbacks.values()) {
+            if (sessionId !== callbackSessionId) {
+                continue;
+            }
+            resolve({
+                error: {
+                    message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
+                    code: CDPErrorStatus.SESSION_NOT_FOUND,
+                }
+            });
+        }
+    }
+    sendRawMessageForTesting(method, params, callback, sessionId = '') {
+        void this.send(method, params, sessionId).then(response => {
+            if ('error' in response && response.error) {
+                callback?.(response.error, null);
+            }
+            else if ('result' in response) {
+                callback?.(null, response.result);
+            }
+        });
+    }
+    onMessage(message) {
+        if (test.dumpProtocol) {
+            test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
+        }
+        if (test.onMessageReceived) {
+            const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
+            test.onMessageReceived(messageObjectCopy);
+        }
+        const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message);
+        if ('id' in messageObject && messageObject.id !== undefined) { // just a response for some request
+            const callback = this.#callbacks.get(messageObject.id);
+            this.#callbacks.delete(messageObject.id);
+            if (!callback) {
+                // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
+                return;
+            }
+            callback.resolve(messageObject);
+            --this.#pendingResponsesCount;
+            this.#pendingLongPollingMessageIds.delete(messageObject.id);
+            if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
+                this.deprecatedRunAfterPendingDispatches();
+            }
+        }
+        else if ('method' in messageObject) {
+            this.#observers.forEach(observer => observer.onEvent(messageObject));
+        }
+        else {
+            InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
+        }
+    }
+    hasOutstandingNonLongPollingRequests() {
+        return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
+    }
+    deprecatedRunAfterPendingDispatches(script) {
+        if (script) {
+            this.#pendingScripts.push(script);
+        }
+        // Execute all promises.
+        setTimeout(() => {
+            if (!this.hasOutstandingNonLongPollingRequests()) {
+                this.executeAfterPendingDispatches();
+            }
+            else {
+                this.deprecatedRunAfterPendingDispatches();
+            }
+        }, 0);
+    }
+    executeAfterPendingDispatches() {
+        if (!this.hasOutstandingNonLongPollingRequests()) {
+            const scripts = this.#pendingScripts;
+            this.#pendingScripts = [];
+            for (let id = 0; id < scripts.length; ++id) {
+                scripts[id]();
+            }
+        }
+    }
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/InspectorBackend.js

@@ -4,7 +4,7 @@
 import * as InspectorBackendCommands from '../../generated/InspectorBackendCommands.js';
 import { CDPErrorStatus } from './CDPConnection.js';
 import { ConnectionTransport } from './ConnectionTransport.js';
-import { NodeURL } from './NodeURL.js';
+import { DevToolsCDPConnection } from './DevToolsCDPConnection.js';
 export const splitQualifiedName = (string) => {
     const [domain, eventName] = string.split('.');
     return [domain, eventName];
@@ -105,34 +105,12 @@ export const test = {
      */
     onMessageReceived: null,
 };
-const LongPollingMethods = new Set(['CSS.takeComputedStyleUpdates']);
 export class SessionRouter {
     #connection;
-    #lastMessageId = 1;
-    #pendingResponsesCount = 0;
-    #pendingLongPollingMessageIds = new Set();
     #sessions = new Map();
-    #pendingScripts = [];
-    #callbacks = new Map();
-    #observers = new Set();
     constructor(connection) {
         this.#connection = connection;
-        test.deprecatedRunAfterPendingDispatches = this.deprecatedRunAfterPendingDispatches.bind(this);
-        test.sendRawMessage = this.sendRawMessageForTesting.bind(this);
-        this.#connection.setOnMessage(this.onMessage.bind(this));
-        this.#connection.setOnDisconnect(reason => {
-            const session = this.#sessions.get('');
-            if (session) {
-                session.target.dispose(reason);
-            }
-            this.#observers.forEach(observer => observer.onDisconnect(reason));
-        });
-    }
-    observe(observer) {
-        this.#observers.add(observer);
-    }
-    unobserve(observer) {
-        this.#observers.delete(observer);
+        this.#connection.observe(this);
     }
     registerSession(target, sessionId) {
         this.#sessions.set(sessionId, { target });
@@ -142,136 +120,32 @@ export class SessionRouter {
         if (!session) {
             return;
         }
-        for (const { resolve, method, sessionId: callbackSessionId } of this.#callbacks.values()) {
-            if (sessionId !== callbackSessionId) {
-                continue;
-            }
-            resolve({
-                error: {
-                    message: `Session is unregistering, can\'t dispatch pending call to ${method}`,
-                    code: CDPErrorStatus.SESSION_NOT_FOUND,
-                }
-            });
+        if (this.#connection instanceof DevToolsCDPConnection) {
+            this.#connection.resolvePendingCalls(sessionId);
         }
         this.#sessions.delete(sessionId);
     }
-    nextMessageId() {
-        return this.#lastMessageId++;
-    }
-    connection() {
-        return this.#connection;
-    }
-    send(method, params, sessionId) {
-        const messageId = this.nextMessageId();
-        const messageObject = {
-            id: messageId,
-            method,
-        };
-        if (params) {
-            messageObject.params = params;
-        }
-        if (sessionId) {
-            messageObject.sessionId = sessionId;
+    onDisconnect(reason) {
+        const session = this.#sessions.get('');
+        if (session) {
+            session.target.dispose(reason);
         }
-        if (test.dumpProtocol) {
-            test.dumpProtocol('frontend: ' + JSON.stringify(messageObject));
-        }
-        if (test.onMessageSent) {
-            const domain = method.split('.')[0];
-            const paramsObject = JSON.parse(JSON.stringify(params || {}));
-            test.onMessageSent({ domain, method, params: paramsObject, id: messageId, sessionId });
-        }
-        ++this.#pendingResponsesCount;
-        if (LongPollingMethods.has(method)) {
-            this.#pendingLongPollingMessageIds.add(messageId);
-        }
-        return new Promise(resolve => {
-            this.#callbacks.set(messageId, { resolve, method, sessionId });
-            this.#connection.sendRawMessage(JSON.stringify(messageObject));
-        });
-    }
-    sendRawMessageForTesting(method, params, callback, sessionId = '') {
-        void this.send(method, params, sessionId).then(response => {
-            if ('error' in response && response.error) {
-                callback?.(response.error, null);
-            }
-            else if ('result' in response) {
-                callback?.(null, response.result);
-            }
-        });
     }
-    onMessage(message) {
-        if (test.dumpProtocol) {
-            test.dumpProtocol('backend: ' + ((typeof message === 'string') ? message : JSON.stringify(message)));
-        }
-        if (test.onMessageReceived) {
-            const messageObjectCopy = JSON.parse((typeof message === 'string') ? message : JSON.stringify(message));
-            test.onMessageReceived(messageObjectCopy);
-        }
-        const messageObject = ((typeof message === 'string') ? JSON.parse(message) : message);
-        const sessionId = messageObject.sessionId || '';
+    onEvent(event) {
+        const sessionId = event.sessionId || '';
         const session = this.#sessions.get(sessionId);
-        if (session?.target.getNeedsNodeJSPatching()) {
-            NodeURL.patch(messageObject);
-        }
-        if ('id' in messageObject && messageObject.id !== undefined) { // just a response for some request
-            const callback = this.#callbacks.get(messageObject.id);
-            this.#callbacks.delete(messageObject.id);
-            if (!callback) {
-                // Ignore messages with unknown IDs, we might see puppeteer proxied messages here.
-                return;
-            }
-            callback.resolve(messageObject);
-            --this.#pendingResponsesCount;
-            this.#pendingLongPollingMessageIds.delete(messageObject.id);
-            if (this.#pendingScripts.length && !this.hasOutstandingNonLongPollingRequests()) {
-                this.deprecatedRunAfterPendingDispatches();
-            }
-        }
-        else if ('method' in messageObject) {
-            // This cast is justified as we just checked for the presence of messageObject.method.
-            session?.target.dispatch(messageObject);
-            this.#observers.forEach(observer => observer.onEvent(messageObject));
-        }
-        else {
-            InspectorBackend.reportProtocolError('Protocol Error: the message without method', messageObject);
-        }
+        session?.target.dispatch(event);
     }
-    hasOutstandingNonLongPollingRequests() {
-        return this.#pendingResponsesCount - this.#pendingLongPollingMessageIds.size > 0;
-    }
-    deprecatedRunAfterPendingDispatches(script) {
-        if (script) {
-            this.#pendingScripts.push(script);
-        }
-        // Execute all promises.
-        window.setTimeout(() => {
-            if (!this.hasOutstandingNonLongPollingRequests()) {
-                this.executeAfterPendingDispatches();
-            }
-            else {
-                this.deprecatedRunAfterPendingDispatches();
-            }
-        }, 0);
-    }
-    executeAfterPendingDispatches() {
-        if (!this.hasOutstandingNonLongPollingRequests()) {
-            const scripts = this.#pendingScripts;
-            this.#pendingScripts = [];
-            for (let id = 0; id < scripts.length; ++id) {
-                scripts[id]();
-            }
-        }
+    get connection() {
+        return this.#connection;
     }
 }
 export class TargetBase {
-    needsNodeJSPatching;
     sessionId;
     #router;
     #agents = new Map();
     #dispatchers = new Map();
-    constructor(needsNodeJSPatching, parentTarget, sessionId, connection) {
-        this.needsNodeJSPatching = needsNodeJSPatching;
+    constructor(parentTarget, sessionId, connection) {
         this.sessionId = sessionId;
         if (parentTarget && !sessionId) {
             throw new Error('Specifying a parent target requires a session ID');
@@ -284,7 +158,7 @@ export class TargetBase {
             router = new SessionRouter(connection);
         }
         else {
-            router = new SessionRouter(ConnectionTransport.getFactory()());
+            router = new SessionRouter(new DevToolsCDPConnection(ConnectionTransport.getFactory()()));
         }
         this.#router = router;
         router.registerSession(this, this.sessionId);
@@ -316,9 +190,6 @@ export class TargetBase {
     isDisposed() {
         return !this.#router;
     }
-    markAsNodeJSForTest() {
-        this.needsNodeJSPatching = true;
-    }
     router() {
         return this.#router;
     }
@@ -570,9 +441,6 @@ export class TargetBase {
     registerWebAuthnDispatcher(dispatcher) {
         this.registerDispatcher('WebAuthn', dispatcher);
     }
-    getNeedsNodeJSPatching() {
-        return this.needsNodeJSPatching;
-    }
 }
 /** These are not logged as console.error */
 const IGNORED_ERRORS = new Set([
@@ -608,11 +476,12 @@ class AgentPrototype {
         this['invoke_' + methodName] = invoke;
     }
     invoke(method, request) {
-        const router = this.target.router();
-        if (!router) {
+        const connection = this.target.router()?.connection;
+        if (!connection) {
             return Promise.resolve({ result: null, getError: () => `Connection is closed, can\'t dispatch pending call to ${method}` });
         }
-        return router.send(method, request, this.target.sessionId).then(response => {
+        return connection.send(method, request, this.target.sessionId)
+            .then(response => {
             if ('error' in response && response.error) {
                 if (!test.suppressRequestErrors && !IGNORED_ERRORS.has(response.error.code)) {
                     console.error('Request ' + method + ' failed. ' + JSON.stringify(response.error));

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/protocol_client.js

@@ -3,6 +3,6 @@
 // found in the LICENSE file.
 import * as CDPConnection from './CDPConnection.js';
 import * as ConnectionTransport from './ConnectionTransport.js';
+import * as DevToolsCDPConnection from './DevToolsCDPConnection.js';
 import * as InspectorBackend from './InspectorBackend.js';
-import * as NodeURL from './NodeURL.js';
-export { CDPConnection, ConnectionTransport, InspectorBackend, NodeURL, };
+export { CDPConnection, ConnectionTransport, DevToolsCDPConnection, InspectorBackend, };

package/build/node_modules/chrome-devtools-frontend/front_end/core/root/DevToolsContext.js

@@ -0,0 +1,54 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+/**
+ * Container for singletons scoped to a single DevTools universe.
+ *
+ * When wiring up dependencies, strongly prefer to pass all direct dependencies
+ * via constructor, and not just pass a {@link DevToolsContext} around. That would hide
+ * dependencies and we want to be explicit.
+ */
+export class DevToolsContext {
+    #instances = new Map();
+    get(ctor) {
+        const instance = this.#instances.get(ctor);
+        if (!instance) {
+            throw new Error(`No instance for ${ctor.name}. Ensure the bootstrapper creates it.`);
+        }
+        return instance;
+    }
+    /** @deprecated Should only be used by existing `instance` accessors. */
+    has(ctor) {
+        return this.#instances.has(ctor);
+    }
+    /**
+     * @deprecated Should only be used by existing `instance` accessors and the bootstrapper.
+     * Exists on the public interface only for migration purposes for now.
+     */
+    set(ctor, instance) {
+        // TODO(crbug.com/458180550): We need to throw here if an instance was already set!
+        this.#instances.set(ctor, instance);
+    }
+    /** @deprecated Should only be used by existing `removeInstance` static methods. */
+    delete(ctor) {
+        this.#instances.delete(ctor);
+    }
+}
+let gInstance = null;
+/**
+ * @deprecated Exists to migrate instance() methods.
+ */
+export function globalInstance() {
+    if (!gInstance) {
+        // TODO(crbug.com/458180550): This should really throw to prevent side-effects and globals
+        //                            from leaking all over the place.
+        gInstance = new DevToolsContext();
+    }
+    return gInstance;
+}
+/**
+ * @deprecated Should only be called by test setup and MainImpl
+ */
+export function setGlobalInstance(context) {
+    gInstance = context;
+}

package/build/node_modules/chrome-devtools-frontend/front_end/core/root/Runtime.js

@@ -1,4 +1,11 @@
 
 export function getChromeVersion() { return ''; };
 export const hostConfig = {};
+export const Runtime = {
+  isDescriptorEnabled: () => true,
+  queryParam: () => null,
+}
+export const experiments = {
+  isEnabled: () => false,
+}
   

package/build/node_modules/chrome-devtools-frontend/front_end/core/root/root.js

@@ -1,5 +1,6 @@
 // Copyright 2020 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+import * as DevToolsContext from './DevToolsContext.js';
 import * as Runtime from './Runtime.js';
-export { Runtime };
+export { DevToolsContext, Runtime, };

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/AnimationModel.js

@@ -302,7 +302,7 @@ export class AnimationModel extends SDKModel {
         const animation = await AnimationImpl.parsePayload(this, payload);
         // Ignore Web Animations custom effects & groups.
         const keyframesRule = animation.source().keyframesRule();
-        if (animation.type() === 'WebAnimation' && keyframesRule && keyframesRule.keyframes().length === 0) {
+        if (animation.type() === 'WebAnimation' && keyframesRule?.keyframes().length === 0) {
             this.#pendingAnimations.delete(animation.id());
         }
         else {

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CPUThrottlingManager.js

@@ -148,9 +148,6 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper {
         // Implemented as a requirement for being a SDKModelObserver.
     }
 }
-export function throttlingManager() {
-    return CPUThrottlingManager.instance();
-}
 export var CPUThrottlingRates;
 (function (CPUThrottlingRates) {
     CPUThrottlingRates[CPUThrottlingRates["NO_THROTTLING"] = 1] = "NO_THROTTLING";

package/build/node_modules/chrome-devtools-frontend/front_end/core/sdk/CSSMatchedStyles.js

@@ -5,8 +5,8 @@ import * as Platform from '../platform/platform.js';
 import { CSSMetadata, cssMetadata } from './CSSMetadata.js';
 import { CSSProperty } from './CSSProperty.js';
 import * as PropertyParser from './CSSPropertyParser.js';
-import { AnchorFunctionMatcher, AngleMatcher, AttributeMatcher, AutoBaseMatcher, BaseVariableMatcher, BezierMatcher, BinOpMatcher, ColorMatcher, ColorMixMatcher, CustomFunctionMatcher, defaultValueForCSSType, EnvFunctionMatcher, FlexGridMasonryMatcher, GridTemplateMatcher, LengthMatcher, LightDarkColorMatcher, LinearGradientMatcher, LinkableNameMatcher, localEvalCSS, MathFunctionMatcher, PositionAnchorMatcher, PositionTryMatcher, RelativeColorChannelMatcher, ShadowMatcher, StringMatcher, URLMatcher, VariableMatcher } from './CSSPropertyParserMatchers.js';
-import { CSSFontPaletteValuesRule, CSSFunctionRule, CSSKeyframeRule, CSSKeyframesRule, CSSPositionTryRule, CSSPropertyRule, CSSStyleRule, } from './CSSRule.js';
+import { AnchorFunctionMatcher, AngleMatcher, AttributeMatcher, AutoBaseMatcher, BaseVariableMatcher, BezierMatcher, BinOpMatcher, ColorMatcher, ColorMixMatcher, CustomFunctionMatcher, defaultValueForCSSType, EnvFunctionMatcher, FlexGridGridLanesMatcher, GridTemplateMatcher, LengthMatcher, LightDarkColorMatcher, LinearGradientMatcher, LinkableNameMatcher, localEvalCSS, MathFunctionMatcher, PositionAnchorMatcher, PositionTryMatcher, RelativeColorChannelMatcher, ShadowMatcher, StringMatcher, URLMatcher, VariableMatcher } from './CSSPropertyParserMatchers.js';
+import { CSSAtRule, CSSFunctionRule, CSSKeyframeRule, CSSKeyframesRule, CSSPositionTryRule, CSSPropertyRule, CSSStyleRule, } from './CSSRule.js';
 import { CSSStyleDeclaration, Type } from './CSSStyleDeclaration.js';
 function containsStyle(styles, query) {
     if (!query.styleSheetId || !query.range) {
@@ -212,15 +212,15 @@ export class CSSMatchedStyles {
     #pseudoDOMCascades;
     #customHighlightPseudoDOMCascades;
     #functionRules;
+    #atRules;
     #functionRuleMap = new Map();
-    #fontPaletteValuesRule;
     #environmentVariables = {};
     static async create(payload) {
         const cssMatchedStyles = new CSSMatchedStyles(payload);
         await cssMatchedStyles.init(payload);
         return cssMatchedStyles;
     }
-    constructor({ cssModel, node, animationsPayload, parentLayoutNodeId, positionTryRules, propertyRules, cssPropertyRegistrations, fontPaletteValuesRule, activePositionFallbackIndex, functionRules, }) {
+    constructor({ cssModel, node, animationsPayload, parentLayoutNodeId, positionTryRules, propertyRules, cssPropertyRegistrations, activePositionFallbackIndex, functionRules, atRules, }) {
         this.#cssModel = cssModel;
         this.#node = node;
         this.#registeredProperties = [
@@ -232,10 +232,9 @@ export class CSSMatchedStyles {
         }
         this.#positionTryRules = positionTryRules.map(rule => new CSSPositionTryRule(cssModel, rule));
         this.#parentLayoutNodeId = parentLayoutNodeId;
-        this.#fontPaletteValuesRule =
-            fontPaletteValuesRule ? new CSSFontPaletteValuesRule(cssModel, fontPaletteValuesRule) : undefined;
         this.#activePositionFallbackIndex = activePositionFallbackIndex;
         this.#functionRules = functionRules.map(rule => new CSSFunctionRule(cssModel, rule));
+        this.#atRules = atRules.map(rule => new CSSAtRule(cssModel, rule));
     }
     async init({ matchedPayload, inheritedPayload, inlinePayload, attributesPayload, pseudoPayload, inheritedPseudoPayload, animationStylesPayload, transitionsStylePayload, inheritedAnimatedPayload, }) {
         matchedPayload = cleanUserAgentPayload(matchedPayload);
@@ -599,8 +598,8 @@ export class CSSMatchedStyles {
     functionRules() {
         return this.#functionRules;
     }
-    fontPaletteValuesRule() {
-        return this.#fontPaletteValuesRule;
+    atRules() {
+        return this.#atRules;
     }
     keyframes() {
         return this.#keyframes;
@@ -714,7 +713,7 @@ export class CSSMatchedStyles {
             new LinearGradientMatcher(),
             new AnchorFunctionMatcher(),
             new PositionAnchorMatcher(),
-            new FlexGridMasonryMatcher(),
+            new FlexGridGridLanesMatcher(),
             new PositionTryMatcher(),
             new LengthMatcher(),
             new MathFunctionMatcher(),