@mcp-b/chrome-devtools-mcp 2.0.2 → 2.0.6

package/build/vendor/chrome-devtools-frontend/front_end/core/host/UserMetrics.js

@@ -159,33 +159,15 @@ export class UserMetrics {
             InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.SyncSetting" /* EnumeratedHistogram.SyncSetting */, settingValue, 5 /* SyncSetting.MAX_VALUE */);
         });
     }
-    recordingAssertion(value) {
-        InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingAssertion" /* EnumeratedHistogram.RecordingAssertion */, value, 4 /* RecordingAssertion.MAX_VALUE */);
-    }
     recordingToggled(value) {
         InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingToggled" /* EnumeratedHistogram.RecordingToggled */, value, 3 /* RecordingToggled.MAX_VALUE */);
     }
     recordingReplayFinished(value) {
         InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingReplayFinished" /* EnumeratedHistogram.RecordingReplayFinished */, value, 5 /* RecordingReplayFinished.MAX_VALUE */);
     }
-    recordingReplaySpeed(value) {
-        InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingReplaySpeed" /* EnumeratedHistogram.RecordingReplaySpeed */, value, 5 /* RecordingReplaySpeed.MAX_VALUE */);
-    }
     recordingReplayStarted(value) {
         InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingReplayStarted" /* EnumeratedHistogram.RecordingReplayStarted */, value, 4 /* RecordingReplayStarted.MAX_VALUE */);
     }
-    recordingEdited(value) {
-        InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingEdited" /* EnumeratedHistogram.RecordingEdited */, value, 11 /* RecordingEdited.MAX_VALUE */);
-    }
-    recordingExported(value) {
-        InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingExported" /* EnumeratedHistogram.RecordingExported */, value, 6 /* RecordingExported.MAX_VALUE */);
-    }
-    recordingCodeToggled(value) {
-        InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingCodeToggled" /* EnumeratedHistogram.RecordingCodeToggled */, value, 3 /* RecordingCodeToggled.MAX_VALUE */);
-    }
-    recordingCopiedToClipboard(value) {
-        InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.RecordingCopiedToClipboard" /* EnumeratedHistogram.RecordingCopiedToClipboard */, value, 9 /* RecordingCopiedToClipboard.MAX_VALUE */);
-    }
     lighthouseModeRun(type) {
         InspectorFrontendHostInstance.recordEnumeratedHistogram("DevTools.LighthouseModeRun" /* EnumeratedHistogram.LighthouseModeRun */, type, 4 /* LighthouseModeRun.MAX_VALUE */);
     }
@@ -222,9 +204,30 @@ export class UserMetrics {
     consoleInsightTeaserGenerated(timeInMilliseconds) {
         InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserGenerationTime', timeInMilliseconds);
     }
+    consoleInsightTeaserGeneratedMedium(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogramMedium('DevTools.Insights.TeaserGenerationTimeMedium', timeInMilliseconds);
+    }
     consoleInsightTeaserFirstChunkGenerated(timeInMilliseconds) {
         InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserFirstChunkGenerationTime', timeInMilliseconds);
     }
+    consoleInsightTeaserFirstChunkGeneratedMedium(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogramMedium('DevTools.Insights.TeaserFirstChunkGenerationTimeMedium', timeInMilliseconds);
+    }
+    consoleInsightTeaserChunkToEndMedium(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogramMedium('DevTools.Insights.TeaserChunkToEndMedium', timeInMilliseconds);
+    }
+    consoleInsightTeaserAbortedAfterFirstCharacter(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserAfterFirstCharacterAbortionTime', timeInMilliseconds);
+    }
+    consoleInsightTeaserAbortedBeforeFirstCharacter(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.TeaserBeforeFirstCharacterAbortionTime', timeInMilliseconds);
+    }
+    consoleInsightLongTeaserGenerated(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.LongTeaserGenerationTime', timeInMilliseconds);
+    }
+    consoleInsightShortTeaserGenerated(timeInMilliseconds) {
+        InspectorFrontendHostInstance.recordPerformanceHistogram('DevTools.Insights.ShortTeaserGenerationTime', timeInMilliseconds);
+    }
 }
 /**
  * The numeric enum values are not necessarily continuous! It is possible that
@@ -436,7 +439,11 @@ export var Action;
     Action[Action["InsightTeaserGenerationErrored"] = 194] = "InsightTeaserGenerationErrored";
     Action[Action["AiCodeGenerationSuggestionDisplayed"] = 195] = "AiCodeGenerationSuggestionDisplayed";
     Action[Action["AiCodeGenerationSuggestionAccepted"] = 196] = "AiCodeGenerationSuggestionAccepted";
-    Action[Action["MAX_VALUE"] = 197] = "MAX_VALUE";
+    Action[Action["InsightTeaserModelDownloadStarted"] = 197] = "InsightTeaserModelDownloadStarted";
+    Action[Action["InsightTeaserModelDownloadCompleted"] = 198] = "InsightTeaserModelDownloadCompleted";
+    Action[Action["AiCodeGenerationError"] = 199] = "AiCodeGenerationError";
+    Action[Action["AiCodeGenerationRequestTriggered"] = 200] = "AiCodeGenerationRequestTriggered";
+    Action[Action["MAX_VALUE"] = 201] = "MAX_VALUE";
     /* eslint-enable @typescript-eslint/naming-convention */
 })(Action || (Action = {}));
 export var PanelCodes;
