feat(extension): support OOPIF refs with unified frame geometry

apps/extension/src/tools/vom/__tests__/frame-document.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+import type { CdpFrameGraph } from "@/browser-driver/frame-graph";
 import type { CapturedNode, CapturedViewModel } from "../capture";
 import { buildFrameDocuments, type FrameAxBatch, type FrameOwnedAxNode } from "../frame-document";
 
@@ -9,8 +10,7 @@ function domNode(frameId: string, backendNodeId: number): CapturedNode {
     frameId,
     tag: "div",
     attrs: {},
-    rect: null,
-    localRect: { x: 0, y: 0, w: 20, h: 20 },
+    rect: { x: 0, y: 0, w: 20, h: 20 },
     paintOrder: 0,
     position: "static",
     pointerEvents: "auto",
@@ -30,9 +30,16 @@ function captured(frameNodes: Map<string, CapturedNode[]>): CapturedViewModel {
 
 describe("buildFrameDocuments", () => {
   it("partitions mixed AX results by node ownership and cuts cross-frame parent edges", () => {
+    const graph: CdpFrameGraph = {
+      rootFrameId: "main",
+      frames: [
+        { frameId: "main", target: { tabId: 4 } },
+        { frameId: "child", parentFrameId: "main", target: { tabId: 4 } },
+      ],
+    };
     const batches: FrameAxBatch<FrameOwnedAxNode>[] = [
       {
-        frameId: "main",
+        frame: graph.frames[0],
         nodes: [
           { nodeId: "root", frameId: "main", backendDOMNodeId: 1, childIds: ["h"] },
           {
@@ -48,6 +55,7 @@ describe("buildFrameDocuments", () => {
     ];
 
     const documents = buildFrameDocuments(
+      graph,
       batches,
       captured(
         new Map([
@@ -64,14 +72,28 @@ describe("buildFrameDocuments", () => {
     expect(childNodes.find((node) => node.nodeId === "virtual")?.frameId).toBe("child");
   });
 
-  it("deduplicates overlapping AX results using the strongest ownership", () => {
+  it("deduplicates overlapping same-target AX results using the strongest ownership", () => {
+    const graph: CdpFrameGraph = {
+      rootFrameId: "main",
+      frames: [
+        { frameId: "main", target: { tabId: 4 } },
+        { frameId: "child", parentFrameId: "main", target: { tabId: 4 } },
+      ],
+    };
     const childNode = { nodeId: "shared", backendDOMNodeId: 100 };
     const batches: FrameAxBatch<FrameOwnedAxNode>[] = [
-      { frameId: "main", nodes: [{ ...childNode, frameId: "child" }] },
-      { frameId: "child", nodes: [childNode] },
+      {
+        frame: graph.frames[0],
+        nodes: [{ ...childNode, frameId: "child" }],
+      },
+      {
+        frame: graph.frames[1],
+        nodes: [childNode],
+      },
     ];
 
     const documents = buildFrameDocuments(
+      graph,
       batches,
       captured(
         new Map([
@@ -85,22 +107,64 @@ describe("buildFrameDocuments", () => {
     expect(documents.find((document) => document.frameId === "child")?.axNodes).toHaveLength(1);
   });
 
+  it("uses target-scoped backend ownership when OOPIF backend ids collide", () => {
+    const graph: CdpFrameGraph = {
+      rootFrameId: "main",
+      frames: [
+        { frameId: "main", target: { tabId: 4 } },
+        {
+          frameId: "left",
+          parentFrameId: "main",
+          target: { tabId: 4, sessionId: "left-session" },
+        },
+        {
+          frameId: "right",
+          parentFrameId: "main",
+          target: { tabId: 4, sessionId: "right-session" },
+        },
+      ],
+    };
+    const batches: FrameAxBatch<FrameOwnedAxNode>[] = graph.frames.slice(1).map((frame) => ({
+      frame,
+      nodes: [{ nodeId: `${frame.frameId}-node`, backendDOMNodeId: 7 }],
+    }));
+
+    const documents = buildFrameDocuments(
+      graph,
+      batches,
+      captured(
+        new Map([
+          ["main", []],
+          ["left", [domNode("left", 7)]],
+          ["right", [domNode("right", 7)]],
+        ]),
+      ),
+    );
+
+    expect(documents.find((document) => document.frameId === "left")?.axNodes[0]?.nodeId).toBe(
+      "left-node",
+    );
+    expect(documents.find((document) => document.frameId === "right")?.axNodes[0]?.nodeId).toBe(
+      "right-node",
+    );
+  });
+
   it("uses captured frame parent identity instead of guessing from backend ids", () => {
     const frameNodes = new Map([
       ["main", [domNode("main", 1)]],
       ["left", [domNode("left", 7)]],
-      ["right", [domNode("right", 8)]],
+      ["right", [domNode("right", 7)]],
       ["child", [domNode("child", 9)]],
     ]);
     const capture = captured(frameNodes);
     capture.frameOwnerBackendNodeIds = new Map([["child", 7]]);
     capture.frameParentIds = new Map([["child", "left"]]);
-    const batches = ["main", "left", "right", "child"].map((frameId) => ({
-      frameId,
+    const frames = ["main", "left", "right", "child"].map((frameId) => ({
+      frame: { frameId, target: { tabId: 4 } },
       nodes: [],
     }));
 
-    const documents = buildFrameDocuments(batches, capture);
+    const documents = buildFrameDocuments(null, frames, capture);
 
     expect(documents.find((document) => document.frameId === "child")).toMatchObject({
       parentFrameId: "left",