chrome-devtools-frontend 1.0.1660788 → 1.0.1662289

package/extension-api/ExtensionAPI.d.ts

@@ -148,12 +148,69 @@ export namespace Chrome {
 
     export interface ExtensionSidebarPane extends ExtensionView {
       setHeight(height: string): void;
+
+      /**
+       * Sets an object to be displayed in the sidebar pane.
+       *
+       * If a `callback` is provided, it is invoked when the object has been set
+       * and the method returns `void`. If no `callback` is provided, the method
+       * returns a `Promise`.
+       *
+       * @param jsonObject The JSON object to display in the pane (as a string).
+       * @param rootTitle Optional title of the root node.
+       * @param callback Optional callback to be invoked when the object has been set.
+       * @returns A Promise that resolves when the object has been set if no callback is
+       * provided, otherwise void. Rejects with an error object on failure.
+       */
+      setObject(jsonObject: string, rootTitle?: string): Promise<void>;
       setObject(jsonObject: string, rootTitle?: string, callback?: () => unknown): void;
+
+      /**
+       * Evaluates an expression in the context of the inspected page and displays the
+       * result in the sidebar pane.
+       *
+       * If a `callback` is provided, it is invoked when the expression has been evaluated
+       * and the method returns `void`. If no `callback` is provided, the method
+       * returns a `Promise`.
+       *
+       * @param expression The expression to evaluate.
+       * @param rootTitle Optional title of the root node.
+       * @param evaluateOptions Options for evaluating the expression.
+       * @param callback Optional callback to be invoked when the expression has been evaluated.
+       * @returns A Promise that resolves when the expression has been evaluated if no callback is
+       * provided, otherwise void. Rejects with an error object on failure.
+       */
+      setExpression(expression: string, rootTitle?: string, evaluateOptions?: {
+        frameURL?: string,
+        useContentScriptContext?: boolean,
+        scriptExecutionContext?: string,
+      }): Promise<void>;
+      setExpression(expression: string, rootTitle?: string, evaluateOptions?: {
+        frameURL?: string,
+        useContentScriptContext?: boolean,
+        scriptExecutionContext?: string,
+      },
+                    callback?: () => unknown): void;
+
       setPage(path: string): void;
     }
 
     export interface PanelWithSidebar {
+      /**
+       * Creates a sidebar pane in the Elements or Sources panel.
+       *
+       * If a `callback` is provided, it is invoked with the sidebar pane
+       * and the method returns `void`. If no `callback` is provided, the method
+       * returns a `Promise`.
+       *
+       * @param title The title of the sidebar pane.
+       * @param callback Optional callback to be invoked when the sidebar pane has been created.
+       * @returns A Promise that resolves to the created ExtensionSidebarPane if no callback is
+       * provided, otherwise void. Rejects with an error object on failure.
+       */
+      createSidebarPane(title: string): Promise<ExtensionSidebarPane>;
       createSidebarPane(title: string, callback?: (result: ExtensionSidebarPane) => unknown): void;
+
       onSelectionChanged: EventSink<() => unknown>;
     }
 
@@ -163,7 +220,38 @@ export namespace Chrome {
       network: NetworkPanel;
       themeName: string;
 
+      /**
+       * Creates an extension panel.
+       *
+       * If a `callback` is provided, it is invoked with the panel
+       * and the method returns `void`. If no `callback` is provided, the method
+       * returns a `Promise`.
+       *
+       * @param title The title of the panel.
+       * @param iconPath The path to the icon for the panel.
+       * @param pagePath The path to the page for the panel.
+       * @param callback Optional callback to be invoked when the panel has been created.
+       * @returns A Promise that resolves to the created ExtensionPanel if no callback is
+       * provided, otherwise void. Rejects with an error object on failure.
+       */
+      create(title: string, iconPath: string, pagePath: string): Promise<ExtensionPanel>;
       create(title: string, iconPath: string, pagePath: string, callback?: (panel: ExtensionPanel) => unknown): void;
+
+      /**
+       * Opens a resource in the Sources panel.
+       *
+       * If a `callback` is provided, it is invoked when the resource has been opened
+       * and the method returns `void`. If no `callback` is provided, the method
+       * returns a `Promise`.
+       *
+       * @param url The URL of the resource.
+       * @param lineNumber The line number to highlight.
+       * @param columnNumber Optional column number to highlight.
+       * @param callback Optional callback to be invoked when the resource has been opened.
+       * @returns A Promise that resolves when the resource has been opened if no callback is
+       * provided, otherwise void. Rejects with an error object on failure.
+       */
+      openResource(url: string, lineNumber: number, columnNumber?: number): Promise<void>;
       openResource(url: string, lineNumber: number, columnNumber?: number, callback?: () => unknown): void;
 
       setOpenResourceHandler(

package/front_end/core/common/SettingRegistration.ts

@@ -273,11 +273,6 @@ export interface SettingRegistration {
    * of the setting to be changed only if the user set it.
    */
   userActionCondition?: string;
-  /**
-   * The name of the experiment a setting is associated with. Enabling and disabling the declared
-   * experiment will enable and disable the setting respectively.
-   */
-  experiment?: Root.ExperimentNames.ExperimentName;
   /**
    * A condition is a function that will make the setting available if it
    * returns true, and not available, otherwise. Make sure that objects you

package/front_end/core/host/InspectorFrontendHost.ts

@@ -112,6 +112,7 @@ export function isUnderTest(prefs?: Record<string, string>): boolean {
     return prefs['isUnderTest'] === 'true';
   }
   return Common.Settings.Settings.hasInstance() &&
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       Common.Settings.Settings.instance().createSetting('isUnderTest', false).get();
 }
 

package/front_end/core/host/InspectorFrontendHostStub.ts

@@ -168,11 +168,13 @@ export class InspectorFrontendHostStub implements InspectorFrontendHostAPI {
   }
 
   openSearchResultsInNewTab(_query: string): void {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     Common.Console.Console.instance().error(
         'Search is not enabled in hosted mode. Please inspect using chrome://inspect');
   }
 
   showItemInFolder(_fileSystemPath: Platform.DevToolsPath.RawPathString): void {
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     Common.Console.Console.instance().error(
         'Show item in folder is not enabled in hosted mode. Please inspect using chrome://inspect');
   }

package/front_end/core/platform/ArrayUtilities.ts

@@ -152,6 +152,16 @@ export function lowerBound<S, T, A extends S[]>(
   return r;
 }
 
+/**
+ * Inserts a value into a sorted array in O(n) time (O(log n) search using the provided comparator and O(n) insertion).
+ * Returns the index at which the value was inserted.
+ */
+export function insertWithComparator<T>(array: T[], value: T, comparator: (a: T, b: T) => number): number {
+  const index = lowerBound(array, value, comparator);
+  array.splice(index, 0, value);
+  return index;
+}
+
 /**
  * Returns the index of the element closest to the needle that is greater than
  * it. Assumes that the provided array is sorted.

package/front_end/core/platform/StringUtilities.ts

@@ -50,23 +50,39 @@ const escapedReplacements = new Map([
   ['</script', '\\x3C/script'],
 ]);
 
+export const escapeUnicode = (content: string): string => {
+  return content.replaceAll(/[\p{Format}\p{Surrogate}]/gu, match => {
+    return match.split('').map(char => '\\u' + toHexadecimal(char.charCodeAt(0), 4)).join('');
+  });
+};
+
 export const formatAsJSLiteral = (content: string): string => {
-  const patternsToEscape = /(\\|<(?:!--|\/?script))|(\p{Control})|(\p{Surrogate})/gu;
-  const patternsToEscapePlusSingleQuote = /(\\|'|<(?:!--|\/?script))|(\p{Control})|(\p{Surrogate})/gu;
+  const patternsToEscape = /(\\|<(?:!--|\/?script))|(\p{Control}|\p{Format})|(\p{Surrogate})/giu;
+  const patternsToEscapePlusSingleQuote = /(\\|'|<(?:!--|\/?script))|(\p{Control}|\p{Format})|(\p{Surrogate})/giu;
   const escapePattern = (match: string, pattern: string, controlChar: string, loneSurrogate: string): string => {
     if (controlChar) {
       if (escapedReplacements.has(controlChar)) {
         // @ts-expect-error https://github.com/microsoft/TypeScript/issues/13086
         return escapedReplacements.get(controlChar);
       }
-      const twoDigitHex = toHexadecimal(controlChar.charCodeAt(0), 2);
-      return '\\x' + twoDigitHex;
+      return controlChar.split('')
+          .map(char => {
+            const charCode = char.charCodeAt(0);
+            if (controlChar.length === 1 && charCode <= 0xFF) {
+              return '\\x' + toHexadecimal(charCode, 2);
+            }
+            return '\\u' + toHexadecimal(charCode, 4);
+          })
+          .join('');
     }
     if (loneSurrogate) {
       const fourDigitHex = toHexadecimal(loneSurrogate.charCodeAt(0), 4);
       return '\\u' + fourDigitHex;
     }
     if (pattern) {
+      if (pattern.startsWith('<')) {
+        return '\\x3C' + pattern.slice(1);
+      }
       return escapedReplacements.get(pattern) || '';
     }
     return match;

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -32,8 +32,10 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   } = {forceNew: null}): CPUThrottlingManager {
     const {forceNew} = opts;
     if (!Root.DevToolsContext.globalInstance().has(CPUThrottlingManager) || forceNew) {
+      /* eslint-disable @devtools/no-instance-of-migrated-singletons */
       const manager = new CPUThrottlingManager(opts.settings ?? Common.Settings.Settings.instance(),
                                                opts.targetManager ?? TargetManager.instance());
+      /* eslint-enable @devtools/no-instance-of-migrated-singletons */
       manager.initialize();
       Root.DevToolsContext.globalInstance().set(CPUThrottlingManager, manager);
     }

package/front_end/core/sdk/DOMDebuggerModel.ts

@@ -537,6 +537,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   readonly #eventListenerBreakpoints: DOMEventListenerBreakpoint[] = [];
   readonly #targetManager: TargetManager;
 
+  // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
   constructor(targetManager: TargetManager = TargetManager.instance()) {
     this.#targetManager = targetManager;
     this.#xhrBreakpointsSetting = this.#targetManager.settings.createLocalSetting('xhr-breakpoints', []);
@@ -673,6 +674,7 @@ export class DOMDebuggerManager implements SDKModelObserver<DOMDebuggerModel> {
   } = {forceNew: null}): DOMDebuggerManager {
     const {forceNew, targetManager} = opts;
     if (!Root.DevToolsContext.globalInstance().has(DOMDebuggerManager) || forceNew) {
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       const manager = new DOMDebuggerManager(targetManager ?? TargetManager.instance());
       manager.initialize();
       Root.DevToolsContext.globalInstance().set(

package/front_end/core/sdk/DOMModel.ts

@@ -2108,6 +2108,7 @@ export class DOMModel extends SDKModel<EventTypes> {
     if ('has' in context && typeof context.has === 'function' && context.has(DOMModelUndoStack)) {
       return context.get(DOMModelUndoStack);
     }
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     return DOMModelUndoStack.instance();
   }
 

package/front_end/core/sdk/DebuggerModel.ts

@@ -168,10 +168,10 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     this.agent = target.debuggerAgent();
     this.#runtimeModel = (target.model(RuntimeModel) as RuntimeModel);
 
-    this.#sourceMapManager = new SourceMapManager(
-        target,
-        (compiledURL, sourceMappingURL, payload, script) =>
-            new SourceMap(compiledURL, sourceMappingURL, payload, script));
+    this.#sourceMapManager =
+        new SourceMapManager(target,
+                             (compiledURL, sourceMappingURL, payload, script) => new SourceMap(
+                                 compiledURL, sourceMappingURL, payload, target.targetManager().getConsole(), script));
 
     const settings = this.target().targetManager().settings;
     settings.moduleSetting('pause-on-exception-enabled').addChangeListener(this.pauseOnExceptionStateChanged, this);

package/front_end/core/sdk/EventBreakpointsModel.ts

@@ -88,6 +88,7 @@ export class EventBreakpointsManager implements SDKModelObserver<EventBreakpoint
   readonly #eventListenerBreakpoints: EventListenerBreakpoint[] = [];
   readonly #targetManager: TargetManager;
 
+  // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
   constructor(targetManager: TargetManager = TargetManager.instance()) {
     this.#targetManager = targetManager;
     this.createInstrumentationBreakpoints(Category.AUCTION_WORKLET, [
@@ -152,6 +153,7 @@ export class EventBreakpointsManager implements SDKModelObserver<EventBreakpoint
     const {forceNew, targetManager} = opts;
     if (!Root.DevToolsContext.globalInstance().has(EventBreakpointsManager) || forceNew) {
       Root.DevToolsContext.globalInstance().set(EventBreakpointsManager,
+                                                // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
                                                 new EventBreakpointsManager(targetManager ?? TargetManager.instance()));
     }
 

package/front_end/core/sdk/FrameManager.ts

@@ -45,6 +45,7 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     forceNew: boolean,
   } = {forceNew: false}): FrameManager {
     if (!Root.DevToolsContext.globalInstance().has(FrameManager) || forceNew) {
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       Root.DevToolsContext.globalInstance().set(FrameManager, new FrameManager(TargetManager.instance()));
     }
     return Root.DevToolsContext.globalInstance().get(FrameManager);

package/front_end/core/sdk/IsolateManager.ts

@@ -20,6 +20,7 @@ export class IsolateManager extends Common.ObjectWrapper.ObjectWrapper<EventType
   #pollId = 0;
   readonly #targetManager: TargetManager;
 
+  // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
   constructor(targetManager: TargetManager = TargetManager.instance()) {
     super();
     this.#targetManager = targetManager;

package/front_end/core/sdk/NetworkManager.ts

@@ -2120,8 +2120,10 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   } = {forceNew: null}): MultitargetNetworkManager {
     const {forceNew, targetManager} = opts;
     if (!Root.DevToolsContext.globalInstance().has(MultitargetNetworkManager) || forceNew) {
+      /* eslint-disable @devtools/no-instance-of-migrated-singletons */
       Root.DevToolsContext.globalInstance().set(
           MultitargetNetworkManager, new MultitargetNetworkManager(targetManager ?? TargetManager.instance()));
+      /* eslint-enable @devtools/no-instance-of-migrated-singletons */
     }
 
     return Root.DevToolsContext.globalInstance().get(MultitargetNetworkManager);

package/front_end/core/sdk/NetworkRequest.ts

@@ -309,6 +309,7 @@ export class NetworkRequest extends Common.ObjectWrapper.ObjectWrapper<EventType
       loaderId: Protocol.Network.LoaderId|null,
       initiator: Protocol.Network.Initiator|null,
       hasUserGesture?: boolean,
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       console: Common.Console.Console = Common.Console.Console.instance(),
   ) {
     super();

package/front_end/core/sdk/PageResourceLoader.ts

@@ -135,11 +135,13 @@ export class PageResourceLoader extends Common.ObjectWrapper.ObjectWrapper<Event
     loadOverride: null,
   }): PageResourceLoader {
     if (forceNew) {
+      /* eslint-disable @devtools/no-instance-of-migrated-singletons */
       Root.DevToolsContext.globalInstance().set(
           PageResourceLoader,
           new PageResourceLoader(
               targetManager ?? TargetManager.instance(), settings ?? Common.Settings.Settings.instance(),
               userAgentProvider ?? MultitargetNetworkManager.instance(), loadOverride, maxConcurrentLoads));
+      /* eslint-enable @devtools/no-instance-of-migrated-singletons */
     }
 
     return Root.DevToolsContext.globalInstance().get(PageResourceLoader);

package/front_end/core/sdk/SourceMap.ts

@@ -138,25 +138,25 @@ export class SourceMap {
   readonly #debugId?: DebugId;
 
   #scopesFallbackPromise?: Promise<void>;
+  readonly #console: Common.Console.Console;
 
   /**
    * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
    * for format description.
    */
-  constructor(
-      compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString,
-      payload: SourceMapV3, script?: Script) {
+  constructor(compiledURL: Platform.DevToolsPath.UrlString, sourceMappingURL: Platform.DevToolsPath.UrlString,
+              payload: SourceMapV3, console: Common.Console.Console, script?: Script) {
     this.#json = payload;
     this.#script = script;
     this.#compiledURL = compiledURL;
     this.#sourceMappingURL = sourceMappingURL;
     this.#baseURL = (Common.ParsedURL.schemeIs(sourceMappingURL, 'data:')) ? compiledURL : sourceMappingURL;
     this.#debugId = 'debugId' in payload ? (payload.debugId as DebugId | undefined) : undefined;
+    this.#console = console;
 
     if ('sections' in this.#json) {
       if (this.#json.sections.find(section => 'url' in section)) {
-        Common.Console.Console.instance().warn(
-            `SourceMap "${sourceMappingURL}" contains unsupported "URL" field in one of its sections.`);
+        this.#console.warn(`SourceMap "${sourceMappingURL}" contains unsupported "URL" field in one of its sections.`);
       }
     }
     this.eachSection(this.parseSources.bind(this));

package/front_end/core/sdk/SourceMapManager.ts

@@ -28,8 +28,9 @@ export class SourceMapManager<T extends FrameAssociated> extends Common.ObjectWr
     super();
 
     this.#target = target;
-    this.#factory =
-        factory ?? ((compiledURL, sourceMappingURL, payload) => new SourceMap(compiledURL, sourceMappingURL, payload));
+    this.#factory = factory ??
+        ((compiledURL, sourceMappingURL, payload) =>
+             new SourceMap(compiledURL, sourceMappingURL, payload, this.#target.targetManager().getConsole()));
   }
 
   setEnabled(isEnabled: boolean): void {

package/front_end/core/sdk/TargetManager.ts

@@ -37,6 +37,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   // TODO(crbug.com/493763857): Remove fallback once all unit tests use TestUniverse.
   getConsole(): Common.Console.Console {
     if ('has' in this.context && typeof this.context.has === 'function' && !this.context.has(Common.Console.Console)) {
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       return Common.Console.Console.instance();
     }
     return this.context.get(Common.Console.Console);
@@ -45,6 +46,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   // TODO(crbug.com/493763857): Remove fallback once all unit tests use TestUniverse.
   getFrameManager(): FrameManager {
     if ('has' in this.context && typeof this.context.has === 'function' && !this.context.has(FrameManager)) {
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       return FrameManager.instance();
     }
     return this.context.get(FrameManager);
@@ -54,6 +56,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   getNetworkManager(): MultitargetNetworkManager {
     if ('has' in this.context && typeof this.context.has === 'function' &&
         !this.context.has(MultitargetNetworkManager)) {
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       return MultitargetNetworkManager.instance();
     }
     return this.context.get(MultitargetNetworkManager);
@@ -62,6 +65,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   // TODO(crbug.com/493763857): Remove fallback once all unit tests use TestUniverse.
   getPageResourceLoader(): PageResourceLoader {
     if ('has' in this.context && typeof this.context.has === 'function' && !this.context.has(PageResourceLoader)) {
+      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       return PageResourceLoader.instance();
     }
     return this.context.get(PageResourceLoader);

package/front_end/entrypoints/main/MainImpl.ts

@@ -445,7 +445,8 @@ export class MainImpl {
     IssuesManager.IssuesManager.IssuesManager.instance({
       forceNew: true,
       ensureFirst: true,
-      showThirdPartyIssuesSetting: IssuesManager.Issue.getShowThirdPartyIssuesSetting(),
+      showThirdPartyIssuesSetting:
+          IssuesManager.Issue.getShowThirdPartyIssuesSetting(Common.Settings.Settings.instance()),
       hideIssueSetting: IssuesManager.IssuesManager.getHideIssueByCodeSetting(),
     });
 

package/front_end/foundation/README.md

@@ -8,3 +8,89 @@ As such, allowed use of APIs is restricted to what is available in both runtimes
 A `DevToolsUniverse` is a concrete, encapsulated instance of "foundation" scoped
 to a single root CDP target. It is valid to create multiple `DevToolsUniverse`
 instances simultaneously.
+
+## Architecture Shortcomings & Code Health Projects
+
+The following is a prioritized list of architectural shortcomings and refactoring projects aimed at reducing coupling, eliminating global state, and improving the modularity of the DevTools foundation.
+
+### Priority 1: Move `models/text_utils` to `core/text_utils`
+*   **Problem**: 22 files in `front_end/core/sdk` depend directly on `front_end/models/text_utils` for basic text structures (layering violation).
+*   **Rationale**: `text_utils` contains fundamental, non-business-logic utilities (`TextRange`, `TextCursor`, `ContentData`, `ContentProvider`) that represent the base data structures of the editor, debugger, and network panels. It only depends on `core/common` and `core/platform`. Moving it to `core` is a natural fit and resolves the majority of `core` -> `models` layering violations.
+*   **Action**:
+    1. Move the directory `front_end/models/text_utils` to `front_end/core/text_utils`.
+    2. Update all imports across the codebase.
+
+### Priority 2: Break Circular Dependencies in Bindings (`ResourceMapping` <-> Bindings)
+*   **Problem**: Bidirectional dependencies between `ResourceMapping` and `DebuggerWorkspaceBinding`/`CSSWorkspaceBinding` prevent isolated testing.
+*   **Rationale**: Decoupling `ResourceMapping` from concrete bindings allows better testing and modularity.
+*   **Action**: Introduce abstract listener interfaces in `ResourceMapping` (Dependency Inversion). `DebuggerWorkspaceBinding` and `CSSWorkspaceBinding` should implement these interfaces and register themselves, allowing `ResourceMapping` to invoke them without depending on concrete classes.
+
+### Priority 3: Move `IgnoreListManager` from `workspace` to `bindings`
+*   **Problem**: `models/workspace` depends on `core/sdk` via `IgnoreListManager.ts`.
+*   **Rationale**: Ignore-listing is conceptually a debugger-binding concern, not a basic workspace/file-system concern.
+*   **Action**:
+    1. Remove the convenience helper `UISourceCode.isIgnoreListed()` (and related methods in `UILocation`) from `models/workspace`.
+    2. Update callers to query `IgnoreListManager` directly.
+    3. Move `IgnoreListManager.ts` to `models/bindings`.
+    4. This removes the value-level dependency of `workspace` on `sdk`.
+
+### Priority 4: Decouple `Workspace.Project` from `SDK.Target`
+*   **Problem**: `Workspace.Project` exposes `target()`, coupling the VFS to runtime targets.
+*   **Rationale**: A workspace should be able to exist without knowing about browser targets.
+*   **Action**:
+    1. Remove `target()` from the `Project` interface and `ProjectStore` in `front_end/models/workspace/WorkspaceImpl.ts`.
+    2. In the `bindings` module, maintain a private `WeakMap<Workspace.Project, SDK.Target.Target>` to associate projects with targets.
+    3. Update `NetworkProject.targetForUISourceCode(uiSourceCode)` to look up the target from this `WeakMap`.
+
+### Priority 5: Decouple `core/sdk` from `models/formatter` (AST Scope Fallback)
+*   **Problem**: `SDK/SourceMap.ts` depends on `models/formatter` for fallback scope calculation.
+*   **Rationale**: `SDK` should not depend on high-level formatting/parsing worker pools.
+*   **Action**:
+    1. Remove the fallback scope calculation logic from `SourceMap.ts` and expose a clean API (e.g., `setScopesInfo(...)`).
+    2. Move the AST fallback scope calculation logic to `front_end/models/bindings` (e.g., in `DebuggerWorkspaceBinding`), which coordinates script and source map loading.
+    3. Have the bindings layer calculate the fallback scopes and attach them to the `SourceMap` object.
+
+### Priority 6: Refactor Mapping Engines & Inner Helpers in Bindings
+*   **Problem**: Engines and helpers query global `DebuggerWorkspaceBinding.instance()` directly.
+*   **Rationale**: High coupling hinders testing and isolation.
+*   **Action**: Eliminate direct global singleton queries. Update helpers to access parent mapping engines or pass references via constructors.
+
+### Priority 7: Universe-scoped Embedder Host and HostConfig
+*   **Problem**: `InspectorFrontendHostInstance` and `Root.Runtime.hostConfig` are treated as global mutable singletons. Core classes (`Connections`, `IsolatedFileSystemManager`, `FileManager`) and UI components access them directly, leading to global state pollution and state leaks in tests.
+*   **Rationale**: The host interface and its configuration represent the boundary between DevTools and the Chromium browser. To support multiple isolated `DevToolsUniverse` instances, both the host interface and host configuration must be scoped to the universe context.
+*   **Action**:
+    1. Store the scoped `InspectorFrontendHostAPI` (wrapped in `ScopedInspectorFrontendHost`) in the `DevToolsUniverse` context.
+    2. Refactor core classes (`Connections`, `IsolatedFileSystemManager`, `FileManager`, `UserMetrics`) to receive the scoped host via constructor injection.
+    3. Introduce a scoped `HostConfigProvider` service in the `Universe` context to manage `HostConfig` fetching and caching.
+    4. Move polling and configuration update logic from `HostConfigTracker` in `AidaClient.ts` to `HostConfigProvider`.
+    5. Provide a compatibility Proxy for `Root.Runtime.hostConfig` to allow gradual migration of the 200+ call sites.
+    6. Remove the global side-effect initialization in `InspectorFrontendHost.ts`.
+
+### Priority 8: View-Level Dependency Injection (Universe-ification)
+*   **Problem**: UI panels query global `.instance()` for bindings, causing state leaks in tests.
+*   **Rationale**: DevTools is transitioning to a scoped "Universe" architecture where dependencies are injected. UI panels should receive their dependencies rather than querying globals.
+*   **Action**:
+    1. Expose bindings on `Universe` and inject them via the view loading pipeline.
+    2. Leverage the view loading pipeline (`-meta.ts` files) to pass these bindings to panel constructors upon initialization, avoiding global calls in UI panels.
+
+### Priority 9: Decouple `persistence` from `bindings`
+*   **Problem**: `models/persistence` depends on `models/bindings` to check if a target is Node.js.
+*   **Rationale**: `persistence` (which maps network files to local files) should ideally only depend on `workspace` and not on the complex debugger/bindings layer.
+*   **Action**: Introduce a capability/property on `Workspace.Project` (e.g., `isNodeProject`) to avoid direct target queries.
+
+### Priority 10: Move `SourceFrameIssuesManager` to `bindings`
+*   **Problem**: `models/issues_manager` depends on `workspace` and `bindings` only for placing issue badges.
+*   **Rationale**: Showing badges on source frames is a binding/presentation concern, similar to showing console messages. `issues_manager` itself should be a clean, independent leaf module.
+*   **Action**: Move `SourceFrameIssuesManager.ts` to `models/bindings/` and remove `workspace` and `bindings` dependencies from `issues_manager/BUILD.gn`.
+
+### Priority 11: Decouple UI via Interfaces / Revealers
+*   **Problem**: General UI components (like `Linkifier`) depend on heavy concrete bindings.
+*   **Rationale**: UI components should not be tightly coupled to complex mapping logic.
+*   **Action**: Use light interfaces or `Common.Revealer`.
+
+### Priority 12: Decouple Core Modules from `i18n` (UI Localization)
+*   **Problem**: Core infra/parser modules import `i18n` for localized strings.
+*   **Rationale**: Business logic and core infrastructure should not be tied to UI localization libraries.
+*   **Action**:
+    1. Refactor parsers to return structured error data and let UI handle localization.
+    2. Update registries to use string IDs/keys.