chrome-devtools-frontend 1.0.1697998 → 1.0.1698733

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.ts

@@ -5,11 +5,11 @@
 /* eslint-disable @devtools/prefer-private-class-members */
 
 import * as i18n from '../../core/i18n/i18n.js';
-import type * as PlatformApi from '../../core/platform/api/api.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as HeapSnapshotModel from '../../models/heap_snapshot/heap_snapshot.js';
 
 import {AllocationProfile} from './AllocationProfile.js';
+import * as ContextAnalyzer from './ContextAnalyzer.js';
 import type {HeapSnapshotWorkerDispatcher} from './HeapSnapshotWorkerDispatcher.js';
 
 export interface HeapSnapshotItem {
@@ -724,8 +724,8 @@ function formatProblemReport(snapshot: HeapSnapshot, report: HeapSnapshotProblem
       })
       .join('\n  ');
 }
-function reportProblemToPrimaryWorker(
-    problemReport: HeapSnapshotProblemReport, port: PlatformApi.HostRuntime.WorkerMessagePort): void {
+function reportProblemToPrimaryWorker(problemReport: HeapSnapshotProblemReport,
+                                      port: Platform.HostRuntime.WorkerMessagePort): void {
   port.postMessage({problemReport});
 }
 
@@ -738,6 +738,9 @@ export interface Profile {
   samples: number[];
   strings: string[];
   locations: number[];
+  scopes?: number[];
+  scope_context_vars?: number[];
+  scope_uses?: number[];
   trace_function_infos: Uint32Array;
   trace_tree: Object;
   /* eslint-enable @typescript-eslint/naming-convention */
@@ -790,7 +793,7 @@ interface ArgumentsToComputeDominatorsAndRetainedSizes extends SecondaryInitArgu
   // should be used when computing dominators.
   essentialEdges: Platform.TypedArrayUtilities.BitVector;
   // A message port for reporting problems to the primary worker.
-  port: PlatformApi.HostRuntime.WorkerMessagePort;
+  port: Platform.HostRuntime.WorkerMessagePort;
   // For each node ordinal, this array will contain the node's shallow size.
   nodeSelfSizesPromise: Promise<Uint32Array>;
 }
@@ -825,7 +828,7 @@ export class SecondaryInitManager {
   argsStep1: Promise<SecondaryInitArgumentsStep1>;
   argsStep2: Promise<SecondaryInitArgumentsStep2>;
   argsStep3: Promise<SecondaryInitArgumentsStep3>;
-  constructor(port: PlatformApi.HostRuntime.WorkerMessagePort) {
+  constructor(port: Platform.HostRuntime.WorkerMessagePort) {
     const {promise: argsStep1, resolve: resolveArgsStep1} = Promise.withResolvers<SecondaryInitArgumentsStep1>();
     this.argsStep1 = argsStep1;
     const {promise: argsStep2, resolve: resolveArgsStep2} = Promise.withResolvers<SecondaryInitArgumentsStep2>();
@@ -833,7 +836,7 @@ export class SecondaryInitManager {
     const {promise: argsStep3, resolve: resolveArgsStep3} = Promise.withResolvers<SecondaryInitArgumentsStep3>();
     this.argsStep3 = argsStep3;
     const listener = (e: unknown): void => {
-      const data = (e as PlatformApi.HostRuntime.WorkerMessageEvent).data;
+      const data = (e as Platform.HostRuntime.WorkerMessageEvent).data;
       switch (data.step) {
         case 1:
           resolveArgsStep1(data.args);
@@ -856,7 +859,7 @@ export class SecondaryInitManager {
     return (await this.argsStep3).nodeSelfSizes;
   }
 
-  private async initialize(port: PlatformApi.HostRuntime.WorkerMessagePort): Promise<void> {
+  private async initialize(port: Platform.HostRuntime.WorkerMessagePort): Promise<void> {
     try {
       const argsStep1 = await this.argsStep1;
       const retainers = HeapSnapshot.buildRetainers(argsStep1);
@@ -1024,7 +1027,7 @@ export abstract class HeapSnapshot {
     this.#edgeNamesThatAreNotWeakMaps = Platform.TypedArrayUtilities.createBitVector(this.strings.length);
   }
 
-  async initialize(secondWorker: PlatformApi.HostRuntime.WorkerMessagePort): Promise<void> {
+  async initialize(secondWorker: Platform.HostRuntime.WorkerMessagePort): Promise<void> {
     const meta = this.#metaNode;
 
     this.nodeTypeOffset = meta.node_fields.indexOf('type');
@@ -1170,11 +1173,19 @@ export abstract class HeapSnapshot {
     };
   }
 
-  private startInitStep1InSecondThread(secondWorker: PlatformApi.HostRuntime.WorkerMessagePort):
+  /**
+   * Computes for every context field whether it is still live, i.e. whether it
+   * can be reached by some closure, and reports the dead fields.
+   */
+  analyzeContexts(): HeapSnapshotModel.HeapSnapshotModel.ContextAnalysisResult {
+    return ContextAnalyzer.analyzeContexts(this);
+  }
+
+  private startInitStep1InSecondThread(secondWorker: Platform.HostRuntime.WorkerMessagePort):
       Promise<ResultsFromSecondWorker> {
     const resultsFromSecondWorker = new Promise<ResultsFromSecondWorker>((resolve, reject) => {
       const listener = (e: unknown): void => {
-        const data = (e as PlatformApi.HostRuntime.WorkerMessageEvent).data;
+        const data = (e as Platform.HostRuntime.WorkerMessageEvent).data;
         if (data?.problemReport) {
           const problemReport: HeapSnapshotProblemReport = data.problemReport;
           console.warn(formatProblemReport(this, problemReport));
@@ -1211,14 +1222,14 @@ export abstract class HeapSnapshot {
     return resultsFromSecondWorker;
   }
 
-  private startInitStep2InSecondThread(secondWorker: PlatformApi.HostRuntime.WorkerMessagePort): void {
+  private startInitStep2InSecondThread(secondWorker: Platform.HostRuntime.WorkerMessagePort): void {
     const rootNodeOrdinal = this.rootNodeIndexInternal / this.nodeFieldCount;
     const essentialEdges = this.initEssentialEdges();
     const args: SecondaryInitArgumentsStep2 = {rootNodeOrdinal, essentialEdgesBuffer: essentialEdges.buffer};
     secondWorker.postMessage({step: 2, args}, [essentialEdges.buffer]);
   }
 
-  private startInitStep3InSecondThread(secondWorker: PlatformApi.HostRuntime.WorkerMessagePort): void {
+  private startInitStep3InSecondThread(secondWorker: Platform.HostRuntime.WorkerMessagePort): void {
     const {nodes, nodeFieldCount, nodeSelfSizeOffset, nodeCount} = this;
     const nodeSelfSizes = new Uint32Array(nodeCount);
     for (let nodeOrdinal = 0; nodeOrdinal < nodeCount; ++nodeOrdinal) {
@@ -3837,6 +3848,9 @@ interface HeapSnapshotMetaInfo {
   trace_node_fields: string[];
   sample_fields: string[];
   type_strings: Record<string, string>;
+  scope_fields?: string[];
+  scope_context_var_fields?: string[];
+  scope_use_fields?: string[];
   /* eslint-enable @typescript-eslint/naming-convention */
 }
 

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotLoader.ts

@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as PlatformApi from '../../core/platform/api/api.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as TextUtils from '../../core/text_utils/text_utils.js';
 
@@ -49,7 +48,7 @@ export class HeapSnapshotLoader {
     }
   }
 
-  async buildSnapshot(secondWorker: PlatformApi.HostRuntime.WorkerMessagePort): Promise<JSHeapSnapshot> {
+  async buildSnapshot(secondWorker: Platform.HostRuntime.WorkerMessagePort): Promise<JSHeapSnapshot> {
     await this.parsingComplete;
 
     this.#snapshot = this.#snapshot || {};
@@ -252,6 +251,21 @@ export class HeapSnapshotLoader {
       this.#snapshot.locations = [];
     }
 
+    if (this.#snapshot.snapshot.meta.scope_fields) {
+      const scopes = await this.#parseArray('"scopes"', 'Loading scopes…');
+      this.#snapshot.scopes = scopes.asArrayOrFail();
+    }
+
+    if (this.#snapshot.snapshot.meta.scope_context_var_fields) {
+      const scopeContextVars = await this.#parseArray('"scope_context_vars"', 'Loading scope context vars…');
+      this.#snapshot.scope_context_vars = scopeContextVars.asArrayOrFail();
+    }
+
+    if (this.#snapshot.snapshot.meta.scope_use_fields) {
+      const scopeUses = await this.#parseArray('"scope_uses"', 'Loading scope uses…');
+      this.#snapshot.scope_uses = scopeUses.asArrayOrFail();
+    }
+
     this.#progress.updateStatus('Loading strings…');
     const stringsTokenIndex = await this.#findToken('"strings"');
     const bracketIndex = await this.#findToken('[', stringsTokenIndex);

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotWorkerDispatcher.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as PlatformApi from '../../core/platform/api/api.js';
+import type * as Platform from '../../core/platform/platform.js';
 import * as HeapSnapshotModel from '../../models/heap_snapshot/heap_snapshot.js';
 
 // We mirror what heap_snapshot_worker.ts does, but we can't use it here as we'd have a
@@ -24,8 +24,8 @@ export class HeapSnapshotWorkerDispatcher {
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   #objects: any[] = [];
-  readonly #postMessage: PlatformApi.HostRuntime.Worker['postMessage'];
-  constructor(postMessage: PlatformApi.HostRuntime.Worker['postMessage']) {
+  readonly #postMessage: Platform.HostRuntime.Worker['postMessage'];
+  constructor(postMessage: Platform.HostRuntime.Worker['postMessage']) {
     this.#postMessage = postMessage;
   }
 
@@ -36,7 +36,7 @@ export class HeapSnapshotWorkerDispatcher {
   async dispatchMessage({
     data,
     ports,
-  }: PlatformApi.HostRuntime.WorkerMessageEvent<HeapSnapshotModel.HeapSnapshotModel.WorkerCommand>): Promise<void> {
+  }: Platform.HostRuntime.WorkerMessageEvent<HeapSnapshotModel.HeapSnapshotModel.WorkerCommand>): Promise<void> {
     const response: DispatcherResponse = {
       callId: data.callId,
       result: null,

package/front_end/entrypoints/heap_snapshot_worker/heap_snapshot_worker.ts

@@ -3,12 +3,14 @@
 // found in the LICENSE file.
 
 import * as AllocationProfile from './AllocationProfile.js';
+import * as ContextAnalyzer from './ContextAnalyzer.js';
 import * as HeapSnapshot from './HeapSnapshot.js';
 import * as HeapSnapshotLoader from './HeapSnapshotLoader.js';
 import * as HeapSnapshotWorkerDispatcher from './HeapSnapshotWorkerDispatcher.js';
 
 export {
   AllocationProfile,
+  ContextAnalyzer,
   HeapSnapshot,
   HeapSnapshotLoader,
   HeapSnapshotWorkerDispatcher,

package/front_end/entrypoints/shell/shell.ts

@@ -23,7 +23,7 @@ import '../../ui/legacy/components/source_frame/source_frame-meta.js';
 import '../../panels/console_counters/console_counters-meta.js';
 import '../../panels/explain/explain-meta.js';
 import '../../panels/ai_assistance/ai_assistance-meta.js';
-import '../../ui/comments/comments-meta.js';
+import '../../panels/common/common-meta.js';
 import '../main/main.js';
 
 // We generate the descriptors in this file, which depend on the runtime.

package/front_end/models/ai_assistance/DOMHelpers.ts

@@ -0,0 +1,95 @@
+// 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.
+
+/**
+ * @file This file includes DOM helpers and page-evaluated serialization helpers
+ * used by AI assistance that require DOM types. They are isolated in a separate
+ * target so DOM types do not leak into the rest of models/ai_assistance.
+ */
+
+import * as Platform from '../../core/platform/platform.js';
+
+export interface GetErrorStackOutput {
+  message: string;
+  stack?: string;
+}
+
+/* istanbul ignore next */
+export function getErrorStackOnThePage(this: Error): GetErrorStackOutput {
+  // Using this.stack causes side effect checks to throw.
+  return {stack: '', message: this.message};
+}
+
+/* istanbul ignore next */
+export function stringifyObjectOnThePage(this: unknown): string {
+  const seenBefore = new Map();
+  return JSON.stringify(this, function replacer(this: unknown, key: string, value: unknown) {
+    if (typeof value === 'object' && value !== null) {
+      if (seenBefore.has(value)) {
+        return '(cycle)';
+      }
+
+      seenBefore.set(value, true);
+    }
+
+    if (value instanceof HTMLElement) {
+      const idAttribute = value.id ? ` id="${value.id}"` : '';
+      const classAttribute = value.classList.value ? ` class="${value.classList.value}"` : '';
+
+      return `<${value.nodeName.toLowerCase()}${idAttribute}${classAttribute}>${value.hasChildNodes() ? '...' : ''}</${
+          value.nodeName.toLowerCase()}>`;
+    }
+
+    if (this instanceof CSSStyleDeclaration) {
+      // Do not add number keys to the output.
+      if (!isNaN(Number(key))) {
+        return undefined;
+      }
+    }
+
+    return value;
+  });
+}
+
+export async function sanitizeStyleChanges(selector: string,
+                                           styles: Record<string, string>): Promise<Record<string, string>> {
+  const cssStyleValue: string[] = [];
+  const changedStyles: string[] = [];
+  const kebabStyles = Platform.StringUtilities.toKebabCaseKeys(styles);
+  for (const [style, value] of Object.entries(kebabStyles)) {
+    // Build up the CSS style
+    cssStyleValue.push(`${style}: ${value};`);
+    // Keep track of what style changed to query later.
+    changedStyles.push(style);
+  }
+
+  if (typeof CSSStyleSheet === 'undefined' || typeof CSSStyleRule === 'undefined') {
+    return kebabStyles;
+  }
+
+  const styleSheet = new CSSStyleSheet({disabled: true});
+  // Build up the CSS stylesheet value.
+  await styleSheet.replace(`${selector} { ${cssStyleValue.join(' ')} }`);
+
+  const sanitizedStyles: Record<string, string> = {};
+  for (const cssRule of styleSheet.cssRules) {
+    if (!(cssRule instanceof CSSStyleRule)) {
+      continue;
+    }
+    for (const style of changedStyles) {
+      const value = cssRule.style.getPropertyValue(style);
+      if (value) {
+        sanitizedStyles[style] = value;
+      }
+    }
+  }
+
+  return sanitizedStyles;
+}
+
+export function dispatchAiAssistanceDoneEvent(): void {
+  if (typeof window !== 'undefined') {
+    window.dispatchEvent(new CustomEvent('aiassistancedone'));
+  }
+}

package/front_end/models/ai_assistance/EvaluateAction.ts

@@ -5,6 +5,11 @@
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 
+import {
+  getErrorStackOnThePage,
+  type GetErrorStackOutput,
+  stringifyObjectOnThePage,
+} from './DOMHelpers.js';
 import {PAGE_EXPOSED_FUNCTIONS} from './injected.js';
 
 export function formatError(message: string): string {
@@ -12,48 +17,6 @@ export function formatError(message: string): string {
 }
 export class SideEffectError extends Error {}
 
-export interface GetErrorStackOutput {
-  message: string;
-  stack?: string;
-}
-
-/* istanbul ignore next */
-export function getErrorStackOnThePage(this: Error): GetErrorStackOutput {
-  // Using this.stack causes side effect checks to throw.
-  return {stack: '', message: this.message};
-}
-
-/* istanbul ignore next */
-export function stringifyObjectOnThePage(this: unknown): string {
-  const seenBefore = new Map();
-  return JSON.stringify(this, function replacer(this: unknown, key: string, value: unknown) {
-    if (typeof value === 'object' && value !== null) {
-      if (seenBefore.has(value)) {
-        return '(cycle)';
-      }
-
-      seenBefore.set(value, true);
-    }
-
-    if (value instanceof HTMLElement) {
-      const idAttribute = value.id ? ` id="${value.id}"` : '';
-      const classAttribute = value.classList.value ? ` class="${value.classList.value}"` : '';
-
-      return `<${value.nodeName.toLowerCase()}${idAttribute}${classAttribute}>${value.hasChildNodes() ? '...' : ''}</${
-          value.nodeName.toLowerCase()}>`;
-    }
-
-    if (this instanceof CSSStyleDeclaration) {
-      // Do not add number keys to the output.
-      if (!isNaN(Number(key))) {
-        return undefined;
-      }
-    }
-
-    return value;
-  });
-}
-
 export async function stringifyRemoteObject(
     object: SDK.RemoteObject.RemoteObject, functionDeclaration: string): Promise<string> {
   switch (object.type) {

package/front_end/models/ai_assistance/ExtensionScope.ts

@@ -3,12 +3,12 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
-import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 
 import {getOrCreateIsolatedWorld} from './agents/ExecuteJavascript.js';
 import type {ChangeManager} from './ChangeManager.js';
+import {sanitizeStyleChanges} from './DOMHelpers.js';
 import {
   AI_ASSISTANCE_CSS_CLASS_NAME,
   type FreestyleCallbackArgs,
@@ -330,36 +330,7 @@ export class ExtensionScope {
   }
 
   async sanitizedStyleChanges(selector: string, styles: Record<string, string>): Promise<Record<string, string>> {
-    const cssStyleValue: string[] = [];
-    const changedStyles: string[] = [];
-    const styleSheet = new CSSStyleSheet({disabled: true});
-    const kebabStyles = Platform.StringUtilities.toKebabCaseKeys(styles);
-    for (const [style, value] of Object.entries(kebabStyles)) {
-      // Build up the CSS style
-      cssStyleValue.push(`${style}: ${value};`);
-      // Keep track of what style changed to query later.
-      changedStyles.push(style);
-    }
-
-    // Build up the CSS stylesheet value.
-    await styleSheet.replace(`${selector} { ${cssStyleValue.join(' ')} }`);
-
-    const sanitizedStyles: Record<string, string> = {};
-    for (const cssRule of styleSheet.cssRules) {
-      if (!(cssRule instanceof CSSStyleRule)) {
-        continue;
-      }
-      for (const style of changedStyles) {
-        // We need to use the style rather then the stylesMap
-        // as the latter expands the styles to each separate part
-        // Example:
-        // padding: 10px 20px -> padding-top: 10px, padding-bottom: 10px, etc.
-        const value = cssRule.style.getPropertyValue(style);
-        if (value) {
-          sanitizedStyles[style] = value;
-        }
-      }
-    }
+    const sanitizedStyles = await sanitizeStyleChanges(selector, styles);
 
     if (Object.keys(sanitizedStyles).length === 0) {
       throw new Error(

package/front_end/models/ai_assistance/agents/AiAgent.ts

@@ -12,6 +12,7 @@ import type * as LHModel from '../../lighthouse/lighthouse.js';
 import type * as Trace from '../../trace/trace.js';
 import type * as Workspace from '../../workspace/workspace.js';
 import {debugLog, isStructuredLogEnabled} from '../debug.js';
+import {dispatchAiAssistanceDoneEvent} from '../DOMHelpers.js';
 import type {ContextHandlerResult, DataHandlerResult} from '../tools/Tool.js';
 
 type UrlString = Platform.DevToolsPath.UrlString;
@@ -956,7 +957,7 @@ export abstract class AiAgent<T> {
     }
 
     if (isStructuredLogEnabled()) {
-      window.dispatchEvent(new CustomEvent('aiassistancedone'));
+      dispatchAiAssistanceDoneEvent();
     }
     return;
   }

package/front_end/models/ai_assistance/agents/ContextSelectionAgent.ts

@@ -292,7 +292,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
         const files: Array<{file: string, id: number | undefined}> = [];
         const uiSourceCodes: Workspace.UISourceCode.UISourceCode[] = [];
         for (const file of ContextSelectionAgent.getUISourceCodes(this.#workspace)) {
-          const fileSecurityOrigin = FileContext.originForUISourceCode(file);
+          const fileSecurityOrigin = file.securityOrigin();
 
           if (origin && !fileSecurityOrigin.isSameOriginWith(origin)) {
             continue;
@@ -352,7 +352,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
           if (ContextSelectionAgent.uiSourceCodeId.get(file) !== params.id) {
             return false;
           }
-          const fileSecurityOrigin = FileContext.originForUISourceCode(file);
+          const fileSecurityOrigin = file.securityOrigin();
           return !origin || fileSecurityOrigin.isSameOriginWith(origin);
         });
 
@@ -609,8 +609,7 @@ export class ContextSelectionAgent extends AiAgent<never> {
       if (ContextSelectionAgent.uiSourceCodeId.get(file) !== id) {
         return false;
       }
-      return isOriginAllowedByLock({status: 'ESTABLISHED_ORIGIN', origin: establishedOrigin},
-                                   FileContext.originForUISourceCode(file));
+      return isOriginAllowedByLock({status: 'ESTABLISHED_ORIGIN', origin: establishedOrigin}, file.securityOrigin());
     });
   }
 }

package/front_end/models/ai_assistance/ai_assistance.ts

@@ -30,6 +30,7 @@ import * as PerformanceInsightFormatter from './data_formatters/PerformanceInsig
 import * as PerformanceTraceFormatter from './data_formatters/PerformanceTraceFormatter.js';
 import * as UnitFormatters from './data_formatters/UnitFormatters.js';
 import * as Debug from './debug.js';
+import * as DOMHelpers from './DOMHelpers.js';
 import * as EvaluateAction from './EvaluateAction.js';
 import * as ExtensionScope from './ExtensionScope.js';
 import * as Injected from './injected.js';
@@ -88,6 +89,7 @@ export {
   ConversationSummary,
   CookieUtils,
   Debug,
+  DOMHelpers,
   DOMNodeContext,
   DOMStorageUtils,
   EvaluateAction,

package/front_end/models/ai_assistance/contexts/DOMNodeContext.ts

@@ -124,8 +124,9 @@ ${await this.describe()}`;
 * Its selector is \`${element.simpleSelector()}\``;
     const childNodes = await element.getChildNodesPromise();
     if (childNodes) {
-      const textChildNodes = childNodes.filter(childNode => childNode.nodeType() === Node.TEXT_NODE);
-      const elementChildNodes = childNodes.filter(childNode => childNode.nodeType() === Node.ELEMENT_NODE);
+      const textChildNodes = childNodes.filter(childNode => childNode.nodeType() === SDK.DOMModel.NodeType.TEXT_NODE);
+      const elementChildNodes =
+          childNodes.filter(childNode => childNode.nodeType() === SDK.DOMModel.NodeType.ELEMENT_NODE);
       switch (elementChildNodes.length) {
         case 0:
           output += '\n* It doesn\'t have any child element nodes';
@@ -151,14 +152,14 @@ ${await this.describe()}`;
     }
 
     if (element.nextSibling) {
-      const elementOrNodeElementNodeText = element.nextSibling.nodeType() === Node.ELEMENT_NODE ?
+      const elementOrNodeElementNodeText = element.nextSibling.nodeType() === SDK.DOMModel.NodeType.ELEMENT_NODE ?
           `an element (uid=${element.nextSibling.backendNodeId()})` :
           'a non element';
       output += `\n* It has a next sibling and it is ${elementOrNodeElementNodeText} node`;
     }
 
     if (element.previousSibling) {
-      const elementOrNodeElementNodeText = element.previousSibling.nodeType() === Node.ELEMENT_NODE ?
+      const elementOrNodeElementNodeText = element.previousSibling.nodeType() === SDK.DOMModel.NodeType.ELEMENT_NODE ?
           `an element (uid=${element.previousSibling.backendNodeId()})` :
           'a non element';
       output += `\n* It has a previous sibling and it is ${elementOrNodeElementNodeText} node`;
@@ -172,14 +173,15 @@ ${await this.describe()}`;
     if (parentNode) {
       const parentChildrenNodes = await parentNode.getChildNodesPromise();
       output += `\n* Its parent's selector is \`${parentNode.simpleSelector()}\` (uid=${parentNode.backendNodeId()})`;
-      const elementOrNodeElementNodeText = parentNode.nodeType() === Node.ELEMENT_NODE ? 'an element' : 'a non element';
+      const elementOrNodeElementNodeText =
+          parentNode.nodeType() === SDK.DOMModel.NodeType.ELEMENT_NODE ? 'an element' : 'a non element';
       output += `\n* Its parent is ${elementOrNodeElementNodeText} node`;
       if (parentNode.isShadowRoot()) {
         output += '\n* Its parent is a shadow root.';
       }
       if (parentChildrenNodes) {
         const childElementNodes =
-            parentChildrenNodes.filter(siblingNode => siblingNode.nodeType() === Node.ELEMENT_NODE);
+            parentChildrenNodes.filter(siblingNode => siblingNode.nodeType() === SDK.DOMModel.NodeType.ELEMENT_NODE);
         switch (childElementNodes.length) {
           case 0:
             break;
@@ -193,7 +195,8 @@ ${await this.describe()}`;
             break;
         }
 
-        const siblingTextNodes = parentChildrenNodes.filter(siblingNode => siblingNode.nodeType() === Node.TEXT_NODE);
+        const siblingTextNodes =
+            parentChildrenNodes.filter(siblingNode => siblingNode.nodeType() === SDK.DOMModel.NodeType.TEXT_NODE);
         switch (siblingTextNodes.length) {
           case 0:
             break;

package/front_end/models/ai_assistance/contexts/FileContext.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as SDK from '../../../core/sdk/sdk.js';
+import type * as SDK from '../../../core/sdk/sdk.js';
 import type * as Bindings from '../../bindings/bindings.js';
 import type * as Workspace from '../../workspace/workspace.js';
 import {type ContextDetail, ConversationContext} from '../agents/AiAgent.js';
@@ -20,20 +20,12 @@ export class FileContext extends ConversationContext<Workspace.UISourceCode.UISo
     this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
   }
 
-  /**
-   * Resolves the security origin of a given UISourceCode.
-   * Prefers the project security origin, falling back to the origin of the file URL.
-   */
-  static originForUISourceCode(file: Workspace.UISourceCode.UISourceCode): SDK.SecurityOrigin.SecurityOrigin {
-    return file.project()?.securityOrigin?.() ?? SDK.SecurityOrigin.SecurityOrigin.create(file.url());
-  }
-
   /**
    * Returns the security origin of the project containing the file, falling
    * back to the origin derived from the file URL.
    */
   override getOrigin(): SDK.SecurityOrigin.SecurityOrigin {
-    return FileContext.originForUISourceCode(this.#file);
+    return this.#file.securityOrigin();
   }
 
   override getItem(): Workspace.UISourceCode.UISourceCode {

package/front_end/models/ai_assistance/tools/GetSourceContent.ts

@@ -65,12 +65,13 @@ export class GetSourceContentTool implements
       args: GetSourceContentArgs,
       context: BaseToolCapability&OriginLockCapability,
       ): Promise<DataHandlerResult<{content: string}>> {
-    const originResult = resolveOriginFromLock(context.getOriginLock());
+    const originLock = context.getOriginLock();
+    const originResult = resolveOriginFromLock(originLock);
     if ('error' in originResult) {
       return originResult;
     }
 
-    const file = ListSourcesTool.getSourceById(args.id, originResult.origin);
+    const file = ListSourcesTool.getSourceById(args.id, originLock);
 
     if (!file) {
       return {