@@ -698,7 +705,7 @@ export var DevtoolsExperiments;
     DevtoolsExperiments[DevtoolsExperiments["live-heap-profile"] = 11] = "live-heap-profile";
     DevtoolsExperiments[DevtoolsExperiments["protocol-monitor"] = 13] = "protocol-monitor";
     DevtoolsExperiments[DevtoolsExperiments["sampling-heap-profiler-timeline"] = 17] = "sampling-heap-profiler-timeline";
-    DevtoolsExperiments[DevtoolsExperiments["show-option-tp-expose-internals-in-heap-snapshot"] = 18] = "show-option-tp-expose-internals-in-heap-snapshot";
+    DevtoolsExperiments[DevtoolsExperiments["show-option-to-expose-internals-in-heap-snapshot"] = 18] = "show-option-to-expose-internals-in-heap-snapshot";
     DevtoolsExperiments[DevtoolsExperiments["timeline-invalidation-tracking"] = 26] = "timeline-invalidation-tracking";
     DevtoolsExperiments[DevtoolsExperiments["timeline-show-all-events"] = 27] = "timeline-show-all-events";
     DevtoolsExperiments[DevtoolsExperiments["timeline-v8-runtime-call-stats"] = 28] = "timeline-v8-runtime-call-stats";

package/build/vendor/chrome-devtools-frontend/front_end/core/i18n/collect-ui-strings.js

@@ -1,14 +1,13 @@
-"use strict";
 // Copyright 2022 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-const glob = require('glob');
-const path = require('node:path');
-const yargs = require('yargs');
-const { hideBin } = require('yargs/helpers');
-const { writeIfChanged } = require('../../../scripts/build/ninja/write-if-changed.js');
-const { bakePlaceholders } = require('../../../third_party/i18n/bake-ctc-to-lhl.js');
-const { collectAllStringsInDir, createPsuedoLocaleStrings, IGNORED_PATH_COMPONENTS } = require('../../../third_party/i18n/collect-strings.js');
+import glob from 'glob';
+import * as path from 'node:path';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { writeIfChanged } from '../../../scripts/build/ninja/write-if-changed.js';
+import { bakePlaceholders } from '../../../third_party/i18n/bake-ctc-to-lhl.js';
+import { collectAllStringsInDir, createPsuedoLocaleStrings, IGNORED_PATH_COMPONENTS, } from '../../../third_party/i18n/collect-strings.js';
 /** @typedef {import('../../../third_party/i18n/bake-ctc-to-lhl.js').CtcMessage} CtcMessage */
 const yargsObject = yargs(hideBin(process.argv))
     .option('input-directories', {

package/build/vendor/chrome-devtools-frontend/front_end/core/i18n/generate-locales-js.js

@@ -1,11 +1,10 @@
-"use strict";
 // Copyright 2022 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-const path = require('node:path');
-const yargs = require('yargs');
-const { hideBin } = require('yargs/helpers');
-const { writeIfChanged } = require('../../../scripts/build/ninja/write-if-changed.js');
+import * as path from 'node:path';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { writeIfChanged } from '../../../scripts/build/ninja/write-if-changed.js';
 const yargsObject = yargs(hideBin(process.argv))
     .option('target-gen-dir', {
     type: 'string',

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

@@ -197,3 +197,13 @@ export function nearestIndexFromEnd(arr, predicate) {
 export function arrayDoesNotContainNullOrUndefined(arr) {
     return !arr.includes(null) && !arr.includes(undefined);
 }
+export function assertArrayIsSorted(arr, compareFn) {
+    const comparator = compareFn || DEFAULT_COMPARATOR;
+    for (let i = 0; i < arr.length - 1; i++) {
+        const current = arr[i];
+        const next = arr[i + 1];
+        if (comparator(current, next) > 0) {
+            throw new Error(`Array is not sorted at index ${i}: ${JSON.stringify(current)} > ${JSON.stringify(next)}`);
+        }
+    }
+}

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

@@ -325,26 +325,77 @@ export const compare = (a, b) => {
     }
     return 0;
 };
+/** Returns a string that has no more than maxLength characters. Actual graphemes are used, not bytes. */
 export const trimMiddle = (str, maxLength) => {
+    // Early return for the case where there are fewer bytes than the character limit.
     if (str.length <= maxLength) {
-        return String(str);
-    }
-    let leftHalf = maxLength >> 1;
-    let rightHalf = maxLength - leftHalf - 1;
-    if (str.codePointAt(str.length - rightHalf - 1) >= 0x10000) {
-        --rightHalf;
-        ++leftHalf;
+        return str;
+    }
+    const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+    // If the max length is so small it can't fit the ellipsis, just return the ellipsis.
+    const ellipsis = '…';
+    const ellipsisLength = 1;
+    if (maxLength <= ellipsisLength) {
+        return ellipsis;
+    }
+    // Calculate how many graphemes to keep on each side.
+    const freeSpace = maxLength - ellipsisLength;
+    const leftCount = Math.ceil(freeSpace / 2);
+    const rightCount = Math.floor(freeSpace / 2);
+    let currentGraphemeCount = 0;
+    let leftEndIndex = 0;
+    // Sliding Window Buffer
+    // We need to know where the "Right Half" starts. Since we can't iterate backwards,
+    // we keep track of the start index of the last N graphemes we've seen.
+    const rightIndexBuffer = [];
+    // This function would be significantly simpler if we created an array of all the
+    // segments upfront, but could result in poor performance for large input strings.
+    for (const { segment, index } of segmenter.segment(str)) {
+        currentGraphemeCount++;
+        // Mark the byte index where the "Left Half" ends
+        if (currentGraphemeCount === leftCount) {
+            leftEndIndex = index + segment.length;
+        }
+        // Maintain the buffer for the "Right Half"
+        if (rightCount > 0) {
+            rightIndexBuffer.push(index);
+            if (rightIndexBuffer.length > rightCount) {
+                rightIndexBuffer.shift(); // Remove the oldest index to keep buffer size constant.
+            }
+        }
     }
-    if (leftHalf > 0 && str.codePointAt(leftHalf - 1) >= 0x10000) {
-        --leftHalf;
+    // If the total grapheme count didn't exceed the limit, return the original string.
+    if (currentGraphemeCount <= maxLength) {
+        return str;
     }
-    return str.substr(0, leftHalf) + '…' + str.substr(str.length - rightHalf, rightHalf);
+    // The first item in our buffer is exactly 'rightCount' graphemes away from the end.
+    const rightStartIndex = rightCount > 0 ? rightIndexBuffer[0] : str.length;
+    return str.slice(0, leftEndIndex) + ellipsis + str.slice(rightStartIndex);
 };
+/** Returns a string that has no more than maxLength characters. Actual graphemes are used, not bytes. */
 export const trimEndWithMaxLength = (str, maxLength) => {
+    // Early return for the case where there are fewer bytes than the character limit.
     if (str.length <= maxLength) {
-        return String(str);
+        return str;
+    }
+    const ellipsis = '…';
+    const ellipsisLength = 1;
+    const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+    const iterator = segmenter.segment(str)[Symbol.iterator]();
+    let lastSegmentIndex = 0;
+    for (let i = 0; i <= maxLength - ellipsisLength; i++) {
+        const result = iterator.next();
+        if (result.done) {
+            return str;
+        }
+        lastSegmentIndex = result.value.index;
+    }
+    for (let i = 0; i < ellipsisLength; i++) {
+        if (iterator.next().done) {
+            return str;
+        }
     }
-    return str.substr(0, maxLength - 1) + '…';
+    return str.slice(0, lastSegmentIndex) + ellipsis;
 };
 export const escapeForRegExp = (str) => {
     return escapeCharacters(str, SPECIAL_REGEX_CHARACTERS);

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

@@ -14,4 +14,5 @@ export var CDPErrorStatus;
     CDPErrorStatus[CDPErrorStatus["SERVER_ERROR"] = -32000] = "SERVER_ERROR";
     CDPErrorStatus[CDPErrorStatus["SESSION_NOT_FOUND"] = -32001] = "SESSION_NOT_FOUND";
     CDPErrorStatus[CDPErrorStatus["DEVTOOLS_STUB_ERROR"] = -32015] = "DEVTOOLS_STUB_ERROR";
+    CDPErrorStatus[CDPErrorStatus["DEVTOOLS_REHYDRATION_ERROR"] = -32016] = "DEVTOOLS_REHYDRATION_ERROR";
 })(CDPErrorStatus || (CDPErrorStatus = {}));

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

@@ -444,6 +444,7 @@ export class TargetBase {
 }
 /** These are not logged as console.error */
 const IGNORED_ERRORS = new Set([
+    CDPErrorStatus.DEVTOOLS_REHYDRATION_ERROR,
     CDPErrorStatus.DEVTOOLS_STUB_ERROR,
     CDPErrorStatus.SERVER_ERROR,
     CDPErrorStatus.SESSION_NOT_FOUND,
@@ -491,7 +492,9 @@ class AgentPrototype {
             if ('result' in response) {
                 return { ...response.result, getError: () => undefined };
             }
-            return { getError: () => undefined };
+            return {
+                getError: () => `Command ${method} returned neither result nor an error, params: ${JSON.stringify(request, undefined, 2)}`,
+            };
         });
     }
 }

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

@@ -0,0 +1,30 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export var ExperimentName;
+(function (ExperimentName) {
+    ExperimentName["ALL"] = "*";
+    ExperimentName["CAPTURE_NODE_CREATION_STACKS"] = "capture-node-creation-stacks";
+    ExperimentName["LIVE_HEAP_PROFILE"] = "live-heap-profile";
+    ExperimentName["PROTOCOL_MONITOR"] = "protocol-monitor";
+    ExperimentName["SAMPLING_HEAP_PROFILER_TIMELINE"] = "sampling-heap-profiler-timeline";
+    ExperimentName["SHOW_OPTION_TO_EXPOSE_INTERNALS_IN_HEAP_SNAPSHOT"] = "show-option-to-expose-internals-in-heap-snapshot";
+    ExperimentName["TIMELINE_INVALIDATION_TRACKING"] = "timeline-invalidation-tracking";
+    ExperimentName["TIMELINE_SHOW_ALL_EVENTS"] = "timeline-show-all-events";
+    ExperimentName["TIMELINE_V8_RUNTIME_CALL_STATS"] = "timeline-v8-runtime-call-stats";
+    ExperimentName["APCA"] = "apca";
+    ExperimentName["FONT_EDITOR"] = "font-editor";
+    ExperimentName["FULL_ACCESSIBILITY_TREE"] = "full-accessibility-tree";
+    ExperimentName["CONTRAST_ISSUES"] = "contrast-issues";
+    ExperimentName["EXPERIMENTAL_COOKIE_FEATURES"] = "experimental-cookie-features";
+    ExperimentName["INSTRUMENTATION_BREAKPOINTS"] = "instrumentation-breakpoints";
+    ExperimentName["AUTHORED_DEPLOYED_GROUPING"] = "authored-deployed-grouping";
+    ExperimentName["JUST_MY_CODE"] = "just-my-code";
+    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";
+    // Adding or removing an entry from this enum?
+    // You will need to update:
+    // 1. DevToolsExperiments enum in host/UserMetrics.ts
+    // 2. Maybe REGISTERED_EXPERIMENTS in EnvironmentHelpers.ts (to create this experiment in the test env)
+})(ExperimentName || (ExperimentName = {}));

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

@@ -2,5 +2,6 @@
 // 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 ExperimentNames from './ExperimentNames.js';
 import * as Runtime from './Runtime.js';
-export { DevToolsContext, Runtime, };
+export { DevToolsContext, ExperimentNames, Runtime, };

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

@@ -362,10 +362,6 @@ export class AnimationModel extends SDKModel {
         this.playbackRate = playbackRate;
         void this.agent.invoke_setPlaybackRate({ playbackRate });
     }
-    async releaseAllAnimations() {
-        const animationIds = [...this.animationGroups.values()].flatMap(animationGroup => animationGroup.animations().map(animation => animation.id()));
-        await this.agent.invoke_releaseAnimations({ animations: animationIds });
-    }
     releaseAnimations(animations) {
         void this.agent.invoke_releaseAnimations({ animations });
     }

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

@@ -474,10 +474,10 @@ export class CSSMatchedStyles {
         // Now that we've built the arrays of NodeCascades for each pseudo type, convert them into
         // DOMInheritanceCascades.
         for (const [pseudoType, nodeCascade] of pseudoCascades.entries()) {
-            pseudoInheritanceCascades.set(pseudoType, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties));
+            pseudoInheritanceCascades.set(pseudoType, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties, this.#mainDOMCascade));
         }
         for (const [highlightName, nodeCascade] of customHighlightPseudoCascades.entries()) {
-            customHighlightPseudoInheritanceCascades.set(highlightName, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties));
+            customHighlightPseudoInheritanceCascades.set(highlightName, new DOMInheritanceCascade(this, nodeCascade, this.#registeredProperties, this.#mainDOMCascade));
         }
         return [pseudoInheritanceCascades, customHighlightPseudoInheritanceCascades];
     }
@@ -685,6 +685,10 @@ export class CSSMatchedStyles {
         const domCascade = this.#styleToDOMCascade.get(property.ownerStyle);
         return domCascade ? domCascade.propertyState(property) : null;
     }
+    isPropertyOverriddenByAnimation(property) {
+        const domCascade = this.#styleToDOMCascade.get(property.ownerStyle);
+        return domCascade?.isPropertyOverriddenByAnimation(property) ?? false;
+    }
     resetActiveProperties() {
         Platform.assertNotNullOrUndefined(this.#mainDOMCascade);
         Platform.assertNotNullOrUndefined(this.#pseudoDOMCascades);
@@ -730,22 +734,24 @@ export class CSSMatchedStyles {
     }
 }
 class NodeCascade {
+    isHighlightPseudoCascade;
     #matchedStyles;
     styles;
     #isInherited;
-    #isHighlightPseudoCascade;
     propertiesState = new Map();
+    propertiesOverriddenByAnimation = new Set();
     activeProperties = new Map();
     #node;
     constructor(matchedStyles, styles, node, isInherited, isHighlightPseudoCascade = false) {
+        this.isHighlightPseudoCascade = isHighlightPseudoCascade;
         this.#matchedStyles = matchedStyles;
         this.styles = styles;
         this.#isInherited = isInherited;
-        this.#isHighlightPseudoCascade = isHighlightPseudoCascade;
         this.#node = node;
     }
     computeActiveProperties() {
         this.propertiesState.clear();
+        this.propertiesOverriddenByAnimation.clear();
         this.activeProperties.clear();
         for (let i = this.styles.length - 1; i >= 0; i--) {
             const style = this.styles[i];
@@ -760,9 +766,17 @@ class NodeCascade {
             for (const property of style.allProperties()) {
                 // Do not pick non-inherited properties from inherited styles.
                 const metadata = cssMetadata();
-                // All properties are inherited for highlight pseudos.
-                if (this.#isInherited && !this.#isHighlightPseudoCascade && !metadata.isPropertyInherited(property.name)) {
-                    continue;
+                if (this.#isInherited) {
+                    if (this.isHighlightPseudoCascade) {
+                        // All properties are inherited for highlight pseudos, but custom
+                        // variables do not come from the inherited pseudo elements.
+                        if (property.name.startsWith('--')) {
+                            continue;
+                        }
+                    }
+                    else if (!metadata.isPropertyInherited(property.name)) {
+                        continue;
+                    }
                 }
                 // When a property does not have a range in an otherwise ranged CSSStyleDeclaration,
                 // we consider it as a non-leading property (see computeLeadingProperties()), and most
@@ -833,6 +847,10 @@ class NodeCascade {
         }
         if (activeProperty) {
             this.propertiesState.set(activeProperty, "Overloaded" /* PropertyState.OVERLOADED */);
+            if (propertyWithHigherSpecificity.ownerStyle.type === Type.Animation ||
+                propertyWithHigherSpecificity.ownerStyle.type === Type.Transition) {
+                this.propertiesOverriddenByAnimation.add(activeProperty);
+            }
         }
         this.propertiesState.set(propertyWithHigherSpecificity, "Active" /* PropertyState.ACTIVE */);
         this.activeProperties.set(canonicalName, propertyWithHigherSpecificity);
@@ -913,6 +931,7 @@ function* forEach(array, startAfter) {
 }
 class DOMInheritanceCascade {
     #propertiesState = new Map();
+    #propertiesOverriddenByAnimation = new Set();
     #availableCSSVariables = new Map();
     #computedCSSVariables = new Map();
     #styleToNodeCascade = new Map();
@@ -920,13 +939,24 @@ class DOMInheritanceCascade {
     #nodeCascades;
     #registeredProperties;
     #matchedStyles;
-    constructor(matchedStyles, nodeCascades, registeredProperties) {
+    #fallbackCascade = null;
+    #styles = [];
+    constructor(matchedStyles, nodeCascades, registeredProperties, fallbackCascade = null) {
         this.#nodeCascades = nodeCascades;
         this.#matchedStyles = matchedStyles;
         this.#registeredProperties = registeredProperties;
+        this.#fallbackCascade = fallbackCascade;
         for (const nodeCascade of nodeCascades) {
             for (const style of nodeCascade.styles) {
                 this.#styleToNodeCascade.set(style, nodeCascade);
+                this.#styles.push(style);
+            }
+        }
+        if (fallbackCascade) {
+            for (const [style, nodeCascade] of fallbackCascade.#styleToNodeCascade) {
+                if (!this.#styles.includes(style)) {
+                    this.#styleToNodeCascade.set(style, nodeCascade);
+                }
             }
         }
     }
@@ -981,6 +1011,9 @@ class DOMInheritanceCascade {
                 }
             }
         }
+        if (this.#fallbackCascade && (!nodeCascade.isHighlightPseudoCascade || property.name.startsWith('--'))) {
+            return this.#fallbackCascade.resolveProperty(property.name, property.ownerStyle);
+        }
         return null;
     }
     #findPropertyInParentCascadeIfInherited(property) {
@@ -1224,15 +1257,20 @@ class DOMInheritanceCascade {
         }
     }
     styles() {
-        return Array.from(this.#styleToNodeCascade.keys());
+        return this.#styles;
     }
     propertyState(property) {
         this.ensureInitialized();
         return this.#propertiesState.get(property) || null;
     }
+    isPropertyOverriddenByAnimation(property) {
+        this.ensureInitialized();
+        return this.#propertiesOverriddenByAnimation.has(property);
+    }
     reset() {
         this.#initialized = false;
         this.#propertiesState.clear();
+        this.#propertiesOverriddenByAnimation.clear();
         this.#availableCSSVariables.clear();
         this.#computedCSSVariables.clear();
     }
@@ -1247,11 +1285,20 @@ class DOMInheritanceCascade {
             for (const [property, state] of nodeCascade.propertiesState) {
                 if (state === "Overloaded" /* PropertyState.OVERLOADED */) {
                     this.#propertiesState.set(property, "Overloaded" /* PropertyState.OVERLOADED */);
+                    if (nodeCascade.propertiesOverriddenByAnimation.has(property)) {
+                        this.#propertiesOverriddenByAnimation.add(property);
+                    }
                     continue;
                 }
                 const canonicalName = cssMetadata().canonicalPropertyName(property.name);
                 if (activeProperties.has(canonicalName)) {
                     this.#propertiesState.set(property, "Overloaded" /* PropertyState.OVERLOADED */);
+                    const activeProperty = activeProperties.get(canonicalName);
+                    if (activeProperty &&
+                        (activeProperty.ownerStyle.type === Type.Animation ||
+                            activeProperty.ownerStyle.type === Type.Transition)) {
+                        this.#propertiesOverriddenByAnimation.add(property);
+                    }
                     continue;
                 }
                 activeProperties.set(canonicalName, property);
@@ -1289,6 +1336,19 @@ class DOMInheritanceCascade {
             const initialValue = rule.initialValue();
             accumulatedCSSVariables.set(rule.propertyName(), initialValue !== null ? { value: initialValue, declaration: new CSSValueSource(rule) } : null);
         }
+        if (this.#fallbackCascade) {
+            this.#fallbackCascade.ensureInitialized();
+            for (const [cascade, available] of this.#fallbackCascade.#availableCSSVariables) {
+                this.#availableCSSVariables.set(cascade, available);
+            }
+            for (const [cascade, computed] of this.#fallbackCascade.#computedCSSVariables) {
+                this.#computedCSSVariables.set(cascade, computed);
+            }
+            for (const [key, value] of this.#fallbackCascade.#availableCSSVariables.get(this.#fallbackCascade.#nodeCascades[0]) ??
+                []) {
+                accumulatedCSSVariables.set(key, value);
+            }
+        }
         for (let i = this.#nodeCascades.length - 1; i >= 0; --i) {
             const nodeCascade = this.#nodeCascades[i];
             const variableNames = [];

package/build/vendor/chrome-devtools-frontend/front_end/core/sdk/CSSMetadata.js

@@ -526,7 +526,7 @@ const extraPropertyValues = new Map([
     ['background-repeat', new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat', 'space', 'round'])],
     ['content', new Set(['normal', 'close-quote', 'no-close-quote', 'no-open-quote', 'open-quote'])],
     ['baseline-shift', new Set(['baseline'])],
-    ['max-height', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content'])],
+    ['max-height', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content', 'stretch'])],
     ['color', new Set(['black'])],
     ['background-color', new Set(['white'])],
     ['box-shadow', new Set(['inset'])],
@@ -600,7 +600,7 @@ const extraPropertyValues = new Map([
         ]),
     ],
     ['zoom', new Set(['normal'])],
-    ['max-width', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content'])],
+    ['max-width', new Set(['min-content', 'max-content', '-webkit-fill-available', 'fit-content', 'stretch'])],
     ['-webkit-font-smoothing', new Set(['antialiased', 'subpixel-antialiased'])],
     [
         'border',
@@ -991,7 +991,7 @@ const extraPropertyValues = new Map([
         ]),
     ],
     ['flex-flow', new Set(['nowrap', 'row', 'row-reverse', 'column', 'column-reverse', 'wrap', 'wrap-reverse'])],
-    ['height', new Set(['-webkit-fill-available'])],
+    ['height', new Set(['-webkit-fill-available', 'stretch'])],
     ['inline-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
     [
         'list-style',
@@ -1058,9 +1058,9 @@ const extraPropertyValues = new Map([
     ['max-block-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
     ['max-inline-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
     ['min-block-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
-    ['min-height', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
+    ['min-height', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content', 'stretch'])],
     ['min-inline-size', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
-    ['min-width', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content'])],
+    ['min-width', new Set(['-webkit-fill-available', 'min-content', 'max-content', 'fit-content', 'stretch'])],
     ['object-position', new Set(['top', 'bottom', 'left', 'right', 'center'])],
     ['shape-outside', new Set(['border-box', 'content-box', 'padding-box', 'margin-box'])],
     [
@@ -1222,7 +1222,7 @@ const extraPropertyValues = new Map([
     ['-webkit-text-stroke-width', new Set(['medium', 'thick', 'thin'])],
     ['-webkit-transform-origin-x', new Set(['left', 'right', 'center'])],
     ['-webkit-transform-origin-y', new Set(['top', 'bottom', 'center'])],
-    ['width', new Set(['-webkit-fill-available'])],
+    ['width', new Set(['-webkit-fill-available', 'stretch'])],
     ['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'])],

package/build/vendor/chrome-devtools-frontend/front_end/core/sdk/CSSModel.js

@@ -296,6 +296,12 @@ export class CSSModel extends SDKModel {
         }
         return await this.#styleLoader.computedStylePromise(nodeId);
     }
+    async getComputedStyleExtraFields(nodeId) {
+        if (!this.isEnabled()) {
+            await this.enable();
+        }
+        return await this.#styleLoader.extraFieldsPromise(nodeId);
+    }
     async getLayoutPropertiesFromComputedStyle(nodeId) {
         const styles = await this.getComputedStyle(nodeId);
         if (!styles) {
@@ -317,7 +323,7 @@ export class CSSModel extends SDKModel {
             isGrid,
             isSubgrid,
             isGridLanes,
-            isContainer,
+            containerType: isContainer ? containerType : undefined,
             hasScroll,
         };
     }
@@ -858,25 +864,34 @@ class ComputedStyleLoader {
     constructor(cssModel) {
         this.#cssModel = cssModel;
     }
-    computedStylePromise(nodeId) {
+    #getResponsePromise(nodeId) {
         let promise = this.#nodeIdToPromise.get(nodeId);
         if (promise) {
             return promise;
         }
-        promise = this.#cssModel.getAgent().invoke_getComputedStyleForNode({ nodeId }).then(({ computedStyle }) => {
-            this.#nodeIdToPromise.delete(nodeId);
-            if (!computedStyle?.length) {
-                return null;
-            }
-            const result = new Map();
-            for (const property of computedStyle) {
-                result.set(property.name, property.value);
-            }
-            return result;
-        });
+        promise =
+            this.#cssModel.getAgent().invoke_getComputedStyleForNode({ nodeId }).then(({ computedStyle, extraFields }) => {
+                this.#nodeIdToPromise.delete(nodeId);
+                if (!computedStyle?.length) {
+                    return { style: null, extraFields };
+                }
+                const result = new Map();
+                for (const property of computedStyle) {
+                    result.set(property.name, property.value);
+                }
+                return { style: result, extraFields };
+            });
         this.#nodeIdToPromise.set(nodeId, promise);
         return promise;
     }
+    async computedStylePromise(nodeId) {
+        const computedStyleWithExtraFields = await this.#getResponsePromise(nodeId);
+        return computedStyleWithExtraFields.style;
+    }
+    async extraFieldsPromise(nodeId) {
+        const computedStyleWithExtraFields = await this.#getResponsePromise(nodeId);
+        return computedStyleWithExtraFields.extraFields;
+    }
 }
 export class InlineStyleResult {
     inlineStyle;

package/build/vendor/chrome-devtools-frontend/front_end/core/sdk/CSSProperty.js

@@ -77,7 +77,7 @@ export class CSSProperty extends Common.ObjectWrapper.ObjectWrapper {
     #matchers(matchedStyles, computedStyles) {
         const matchers = matchedStyles.propertyMatchers(this.ownerStyle, computedStyles);
         matchers.push(new CSSWideKeywordMatcher(this, matchedStyles));
-        if (Root.Runtime.experiments.isEnabled('font-editor')) {
+        if (Root.Runtime.experiments.isEnabled(Root.ExperimentNames.ExperimentName.FONT_EDITOR)) {
             matchers.push(new FontMatcher());
         }
         return matchers;