mirror of
https://github.com/Tencent/BrowserSkill.git
synced 2026-09-10 13:01:23 +08:00
Compare commits
3
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
fa0952ac1b | ||
|
|
f6e7a98508 | ||
|
|
972232bba9 |
No files matched your search
@@ -436,8 +436,6 @@ describe("file transfer tools", () => {
|
||||
if (method === "DOM.getContentQuads") {
|
||||
return { quads: [[10, 20, 210, 20, 210, 120, 10, 120]] };
|
||||
}
|
||||
if (method === "Runtime.evaluate")
|
||||
return { result: { value: { width: 400, height: 300 } } };
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return { cssLayoutViewport: { clientWidth: 400, clientHeight: 300 } };
|
||||
}
|
||||
|
||||
@@ -13,138 +13,7 @@ import {
|
||||
import { GeometryContext } from "../geometry/frame-context";
|
||||
import type { CdpRunner } from "../shared";
|
||||
|
||||
function scrollbarDriver(
|
||||
visible = { width: 185, height: 89 },
|
||||
frameSize: unknown = { width: 200, height: 100 },
|
||||
) {
|
||||
const send = vi.fn(async (target: { sessionId?: string }, method: string) => {
|
||||
if (method === "Runtime.evaluate") return { result: { value: frameSize } };
|
||||
if (method === "Page.getLayoutMetrics")
|
||||
return {
|
||||
cssLayoutViewport: {
|
||||
clientWidth: target.sessionId ? visible.width : 800,
|
||||
clientHeight: target.sessionId ? visible.height : 600,
|
||||
},
|
||||
};
|
||||
if (method === "DOM.getBoxModel")
|
||||
return {
|
||||
model: {
|
||||
content: target.sessionId
|
||||
? [0, 0, 200, 0, 200, 100, 0, 100]
|
||||
: [100, 100, 500, 100, 500, 300, 100, 300],
|
||||
},
|
||||
};
|
||||
if (method === "DOM.getContentQuads")
|
||||
return { quads: [[180, 80, 230, 80, 230, 120, 180, 120]] };
|
||||
throw new Error(`unexpected ${method}`);
|
||||
});
|
||||
const cdp: CdpRunner = {
|
||||
send: (tabId, method) => send({ tabId } as never, method) as never,
|
||||
sendToTarget: send as CdpRunner["sendToTarget"],
|
||||
getFrameGraph: async () => ({
|
||||
rootFrameId: "main",
|
||||
frames: [
|
||||
{ frameId: "main", target: { tabId: 4 } },
|
||||
{
|
||||
frameId: "child",
|
||||
parentFrameId: "main",
|
||||
ownerBackendNodeId: 10,
|
||||
target: { tabId: 4, sessionId: "child" },
|
||||
},
|
||||
{
|
||||
frameId: "same-child",
|
||||
parentFrameId: "child",
|
||||
ownerBackendNodeId: 20,
|
||||
target: { tabId: 4, sessionId: "child" },
|
||||
},
|
||||
],
|
||||
}),
|
||||
};
|
||||
return { cdp, send };
|
||||
}
|
||||
|
||||
describe("frame geometry projection", () => {
|
||||
it.each([
|
||||
{ width: 200, height: 100 },
|
||||
{ width: 185, height: 100 },
|
||||
{ width: 200, height: 89 },
|
||||
{ width: 185, height: 89 },
|
||||
])("preserves scale and clips scrollbar strips for visible viewport $width × $height", async (visible) => {
|
||||
const { cdp, send } = scrollbarDriver(visible);
|
||||
const geometry = await resolveNodeGeometry(cdp, 4, {
|
||||
target: { tabId: 4, sessionId: "child" },
|
||||
frameId: "child",
|
||||
backendNodeId: 101,
|
||||
});
|
||||
expect(geometry).toMatchObject({
|
||||
topBounds: {
|
||||
x: 460,
|
||||
y: 260,
|
||||
width: (visible.width - 180) * 2,
|
||||
height: (visible.height - 80) * 2,
|
||||
},
|
||||
actionPoint: { x: 460 + visible.width - 180, y: 260 + visible.height - 80 },
|
||||
targetActionPoint: { x: (180 + visible.width) / 2, y: (80 + visible.height) / 2 },
|
||||
});
|
||||
expect(send.mock.calls.filter(([, method]) => method === "Runtime.evaluate")).toHaveLength(1);
|
||||
expect(send.mock.calls.filter(([, method]) => method === "Page.getLayoutMetrics")).toHaveLength(
|
||||
2,
|
||||
);
|
||||
});
|
||||
|
||||
it("shares the full viewport read across same-target frames, and refreshes it next operation", async () => {
|
||||
const { cdp, send } = scrollbarDriver();
|
||||
const context = new GeometryContext(cdp, 4);
|
||||
await Promise.all([context.targetProjection("child"), context.targetProjection("same-child")]);
|
||||
expect(send.mock.calls.filter(([, method]) => method === "Runtime.evaluate")).toHaveLength(1);
|
||||
await new GeometryContext(cdp, 4).targetProjection("child");
|
||||
expect(send.mock.calls.filter(([, method]) => method === "Runtime.evaluate")).toHaveLength(2);
|
||||
});
|
||||
|
||||
it.each([
|
||||
null,
|
||||
{},
|
||||
{ width: 0, height: 100 },
|
||||
{ width: 200, height: NaN },
|
||||
])("rejects unavailable full viewport dimensions: %j", async (size) => {
|
||||
const { cdp } = scrollbarDriver(undefined, size);
|
||||
expect(await new GeometryContext(cdp, 4).targetProjection("child")).toBeNull();
|
||||
});
|
||||
|
||||
it("clips an inner OOPIF against an intermediate OOPIF's occupied scrollbar strips", async () => {
|
||||
const { cdp } = scrollbarDriver();
|
||||
const outer = cdp.sendToTarget!;
|
||||
cdp.sendToTarget = async (target, method, params) => {
|
||||
if (method === "DOM.getBoxModel")
|
||||
return { model: { content: [150, 60, 250, 60, 250, 120, 150, 120] } } as never;
|
||||
if (target.sessionId !== "inner") return outer(target, method, params);
|
||||
if (method === "Runtime.evaluate")
|
||||
return { result: { value: { width: 100, height: 60 } } } as never;
|
||||
if (method === "Page.getLayoutMetrics")
|
||||
return { cssLayoutViewport: { clientWidth: 90, clientHeight: 50 } } as never;
|
||||
if (method === "DOM.getContentQuads")
|
||||
return { quads: [[0, 0, 100, 0, 100, 60, 0, 60]] } as never;
|
||||
throw new Error(`unexpected ${method}`);
|
||||
};
|
||||
const graph = await cdp.getFrameGraph!(4);
|
||||
graph.frames[2] = {
|
||||
frameId: "inner",
|
||||
parentFrameId: "child",
|
||||
ownerBackendNodeId: 20,
|
||||
target: { tabId: 4, sessionId: "inner" },
|
||||
};
|
||||
cdp.getFrameGraph = async () => graph;
|
||||
expect(
|
||||
await resolveNodeGeometry(cdp, 4, {
|
||||
target: { tabId: 4, sessionId: "inner" },
|
||||
frameId: "inner",
|
||||
backendNodeId: 101,
|
||||
}),
|
||||
).toMatchObject({
|
||||
topBounds: { x: 400, y: 220, width: 70, height: 58 },
|
||||
});
|
||||
});
|
||||
|
||||
it("keeps region bounds separate from polygon area", () => {
|
||||
const region = [
|
||||
rectPolygon({ x: 0, y: 0, w: 10, h: 10 }),
|
||||
@@ -208,8 +77,6 @@ describe("frame geometry projection", () => {
|
||||
const cdp: CdpRunner = {
|
||||
send: send as CdpRunner["send"],
|
||||
sendToTarget: vi.fn(async (_target, method) => {
|
||||
if (method === "Runtime.evaluate")
|
||||
return { result: { value: { width: 200, height: 100 } } };
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return { cssLayoutViewport: { clientWidth: 200, clientHeight: 100 } };
|
||||
}
|
||||
@@ -268,8 +135,6 @@ describe("frame geometry projection", () => {
|
||||
throw new Error(`unexpected root command ${method}`);
|
||||
}) as CdpRunner["send"],
|
||||
sendToTarget: vi.fn(async (_target, method) => {
|
||||
if (method === "Runtime.evaluate")
|
||||
return { result: { value: { width: 200, height: 100 } } };
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return { cssLayoutViewport: { clientWidth: 200, clientHeight: 100 } };
|
||||
}
|
||||
@@ -331,8 +196,6 @@ describe("frame geometry projection", () => {
|
||||
}) as CdpRunner["send"],
|
||||
sendToTarget: vi.fn(async (_target, method) => {
|
||||
if (method === "DOM.scrollIntoViewIfNeeded") return {};
|
||||
if (method === "Runtime.evaluate")
|
||||
return { result: { value: { width: 200, height: 100 } } };
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return { cssLayoutViewport: { clientWidth: 200, clientHeight: 100 } };
|
||||
}
|
||||
|
||||
@@ -433,7 +433,6 @@ describe("handleRequestHelp", () => {
|
||||
if (method === "DOM.getContentQuads") {
|
||||
return { quads: [[10, 20, 110, 20, 110, 60, 10, 60]] };
|
||||
}
|
||||
if (method === "Runtime.evaluate") return { result: { value: { width: 200, height: 100 } } };
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return { cssLayoutViewport: { clientWidth: 200, clientHeight: 100 } };
|
||||
}
|
||||
|
||||
@@ -201,7 +201,6 @@ describe("handleClick", () => {
|
||||
if (method === "DOM.getContentQuads") {
|
||||
return { quads: [[10, 20, 110, 20, 110, 60, 10, 60]] };
|
||||
}
|
||||
if (method === "Runtime.evaluate") return { result: { value: { width: 200, height: 100 } } };
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return { cssLayoutViewport: { clientWidth: 200, clientHeight: 100 } };
|
||||
}
|
||||
@@ -221,7 +220,6 @@ describe("handleClick", () => {
|
||||
{ sessionId: "child-session", method: "DOM.scrollIntoViewIfNeeded" },
|
||||
{ sessionId: "child-session", method: "DOM.getContentQuads" },
|
||||
{ sessionId: "child-session", method: "Page.getLayoutMetrics" },
|
||||
{ sessionId: "child-session", method: "Runtime.evaluate" },
|
||||
]);
|
||||
expect(fake.sent.filter((call) => call.method === "Input.dispatchMouseEvent")).toHaveLength(3);
|
||||
});
|
||||
|
||||
@@ -3380,7 +3380,6 @@ describe("handleSnapshot", () => {
|
||||
throw new Error(`unexpected root CDP method ${method}`);
|
||||
});
|
||||
const sendToTarget = vi.fn(async (_target, method: string) => {
|
||||
if (method === "Runtime.evaluate") return { result: { value: { width: 400, height: 300 } } };
|
||||
if (method === "Page.getLayoutMetrics" && ownerGeometry !== "unavailable")
|
||||
return {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
// @vitest-environment node
|
||||
import { describe, expect, it } from "vitest";
|
||||
import type { CdpFrame, CdpFrameGraph, CdpTarget } from "@/browser-driver/frame-graph";
|
||||
import { resolveNodeGeometry } from "../frame-geometry";
|
||||
import type { CdpRunner } from "../shared";
|
||||
import { captureObservationFacts } from "../vom/capture-coordinator";
|
||||
|
||||
@@ -12,28 +11,12 @@ type Send = <T = Record<string, unknown>>(
|
||||
) => Promise<T>;
|
||||
type Tree = { frame: { id: string; parentId?: string; name?: string }; childFrames?: Tree[] };
|
||||
type Rect = { x: number; y: number; w: number; h: number };
|
||||
type Oracle = {
|
||||
probes: Record<string, Rect>;
|
||||
viewport: { width: number; height: number };
|
||||
owners: Record<string, { x: number; y: number; scale: number }>;
|
||||
};
|
||||
|
||||
function clip(rect: Rect, viewport: Oracle["viewport"]): Rect | null {
|
||||
const x = Math.max(0, rect.x),
|
||||
y = Math.max(0, rect.y);
|
||||
const right = Math.min(viewport.width, rect.x + rect.w);
|
||||
const bottom = Math.min(viewport.height, rect.y + rect.h);
|
||||
return right > x && bottom > y ? { x, y, w: right - x, h: bottom - y } : null;
|
||||
}
|
||||
type Oracle = { probe: Rect; owners: Record<string, { x: number; y: number; scale: number }> };
|
||||
|
||||
// The independent oracle uses DOM border boxes and this fixture's axis-aligned
|
||||
// iframe transforms. No production snapshot conversion/projection builds expectations.
|
||||
const oracleExpression = `(() => {
|
||||
const probes = {};
|
||||
for (const node of document.querySelectorAll('[data-geometry-probe]')) {
|
||||
const box = node.getBoundingClientRect();
|
||||
probes[node.id] = { x: box.x, y: box.y, w: box.width, h: box.height };
|
||||
}
|
||||
const box = document.querySelector('#probe').getBoundingClientRect();
|
||||
const owners = {};
|
||||
for (const frame of document.querySelectorAll('iframe')) {
|
||||
const rect = frame.getBoundingClientRect();
|
||||
@@ -45,31 +28,17 @@ const oracleExpression = `(() => {
|
||||
scale,
|
||||
};
|
||||
}
|
||||
return { probes, viewport: { width: document.documentElement.clientWidth, height: document.documentElement.clientHeight }, owners };
|
||||
return { probe: { x: box.x, y: box.y, w: box.width, h: box.height }, owners };
|
||||
})()`;
|
||||
|
||||
describe.skipIf(!process.env.BSK_GEOMETRY_CHROME)("real DOMSnapshot coordinate contract", () => {
|
||||
it.each(
|
||||
[
|
||||
{ deviceScale: 1, zoom: 1 },
|
||||
{ deviceScale: 0.8, zoom: 1 },
|
||||
{ deviceScale: 1, zoom: 1.25 },
|
||||
{ deviceScale: 2, zoom: 1 },
|
||||
{ deviceScale: 2, zoom: 0.8 },
|
||||
]
|
||||
.flatMap((configuration) => [
|
||||
{ ...configuration, fixture: "snapshot-coordinates", scrollbars: "none" },
|
||||
{ ...configuration, fixture: "oopif-scrollbars", scrollbars: "both" },
|
||||
])
|
||||
.concat(
|
||||
["vertical", "horizontal", "none"].map((scrollbars) => ({
|
||||
deviceScale: 1,
|
||||
zoom: 1,
|
||||
fixture: "oopif-scrollbars",
|
||||
scrollbars,
|
||||
})),
|
||||
),
|
||||
)("$fixture: device scale $deviceScale, zoom $zoom, scrollbars $scrollbars", async (configuration) => {
|
||||
it.each([
|
||||
{ deviceScale: 1, zoom: 1 },
|
||||
{ deviceScale: 0.8, zoom: 1 },
|
||||
{ deviceScale: 1, zoom: 1.25 },
|
||||
{ deviceScale: 2, zoom: 1 },
|
||||
{ deviceScale: 2, zoom: 0.8 },
|
||||
])("matches DOM geometry at device scale $deviceScale and zoom $zoom", async (configuration) => {
|
||||
const evalRoot = new URL("../../../../../evals/browser/", import.meta.url);
|
||||
const { createEvalServer } = await import(new URL("lib/server.mjs", evalRoot).href);
|
||||
const { withChrome } = await import(
|
||||
@@ -90,9 +59,7 @@ describe.skipIf(!process.env.BSK_GEOMETRY_CHROME)("real DOMSnapshot coordinate c
|
||||
);
|
||||
await send(
|
||||
"Page.navigate",
|
||||
{
|
||||
url: `${baseUrl}/${configuration.fixture}?run=coordinates&scrollbars=${configuration.scrollbars}`,
|
||||
},
|
||||
{ url: `${baseUrl}/snapshot-coordinates?run=coordinates` },
|
||||
rootSession,
|
||||
);
|
||||
await expect
|
||||
@@ -119,7 +86,7 @@ describe.skipIf(!process.env.BSK_GEOMETRY_CHROME)("real DOMSnapshot coordinate c
|
||||
});
|
||||
sessions.push(sessionId);
|
||||
}
|
||||
expect(sessions.length).toBe(configuration.fixture === "oopif-scrollbars" ? 3 : 2);
|
||||
expect(sessions.length).toBe(2); // The cross-site fixture must actually be an OOPIF.
|
||||
const frames: CdpFrame[] = [];
|
||||
const names = new Map<string, string>();
|
||||
const sessionFor = (target: CdpTarget) => target.sessionId ?? rootSession;
|
||||
@@ -140,7 +107,7 @@ describe.skipIf(!process.env.BSK_GEOMETRY_CHROME)("real DOMSnapshot coordinate c
|
||||
};
|
||||
visit(frameTree);
|
||||
}
|
||||
expect(frames).toHaveLength(configuration.fixture === "oopif-scrollbars" ? 3 : 5);
|
||||
expect(frames).toHaveLength(5);
|
||||
for (const frame of frames) {
|
||||
if (!frame.parentFrameId) continue;
|
||||
const parent = frames.find((item) => item.frameId === frame.parentFrameId)!;
|
||||
@@ -160,11 +127,6 @@ describe.skipIf(!process.env.BSK_GEOMETRY_CHROME)("real DOMSnapshot coordinate c
|
||||
},
|
||||
sendToTarget: (target, method, params) => {
|
||||
calls.push(`${target.sessionId ?? target.tabId}:${method}`);
|
||||
if (
|
||||
method === "Runtime.evaluate" &&
|
||||
(params as { expression?: string })?.expression?.includes("window.innerWidth")
|
||||
)
|
||||
calls.push(`${target.sessionId ?? target.tabId}:viewport-size`);
|
||||
return send(method, params, sessionFor(target));
|
||||
},
|
||||
getFrameGraph: async () => graph,
|
||||
@@ -217,130 +179,47 @@ describe.skipIf(!process.env.BSK_GEOMETRY_CHROME)("real DOMSnapshot coordinate c
|
||||
);
|
||||
oracles.set(frame.frameId, reply.result.value);
|
||||
}
|
||||
const childViewport = await send<{
|
||||
result: {
|
||||
value: { width: number; height: number; clientWidth: number; clientHeight: number };
|
||||
};
|
||||
}>(
|
||||
"Runtime.evaluate",
|
||||
{
|
||||
expression:
|
||||
"({ width: innerWidth, height: innerHeight, clientWidth: document.documentElement.clientWidth, clientHeight: document.documentElement.clientHeight })",
|
||||
returnByValue: true,
|
||||
},
|
||||
sessions[1],
|
||||
);
|
||||
for (const dimension of ["Width", "Height"] as const) {
|
||||
const occupied =
|
||||
childViewport.result.value[dimension === "Width" ? "width" : "height"] -
|
||||
childViewport.result.value[`client${dimension}`];
|
||||
if (
|
||||
configuration.scrollbars === "both" ||
|
||||
configuration.scrollbars === (dimension === "Width" ? "vertical" : "horizontal")
|
||||
)
|
||||
expect(occupied).toBeGreaterThan(0);
|
||||
else expect(occupied).toBe(0);
|
||||
}
|
||||
const facts = await captureObservationFacts(cdp, 1);
|
||||
expect(facts.issues).toEqual([]);
|
||||
for (const frame of frames) {
|
||||
const node = facts.documents
|
||||
.find((doc) => doc.frame.frameId === frame.frameId)
|
||||
?.domNodes.find((node) => node.attrs.id === "probe");
|
||||
expect(node, `missing probe in ${names.get(frame.frameId) || "root"}`).toBeDefined();
|
||||
const local = oracles.get(frame.frameId)!.probe;
|
||||
const top = { ...local };
|
||||
let current = frame;
|
||||
while (current.parentFrameId) {
|
||||
const owner = oracles.get(current.parentFrameId)!.owners[names.get(current.frameId)!];
|
||||
top.x = owner.x + top.x * owner.scale;
|
||||
top.y = owner.y + top.y * owner.scale;
|
||||
top.w *= owner.scale;
|
||||
top.h *= owner.scale;
|
||||
current = frames.find((item) => item.frameId === current.parentFrameId)!;
|
||||
}
|
||||
expect(
|
||||
node!.rect,
|
||||
JSON.stringify({
|
||||
frame: names.get(frame.frameId),
|
||||
local,
|
||||
top,
|
||||
viewport: facts.viewport,
|
||||
}),
|
||||
).not.toBeNull();
|
||||
for (const key of ["x", "y", "w", "h"] as const) {
|
||||
expect(
|
||||
Math.abs(node!.localRect![key] - local[key]),
|
||||
`${names.get(frame.frameId)} local ${key}`,
|
||||
).toBeLessThan(2);
|
||||
expect(
|
||||
Math.abs(node!.rect![key] - top[key]),
|
||||
`${names.get(frame.frameId)} top ${key}`,
|
||||
).toBeLessThan(2);
|
||||
}
|
||||
}
|
||||
expect(calls.filter((call) => call.endsWith(":Page.getLayoutMetrics"))).toHaveLength(
|
||||
sessions.length,
|
||||
);
|
||||
// Identity verification also uses Runtime.evaluate; count the full viewport reads separately.
|
||||
const viewportReadsBeforeLive = calls.filter((call) => call.endsWith(":viewport-size"));
|
||||
expect(new Set(viewportReadsBeforeLive).size).toBe(viewportReadsBeforeLive.length);
|
||||
expect(viewportReadsBeforeLive.length).toBeLessThanOrEqual(sessions.length - 1);
|
||||
for (const frame of frames) {
|
||||
for (const [id, local] of Object.entries(oracles.get(frame.frameId)!.probes)) {
|
||||
const node = facts.documents
|
||||
.find((doc) => doc.frame.frameId === frame.frameId)
|
||||
?.domNodes.find((node) => node.attrs.id === id);
|
||||
expect(node, `missing ${id} in ${names.get(frame.frameId) || "root"}`).toBeDefined();
|
||||
let top = clip(local, oracles.get(frame.frameId)!.viewport);
|
||||
let current = frame;
|
||||
while (top && current.parentFrameId) {
|
||||
const parentOracle = oracles.get(current.parentFrameId)!;
|
||||
const owner = parentOracle.owners[names.get(current.frameId)!];
|
||||
top = clip(
|
||||
{
|
||||
x: owner.x + top.x * owner.scale,
|
||||
y: owner.y + top.y * owner.scale,
|
||||
w: top.w * owner.scale,
|
||||
h: top.h * owner.scale,
|
||||
},
|
||||
parentOracle.viewport,
|
||||
);
|
||||
current = frames.find((item) => item.frameId === current.parentFrameId)!;
|
||||
}
|
||||
for (const key of ["x", "y", "w", "h"] as const)
|
||||
expect(
|
||||
Math.abs(node!.localRect![key] - local[key]),
|
||||
`${names.get(frame.frameId)} ${id} local ${key}`,
|
||||
).toBeLessThan(2);
|
||||
if (!top) {
|
||||
expect(node!.rect, `${id} must be clipped out`).toBeNull();
|
||||
if (configuration.fixture === "oopif-scrollbars")
|
||||
expect(
|
||||
await resolveNodeGeometry(cdp, 1, {
|
||||
target: frame.target,
|
||||
frameId: frame.frameId,
|
||||
backendNodeId: node!.backendNodeId,
|
||||
}),
|
||||
).toMatchObject({ code: "permission_denied" });
|
||||
continue;
|
||||
}
|
||||
expect(node!.rect).not.toBeNull();
|
||||
for (const key of ["x", "y", "w", "h"] as const)
|
||||
expect(
|
||||
Math.abs(node!.rect![key] - top[key]),
|
||||
`${names.get(frame.frameId)} ${id} top ${key}`,
|
||||
).toBeLessThan(2);
|
||||
if (configuration.fixture !== "oopif-scrollbars") continue;
|
||||
const live = await resolveNodeGeometry(cdp, 1, {
|
||||
target: frame.target,
|
||||
frameId: frame.frameId,
|
||||
backendNodeId: node!.backendNodeId,
|
||||
});
|
||||
if ("code" in live) throw new Error(live.message);
|
||||
for (const [key, liveKey] of [
|
||||
["x", "x"],
|
||||
["y", "y"],
|
||||
["w", "width"],
|
||||
["h", "height"],
|
||||
] as const)
|
||||
expect(
|
||||
Math.abs(live.topBounds[liveKey] - top[key]),
|
||||
`${id} live ${key}`,
|
||||
).toBeLessThan(2);
|
||||
const before = server.snapshot("coordinates").events.length;
|
||||
for (const type of ["mousePressed", "mouseReleased"])
|
||||
await send(
|
||||
"Input.dispatchMouseEvent",
|
||||
{ type, ...live.actionPoint, button: "left", clickCount: 1 },
|
||||
rootSession,
|
||||
);
|
||||
await expect
|
||||
.poll(
|
||||
() =>
|
||||
server
|
||||
.snapshot("coordinates")
|
||||
.events.slice(before)
|
||||
.some(
|
||||
(event: { type: string; path: string; data: { probe?: string } }) =>
|
||||
event.type === "geometry.clicked" &&
|
||||
event.data.probe === id &&
|
||||
event.path ===
|
||||
(frame.parentFrameId
|
||||
? names.get(frame.frameId) === "nested"
|
||||
? "/oopif-scrollbars/nested"
|
||||
: "/oopif-scrollbars/frame"
|
||||
: "/oopif-scrollbars"),
|
||||
),
|
||||
{ timeout: 3000 },
|
||||
)
|
||||
.toBe(true);
|
||||
}
|
||||
}
|
||||
const metrics = await send<{
|
||||
cssVisualViewport: { zoom: number };
|
||||
visualViewport: { clientWidth: number };
|
||||
|
||||
@@ -161,8 +161,7 @@ export async function resolveNodeGeometry(
|
||||
return geometryError(`could not resolve frame geometry for ${address.frameId}`);
|
||||
topVisibleRegions = projectRegionToViewport(localRegion, projection);
|
||||
if (address.target.sessionId) {
|
||||
const localViewport = await context.viewport(address.target);
|
||||
if (!localViewport) return geometryError("could not resolve target viewport geometry");
|
||||
const localViewport = projection.edges[0]?.sourceViewport ?? projection.topViewport;
|
||||
const localVisibleRegions = localRegion
|
||||
.map((polygon) =>
|
||||
clipPolygon(
|
||||
|
||||
@@ -9,10 +9,8 @@ import {
|
||||
type Polygon,
|
||||
type ProjectiveEdge,
|
||||
parseCdpQuad,
|
||||
projectPolygon,
|
||||
type Quad,
|
||||
type Size,
|
||||
viewportPolygon,
|
||||
} from "../geometry";
|
||||
import { type CdpRunner, sendToCdpTarget } from "../shared";
|
||||
import type { CoordinateOwner, CssViewport, SnapshotProjectionResult } from "./coordinate-types";
|
||||
@@ -20,8 +18,13 @@ import type { CoordinateOwner, CssViewport, SnapshotProjectionResult } from "./c
|
||||
import { readSnapshotOwnerSizes } from "./snapshot-owner-sizes";
|
||||
|
||||
export interface LayoutMetrics {
|
||||
cssVisualViewport?: { zoom?: number; clientWidth?: number; clientHeight?: number };
|
||||
visualViewport?: { zoom?: number; clientWidth?: number; clientHeight?: number };
|
||||
cssVisualViewport?: {
|
||||
zoom?: number;
|
||||
scale?: number;
|
||||
clientWidth?: number;
|
||||
clientHeight?: number;
|
||||
};
|
||||
visualViewport?: { zoom?: number; scale?: number; clientWidth?: number; clientHeight?: number };
|
||||
cssLayoutViewport?: {
|
||||
clientWidth?: number;
|
||||
clientHeight?: number;
|
||||
@@ -69,7 +72,6 @@ export function cssViewport(metrics: LayoutMetrics): CssViewport {
|
||||
/** One read-only measurement phase. Discard after scrolling or any later operation. */
|
||||
export class GeometryContext {
|
||||
private readonly metrics = new Map<string, Promise<LayoutMetrics>>();
|
||||
private readonly frameViewports = new Map<string, Promise<Size | null>>();
|
||||
private readonly owners = new Map<string, Promise<Quad | null>>();
|
||||
private readonly projections = new Map<string, Promise<GeometryProjection | null>>();
|
||||
private readonly snapshotOwners = new Map<string, Promise<{ quad: Quad; size: Size } | null>>();
|
||||
@@ -160,35 +162,6 @@ export class GeometryContext {
|
||||
: null;
|
||||
}
|
||||
|
||||
/** The full OOPIF viewport maps to its owner's content quad. Layout metrics
|
||||
* exclude occupied scrollbars and remain the clipping boundary, not the scale. */
|
||||
private frameViewport(target: CdpTarget): Promise<Size | null> {
|
||||
const key = cdpTargetKey(target);
|
||||
let promise = this.frameViewports.get(key);
|
||||
if (!promise) {
|
||||
promise = this.request<{ result?: { value?: Size }; exceptionDetails?: unknown }>(
|
||||
target,
|
||||
"Runtime.evaluate",
|
||||
{
|
||||
expression: "({ width: window.innerWidth, height: window.innerHeight })",
|
||||
returnByValue: true,
|
||||
},
|
||||
).then(({ result, exceptionDetails }) => {
|
||||
const size = result?.value;
|
||||
return !exceptionDetails &&
|
||||
size &&
|
||||
Number.isFinite(size.width) &&
|
||||
Number.isFinite(size.height) &&
|
||||
size.width > 0 &&
|
||||
size.height > 0
|
||||
? size
|
||||
: null;
|
||||
});
|
||||
this.frameViewports.set(key, promise);
|
||||
}
|
||||
return promise;
|
||||
}
|
||||
|
||||
ownerContent(target: CdpTarget, backendNodeId: number): Promise<Quad | null> {
|
||||
const key = `${cdpTargetKey(target)}:${backendNodeId}`;
|
||||
let promise = this.owners.get(key);
|
||||
@@ -374,19 +347,12 @@ export class GeometryContext {
|
||||
const parent = frames.get(root.parentFrameId);
|
||||
if (!parent || root.ownerBackendNodeId === undefined) return null;
|
||||
const destinationQuad = await this.ownerContent(parent.target, root.ownerBackendNodeId);
|
||||
if (!destinationQuad) return null;
|
||||
const source = await this.frameViewport(root.target);
|
||||
const visible = await this.viewport(root.target);
|
||||
const source = await this.viewport(root.target);
|
||||
const parentRoot = this.targetRoot(frames, parent);
|
||||
if (!source || !visible || !parentRoot) return null;
|
||||
if (!destinationQuad || !source || !parentRoot) return null;
|
||||
const destinationClips = await this.clips(frames, parent, parentRoot);
|
||||
if (!destinationClips) return null;
|
||||
const edge = { sourceViewport: source, destinationQuad, destinationClips };
|
||||
// Keep scrollbar strips clipped at every target boundary, including
|
||||
// intermediate OOPIFs. Project the clip with the same full-viewport scale.
|
||||
if (source.width !== visible.width || source.height !== visible.height)
|
||||
destinationClips.push(projectPolygon(viewportPolygon(visible), edge));
|
||||
edges.push(edge);
|
||||
edges.push({ sourceViewport: source, destinationQuad, destinationClips });
|
||||
root = parentRoot;
|
||||
}
|
||||
const topViewport = await this.viewport(root.target);
|
||||
|
||||
@@ -5,12 +5,15 @@ import { OVERLAY_HOST_MARKER_ATTR } from "@/lib/overlay-bridge";
|
||||
import { captureVomObservation } from "../../observation";
|
||||
import type { CdpRunner } from "../../shared";
|
||||
import { captureObservationFacts, semanticCapture } from "../capture-coordinator";
|
||||
import { buildSemanticGraph } from "../semantic-graph/build";
|
||||
import { REQUESTED_STYLES, type SnapshotReply } from "../snapshot";
|
||||
import { buildSemanticGraph, buildSemanticVomScene } from "../semantic-graph";
|
||||
import { REQUESTED_STYLES, type SnapshotReply, VISUAL_STYLES } from "../snapshot";
|
||||
import { deduplicateVisualCandidates } from "../visual-dedup";
|
||||
import { discoverVisualCandidates } from "../visual-discovery";
|
||||
|
||||
function fixture(
|
||||
options: {
|
||||
frames?: CdpFrame[];
|
||||
canvas?: boolean;
|
||||
after?: Record<string, { element?: number; missing?: boolean; unreadable?: boolean }>;
|
||||
fail?: string;
|
||||
missingIdentity?: boolean;
|
||||
@@ -78,23 +81,27 @@ function fixture(
|
||||
if (method === "Page.getLayoutMetrics")
|
||||
result = {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 1000, clientHeight: 800 },
|
||||
};
|
||||
if (method === "DOMSnapshot.captureSnapshot") {
|
||||
snapshots++;
|
||||
expect((params as { computedStyles: unknown }).computedStyles).toEqual(REQUESTED_STYLES);
|
||||
const requested = (params as { computedStyles: readonly string[] }).computedStyles;
|
||||
expect([REQUESTED_STYLES, VISUAL_STYLES]).toContainEqual(requested);
|
||||
result = {
|
||||
strings: [
|
||||
"#document",
|
||||
"html",
|
||||
"button",
|
||||
options.canvas ? "canvas" : "button",
|
||||
OVERLAY_HOST_MARKER_ATTR,
|
||||
"",
|
||||
"visible",
|
||||
"1",
|
||||
"static",
|
||||
"auto",
|
||||
"block",
|
||||
"none",
|
||||
"0px",
|
||||
],
|
||||
documents: frames
|
||||
.filter(
|
||||
@@ -144,10 +151,18 @@ function fixture(
|
||||
[0, 0, 1000, 800],
|
||||
[10, 20, 100, 40],
|
||||
],
|
||||
styles: [
|
||||
[7, 8, 8, 5, 6],
|
||||
[7, 8, 8, 5, 6],
|
||||
clientRects: [
|
||||
[0, 0, 1000, 800],
|
||||
[0, 0, 100, 40],
|
||||
],
|
||||
styles: Array.from({ length: 2 }, () =>
|
||||
requested.map(
|
||||
(name) =>
|
||||
[7, 8, 8, 5, 6, 9, 5, 5, 10, 6, 10, 10, 10, 10, 10, 8, 10, 11][
|
||||
VISUAL_STYLES.indexOf(name as (typeof VISUAL_STYLES)[number])
|
||||
],
|
||||
),
|
||||
),
|
||||
},
|
||||
};
|
||||
}),
|
||||
@@ -193,7 +208,7 @@ describe("captureObservationFacts", () => {
|
||||
if (method === "Page.getLayoutMetrics")
|
||||
return {
|
||||
visualViewport: { clientWidth: 2000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 1000, clientHeight: 800, pageX: 999, pageY: 999 },
|
||||
} as never;
|
||||
const reply = await original(target, method, params);
|
||||
@@ -655,11 +670,10 @@ function childSnapshot(frameId: string, backendNodeId: number) {
|
||||
describe("OOPIF capture", () => {
|
||||
it("captures and positions multiple OOPIF documents missing from the root snapshot", async () => {
|
||||
const sendToTarget = vi.fn(async (target, method) => {
|
||||
if (method === "Runtime.evaluate") return { result: { value: { width: 300, height: 200 } } };
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 300, clientHeight: 200, pageX: 0, pageY: 0 },
|
||||
};
|
||||
}
|
||||
@@ -685,7 +699,7 @@ describe("OOPIF capture", () => {
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 1000, clientHeight: 800 },
|
||||
};
|
||||
}
|
||||
@@ -767,7 +781,7 @@ describe("OOPIF capture", () => {
|
||||
if (method === "Page.getLayoutMetrics")
|
||||
return {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 300, clientHeight: 200 },
|
||||
};
|
||||
if (method === "DOMSnapshot.captureSnapshot")
|
||||
@@ -829,7 +843,7 @@ describe("OOPIF capture", () => {
|
||||
if (method === "Page.getLayoutMetrics") {
|
||||
return {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 1000, clientHeight: 800 },
|
||||
};
|
||||
}
|
||||
@@ -919,7 +933,7 @@ function siblingCaptureFixture(
|
||||
if (method === "Page.getLayoutMetrics")
|
||||
return {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 1000, clientHeight: 800 },
|
||||
};
|
||||
if (method === "DOM.getBoxModel")
|
||||
@@ -1127,7 +1141,7 @@ describe("snapshot document provenance", () => {
|
||||
: method === "Page.getLayoutMetrics"
|
||||
? {
|
||||
visualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000 },
|
||||
cssVisualViewport: { clientWidth: 1000, scale: 1 },
|
||||
cssLayoutViewport: { clientWidth: 200, clientHeight: 100 },
|
||||
}
|
||||
: {}) as T,
|
||||
@@ -1363,3 +1377,101 @@ describe("AX frame scheduling", () => {
|
||||
expect(active).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("visual facts integration", () => {
|
||||
it("defaults to base facts across targets and shares semantic behavior with visual capture", async () => {
|
||||
const base = fixture({ canvas: true });
|
||||
const visual = fixture({ canvas: true });
|
||||
const baseFacts = await captureObservationFacts(base.cdp, 4);
|
||||
const visualFacts = await captureObservationFacts(visual.cdp, 4, undefined, undefined, {
|
||||
includeVisualFacts: true,
|
||||
});
|
||||
expect(baseFacts.visualFactsCollected).toBe(false);
|
||||
expect(visualFacts.visualFactsCollected).toBe(true);
|
||||
expect(baseFacts.documents).toHaveLength(4);
|
||||
expect(visualFacts.documents).toHaveLength(4);
|
||||
for (const doc of baseFacts.documents) {
|
||||
expect(doc.geometry).toBeUndefined();
|
||||
expect(doc.index.ancestryComplete).toBeUndefined();
|
||||
for (const node of doc.index.nodes.values()) {
|
||||
expect(node.parentMissing).toBeUndefined();
|
||||
expect(node.layout?.clientRect).toBeUndefined();
|
||||
if (node.layout) expect(Object.keys(node.layout.styles)).toEqual([...REQUESTED_STYLES]);
|
||||
}
|
||||
}
|
||||
// This fixture has no child frame projection measurements. Enabling visual
|
||||
// collection must preserve that missing evidence, not invent geometry.
|
||||
expect(
|
||||
visualFacts.documents.find((doc) => doc.frame.frameId === "main")?.geometry,
|
||||
).toBeDefined();
|
||||
expect(visualFacts.documents.filter((doc) => doc.geometry)).toHaveLength(1);
|
||||
for (const doc of visualFacts.documents) {
|
||||
expect(doc.index.ancestryComplete).toBeDefined();
|
||||
for (const node of doc.index.nodes.values())
|
||||
if (node.layout) {
|
||||
expect(Object.keys(node.layout.styles)).toEqual([...VISUAL_STYLES]);
|
||||
expect(Object.keys(node.layout.styles).some((key) => key.includes("radius"))).toBe(false);
|
||||
}
|
||||
}
|
||||
for (const [capture, expected] of [
|
||||
[base, REQUESTED_STYLES],
|
||||
[visual, VISUAL_STYLES],
|
||||
] as const) {
|
||||
const calls = capture.logs.filter((c) => c.method === "DOMSnapshot.captureSnapshot");
|
||||
expect(calls).toHaveLength(2);
|
||||
for (const call of calls) expect(call.params.computedStyles).toEqual(expected);
|
||||
}
|
||||
expect(base.logs.map((c) => [c.target, c.method])).toEqual(
|
||||
visual.logs.map((c) => [c.target, c.method]),
|
||||
);
|
||||
const scene = (input: typeof baseFacts) =>
|
||||
buildSemanticVomScene({
|
||||
documents: semanticCapture(input).documents,
|
||||
viewport: input.viewport,
|
||||
rootFrameId: input.rootFrameId,
|
||||
excludedBackendNodeIds: semanticCapture(input).captured.excludedBackendNodeIds,
|
||||
});
|
||||
expect(scene(baseFacts)).toEqual(scene(visualFacts));
|
||||
const before = base.logs.length;
|
||||
expect(await discoverVisualCandidates(baseFacts)).toMatchObject({
|
||||
complete: false,
|
||||
candidates: [],
|
||||
issues: [{ reason: "visual-facts-not-collected" }],
|
||||
});
|
||||
expect(base.logs).toHaveLength(before);
|
||||
});
|
||||
|
||||
it("passes actual snapshot styles, client units, projection and identity to pure discovery without additional CDP", async () => {
|
||||
const { cdp, logs } = fixture({
|
||||
canvas: true,
|
||||
frames: [{ frameId: "main", target: { tabId: 4 } }],
|
||||
});
|
||||
const facts = await captureObservationFacts(cdp, 4, undefined, undefined, {
|
||||
includeVisualFacts: true,
|
||||
});
|
||||
const before = logs.length;
|
||||
const result = await discoverVisualCandidates(facts);
|
||||
expect(logs).toHaveLength(before);
|
||||
expect(logs.filter((call) => call.method === "DOMSnapshot.captureSnapshot")).toHaveLength(1);
|
||||
expect(result.complete).toBe(true);
|
||||
expect(result.candidates).toHaveLength(1);
|
||||
expect(result.candidates[0]).toMatchObject({
|
||||
document: { frameId: "main", documentElementBackendNodeId: 1 },
|
||||
region: { crop: { x: 10, y: 20, width: 100, height: 40 } },
|
||||
});
|
||||
const deduplicated = await deduplicateVisualCandidates(result);
|
||||
expect(deduplicated.candidates).toEqual(result.candidates);
|
||||
expect(deduplicated.candidates[0]).toBe(result.candidates[0]);
|
||||
expect(deduplicated).toMatchObject({
|
||||
candidateCount: 1,
|
||||
deduplicatedCount: 0,
|
||||
dedupDegraded: false,
|
||||
});
|
||||
expect(logs).toHaveLength(before);
|
||||
expect(facts.documents[0].index.nodes.get(2)?.layout?.clientRect).toEqual([0, 0, 100, 40]);
|
||||
expect(facts.documents[0].geometry?.pageScale).toBe(1);
|
||||
const baseline = fixture({ frames: [{ frameId: "main", target: { tabId: 4 } }] });
|
||||
await captureObservationFacts(baseline.cdp, 4);
|
||||
expect(logs.map((call) => call.method)).toEqual(baseline.logs.map((call) => call.method));
|
||||
});
|
||||
});
|
||||
@@ -2,7 +2,7 @@ import { describe, expect, it, vi } from "vitest";
|
||||
import { OVERLAY_HOST_MARKER_ATTR } from "@/lib/overlay-bridge";
|
||||
import { createCaptureCheckpoint } from "../capture-abort";
|
||||
import { buildDocumentIndex, type DecodedNode } from "../facts";
|
||||
import { decodeDocument, REQUESTED_STYLES } from "../snapshot";
|
||||
import { decodeDocument, REQUESTED_STYLES, VISUAL_SNAPSHOT } from "../snapshot";
|
||||
|
||||
function node(id: number, parent: number | null): DecodedNode {
|
||||
return {
|
||||
@@ -125,3 +125,44 @@ describe("document facts", () => {
|
||||
expect(reads).toBeLessThanOrEqual(356);
|
||||
});
|
||||
});
|
||||
|
||||
describe("visual ancestry facts", () => {
|
||||
it("distinguishes document roots, malformed roots, missing parents and cycles", async () => {
|
||||
const input = [
|
||||
{ ...node(0, null), nodeType: 9 },
|
||||
{ ...node(1, 0), nodeType: 1 },
|
||||
{ ...node(2, 1), nodeType: 11 },
|
||||
node(3, 2),
|
||||
node(4, 99),
|
||||
node(5, 6),
|
||||
node(6, 5),
|
||||
node(7, 5),
|
||||
{ ...node(8, null), nodeType: 1 },
|
||||
{ ...node(9, null), nodeType: 9, parentMissing: true },
|
||||
];
|
||||
const index = await buildDocumentIndex(input.reverse(), undefined, true);
|
||||
for (const id of [0, 1, 2, 3]) expect(index.ancestryComplete!.get(id)).toBe(true);
|
||||
for (const id of [4, 5, 6, 7, 8, 9]) expect(index.ancestryComplete!.get(id)).toBe(false);
|
||||
});
|
||||
|
||||
it("retains client offsets in their source units and does not disguise missing parent indices", async () => {
|
||||
const decoded = await decodeDocument(
|
||||
{
|
||||
nodes: { backendNodeId: [1, 2], nodeType: [1, 1], nodeName: [0, 0], parentIndex: [99] },
|
||||
layout: {
|
||||
nodeIndex: [0],
|
||||
bounds: [[745, 455.625, 97, 59.5]],
|
||||
clientRects: [[5, 5, 68, 38]],
|
||||
},
|
||||
},
|
||||
["div"],
|
||||
undefined,
|
||||
VISUAL_SNAPSHOT,
|
||||
);
|
||||
expect(decoded.nodes[0].layout?.clientRect).toEqual([5, 5, 68, 38]);
|
||||
expect(decoded.nodes[0].layout?.bounds).toEqual([745, 455.625, 97, 59.5]);
|
||||
expect(decoded.nodes.every((node) => node.parentMissing)).toBe(true);
|
||||
const index = await buildDocumentIndex(decoded.nodes, undefined, true);
|
||||
expect([...index.ancestryComplete!.values()]).toEqual([false, false]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,147 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { deduplicateVisualCandidates, MAX_VISUAL_DEDUP_KEYS } from "../visual-dedup";
|
||||
import type { VisualCandidate, VisualDiscoveryResult } from "../visual-discovery";
|
||||
|
||||
function candidate(id: number, width = 100, parent = 1): VisualCandidate {
|
||||
const crop = { x: 0, y: 0, width, height: 100 };
|
||||
return {
|
||||
document: {
|
||||
attachmentId: "a",
|
||||
target: { tabId: 1 },
|
||||
frameId: "main",
|
||||
documentElementBackendNodeId: 1,
|
||||
},
|
||||
backendNodeId: id,
|
||||
parentBackendNodeId: parent,
|
||||
region: { status: "available", borderBox: crop, crop },
|
||||
};
|
||||
}
|
||||
function discovery(candidates: VisualCandidate[]): VisualDiscoveryResult {
|
||||
return { candidates, complete: true, issues: [], captureIssues: [] };
|
||||
}
|
||||
|
||||
describe("visual candidate deduplication", () => {
|
||||
it("preserves small, unnamed and labelled candidates and their original evidence", async () => {
|
||||
const small = { ...candidate(3, 1), label: ' A "label"\n😀' };
|
||||
const large = candidate(2, 1000);
|
||||
const input = discovery([small, large]);
|
||||
Object.freeze(input.candidates);
|
||||
Object.freeze(small);
|
||||
Object.freeze(large);
|
||||
for (let i = 0; i < 2; i++) {
|
||||
const result = await deduplicateVisualCandidates(input);
|
||||
expect(result.candidates).toEqual([small, large]);
|
||||
expect(result.candidates[0]).toBe(small);
|
||||
expect(result.candidates[1]).toBe(large);
|
||||
expect(result).toMatchObject({
|
||||
candidateCount: 2,
|
||||
deduplicatedCount: 0,
|
||||
dedupDegraded: false,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it("only deduplicates exact crops within the same full DOM identity and direct parent", async () => {
|
||||
const base = candidate(20);
|
||||
const variants = [
|
||||
candidate(30, 100, 2),
|
||||
{ ...candidate(40), parentBackendNodeId: null },
|
||||
...["x", "y", "width", "height"].map((axis) => ({
|
||||
...base,
|
||||
region: {
|
||||
...base.region,
|
||||
crop: {
|
||||
...base.region.crop,
|
||||
[axis]: base.region.crop[axis as keyof typeof base.region.crop] + 0.001,
|
||||
},
|
||||
},
|
||||
})),
|
||||
...[
|
||||
{ frameId: "child" },
|
||||
{ target: { tabId: 2 } },
|
||||
{ target: { tabId: 1, sessionId: "remote" } },
|
||||
{ documentElementBackendNodeId: 9 },
|
||||
{ attachmentId: "b" },
|
||||
].map((identity) => ({ ...base, document: { ...base.document, ...identity } })),
|
||||
];
|
||||
const duplicate = { ...candidate(10), label: "Not a new target" };
|
||||
const result = await deduplicateVisualCandidates(discovery([base, ...variants, duplicate]));
|
||||
expect(result.candidates).toEqual([base, ...variants]);
|
||||
expect(result.candidates[0]).toBe(base);
|
||||
expect(result.deduplicatedCount).toBe(1);
|
||||
});
|
||||
|
||||
it.each([
|
||||
50_001, 100_000,
|
||||
])("keeps all %s distinct candidates including the last tiny Canvas", async (count) => {
|
||||
const input = Array.from({ length: count }, (_, i) => candidate(i + 1, 100, i + 1));
|
||||
input[count - 1] = candidate(count, 1, count);
|
||||
// A remembered key still deduplicates; an unremembered key passes through.
|
||||
input.push({ ...input[0] }, { ...input[count - 1] });
|
||||
const result = await deduplicateVisualCandidates(discovery(input));
|
||||
expect(result.candidates).toEqual([...input.slice(0, count), input[count + 1]]);
|
||||
expect(result.candidates[count - 1]).toBe(input[count - 1]);
|
||||
expect(result).toMatchObject({
|
||||
candidateCount: count + 2,
|
||||
deduplicatedCount: 1,
|
||||
dedupDegraded: true,
|
||||
});
|
||||
});
|
||||
|
||||
it("does not report degradation when every key fits", async () => {
|
||||
const input = Array.from({ length: MAX_VISUAL_DEDUP_KEYS }, (_, i) => candidate(i, 1, i));
|
||||
input.push({ ...input[0] });
|
||||
const result = await deduplicateVisualCandidates(discovery(input));
|
||||
expect(result.candidates).toHaveLength(MAX_VISUAL_DEDUP_KEYS);
|
||||
expect(result.dedupDegraded).toBe(false);
|
||||
expect(result.deduplicatedCount).toBe(1);
|
||||
});
|
||||
|
||||
it("preserves upstream unknowns without counting issues as Canvas nodes", async () => {
|
||||
const input: VisualDiscoveryResult = {
|
||||
...discovery([candidate(2)]),
|
||||
complete: false,
|
||||
issues: [{ reason: "geometry-unavailable", target: { tabId: 1 }, frameId: "missing" }],
|
||||
captureIssues: [{ stage: "ax", reason: "capture-unavailable", target: { tabId: 1 } }],
|
||||
};
|
||||
const result = await deduplicateVisualCandidates(input);
|
||||
expect(result.complete).toBe(false);
|
||||
expect(result.candidateCount).toBe(1);
|
||||
expect(result.issues).toBe(input.issues);
|
||||
expect(result.captureIssues).toBe(input.captureIssues);
|
||||
const absent = await deduplicateVisualCandidates({
|
||||
...input,
|
||||
candidates: [],
|
||||
issues: [{ reason: "visual-facts-not-collected" }],
|
||||
});
|
||||
expect(absent).toMatchObject({
|
||||
complete: false,
|
||||
candidateCount: 0,
|
||||
issues: [{ reason: "visual-facts-not-collected" }],
|
||||
});
|
||||
expect(await deduplicateVisualCandidates(discovery([]))).toMatchObject({
|
||||
complete: true,
|
||||
candidates: [],
|
||||
candidateCount: 0,
|
||||
dedupDegraded: false,
|
||||
});
|
||||
});
|
||||
|
||||
it("drains cancellation through the shared checkpoint", async () => {
|
||||
const controller = new AbortController();
|
||||
controller.abort();
|
||||
await expect(
|
||||
deduplicateVisualCandidates(discovery([]), controller.signal),
|
||||
).rejects.toMatchObject({ name: "AbortError" });
|
||||
const during = new AbortController();
|
||||
const input = discovery(Array.from({ length: 100_000 }, (_, i) => candidate(i, 100, i)));
|
||||
const timer = setTimeout(() => during.abort(), 0);
|
||||
try {
|
||||
await expect(deduplicateVisualCandidates(input, during.signal)).rejects.toMatchObject({
|
||||
name: "AbortError",
|
||||
});
|
||||
} finally {
|
||||
clearTimeout(timer);
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,502 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import type { CdpFrame } from "@/browser-driver/frame-graph";
|
||||
import { OVERLAY_HOST_MARKER_ATTR } from "@/lib/overlay-bridge";
|
||||
import type { GeometryProjection } from "../../geometry";
|
||||
import { buildDocumentIndex, type DocumentFacts, type ObservationFacts } from "../facts";
|
||||
import type { FrameOwnedAxNode } from "../frame-document";
|
||||
import { normalizeDocument } from "../normalize";
|
||||
import { VISUAL_SNAPSHOT, VISUAL_STYLES } from "../snapshot";
|
||||
import { discoverVisualCandidates } from "../visual-discovery";
|
||||
|
||||
const defaults: Record<string, string> = {
|
||||
position: "static",
|
||||
"pointer-events": "auto",
|
||||
cursor: "auto",
|
||||
visibility: "visible",
|
||||
opacity: "1",
|
||||
display: "block",
|
||||
"overflow-x": "visible",
|
||||
"overflow-y": "visible",
|
||||
transform: "none",
|
||||
zoom: "1",
|
||||
"clip-path": "none",
|
||||
"mask-image": "none",
|
||||
rotate: "none",
|
||||
scale: "none",
|
||||
perspective: "none",
|
||||
clip: "auto",
|
||||
contain: "none",
|
||||
"overflow-clip-margin": "0px",
|
||||
};
|
||||
const projection: GeometryProjection = {
|
||||
sourceClips: [],
|
||||
edges: [],
|
||||
topViewport: { width: 1000, height: 800 },
|
||||
};
|
||||
interface Spec {
|
||||
id: number;
|
||||
parent?: number;
|
||||
tag?: string;
|
||||
styles?: Record<string, string>;
|
||||
bounds?: number[] | null;
|
||||
client?: number[];
|
||||
attrs?: Record<string, string>;
|
||||
}
|
||||
async function document(
|
||||
nodes: Spec[],
|
||||
options: {
|
||||
frame?: CdpFrame;
|
||||
projection?: GeometryProjection;
|
||||
pageScale?: number;
|
||||
scrollY?: number;
|
||||
layoutScale?: number;
|
||||
} = {},
|
||||
): Promise<DocumentFacts<FrameOwnedAxNode>> {
|
||||
const frame = options.frame ?? { frameId: "main", target: { tabId: 1 } };
|
||||
const strings: string[] = [];
|
||||
const str = (value: string) => {
|
||||
const index = strings.indexOf(value);
|
||||
if (index >= 0) return index;
|
||||
strings.push(value);
|
||||
return strings.length - 1;
|
||||
};
|
||||
const input: Spec[] = [
|
||||
{ id: 0, tag: "#document", bounds: null },
|
||||
{ id: 1, parent: 0, tag: "html", bounds: [0, 0, 1000, 800] },
|
||||
...nodes,
|
||||
];
|
||||
const layouts = input.filter((node) => node.bounds !== null);
|
||||
const normalized = await normalizeDocument(
|
||||
{
|
||||
nodes: {
|
||||
backendNodeId: input.map((n) => n.id),
|
||||
nodeType: input.map((n) =>
|
||||
n.tag === "#document" ? 9 : n.tag === "#document-fragment" ? 11 : 1,
|
||||
),
|
||||
parentIndex: input.map((n) =>
|
||||
n.parent === undefined ? -1 : input.findIndex((p) => p.id === n.parent),
|
||||
),
|
||||
nodeName: input.map((n) => str(n.tag ?? "canvas")),
|
||||
attributes: input.map((n) =>
|
||||
Object.entries(n.attrs ?? {}).flatMap(([k, v]) => [str(k), str(v)]),
|
||||
),
|
||||
},
|
||||
layout: {
|
||||
nodeIndex: layouts.map((n) => input.indexOf(n)),
|
||||
bounds: layouts.map((n) => n.bounds ?? [10, 20, 120, 40]),
|
||||
clientRects: layouts.map((n) => n.client ?? [0, 0, 1000, 800]),
|
||||
styles: layouts.map((n) =>
|
||||
VISUAL_STYLES.map((key) => str({ ...defaults, ...n.styles }[key])),
|
||||
),
|
||||
},
|
||||
},
|
||||
strings,
|
||||
{
|
||||
frameId: frame.frameId,
|
||||
ownerFrameBackendNodeId: frame.ownerBackendNodeId ?? null,
|
||||
target: frame.target,
|
||||
projection: {
|
||||
status: "available",
|
||||
projection: {
|
||||
source: { target: frame.target, frameId: frame.frameId },
|
||||
geometry: options.projection ?? projection,
|
||||
},
|
||||
},
|
||||
coordinates: {
|
||||
layoutUnitsPerCssPixel: options.layoutScale ?? 1,
|
||||
scrollCss: { x: 0, y: options.scrollY ?? 0 },
|
||||
},
|
||||
pageScale: options.pageScale ?? 1,
|
||||
},
|
||||
undefined,
|
||||
VISUAL_SNAPSHOT,
|
||||
);
|
||||
return {
|
||||
frame,
|
||||
identity: {
|
||||
attachmentId: "attached",
|
||||
target: frame.target,
|
||||
frameId: frame.frameId,
|
||||
documentElementBackendNodeId: 1,
|
||||
},
|
||||
index: normalized.index,
|
||||
geometry: normalized.geometry,
|
||||
domNodes: normalized.nodes,
|
||||
axNodes: [],
|
||||
};
|
||||
}
|
||||
function facts(
|
||||
documents: DocumentFacts<FrameOwnedAxNode>[],
|
||||
issues: ObservationFacts<FrameOwnedAxNode>["issues"] = [],
|
||||
): ObservationFacts<FrameOwnedAxNode> {
|
||||
return {
|
||||
visualFactsCollected: true,
|
||||
rootFrameId: "main",
|
||||
documents,
|
||||
viewport: { width: 1000, height: 800 },
|
||||
issues,
|
||||
startedAt: 1,
|
||||
finishedAt: 2,
|
||||
};
|
||||
}
|
||||
|
||||
describe("Canvas discovery", () => {
|
||||
it("distinguishes visual facts not collected from complete empty discovery and honors cancellation", async () => {
|
||||
const empty = facts([]);
|
||||
expect(await discoverVisualCandidates(empty)).toMatchObject({
|
||||
complete: true,
|
||||
candidates: [],
|
||||
issues: [],
|
||||
});
|
||||
expect(await discoverVisualCandidates({ ...empty, visualFactsCollected: false })).toMatchObject(
|
||||
{ complete: false, candidates: [], issues: [{ reason: "visual-facts-not-collected" }] },
|
||||
);
|
||||
const controller = new AbortController();
|
||||
controller.abort();
|
||||
await expect(
|
||||
discoverVisualCandidates({ ...empty, visualFactsCollected: false }, controller.signal),
|
||||
).rejects.toMatchObject({ name: "AbortError" });
|
||||
});
|
||||
|
||||
it("discovers Canvas and frame contents without corner radius facts", async () => {
|
||||
const own = await document([{ id: 2, parent: 1, styles: {} }]);
|
||||
expect(await discoverVisualCandidates(facts([own]))).toMatchObject({
|
||||
candidates: [{ backendNodeId: 2 }],
|
||||
complete: true,
|
||||
issues: [],
|
||||
});
|
||||
const parent = await document([{ id: 2, parent: 1, tag: "iframe", styles: {} }]);
|
||||
const child = await document([{ id: 3, parent: 1 }], {
|
||||
frame: {
|
||||
frameId: "child",
|
||||
parentFrameId: "main",
|
||||
ownerBackendNodeId: 2,
|
||||
target: { tabId: 1 },
|
||||
},
|
||||
});
|
||||
expect(await discoverVisualCandidates(facts([parent, child]))).toMatchObject({
|
||||
candidates: [{ backendNodeId: 3 }],
|
||||
complete: true,
|
||||
issues: [],
|
||||
});
|
||||
});
|
||||
|
||||
it.each([
|
||||
0.8, 1, 1.25, 2,
|
||||
])("combines layout-unit bounds with CSS client clips at scale %s", async (scale) => {
|
||||
const doc = await document(
|
||||
[
|
||||
{
|
||||
id: 2,
|
||||
parent: 1,
|
||||
tag: "div",
|
||||
bounds: [100, 200, 64, 34].map((n) => n * scale),
|
||||
client: [2, 2, 60, 30],
|
||||
styles: { "overflow-x": "hidden", "overflow-y": "hidden" },
|
||||
},
|
||||
{ id: 3, parent: 2, bounds: [102, 202, 120, 40].map((n) => n * scale) },
|
||||
],
|
||||
{ layoutScale: scale, scrollY: 75 },
|
||||
);
|
||||
const result = await discoverVisualCandidates(facts([doc]));
|
||||
expect(result.issues).toEqual([]);
|
||||
const expected = {
|
||||
borderBox: { x: 102, y: 127, width: 120, height: 40 },
|
||||
crop: { x: 102, y: 127, width: 60, height: 30 },
|
||||
};
|
||||
for (const box of ["borderBox", "crop"] as const)
|
||||
for (const key of ["x", "y", "width", "height"] as const)
|
||||
expect(result.candidates[0].region[box][key]).toBeCloseTo(expected[box][key], 8);
|
||||
});
|
||||
|
||||
it("normalizes a zero-width ancestor origin before one-axis clipping", async () => {
|
||||
const doc = await document(
|
||||
[
|
||||
{
|
||||
id: 2,
|
||||
parent: 1,
|
||||
tag: "div",
|
||||
bounds: [200, 400, 0, 60],
|
||||
client: [0, 0, 0, 30],
|
||||
styles: { "overflow-y": "hidden" },
|
||||
},
|
||||
{ id: 3, parent: 2, bounds: [200, 400, 240, 80] },
|
||||
],
|
||||
{ layoutScale: 2, scrollY: 75 },
|
||||
);
|
||||
const result = await discoverVisualCandidates(facts([doc]));
|
||||
expect(result.issues).toEqual([]);
|
||||
expect(result.candidates[0].region.crop).toEqual({ x: 100, y: 125, width: 120, height: 30 });
|
||||
});
|
||||
|
||||
it("keeps unnamed, semantic, aria-hidden, inert, pointer-none and visibility override Canvas", async () => {
|
||||
const doc = await document([
|
||||
{ id: 2, parent: 1 },
|
||||
{ id: 3, parent: 1, attrs: { "aria-label": "Chart" } },
|
||||
{
|
||||
id: 4,
|
||||
parent: 1,
|
||||
attrs: { "aria-hidden": "true", inert: "" },
|
||||
styles: { "pointer-events": "none" },
|
||||
},
|
||||
{ id: 5, parent: 1, tag: "div", styles: { visibility: "hidden" } },
|
||||
{ id: 6, parent: 5, styles: { visibility: "visible" } },
|
||||
{ id: 7, parent: 1, attrs: { hidden: "" }, styles: { display: "block" } },
|
||||
]);
|
||||
doc.axNodes.push({ nodeId: "canvas", backendDOMNodeId: 2 } as FrameOwnedAxNode);
|
||||
const result = await discoverVisualCandidates(facts([doc]));
|
||||
expect(result.candidates.map((c) => c.backendNodeId)).toEqual([2, 3, 4, 6, 7]);
|
||||
expect(result.candidates[1].label).toBe("Chart");
|
||||
expect(result.complete).toBe(true);
|
||||
});
|
||||
|
||||
it("excludes CSS transparent subtrees, hidden/zero/no-layout/fully clipped nodes and overlays", async () => {
|
||||
const doc = await document([
|
||||
{ id: 2, parent: 1, tag: "div", styles: { opacity: "0" } },
|
||||
{ id: 3, parent: 2 },
|
||||
{ id: 4, parent: 1, styles: { visibility: "hidden" } },
|
||||
{ id: 5, parent: 1, bounds: [0, 0, 0, 40] },
|
||||
{ id: 6, parent: 1, bounds: null },
|
||||
{ id: 7, parent: 1, bounds: [1200, 0, 100, 50] },
|
||||
{ id: 8, parent: 1, tag: "div", attrs: { [OVERLAY_HOST_MARKER_ATTR]: "" } },
|
||||
{ id: 9, parent: 8, tag: "#document-fragment", bounds: null },
|
||||
{ id: 10, parent: 9 },
|
||||
]);
|
||||
expect(await discoverVisualCandidates(facts([doc]))).toMatchObject({
|
||||
candidates: [],
|
||||
issues: [],
|
||||
complete: true,
|
||||
});
|
||||
});
|
||||
|
||||
it.each([
|
||||
["both", "hidden", "hidden", [0, 0, 60, 30], [60, 30]],
|
||||
["x", "clip", "visible", [0, 0, 60, 20], [60, 40]],
|
||||
["border", "hidden", "hidden", [5, 5, 68, 38], [64, 34]],
|
||||
])("uses client box for %s clipping", async (_name, x, y, client, expected) => {
|
||||
const doc = await document([
|
||||
{
|
||||
id: 2,
|
||||
parent: 1,
|
||||
tag: "div",
|
||||
bounds: [0, 0, 78, 48],
|
||||
client: client as number[],
|
||||
styles: { "overflow-x": x as string, "overflow-y": y as string },
|
||||
},
|
||||
{
|
||||
id: 3,
|
||||
parent: 2,
|
||||
bounds: x === "clip" || _name === "both" ? [0, 0, 120, 40] : [9, 9, 120, 40],
|
||||
},
|
||||
]);
|
||||
const [candidate] = (await discoverVisualCandidates(facts([doc]))).candidates;
|
||||
expect([candidate.region.crop.width, candidate.region.crop.height]).toEqual(expected);
|
||||
expect(candidate.region.clips?.backendNodeId).toBe(2);
|
||||
});
|
||||
|
||||
it("keeps Canvas border-box and clips partial viewport intersections", async () => {
|
||||
const doc = await document([{ id: 2, parent: 1, bounds: [950, 20, 130, 50] }]);
|
||||
const [candidate] = (await discoverVisualCandidates(facts([doc]))).candidates;
|
||||
expect(candidate.region.borderBox.width).toBe(130);
|
||||
expect(candidate.region.crop).toEqual({ x: 950, y: 20, width: 50, height: 50 });
|
||||
});
|
||||
|
||||
it("propagates owner ancestry across targets, without depending on semantic parents", async () => {
|
||||
const parent = await document([
|
||||
{
|
||||
id: 2,
|
||||
parent: 1,
|
||||
tag: "div",
|
||||
bounds: [0, 0, 200, 100],
|
||||
client: [0, 0, 200, 100],
|
||||
styles: { "overflow-x": "hidden", "overflow-y": "hidden" },
|
||||
},
|
||||
{ id: 3, parent: 2, tag: "iframe", bounds: [100, 0, 200, 200] },
|
||||
]);
|
||||
parent.domNodes.splice(0); // Visual discovery never reads the semantic subset.
|
||||
const child = await document([{ id: 2, parent: 1, bounds: [0, 0, 200, 200] }], {
|
||||
frame: {
|
||||
frameId: "child",
|
||||
parentFrameId: "main",
|
||||
ownerBackendNodeId: 3,
|
||||
target: { tabId: 1, sessionId: "remote" },
|
||||
},
|
||||
projection: {
|
||||
...projection,
|
||||
edges: [
|
||||
{
|
||||
sourceViewport: { width: 200, height: 200 },
|
||||
destinationQuad: [
|
||||
{ x: 100, y: 0 },
|
||||
{ x: 300, y: 0 },
|
||||
{ x: 300, y: 200 },
|
||||
{ x: 100, y: 200 },
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
});
|
||||
const result = await discoverVisualCandidates(facts([child, parent]));
|
||||
expect(result.complete).toBe(true);
|
||||
expect(result.candidates[0]).toMatchObject({
|
||||
document: { frameId: "child", target: { sessionId: "remote" } },
|
||||
region: { crop: { x: 100, y: 0, width: 100, height: 100 } },
|
||||
});
|
||||
const owner = parent.index.nodes.get(3)!;
|
||||
owner.layout!.styles = { ...owner.layout!.styles, visibility: "hidden" };
|
||||
expect((await discoverVisualCandidates(facts([parent, child]))).candidates).toHaveLength(0);
|
||||
});
|
||||
|
||||
it.each<Record<string, string>>([
|
||||
{ transform: "matrix(0,1,-1,0,0,0)" },
|
||||
{ "clip-path": "circle(50%)" },
|
||||
{ "mask-image": "url(mask)" },
|
||||
{ zoom: "1.25", "overflow-x": "hidden" },
|
||||
])("reports unsupported ancestor geometry: %o", async (styles) => {
|
||||
const doc = await document([
|
||||
{ id: 2, parent: 1, tag: "div", styles },
|
||||
{ id: 3, parent: 2 },
|
||||
]);
|
||||
const result = await discoverVisualCandidates(facts([doc]));
|
||||
expect(result.candidates).toHaveLength(0);
|
||||
expect(result.issues[0].reason).toBe("geometry-unsupported");
|
||||
});
|
||||
|
||||
it("supports positive scale without overflow, rejects pinch and non-rectangular frame projection", async () => {
|
||||
const nodes = [
|
||||
{
|
||||
id: 2,
|
||||
parent: 1,
|
||||
styles: { transform: "matrix(1.25,0,0,1.25,0,0)" },
|
||||
bounds: [10, 20, 150, 50],
|
||||
},
|
||||
];
|
||||
expect(
|
||||
(await discoverVisualCandidates(facts([await document(nodes)]))).candidates,
|
||||
).toHaveLength(1);
|
||||
expect(
|
||||
(await discoverVisualCandidates(facts([await document(nodes, { pageScale: 1.5 })]))).issues[0]
|
||||
.reason,
|
||||
).toBe("geometry-unsupported");
|
||||
const rotated = {
|
||||
...projection,
|
||||
edges: [
|
||||
{
|
||||
sourceViewport: { width: 200, height: 200 },
|
||||
destinationQuad: [
|
||||
{ x: 10, y: 0 },
|
||||
{ x: 200, y: 10 },
|
||||
{ x: 190, y: 200 },
|
||||
{ x: 0, y: 190 },
|
||||
] as [
|
||||
{ x: number; y: number },
|
||||
{ x: number; y: number },
|
||||
{ x: number; y: number },
|
||||
{ x: number; y: number },
|
||||
],
|
||||
},
|
||||
],
|
||||
};
|
||||
expect(
|
||||
(await discoverVisualCandidates(facts([await document(nodes, { projection: rotated })])))
|
||||
.issues[0].reason,
|
||||
).toBe("geometry-unsupported");
|
||||
});
|
||||
|
||||
it("keeps partial capture separate from valid geometry, rejects unverified identities", async () => {
|
||||
const doc = await document([{ id: 2, parent: 1 }]);
|
||||
const partial = facts(
|
||||
[doc],
|
||||
[{ target: doc.frame.target, frameId: "main", stage: "ax", reason: "capture-unavailable" }],
|
||||
);
|
||||
const result = await discoverVisualCandidates(partial);
|
||||
expect(result.candidates).toHaveLength(1);
|
||||
expect(result.captureIssues).toBe(partial.issues);
|
||||
expect(result.complete).toBe(false);
|
||||
const unverified = { ...doc, identity: undefined };
|
||||
const failed = await discoverVisualCandidates(facts([unverified]));
|
||||
expect(failed.candidates).toHaveLength(0);
|
||||
expect(failed.issues[0].reason).toBe("identity-unverified");
|
||||
});
|
||||
|
||||
it("does not trust orphan, cyclic, boxless or missing frame-owner ancestry", async () => {
|
||||
const doc = await document([
|
||||
{ id: 2, parent: 1, tag: "div" },
|
||||
{ id: 3, parent: 2 },
|
||||
]);
|
||||
for (const parent of [99, 3]) {
|
||||
doc.index.nodes.get(2)!.parentBackendNodeId = parent;
|
||||
const index = await buildDocumentIndex([...doc.index.nodes.values()], undefined, true);
|
||||
const result = await discoverVisualCandidates(facts([{ ...doc, index }]));
|
||||
expect(result.candidates).toHaveLength(0);
|
||||
expect(result.issues[0].reason).toBe("ancestry-incomplete");
|
||||
}
|
||||
const boxless = await document([
|
||||
{ id: 2, parent: 1, tag: "div", bounds: null },
|
||||
{ id: 3, parent: 2 },
|
||||
]);
|
||||
expect((await discoverVisualCandidates(facts([boxless]))).issues[0].reason).toBe(
|
||||
"facts-unavailable",
|
||||
);
|
||||
const child = {
|
||||
...doc,
|
||||
frame: { ...doc.frame, frameId: "child", parentFrameId: "absent", ownerBackendNodeId: 2 },
|
||||
};
|
||||
expect((await discoverVisualCandidates(facts([child]))).issues[0].reason).toBe(
|
||||
"ownership-unresolved",
|
||||
);
|
||||
});
|
||||
|
||||
it("is deterministic, does not deduplicate or mutate inputs", async () => {
|
||||
const input = facts([
|
||||
await document([
|
||||
{ id: 2, parent: 1 },
|
||||
{ id: 3, parent: 1 },
|
||||
]),
|
||||
]);
|
||||
const freeze = (value: unknown): void => {
|
||||
if (!value || typeof value !== "object" || Object.isFrozen(value)) return;
|
||||
if (value instanceof Map) for (const item of value.values()) freeze(item);
|
||||
for (const item of Object.values(value)) freeze(item);
|
||||
Object.freeze(value);
|
||||
};
|
||||
freeze(input);
|
||||
const first = await discoverVisualCandidates(input);
|
||||
expect(await discoverVisualCandidates(input)).toEqual(first);
|
||||
expect(first.candidates).toHaveLength(2);
|
||||
});
|
||||
|
||||
it.each([
|
||||
1000, 10000, 100000,
|
||||
])("memoizes deep ancestry across %i nodes and checks cancellation", async (count) => {
|
||||
const doc = await document([{ id: 2, parent: 1 }]);
|
||||
const template = doc.index.nodes.get(2)!;
|
||||
let reads = 0;
|
||||
const input = [doc.index.nodes.get(0)!, doc.index.nodes.get(1)!];
|
||||
for (let id = 2; id < count + 2; id++) {
|
||||
const node = {
|
||||
...template,
|
||||
backendNodeId: id,
|
||||
tag: id < count / 2 ? "div" : "canvas",
|
||||
parentBackendNodeId: id < count / 2 ? id - 1 : count / 2 - 1,
|
||||
};
|
||||
Object.defineProperty(node, "parentBackendNodeId", {
|
||||
get: () => {
|
||||
reads++;
|
||||
return id < count / 2 ? id - 1 : count / 2 - 1;
|
||||
},
|
||||
});
|
||||
input.push(node);
|
||||
}
|
||||
const index = await buildDocumentIndex(input, undefined, true);
|
||||
reads = 0;
|
||||
const result = await discoverVisualCandidates(facts([{ ...doc, index }]));
|
||||
expect(result.candidates).toHaveLength(count / 2 + 2);
|
||||
expect(reads).toBeLessThan(count * 5);
|
||||
const controller = new AbortController();
|
||||
controller.abort();
|
||||
await expect(discoverVisualCandidates(facts([doc]), controller.signal)).rejects.toMatchObject({
|
||||
name: "AbortError",
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,250 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import {
|
||||
EMPTY_VISUAL_CONTEXT,
|
||||
extendVisualContext,
|
||||
projectVisualBox,
|
||||
resolveVisualRegion,
|
||||
type VisualAncestor,
|
||||
} from "../visual-region";
|
||||
|
||||
const styles = {
|
||||
position: "static",
|
||||
visibility: "visible",
|
||||
opacity: "1",
|
||||
display: "block",
|
||||
transform: "none",
|
||||
zoom: "1",
|
||||
"overflow-x": "visible",
|
||||
"overflow-y": "visible",
|
||||
"clip-path": "none",
|
||||
"mask-image": "none",
|
||||
rotate: "none",
|
||||
scale: "none",
|
||||
perspective: "none",
|
||||
clip: "auto",
|
||||
contain: "none",
|
||||
"overflow-clip-margin": "0px",
|
||||
};
|
||||
const ancestor: VisualAncestor = {
|
||||
document: {
|
||||
attachmentId: "a",
|
||||
target: { tabId: 1 },
|
||||
frameId: "main",
|
||||
documentElementBackendNodeId: 1,
|
||||
},
|
||||
backendNodeId: 2,
|
||||
styles,
|
||||
clientBox: { x: 5, y: 5, width: 60, height: 30 },
|
||||
};
|
||||
const box = { x: 0, y: 0, width: 120, height: 40 };
|
||||
|
||||
describe("shared visual region rules", () => {
|
||||
it.each([
|
||||
"visible",
|
||||
"hidden",
|
||||
"auto",
|
||||
"scroll",
|
||||
"clip",
|
||||
])("keeps %s screenshot bounds independent of rounded styling", (overflow) => {
|
||||
for (const clipContents of [true, false]) {
|
||||
const node = {
|
||||
...ancestor,
|
||||
styles: { ...styles, "overflow-x": overflow, "overflow-y": overflow },
|
||||
};
|
||||
const baseline = extendVisualContext(EMPTY_VISUAL_CONTEXT, node, clipContents);
|
||||
for (const radius of ["0px", "8px", "50%", "4px 8px"]) {
|
||||
const rounded = extendVisualContext(
|
||||
EMPTY_VISUAL_CONTEXT,
|
||||
{
|
||||
...node,
|
||||
styles: {
|
||||
...node.styles,
|
||||
"border-top-left-radius": radius,
|
||||
"border-top-right-radius": radius,
|
||||
"border-bottom-left-radius": radius,
|
||||
"border-bottom-right-radius": radius,
|
||||
},
|
||||
},
|
||||
clipContents,
|
||||
);
|
||||
expect(rounded).toEqual(baseline);
|
||||
expect(
|
||||
resolveVisualRegion({
|
||||
borderBox: box,
|
||||
frameVisibleBox: box,
|
||||
visibility: "visible",
|
||||
context: rounded,
|
||||
}),
|
||||
).toMatchObject({ status: "available" });
|
||||
expect(
|
||||
resolveVisualRegion({
|
||||
borderBox: box,
|
||||
frameVisibleBox: box,
|
||||
visibility: "hidden",
|
||||
context: rounded,
|
||||
}),
|
||||
).toEqual({ status: "empty" });
|
||||
if (clipContents && overflow !== "visible")
|
||||
expect(
|
||||
resolveVisualRegion({
|
||||
borderBox: box,
|
||||
frameVisibleBox: { x: 80, y: 0, width: 20, height: 20 },
|
||||
visibility: "visible",
|
||||
context: rounded,
|
||||
}),
|
||||
).toEqual({ status: "empty" });
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it("accepts independently supplied normalized facts and preserves clipping policy", () => {
|
||||
const context = extendVisualContext(EMPTY_VISUAL_CONTEXT, {
|
||||
...ancestor,
|
||||
styles: { ...styles, "overflow-x": "hidden" },
|
||||
});
|
||||
expect(
|
||||
resolveVisualRegion({ borderBox: box, frameVisibleBox: box, visibility: "visible", context }),
|
||||
).toMatchObject({
|
||||
status: "available",
|
||||
crop: { x: 5, y: 0, width: 60, height: 40 },
|
||||
clips: { overflowX: "hidden", overflowY: "visible" },
|
||||
});
|
||||
const differentPolicy = extendVisualContext(EMPTY_VISUAL_CONTEXT, {
|
||||
...ancestor,
|
||||
styles: { ...styles, "overflow-x": "scroll" },
|
||||
});
|
||||
expect(differentPolicy.clip).toEqual(context.clip);
|
||||
expect(differentPolicy.clips).not.toEqual(context.clips);
|
||||
});
|
||||
|
||||
it("distinguishes fully clipped, missing client geometry and invalid rectangles", () => {
|
||||
const clipping = { ...ancestor, styles: { ...styles, "overflow-x": "hidden" } };
|
||||
const context = extendVisualContext(EMPTY_VISUAL_CONTEXT, {
|
||||
...clipping,
|
||||
clientBox: { x: 0, y: 0, width: 0, height: 20 },
|
||||
});
|
||||
expect(
|
||||
resolveVisualRegion({ borderBox: box, frameVisibleBox: box, visibility: "visible", context })
|
||||
.status,
|
||||
).toBe("empty");
|
||||
const unavailable = extendVisualContext(EMPTY_VISUAL_CONTEXT, { ...clipping, clientBox: null });
|
||||
expect(
|
||||
resolveVisualRegion({
|
||||
borderBox: box,
|
||||
frameVisibleBox: box,
|
||||
visibility: "visible",
|
||||
context: unavailable,
|
||||
}),
|
||||
).toEqual({ status: "unavailable", reason: "geometry-unavailable" });
|
||||
expect(
|
||||
resolveVisualRegion({
|
||||
borderBox: { ...box, x: NaN },
|
||||
frameVisibleBox: box,
|
||||
visibility: "visible",
|
||||
context: EMPTY_VISUAL_CONTEXT,
|
||||
}).status,
|
||||
).toBe("unavailable");
|
||||
expect(projectVisualBox({ x: 5, y: 5, width: 0, height: 20 }, [])).toEqual({
|
||||
x: 5,
|
||||
y: 5,
|
||||
width: 0,
|
||||
height: 20,
|
||||
});
|
||||
});
|
||||
|
||||
it.each<Record<string, string>>([
|
||||
{ rotate: "45deg" },
|
||||
{ scale: "-1 1" },
|
||||
{ perspective: "100px" },
|
||||
{ clip: "rect(0px, 20px, 20px, 0px)" },
|
||||
{ contain: "paint" },
|
||||
{ "overflow-x": "clip", "overflow-clip-margin": "10px" },
|
||||
{ transform: "matrix3d(1,0,0,0,0,1,0,0,0,0,1,0.01,0,0,0,1)" },
|
||||
])("refuses unsupported CSS evidence without changing DOM geometry: %o", (change) => {
|
||||
const context = extendVisualContext(EMPTY_VISUAL_CONTEXT, {
|
||||
...ancestor,
|
||||
styles: { ...styles, ...change },
|
||||
});
|
||||
expect(context.issue).toBe("geometry-unsupported");
|
||||
});
|
||||
|
||||
it("accepts axis-preserving matrix3d translation and independent positive scale", () => {
|
||||
for (const change of [
|
||||
{ transform: "matrix3d(1,0,0,0,0,1,0,0,0,0,1,0,10,20,0,1)" },
|
||||
{ scale: "1.25" },
|
||||
])
|
||||
expect(
|
||||
extendVisualContext(EMPTY_VISUAL_CONTEXT, { ...ancestor, styles: { ...styles, ...change } })
|
||||
.issue,
|
||||
).toBeUndefined();
|
||||
});
|
||||
|
||||
it.each([
|
||||
"matrix(1,0,0,1,0,0)",
|
||||
"matrix(1,0,0,1,10,20)",
|
||||
])("accepts unscaled overflow transform %s", (transform) => {
|
||||
const context = extendVisualContext(EMPTY_VISUAL_CONTEXT, {
|
||||
...ancestor,
|
||||
styles: {
|
||||
...styles,
|
||||
transform,
|
||||
position: "relative",
|
||||
"overflow-x": "hidden",
|
||||
"overflow-y": "hidden",
|
||||
},
|
||||
});
|
||||
expect(context.issue).toBeUndefined();
|
||||
const child = extendVisualContext(
|
||||
context,
|
||||
{
|
||||
...ancestor,
|
||||
styles: {
|
||||
...styles,
|
||||
position: "absolute",
|
||||
"overflow-x": "clip",
|
||||
"overflow-y": "clip",
|
||||
"overflow-clip-margin": "content-box",
|
||||
},
|
||||
},
|
||||
false,
|
||||
);
|
||||
expect(
|
||||
resolveVisualRegion({
|
||||
borderBox: box,
|
||||
frameVisibleBox: box,
|
||||
visibility: "visible",
|
||||
context: child,
|
||||
}),
|
||||
).toMatchObject({ status: "available", crop: { x: 5, y: 5, width: 60, height: 30 } });
|
||||
});
|
||||
|
||||
it("supports positioned overflow containers but refuses uncertain out-of-flow clipping", () => {
|
||||
const overflow = { ...ancestor, styles: { ...styles, "overflow-x": "hidden" } };
|
||||
const staticParent = extendVisualContext(EMPTY_VISUAL_CONTEXT, overflow);
|
||||
expect(
|
||||
extendVisualContext(
|
||||
staticParent,
|
||||
{ ...ancestor, styles: { ...styles, position: "absolute" } },
|
||||
false,
|
||||
).issue,
|
||||
).toBe("geometry-unsupported");
|
||||
const positionedParent = extendVisualContext(EMPTY_VISUAL_CONTEXT, {
|
||||
...overflow,
|
||||
styles: { ...overflow.styles, position: "relative" },
|
||||
});
|
||||
const child = extendVisualContext(
|
||||
positionedParent,
|
||||
{ ...ancestor, styles: { ...styles, position: "absolute" } },
|
||||
false,
|
||||
);
|
||||
expect(child.issue).toBeUndefined();
|
||||
expect(child.clip).toEqual(positionedParent.clip);
|
||||
expect(
|
||||
extendVisualContext(
|
||||
positionedParent,
|
||||
{ ...ancestor, styles: { ...styles, position: "fixed" } },
|
||||
false,
|
||||
).issue,
|
||||
).toBe("geometry-unsupported");
|
||||
});
|
||||
});
|
||||
@@ -22,7 +22,12 @@ import {
|
||||
type FrameOwnedAxNode,
|
||||
} from "./frame-document";
|
||||
import { type NormalizedFrameDocument, normalizeSnapshot } from "./normalize";
|
||||
import { describeSnapshotFrames, REQUESTED_STYLES, type SnapshotReply } from "./snapshot";
|
||||
import {
|
||||
BASIC_SNAPSHOT,
|
||||
describeSnapshotFrames,
|
||||
type SnapshotReply,
|
||||
VISUAL_SNAPSHOT,
|
||||
} from "./snapshot";
|
||||
|
||||
interface TargetBatch<T extends FrameOwnedAxNode> {
|
||||
target: CdpTarget;
|
||||
@@ -69,7 +74,9 @@ export async function captureObservationFacts<T extends FrameOwnedAxNode>(
|
||||
tabId: number,
|
||||
signal?: AbortSignal,
|
||||
pageUrl?: string,
|
||||
options: { includeVisualFacts?: boolean } = {},
|
||||
): Promise<ObservationFacts<T>> {
|
||||
const profile = options.includeVisualFacts ? VISUAL_SNAPSHOT : BASIC_SNAPSHOT;
|
||||
const startedAt = Date.now();
|
||||
throwCaptureAborted(signal);
|
||||
let graph: CdpFrameGraph | undefined;
|
||||
@@ -125,7 +132,7 @@ export async function captureObservationFacts<T extends FrameOwnedAxNode>(
|
||||
throwCaptureAborted(signal);
|
||||
batch.snapshotAttachmentId = cdp.getAttachmentId?.(tabId);
|
||||
const snapshot = await scoped.send<SnapshotReply>(tabId, "DOMSnapshot.captureSnapshot", {
|
||||
computedStyles: REQUESTED_STYLES,
|
||||
computedStyles: profile.computedStyles,
|
||||
includePaintOrder: true,
|
||||
includeDOMRects: true,
|
||||
});
|
||||
@@ -146,6 +153,7 @@ export async function captureObservationFacts<T extends FrameOwnedAxNode>(
|
||||
issues,
|
||||
signal,
|
||||
observed.rootFrameId,
|
||||
profile,
|
||||
);
|
||||
const formsAvailable = await enrichFormControlStates(
|
||||
scoped,
|
||||
@@ -375,6 +383,7 @@ export async function captureObservationFacts<T extends FrameOwnedAxNode>(
|
||||
facts.push({
|
||||
frame,
|
||||
identity: identities.get(document.frameId),
|
||||
...(doc?.geometry ? { geometry: doc.geometry } : {}),
|
||||
index: fallback?.size ? { ...index, excludedBackendNodeIds: fallback } : index,
|
||||
domNodes,
|
||||
axNodes,
|
||||
@@ -383,7 +392,15 @@ export async function captureObservationFacts<T extends FrameOwnedAxNode>(
|
||||
throwCaptureAborted(signal);
|
||||
if (firstFailure && facts.every((doc) => !doc.domNodes.length && !doc.axNodes.length))
|
||||
throw firstFailure;
|
||||
return { rootFrameId, viewport, documents: facts, issues, startedAt, finishedAt: Date.now() };
|
||||
return {
|
||||
visualFactsCollected: profile.includeVisualFacts,
|
||||
rootFrameId,
|
||||
viewport,
|
||||
documents: facts,
|
||||
issues,
|
||||
startedAt,
|
||||
finishedAt: Date.now(),
|
||||
};
|
||||
}
|
||||
|
||||
/** Existing semantic consumers get a narrow view; no raw snapshot
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
import type { Viewport } from "@browser-skill/vom";
|
||||
import type { CdpFrame, CdpTarget } from "@/browser-driver/frame-graph";
|
||||
import { isOverlayHostNode } from "@/lib/overlay-bridge";
|
||||
import type { FrameProjectionIssue } from "../geometry/coordinate-types";
|
||||
import type { GeometryProjection } from "../geometry";
|
||||
import type { FrameProjectionIssue, SnapshotCoordinates } from "../geometry/coordinate-types";
|
||||
import { createCaptureCheckpoint } from "./capture-abort";
|
||||
import type { CapturedNode } from "./capture-types";
|
||||
import type { FrameOwnedAxNode } from "./frame-document";
|
||||
@@ -10,21 +11,26 @@ import type { FrameOwnedAxNode } from "./frame-document";
|
||||
export interface SnapshotLayout {
|
||||
readonly boundsSpace: "snapshot-document-layout";
|
||||
bounds?: number[];
|
||||
/** [clientLeft, clientTop, clientWidth, clientHeight], untransformed local CSS units. */
|
||||
clientRect?: number[];
|
||||
styles: Readonly<Record<string, string>>;
|
||||
}
|
||||
|
||||
export interface DecodedNode extends Omit<CapturedNode, "rect" | "localRect" | "rendered"> {
|
||||
nodeType?: number;
|
||||
parentMissing?: boolean;
|
||||
layout?: SnapshotLayout;
|
||||
}
|
||||
|
||||
export interface NodeFacts extends CapturedNode {
|
||||
nodeType?: number;
|
||||
parentMissing?: boolean;
|
||||
layout?: SnapshotLayout;
|
||||
}
|
||||
|
||||
export interface DocumentIndex<T extends DecodedNode = NodeFacts> {
|
||||
readonly nodes: ReadonlyMap<number, T>;
|
||||
readonly ancestryComplete?: ReadonlyMap<number, boolean>;
|
||||
readonly excludedBackendNodeIds: ReadonlySet<number>;
|
||||
}
|
||||
|
||||
@@ -37,10 +43,12 @@ export interface DecodedDocument {
|
||||
export async function buildDocumentIndex<T extends DecodedNode>(
|
||||
input: readonly T[],
|
||||
signal?: AbortSignal,
|
||||
includeVisualFacts = false,
|
||||
): Promise<DocumentIndex<T>> {
|
||||
const checkpoint = createCaptureCheckpoint(signal);
|
||||
const nodes = new Map<number, T>();
|
||||
const overlayByNode = new Map<number, boolean>();
|
||||
const ancestryComplete = includeVisualFacts ? new Map<number, boolean>() : undefined;
|
||||
const excludedBackendNodeIds = new Set<number>();
|
||||
for (let i = 0; i < input.length; i++) {
|
||||
if (i % 256 === 0) {
|
||||
@@ -61,6 +69,7 @@ export async function buildDocumentIndex<T extends DecodedNode>(
|
||||
const visiting = new Set<number>();
|
||||
let current: DecodedNode | undefined = node;
|
||||
let overlay = false;
|
||||
let complete = false;
|
||||
while (current && !overlayByNode.has(current.backendNodeId)) {
|
||||
if (work++ % 256 === 0) {
|
||||
const pending = checkpoint();
|
||||
@@ -76,13 +85,16 @@ export async function buildDocumentIndex<T extends DecodedNode>(
|
||||
visiting.add(current.backendNodeId);
|
||||
path.push(current);
|
||||
if (current.parentBackendNodeId === null) {
|
||||
if (ancestryComplete) complete = !current.parentMissing && current.nodeType === 9;
|
||||
current = undefined;
|
||||
break;
|
||||
}
|
||||
current = nodes.get(current.parentBackendNodeId);
|
||||
}
|
||||
if (current && overlayByNode.has(current.backendNodeId))
|
||||
if (current && overlayByNode.has(current.backendNodeId)) {
|
||||
overlay = overlayByNode.get(current.backendNodeId)!;
|
||||
if (ancestryComplete) complete = ancestryComplete.get(current.backendNodeId) === true;
|
||||
}
|
||||
for (let i = path.length - 1; i >= 0; i--) {
|
||||
if (work++ % 256 === 0) {
|
||||
const pending = checkpoint();
|
||||
@@ -91,10 +103,14 @@ export async function buildDocumentIndex<T extends DecodedNode>(
|
||||
const item = path[i];
|
||||
overlay = overlay || isOverlayHostNode(item.tag, Object.keys(item.attrs));
|
||||
overlayByNode.set(item.backendNodeId, overlay);
|
||||
if (ancestryComplete) {
|
||||
complete = complete && !item.parentMissing;
|
||||
ancestryComplete.set(item.backendNodeId, complete);
|
||||
}
|
||||
if (overlay) excludedBackendNodeIds.add(item.backendNodeId);
|
||||
}
|
||||
}
|
||||
return { nodes, excludedBackendNodeIds };
|
||||
return { nodes, ...(ancestryComplete ? { ancestryComplete } : {}), excludedBackendNodeIds };
|
||||
}
|
||||
|
||||
export interface DocumentIdentity {
|
||||
@@ -127,7 +143,16 @@ export interface CaptureIssue {
|
||||
| "geometry-unavailable";
|
||||
}
|
||||
|
||||
/** Shared per document; never retain the live GeometryContext in published facts. */
|
||||
export interface DocumentGeometry {
|
||||
readonly projections: readonly GeometryProjection[];
|
||||
readonly coordinates: SnapshotCoordinates;
|
||||
/** Visual viewport scale (pinch), distinct from browser UI zoom. */
|
||||
readonly pageScale?: number;
|
||||
}
|
||||
|
||||
export interface DocumentFacts<T extends FrameOwnedAxNode> {
|
||||
readonly geometry?: DocumentGeometry;
|
||||
readonly frame: CdpFrame;
|
||||
readonly identity?: DocumentIdentity;
|
||||
readonly index: DocumentIndex;
|
||||
@@ -136,6 +161,8 @@ export interface DocumentFacts<T extends FrameOwnedAxNode> {
|
||||
}
|
||||
|
||||
export interface ObservationFacts<T extends FrameOwnedAxNode> {
|
||||
/** Whether visual collection was enabled; partial capture failures remain in issues. */
|
||||
readonly visualFactsCollected: boolean;
|
||||
readonly rootFrameId: string;
|
||||
readonly viewport: Viewport;
|
||||
readonly documents: readonly DocumentFacts<T>[];
|
||||
|
||||
@@ -18,10 +18,18 @@ import {
|
||||
isAbortError as isCaptureAbort,
|
||||
throwIfAborted as throwCaptureAborted,
|
||||
} from "./capture-abort";
|
||||
import { buildDocumentIndex, type CaptureIssue, type DocumentIndex, type NodeFacts } from "./facts";
|
||||
import {
|
||||
buildDocumentIndex,
|
||||
type CaptureIssue,
|
||||
type DocumentGeometry,
|
||||
type DocumentIndex,
|
||||
type NodeFacts,
|
||||
} from "./facts";
|
||||
import {
|
||||
BASIC_SNAPSHOT,
|
||||
decodeDocument,
|
||||
type SnapshotDocument,
|
||||
type SnapshotProfile,
|
||||
type SnapshotReply,
|
||||
snapshotFrameId,
|
||||
} from "./snapshot";
|
||||
@@ -33,9 +41,11 @@ export interface FrameContext {
|
||||
targetProjection?: GeometryProjection | null;
|
||||
target: CdpTarget;
|
||||
coordinates: SnapshotCoordinates | null;
|
||||
pageScale?: number;
|
||||
}
|
||||
|
||||
export interface NormalizedDocument {
|
||||
geometry?: DocumentGeometry;
|
||||
nodes: NodeFacts[];
|
||||
index: DocumentIndex;
|
||||
documentElementBackendNodeId?: number;
|
||||
@@ -47,8 +57,9 @@ export async function normalizeDocument(
|
||||
strings: string[],
|
||||
context: FrameContext,
|
||||
signal?: AbortSignal,
|
||||
profile: SnapshotProfile = BASIC_SNAPSHOT,
|
||||
): Promise<NormalizedDocument> {
|
||||
const decoded = await decodeDocument(doc, strings, signal);
|
||||
const decoded = await decodeDocument(doc, strings, signal, profile);
|
||||
const checkpoint = createCaptureCheckpoint(signal);
|
||||
const nodes: NodeFacts[] = [];
|
||||
for (let i = 0; i < decoded.nodes.length; i++) {
|
||||
@@ -93,12 +104,27 @@ export async function normalizeDocument(
|
||||
(Number.parseFloat(opacity) || 0) > 0,
|
||||
});
|
||||
}
|
||||
const index = await buildDocumentIndex(nodes, signal);
|
||||
const index = await buildDocumentIndex(nodes, signal, profile.includeVisualFacts);
|
||||
return {
|
||||
nodes: nodes.filter(
|
||||
(node) => !node.tag.startsWith("#") && !index.excludedBackendNodeIds.has(node.backendNodeId),
|
||||
),
|
||||
index,
|
||||
...(profile.includeVisualFacts &&
|
||||
context.coordinates &&
|
||||
context.projection?.status === "available" &&
|
||||
context.targetProjection !== null
|
||||
? {
|
||||
geometry: {
|
||||
projections: [
|
||||
context.projection.projection.geometry,
|
||||
...(context.targetProjection ? [context.targetProjection] : []),
|
||||
],
|
||||
coordinates: context.coordinates,
|
||||
pageScale: context.pageScale,
|
||||
},
|
||||
}
|
||||
: {}),
|
||||
documentElementBackendNodeId: nodes.find(
|
||||
(node) =>
|
||||
node.nodeType === 1 &&
|
||||
@@ -122,6 +148,7 @@ export async function normalizeSnapshot(
|
||||
issues: CaptureIssue[],
|
||||
signal?: AbortSignal,
|
||||
rootFrameId?: string,
|
||||
profile: SnapshotProfile = BASIC_SNAPSHOT,
|
||||
): Promise<NormalizedFrameDocument[]> {
|
||||
const strings = snapshot.strings ?? [];
|
||||
const raw = snapshot.documents ?? [];
|
||||
@@ -313,11 +340,15 @@ export async function normalizeSnapshot(
|
||||
frameId: frame.frameId,
|
||||
ownerFrameBackendNodeId: frame.ownerBackendNodeId ?? null,
|
||||
projection: state,
|
||||
...(profile.includeVisualFacts
|
||||
? { pageScale: metrics.cssVisualViewport?.scale ?? metrics.visualViewport?.scale }
|
||||
: {}),
|
||||
target,
|
||||
...(target.sessionId ? { targetProjection } : {}),
|
||||
coordinates,
|
||||
},
|
||||
signal,
|
||||
profile,
|
||||
);
|
||||
result.push({ ...normalized, frame });
|
||||
}
|
||||
|
||||
@@ -9,9 +9,30 @@ export const REQUESTED_STYLES = [
|
||||
"visibility",
|
||||
"opacity",
|
||||
] as const;
|
||||
const STYLE_COL = Object.fromEntries(
|
||||
REQUESTED_STYLES.map((name, index) => [name, index]),
|
||||
) as Record<(typeof REQUESTED_STYLES)[number], number>;
|
||||
export const VISUAL_STYLES = [
|
||||
...REQUESTED_STYLES,
|
||||
"display",
|
||||
"overflow-x",
|
||||
"overflow-y",
|
||||
"transform",
|
||||
"zoom",
|
||||
"clip-path",
|
||||
"mask-image",
|
||||
"rotate",
|
||||
"scale",
|
||||
"perspective",
|
||||
"clip",
|
||||
"contain",
|
||||
"overflow-clip-margin",
|
||||
] as const;
|
||||
|
||||
/** The same profile owns request columns, decoding and visual-only derived facts. */
|
||||
export const BASIC_SNAPSHOT = {
|
||||
includeVisualFacts: false,
|
||||
computedStyles: REQUESTED_STYLES,
|
||||
} as const;
|
||||
export const VISUAL_SNAPSHOT = { includeVisualFacts: true, computedStyles: VISUAL_STYLES } as const;
|
||||
export type SnapshotProfile = typeof BASIC_SNAPSHOT | typeof VISUAL_SNAPSHOT;
|
||||
/** Sparse array format Chrome uses for infrequently-set per-node fields. */
|
||||
interface SparseArray {
|
||||
index: number[];
|
||||
@@ -49,6 +70,7 @@ export interface SnapshotDocument {
|
||||
nodeIndex?: number[];
|
||||
styles?: number[][];
|
||||
bounds?: number[][];
|
||||
clientRects?: number[][];
|
||||
paintOrders?: number[];
|
||||
};
|
||||
}
|
||||
@@ -103,6 +125,7 @@ export async function decodeDocument(
|
||||
doc: SnapshotDocument,
|
||||
strings: string[],
|
||||
signal?: AbortSignal,
|
||||
profile: SnapshotProfile = BASIC_SNAPSHOT,
|
||||
): Promise<DecodedDocument> {
|
||||
const checkpoint = createCaptureCheckpoint(signal);
|
||||
const dn = doc.nodes;
|
||||
@@ -170,13 +193,17 @@ export async function decodeDocument(
|
||||
const li = layoutByNode.get(n);
|
||||
const styleRow = li === undefined ? [] : (dl?.styles?.[li] ?? []);
|
||||
const styles: Record<string, string> = {};
|
||||
for (const name of REQUESTED_STYLES) styles[name] = str(strings, styleRow[STYLE_COL[name]]);
|
||||
for (let i = 0; i < profile.computedStyles.length; i++)
|
||||
styles[profile.computedStyles[i]] = str(strings, styleRow[i]);
|
||||
const layout =
|
||||
li === undefined
|
||||
? undefined
|
||||
: {
|
||||
boundsSpace: "snapshot-document-layout" as const,
|
||||
bounds: dl?.bounds?.[li],
|
||||
...(profile.includeVisualFacts && dl?.clientRects?.[li]
|
||||
? { clientRect: dl.clientRects[li] }
|
||||
: {}),
|
||||
styles,
|
||||
};
|
||||
|
||||
@@ -200,6 +227,10 @@ export async function decodeDocument(
|
||||
backendNodeId,
|
||||
nodeType: dn.nodeType?.[n],
|
||||
parentBackendNodeId,
|
||||
...(profile.includeVisualFacts &&
|
||||
(dn.parentIndex?.[n] === undefined || (parentIdx >= 0 && parentBackendNodeId === null))
|
||||
? { parentMissing: true }
|
||||
: {}),
|
||||
|
||||
tag,
|
||||
attrs,
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
import { createCaptureCheckpoint } from "./capture-abort";
|
||||
import type { VisualCandidate, VisualDiscoveryResult } from "./visual-discovery";
|
||||
|
||||
export const MAX_VISUAL_DEDUP_KEYS = 50_000;
|
||||
|
||||
export interface VisualDedupResult extends VisualDiscoveryResult {
|
||||
/** Known valid candidates in this capture, not the total Canvas count on the page. */
|
||||
readonly candidateCount: number;
|
||||
/** Candidates actually removed by exact coverage deduplication. */
|
||||
readonly deduplicatedCount: number;
|
||||
readonly dedupDegraded: boolean;
|
||||
}
|
||||
|
||||
/** Keep the first real anchor for each exact DOM/parent/crop key, in encounter order.
|
||||
* Once the key set is full, unknown keys pass through: capacity never drops candidates. */
|
||||
export async function deduplicateVisualCandidates(
|
||||
discovery: VisualDiscoveryResult,
|
||||
signal?: AbortSignal,
|
||||
): Promise<VisualDedupResult> {
|
||||
const checkpoint = createCaptureCheckpoint(signal);
|
||||
const keys = new Set<string>();
|
||||
const candidates: VisualCandidate[] = [];
|
||||
let deduplicatedCount = 0;
|
||||
let dedupDegraded = false;
|
||||
for (let i = 0; i < discovery.candidates.length; i++) {
|
||||
if (i % 256 === 0) {
|
||||
const pending = checkpoint();
|
||||
if (pending) await pending;
|
||||
}
|
||||
const candidate = discovery.candidates[i];
|
||||
const {
|
||||
document,
|
||||
region: { crop },
|
||||
} = candidate;
|
||||
const key = JSON.stringify([
|
||||
document.attachmentId,
|
||||
document.target.tabId,
|
||||
document.target.sessionId ?? null,
|
||||
document.frameId,
|
||||
document.documentElementBackendNodeId,
|
||||
candidate.parentBackendNodeId,
|
||||
crop.x,
|
||||
crop.y,
|
||||
crop.width,
|
||||
crop.height,
|
||||
]);
|
||||
if (keys.has(key)) {
|
||||
deduplicatedCount++;
|
||||
continue;
|
||||
}
|
||||
if (keys.size < MAX_VISUAL_DEDUP_KEYS) keys.add(key);
|
||||
else dedupDegraded = true;
|
||||
candidates.push(candidate);
|
||||
}
|
||||
const pending = checkpoint();
|
||||
if (pending) await pending;
|
||||
return {
|
||||
...discovery,
|
||||
candidates,
|
||||
candidateCount: discovery.candidates.length,
|
||||
deduplicatedCount,
|
||||
dedupDegraded,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,321 @@
|
||||
import { type CdpTarget } from "@/browser-driver/frame-graph";
|
||||
import type { ViewportRect } from "../geometry";
|
||||
import { createCaptureCheckpoint } from "./capture-abort";
|
||||
import type {
|
||||
CaptureIssue,
|
||||
DocumentFacts,
|
||||
DocumentIdentity,
|
||||
NodeFacts,
|
||||
ObservationFacts,
|
||||
} from "./facts";
|
||||
import type { FrameOwnedAxNode } from "./frame-document";
|
||||
import {
|
||||
EMPTY_VISUAL_CONTEXT,
|
||||
extendVisualContext,
|
||||
projectVisualBox,
|
||||
resolveVisualRegion,
|
||||
type VisualContext,
|
||||
type VisualIssueReason,
|
||||
type VisualRegionResult,
|
||||
visualProjectionIssue,
|
||||
} from "./visual-region";
|
||||
|
||||
export interface VisualCandidate {
|
||||
readonly document: DocumentIdentity;
|
||||
readonly backendNodeId: number;
|
||||
readonly parentBackendNodeId: number | null;
|
||||
readonly label?: string;
|
||||
readonly region: Extract<VisualRegionResult, { status: "available" }>;
|
||||
}
|
||||
|
||||
export type VisualDiscoveryIssue =
|
||||
| {
|
||||
readonly reason: "visual-facts-not-collected";
|
||||
readonly target?: never;
|
||||
readonly frameId?: never;
|
||||
readonly backendNodeId?: never;
|
||||
}
|
||||
| {
|
||||
readonly target: CdpTarget;
|
||||
readonly frameId: string;
|
||||
readonly backendNodeId?: number;
|
||||
readonly reason: VisualIssueReason;
|
||||
};
|
||||
|
||||
export interface VisualDiscoveryResult {
|
||||
readonly candidates: readonly VisualCandidate[];
|
||||
readonly issues: readonly VisualDiscoveryIssue[];
|
||||
/** Preserve upstream failures, including those that do not invalidate Canvas geometry. */
|
||||
readonly captureIssues: readonly CaptureIssue[];
|
||||
readonly complete: boolean;
|
||||
}
|
||||
|
||||
type Document = DocumentFacts<FrameOwnedAxNode>;
|
||||
interface NodeContext {
|
||||
self: VisualContext;
|
||||
children: VisualContext;
|
||||
}
|
||||
|
||||
function viewportRect(
|
||||
rect: { x: number; y: number; w: number; h: number } | null | undefined,
|
||||
): ViewportRect | null {
|
||||
return rect ? { x: rect.x, y: rect.y, width: rect.w, height: rect.h } : null;
|
||||
}
|
||||
|
||||
/** Client offsets are unscaled local CSS units. Only ordinary, untransformed
|
||||
* overflow chains consume this adapter; other combinations are rejected by policy. */
|
||||
function clientBox(node: NodeFacts, document: Document): ViewportRect | null {
|
||||
const client = node.layout?.clientRect;
|
||||
const bounds = node.layout?.bounds;
|
||||
const border =
|
||||
node.localRect ??
|
||||
(bounds?.length === 4 && bounds.every(Number.isFinite) && document.geometry
|
||||
? {
|
||||
x:
|
||||
bounds[0] / document.geometry.coordinates.layoutUnitsPerCssPixel -
|
||||
document.geometry.coordinates.scrollCss.x,
|
||||
y:
|
||||
bounds[1] / document.geometry.coordinates.layoutUnitsPerCssPixel -
|
||||
document.geometry.coordinates.scrollCss.y,
|
||||
}
|
||||
: null);
|
||||
if (
|
||||
!client ||
|
||||
client.length !== 4 ||
|
||||
!client.every(Number.isFinite) ||
|
||||
client[2] < 0 ||
|
||||
client[3] < 0 ||
|
||||
!border ||
|
||||
!document.geometry
|
||||
)
|
||||
return null;
|
||||
return projectVisualBox(
|
||||
{ x: border.x + client[0], y: border.y + client[1], width: client[2], height: client[3] },
|
||||
document.geometry.projections,
|
||||
);
|
||||
}
|
||||
|
||||
/** Pure Facts consumer: no CDP, ref registration, selection, or semantic keep/drop.
|
||||
* Both frame and node ancestry are memoized in this call, using iterative walks. */
|
||||
export async function discoverVisualCandidates(
|
||||
facts: ObservationFacts<FrameOwnedAxNode>,
|
||||
signal?: AbortSignal,
|
||||
): Promise<VisualDiscoveryResult> {
|
||||
const checkpoint = createCaptureCheckpoint(signal);
|
||||
if (!facts.visualFactsCollected)
|
||||
return {
|
||||
candidates: [],
|
||||
complete: false,
|
||||
captureIssues: facts.issues,
|
||||
issues: [{ reason: "visual-facts-not-collected" }],
|
||||
};
|
||||
let work = 0;
|
||||
const candidates: VisualCandidate[] = [];
|
||||
const issues: VisualDiscoveryIssue[] = [];
|
||||
const documents = new Map(facts.documents.map((document) => [document.frame.frameId, document]));
|
||||
const contexts = new Map<string, Map<number, NodeContext>>();
|
||||
const roots = new Map<string, VisualContext>();
|
||||
|
||||
async function nodeContext(document: Document, id: number): Promise<NodeContext> {
|
||||
const cache = contexts.get(document.frame.frameId)!;
|
||||
const path: NodeFacts[] = [];
|
||||
let node = document.index.nodes.get(id);
|
||||
while (node && !cache.has(node.backendNodeId)) {
|
||||
if (work++ % 256 === 0) {
|
||||
const pending = checkpoint();
|
||||
if (pending) await pending;
|
||||
}
|
||||
if (
|
||||
!document.index.ancestryComplete?.get(node.backendNodeId) ||
|
||||
path.length >= document.index.nodes.size
|
||||
) {
|
||||
const incomplete = {
|
||||
...roots.get(document.frame.frameId)!,
|
||||
issue: roots.get(document.frame.frameId)!.issue ?? ("ancestry-incomplete" as const),
|
||||
};
|
||||
cache.set(node.backendNodeId, { self: incomplete, children: incomplete });
|
||||
break;
|
||||
}
|
||||
path.push(node);
|
||||
node =
|
||||
node.parentBackendNodeId === null
|
||||
? undefined
|
||||
: document.index.nodes.get(node.parentBackendNodeId);
|
||||
}
|
||||
let parent = node
|
||||
? cache.get(node.backendNodeId)!.children
|
||||
: roots.get(document.frame.frameId)!;
|
||||
for (let i = path.length - 1; i >= 0; i--) {
|
||||
if (work++ % 256 === 0) {
|
||||
const pending = checkpoint();
|
||||
if (pending) await pending;
|
||||
}
|
||||
const current = path[i];
|
||||
let self = parent;
|
||||
let children = parent;
|
||||
if (document.index.excludedBackendNodeIds.has(current.backendNodeId)) {
|
||||
self = children = { ...parent, hidden: true };
|
||||
} else if (current.nodeType === 1) {
|
||||
if (!current.layout) {
|
||||
// An element without layout is not evidence that descendants are hidden
|
||||
// (e.g. a boxless ancestor). Keep the missing style evidence explicit.
|
||||
self = children = { ...parent, issue: parent.issue ?? "facts-unavailable" };
|
||||
} else if (document.identity) {
|
||||
const ancestor = {
|
||||
document: document.identity,
|
||||
backendNodeId: current.backendNodeId,
|
||||
styles: current.layout.styles,
|
||||
clientBox: clientBox(current, document),
|
||||
};
|
||||
children = extendVisualContext(
|
||||
parent,
|
||||
ancestor,
|
||||
current.tag !== "iframe" && current.tag !== "frame",
|
||||
);
|
||||
self = current.tag === "canvas" ? extendVisualContext(parent, ancestor, false) : children;
|
||||
}
|
||||
}
|
||||
const result = { self, children };
|
||||
cache.set(current.backendNodeId, result);
|
||||
parent = children;
|
||||
}
|
||||
return (
|
||||
cache.get(id) ?? {
|
||||
self: { ...parent, issue: "ancestry-incomplete" },
|
||||
children: { ...parent, issue: "ancestry-incomplete" },
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
// Process parent documents first, independent of snapshot/target completion order.
|
||||
for (const document of facts.documents) {
|
||||
const path: Document[] = [];
|
||||
const visiting = new Set<string>();
|
||||
let current: Document | undefined = document;
|
||||
while (current && !roots.has(current.frame.frameId)) {
|
||||
if (work++ % 256 === 0) {
|
||||
const pending = checkpoint();
|
||||
if (pending) await pending;
|
||||
}
|
||||
if (visiting.has(current.frame.frameId)) {
|
||||
roots.set(current.frame.frameId, {
|
||||
...EMPTY_VISUAL_CONTEXT,
|
||||
issue: "ownership-unresolved",
|
||||
});
|
||||
contexts.set(current.frame.frameId, new Map());
|
||||
break;
|
||||
}
|
||||
visiting.add(current.frame.frameId);
|
||||
path.push(current);
|
||||
current = current.frame.parentFrameId
|
||||
? documents.get(current.frame.parentFrameId)
|
||||
: undefined;
|
||||
}
|
||||
for (let i = path.length - 1; i >= 0; i--) {
|
||||
const doc = path[i];
|
||||
const { frame } = doc;
|
||||
let root: VisualContext = roots.get(frame.frameId) ?? EMPTY_VISUAL_CONTEXT;
|
||||
if (frame.parentFrameId) {
|
||||
const parent = documents.get(frame.parentFrameId);
|
||||
if (
|
||||
!parent ||
|
||||
!roots.has(parent.frame.frameId) ||
|
||||
frame.ownerBackendNodeId === undefined ||
|
||||
!parent.identity
|
||||
) {
|
||||
root = { ...root, issue: "ownership-unresolved" };
|
||||
} else {
|
||||
const owner = parent.index.nodes.get(frame.ownerBackendNodeId);
|
||||
const ownerState = await nodeContext(parent, frame.ownerBackendNodeId);
|
||||
root = {
|
||||
...ownerState.children,
|
||||
// CSS visibility inside a child document cannot override its hidden owner.
|
||||
hidden:
|
||||
ownerState.children.hidden ||
|
||||
owner?.layout?.styles.visibility === "hidden" ||
|
||||
owner?.layout?.styles.visibility === "collapse",
|
||||
// Frame scaling is already interpreted by the shared content-quad projection.
|
||||
transformed: false,
|
||||
localClip: false,
|
||||
unpositionedClip: false,
|
||||
};
|
||||
}
|
||||
} else if (frame.frameId !== facts.rootFrameId)
|
||||
root = { ...root, issue: "ownership-unresolved" };
|
||||
root = {
|
||||
...root,
|
||||
issue:
|
||||
root.issue ??
|
||||
(!doc.identity ? "identity-unverified" : visualProjectionIssue(doc.geometry)),
|
||||
};
|
||||
roots.set(frame.frameId, root);
|
||||
contexts.set(frame.frameId, new Map());
|
||||
}
|
||||
}
|
||||
|
||||
for (const document of facts.documents) {
|
||||
for (const node of document.index.nodes.values()) {
|
||||
if (work++ % 256 === 0) {
|
||||
const pending = checkpoint();
|
||||
if (pending) await pending;
|
||||
}
|
||||
if (node.tag !== "canvas" || document.index.excludedBackendNodeIds.has(node.backendNodeId))
|
||||
continue;
|
||||
// No layout/zero size is positive evidence of no screenshot area for this node.
|
||||
if (!node.layout) continue;
|
||||
const bounds = node.layout.bounds;
|
||||
if (
|
||||
bounds?.length === 4 &&
|
||||
bounds.every(Number.isFinite) &&
|
||||
(bounds[2] <= 0 || bounds[3] <= 0)
|
||||
)
|
||||
continue;
|
||||
const context = (await nodeContext(document, node.backendNodeId)).self;
|
||||
const local = viewportRect(node.localRect);
|
||||
const borderBox =
|
||||
local && document.geometry ? projectVisualBox(local, document.geometry.projections) : null;
|
||||
const region = resolveVisualRegion({
|
||||
borderBox,
|
||||
frameVisibleBox: viewportRect(node.rect),
|
||||
context,
|
||||
visibility: node.layout.styles.visibility,
|
||||
});
|
||||
if (region.status === "unavailable") {
|
||||
issues.push({
|
||||
target: document.frame.target,
|
||||
frameId: document.frame.frameId,
|
||||
backendNodeId: node.backendNodeId,
|
||||
reason: region.reason,
|
||||
});
|
||||
} else if (region.status === "available" && document.identity) {
|
||||
const label = node.attrs["aria-label"]?.trim() || node.attrs.title?.trim();
|
||||
candidates.push({
|
||||
document: document.identity,
|
||||
backendNodeId: node.backendNodeId,
|
||||
parentBackendNodeId: node.parentBackendNodeId,
|
||||
...(label ? { label } : {}),
|
||||
region,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
// AX-only/missing documents have no Canvas nodes to carry the missing evidence.
|
||||
const reportedFrames = new Set(issues.map((issue) => issue.frameId));
|
||||
for (const document of facts.documents) {
|
||||
const reason = roots.get(document.frame.frameId)?.issue;
|
||||
if (
|
||||
reason &&
|
||||
!reportedFrames.has(document.frame.frameId) &&
|
||||
(!document.identity || !document.index.nodes.size)
|
||||
)
|
||||
issues.push({ target: document.frame.target, frameId: document.frame.frameId, reason });
|
||||
}
|
||||
const pending = checkpoint();
|
||||
if (pending) await pending;
|
||||
return {
|
||||
candidates,
|
||||
issues,
|
||||
captureIssues: facts.issues,
|
||||
complete: issues.length === 0 && facts.issues.length === 0,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
import {
|
||||
type GeometryProjection,
|
||||
type Polygon,
|
||||
projectPolygon,
|
||||
rectPolygon,
|
||||
regionBounds,
|
||||
type ViewportRect,
|
||||
} from "../geometry";
|
||||
import type { DocumentGeometry, DocumentIdentity } from "./facts";
|
||||
|
||||
export type VisualIssueReason =
|
||||
| "ancestry-incomplete"
|
||||
| "facts-unavailable"
|
||||
| "geometry-unavailable"
|
||||
| "geometry-unsupported"
|
||||
| "identity-unverified"
|
||||
| "ownership-unresolved";
|
||||
|
||||
/** Top viewport CSS coordinates. Unconstrained axes have infinite bounds. */
|
||||
export interface VisualClip {
|
||||
readonly left: number;
|
||||
readonly top: number;
|
||||
readonly right: number;
|
||||
readonly bottom: number;
|
||||
}
|
||||
|
||||
/** Shared persistent chain: one entry per clipping ancestor, not per Canvas. */
|
||||
export interface VisualClipSource {
|
||||
readonly document: DocumentIdentity;
|
||||
readonly backendNodeId: number;
|
||||
readonly x: boolean;
|
||||
readonly y: boolean;
|
||||
readonly overflowX: string;
|
||||
readonly overflowY: string;
|
||||
readonly box: ViewportRect;
|
||||
readonly parent?: VisualClipSource;
|
||||
}
|
||||
|
||||
export interface VisualContext {
|
||||
readonly clip: VisualClip;
|
||||
readonly clips?: VisualClipSource;
|
||||
readonly hidden: boolean;
|
||||
/** A local CSS scale/zoom makes snapshot client offsets ambiguous. */
|
||||
readonly transformed: boolean;
|
||||
readonly localClip?: boolean;
|
||||
/** Overflow between an absolute target and its nearest positioned ancestor. */
|
||||
readonly unpositionedClip?: boolean;
|
||||
readonly issue?: VisualIssueReason;
|
||||
}
|
||||
|
||||
export const EMPTY_VISUAL_CONTEXT: VisualContext = {
|
||||
clip: { left: -Infinity, top: -Infinity, right: Infinity, bottom: Infinity },
|
||||
hidden: false,
|
||||
transformed: false,
|
||||
};
|
||||
|
||||
function axisRect(polygon: Polygon): boolean {
|
||||
if (polygon.length !== 4 || polygon.some((p) => !Number.isFinite(p.x) || !Number.isFinite(p.y)))
|
||||
return false;
|
||||
const [a, b, c, d] = polygon;
|
||||
return a.y === b.y && b.x === c.x && c.y === d.y && d.x === a.x && b.x > a.x && d.y > a.y;
|
||||
}
|
||||
|
||||
/** Check evidence before projectRectToViewport can reduce a polygon to its bounds. */
|
||||
export function visualProjectionIssue(
|
||||
geometry: DocumentGeometry | undefined,
|
||||
): VisualIssueReason | undefined {
|
||||
if (!geometry || !geometry.projections.length || geometry.pageScale === undefined)
|
||||
return "geometry-unavailable";
|
||||
if (!Number.isFinite(geometry.pageScale) || geometry.pageScale <= 0)
|
||||
return "geometry-unavailable";
|
||||
if (geometry.pageScale !== 1) return "geometry-unsupported";
|
||||
const { layoutUnitsPerCssPixel, scrollCss } = geometry.coordinates;
|
||||
if (
|
||||
!Number.isFinite(layoutUnitsPerCssPixel) ||
|
||||
layoutUnitsPerCssPixel <= 0 ||
|
||||
![scrollCss.x, scrollCss.y].every(Number.isFinite)
|
||||
)
|
||||
return "geometry-unavailable";
|
||||
for (const projection of geometry.projections) {
|
||||
if (
|
||||
![projection.topViewport.width, projection.topViewport.height].every(
|
||||
(n) => Number.isFinite(n) && n > 0,
|
||||
)
|
||||
)
|
||||
return "geometry-unavailable";
|
||||
if (projection.sourceClips.some((clip) => !axisRect(clip))) return "geometry-unsupported";
|
||||
for (const edge of projection.edges) {
|
||||
if (
|
||||
![edge.sourceViewport.width, edge.sourceViewport.height].every(
|
||||
(n) => Number.isFinite(n) && n > 0,
|
||||
)
|
||||
)
|
||||
return "geometry-unavailable";
|
||||
if (!axisRect(edge.destinationQuad) || edge.destinationClips?.some((clip) => !axisRect(clip)))
|
||||
return "geometry-unsupported";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Uses the same projection math as DOM geometry, without clipping away box origins. */
|
||||
export function projectVisualBox(
|
||||
box: ViewportRect,
|
||||
projections: readonly GeometryProjection[],
|
||||
): ViewportRect | null {
|
||||
let polygon: Polygon = rectPolygon({ x: box.x, y: box.y, w: box.width, h: box.height });
|
||||
for (const projection of projections)
|
||||
for (const edge of projection.edges) polygon = projectPolygon(polygon, edge);
|
||||
// Preserve zero-size client boxes: they can prove a fully clipped axis.
|
||||
if (box.width === 0 || box.height === 0) {
|
||||
const [a, , c] = polygon;
|
||||
return { x: a.x, y: a.y, width: c.x - a.x, height: c.y - a.y };
|
||||
}
|
||||
return regionBounds([polygon]);
|
||||
}
|
||||
|
||||
function axisTransformScale(value: string): [number, number] | null {
|
||||
if (value === "none") return [1, 1];
|
||||
const match = /^matrix(3d)?\(([^)]+)\)$/.exec(value);
|
||||
if (!match) return null;
|
||||
const values = match[2].split(",").map((part) => Number(part.trim()));
|
||||
if (!values.every(Number.isFinite)) return null;
|
||||
if (match[1])
|
||||
return values.length === 16 &&
|
||||
values[0] > 0 &&
|
||||
values[5] > 0 &&
|
||||
values[10] === 1 &&
|
||||
values[15] === 1 &&
|
||||
[1, 2, 3, 4, 6, 7, 8, 9, 11, 14].every((index) => values[index] === 0)
|
||||
? [values[0], values[5]]
|
||||
: null;
|
||||
return values.length === 6 && values[0] > 0 && values[3] > 0 && values[1] === 0 && values[2] === 0
|
||||
? [values[0], values[3]]
|
||||
: null;
|
||||
}
|
||||
|
||||
export interface VisualAncestor {
|
||||
readonly document: DocumentIdentity;
|
||||
readonly backendNodeId: number;
|
||||
readonly styles: Readonly<Record<string, string>>;
|
||||
/** Already in top viewport CSS units, from a source-specific adapter. */
|
||||
readonly clientBox?: ViewportRect | null;
|
||||
}
|
||||
|
||||
/** One ancestor step, reusable by discovery and the future live local adapter. */
|
||||
export function extendVisualContext(
|
||||
parent: VisualContext,
|
||||
node: VisualAncestor,
|
||||
clipContents = true,
|
||||
): VisualContext {
|
||||
const styles = node.styles;
|
||||
const opacity = styles.opacity?.trim() ? Number(styles.opacity) : NaN;
|
||||
const zoom = styles.zoom === "normal" ? 1 : styles.zoom?.trim() ? Number(styles.zoom) : NaN;
|
||||
const scale =
|
||||
styles.scale === "none" ? [1] : (styles.scale ?? "").trim().split(/\s+/).map(Number);
|
||||
const scaleSupported =
|
||||
scale.length >= 1 &&
|
||||
scale.length <= 3 &&
|
||||
scale.every((n) => Number.isFinite(n) && n > 0) &&
|
||||
(scale.length < 3 || scale[2] === 1);
|
||||
const transformScale = axisTransformScale(styles.transform ?? "");
|
||||
// Identity/translation changes origins, which bounds already capture, but
|
||||
// leaves client offsets in the same units. Only scaling makes them ambiguous.
|
||||
const transformed =
|
||||
parent.transformed ||
|
||||
transformScale?.some((n) => n !== 1) === true ||
|
||||
zoom !== 1 ||
|
||||
scale.some((n) => n !== 1);
|
||||
const hidden = parent.hidden || opacity === 0 || styles.display === "none";
|
||||
let issue = parent.issue;
|
||||
if (
|
||||
!Number.isFinite(opacity) ||
|
||||
!Number.isFinite(zoom) ||
|
||||
zoom <= 0 ||
|
||||
!styles.display ||
|
||||
!styles.visibility
|
||||
)
|
||||
issue ??= "facts-unavailable";
|
||||
if (!styles.transform || !styles["clip-path"] || !styles["mask-image"])
|
||||
issue ??= "facts-unavailable";
|
||||
else if (!transformScale || styles["clip-path"] !== "none" || styles["mask-image"] !== "none")
|
||||
issue ??= "geometry-unsupported";
|
||||
|
||||
if (
|
||||
!["rotate", "scale", "perspective", "clip", "contain", "overflow-clip-margin"].every(
|
||||
(key) => styles[key],
|
||||
)
|
||||
)
|
||||
issue ??= "facts-unavailable";
|
||||
else if (
|
||||
!scaleSupported ||
|
||||
!["none", "0deg"].includes(styles.rotate) ||
|
||||
styles.perspective !== "none" ||
|
||||
styles.clip !== "auto" ||
|
||||
/(?:^|\s)(paint|strict|content)(?:$|\s)/.test(styles.contain)
|
||||
)
|
||||
issue ??= "geometry-unsupported";
|
||||
// Do not pretend every DOM ancestor clips out-of-flow descendants. Support
|
||||
// the ordinary positioned-container case; other containing-block cases stay explicit.
|
||||
if (
|
||||
(styles.position === "absolute" && parent.unpositionedClip) ||
|
||||
(styles.position === "fixed" && parent.localClip)
|
||||
)
|
||||
issue ??= "geometry-unsupported";
|
||||
const overflow = [styles["overflow-x"], styles["overflow-y"]];
|
||||
if (clipContents && overflow.includes("clip") && styles["overflow-clip-margin"] !== "0px")
|
||||
issue ??= "geometry-unsupported";
|
||||
if (
|
||||
overflow.some(
|
||||
(value) => !["visible", "hidden", "clip", "scroll", "auto", "overlay"].includes(value),
|
||||
)
|
||||
)
|
||||
issue ??= "facts-unavailable";
|
||||
const [x, y] = overflow.map((value) => value !== "visible");
|
||||
let clip = parent.clip;
|
||||
let clips = parent.clips;
|
||||
if (clipContents && (x || y)) {
|
||||
if (transformed) issue ??= "geometry-unsupported";
|
||||
const box = node.clientBox;
|
||||
if (
|
||||
!box ||
|
||||
![box.x, box.y, box.width, box.height].every(Number.isFinite) ||
|
||||
box.width < 0 ||
|
||||
box.height < 0
|
||||
)
|
||||
issue ??= "geometry-unavailable";
|
||||
else {
|
||||
clip = {
|
||||
left: x ? Math.max(clip.left, box.x) : clip.left,
|
||||
right: x ? Math.min(clip.right, box.x + box.width) : clip.right,
|
||||
top: y ? Math.max(clip.top, box.y) : clip.top,
|
||||
bottom: y ? Math.min(clip.bottom, box.y + box.height) : clip.bottom,
|
||||
};
|
||||
clips = {
|
||||
document: node.document,
|
||||
backendNodeId: node.backendNodeId,
|
||||
x,
|
||||
y,
|
||||
overflowX: styles["overflow-x"],
|
||||
overflowY: styles["overflow-y"],
|
||||
box,
|
||||
parent: clips,
|
||||
};
|
||||
}
|
||||
}
|
||||
const clipsHere = clipContents && (x || y);
|
||||
return {
|
||||
hidden,
|
||||
transformed,
|
||||
issue,
|
||||
clip,
|
||||
clips,
|
||||
localClip: parent.localClip || clipsHere,
|
||||
unpositionedClip:
|
||||
styles.position !== "static" ||
|
||||
styles.transform !== "none" ||
|
||||
/(?:^|\s)layout(?:$|\s)/.test(styles.contain ?? "")
|
||||
? false
|
||||
: parent.unpositionedClip || clipsHere,
|
||||
};
|
||||
}
|
||||
|
||||
/** A page screenshot rectangle, not an exact mask of visible Canvas pixels.
|
||||
* Rounded corners are rendered by the browser and do not invalidate this range. */
|
||||
export type VisualRegionResult =
|
||||
| { status: "available"; borderBox: ViewportRect; crop: ViewportRect; clips?: VisualClipSource }
|
||||
| { status: "empty" }
|
||||
| { status: "unavailable"; reason: VisualIssueReason };
|
||||
|
||||
/** Box and frameVisibleBox must come from the same box kind (Canvas border-box).
|
||||
* Frame/viewport clipping is supplied by the shared geometry adapter. */
|
||||
export function resolveVisualRegion(input: {
|
||||
borderBox: ViewportRect | null;
|
||||
frameVisibleBox: ViewportRect | null;
|
||||
context: VisualContext;
|
||||
visibility: string;
|
||||
}): VisualRegionResult {
|
||||
const { borderBox, frameVisibleBox, context, visibility } = input;
|
||||
if (context.hidden || visibility === "hidden" || visibility === "collapse")
|
||||
return { status: "empty" };
|
||||
if (context.issue) return { status: "unavailable", reason: context.issue };
|
||||
if (visibility !== "visible") return { status: "unavailable", reason: "facts-unavailable" };
|
||||
if (!borderBox) return { status: "unavailable", reason: "geometry-unavailable" };
|
||||
if (!frameVisibleBox) return { status: "empty" };
|
||||
if (
|
||||
![
|
||||
borderBox.x,
|
||||
borderBox.y,
|
||||
borderBox.width,
|
||||
borderBox.height,
|
||||
frameVisibleBox.x,
|
||||
frameVisibleBox.y,
|
||||
frameVisibleBox.width,
|
||||
frameVisibleBox.height,
|
||||
].every(Number.isFinite)
|
||||
)
|
||||
return { status: "unavailable", reason: "geometry-unavailable" };
|
||||
if (
|
||||
borderBox.width <= 0 ||
|
||||
borderBox.height <= 0 ||
|
||||
frameVisibleBox.width < 0 ||
|
||||
frameVisibleBox.height < 0 ||
|
||||
Object.values(context.clip).some(Number.isNaN)
|
||||
)
|
||||
return { status: "unavailable", reason: "geometry-unavailable" };
|
||||
const x = Math.max(frameVisibleBox.x, context.clip.left);
|
||||
const y = Math.max(frameVisibleBox.y, context.clip.top);
|
||||
const right = Math.min(frameVisibleBox.x + frameVisibleBox.width, context.clip.right);
|
||||
const bottom = Math.min(frameVisibleBox.y + frameVisibleBox.height, context.clip.bottom);
|
||||
return right > x && bottom > y
|
||||
? {
|
||||
status: "available",
|
||||
borderBox,
|
||||
crop: { x, y, width: right - x, height: bottom - y },
|
||||
clips: context.clips,
|
||||
}
|
||||
: { status: "empty" };
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
# OOPIF occupied-scrollbar regression
|
||||
|
||||
An iframe's content quad includes its child viewport's scrollbar space, while
|
||||
`Page.getLayoutMetrics().cssLayoutViewport` excludes that space. Mapping the latter
|
||||
onto the whole quad stretches positions and sizes. The full target-local viewport
|
||||
must determine scale; the visible viewport must still clip content at every OOPIF
|
||||
boundary and constrain target-local action points.
|
||||
|
||||
This fixture alternates loopback hostnames across two nested OOPIFs. It includes
|
||||
scrolling, borders, padding, scaled iframe owners, a partially clipped button and
|
||||
a fully clipped button. Custom scrollbars occupy different widths and heights.
|
||||
The `scrollbars` query parameter accepts `both` (default), `vertical`, `horizontal`
|
||||
or `none`.
|
||||
|
||||
Run the numerical regression with Node 22+ and a local Chrome executable:
|
||||
|
||||
```sh
|
||||
BSK_GEOMETRY_CHROME=/path/to/chrome pnpm --filter @browser-skill/extension exec vitest run \
|
||||
src/tools/__tests__/snapshot-coordinates.browser.test.ts
|
||||
```
|
||||
|
||||
The existing browser runner is shared with the snapshot-unit regression. The test:
|
||||
|
||||
- Verifies actual OOPIF targets and occupied scrollbar dimensions.
|
||||
- Compares snapshot and live geometry with independent DOM rectangles and clipping.
|
||||
- Dispatches real root-target clicks and verifies the intended frame/button received them.
|
||||
- Rejects fully clipped controls and checks snapshot measurement reuse per target.
|
||||
- Covers five device-scale/browser-zoom combinations plus single-axis and no-scrollbar cases.
|
||||
|
||||
The runner creates and removes isolated browser profiles. It is opt-in and skipped
|
||||
in normal unit runs when `BSK_GEOMETRY_CHROME` is unset.
|
||||
|
||||
Run the CLI fixture smoke with a connected test extension:
|
||||
|
||||
```sh
|
||||
BSK_AUTO_UPDATE=off pnpm eval:browser smoke --case oopif-scrollbars --bsk ./target/debug/bsk
|
||||
```
|
||||
|
||||
The smoke assertions verify both nested frames have occupied scrollbars, that the
|
||||
marker is observed and that the session is closed. Numeric geometry and actual
|
||||
click assertions are exercised by the browser test above, not by smoke alone.
|
||||
@@ -1,39 +0,0 @@
|
||||
{
|
||||
"$schema": "../../../schemas/case.schema.json",
|
||||
"schemaVersion": 1,
|
||||
"id": "oopif-scrollbars",
|
||||
"title": "Nested OOPIFs with occupied scrollbars and clipped controls",
|
||||
"suite": "regression",
|
||||
"tags": ["geometry", "iframe", "scroll"],
|
||||
"fixture": { "startPath": "/oopif-scrollbars" },
|
||||
"prompts": {
|
||||
"en": "Open {url}, observe the page and its frames, report the OOPIF-SCROLLBARS marker, then close the session.",
|
||||
"zh-CN": "打开 {url},观察页面及其 iframe,报告 OOPIF-SCROLLBARS 标记,然后关闭会话。"
|
||||
},
|
||||
"coverage": ["session.start", "session.stop", "page.navigate", "inspect.observe"],
|
||||
"assertions": {
|
||||
"site": [
|
||||
{
|
||||
"label": "nested frame fixture settled",
|
||||
"type": "geometry.ready",
|
||||
"where": { "data.root": true },
|
||||
"minCount": 1
|
||||
},
|
||||
{
|
||||
"label": "both child frames have occupied scrollbars",
|
||||
"type": "geometry.scrollbars",
|
||||
"where": { "data.vertical": true, "data.horizontal": true },
|
||||
"minCount": 2
|
||||
}
|
||||
],
|
||||
"response": [{ "label": "observed the fixture marker", "includes": "OOPIF-SCROLLBARS" }],
|
||||
"adapter": [{ "label": "browser session was closed", "key": "sessionStopped" }]
|
||||
},
|
||||
"smoke": {
|
||||
"steps": [
|
||||
{ "action": "navigate" },
|
||||
{ "action": "wait-site-event", "type": "geometry.ready", "where": { "root": true } },
|
||||
{ "action": "observe" }
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
import { page, withRun } from "../../../lib/fixtures.mjs";
|
||||
|
||||
export default {
|
||||
id: "oopif-scrollbars",
|
||||
routes: ["/oopif-scrollbars", "/oopif-scrollbars/frame", "/oopif-scrollbars/nested"],
|
||||
render({ pathname, runId, query }) {
|
||||
const root = pathname === "/oopif-scrollbars";
|
||||
const nested = pathname.endsWith("/nested");
|
||||
const mode = query.get("scrollbars") ?? "both";
|
||||
return page({
|
||||
title: "OOPIF scrollbar geometry regression",
|
||||
body: `
|
||||
<style>
|
||||
main { margin: 0; width: auto; }
|
||||
body { width: 2000px; height: 2400px; }
|
||||
html { overflow-anchor: none; }
|
||||
${!root ? `html { overflow-x: ${mode === "vertical" || mode === "none" ? "hidden" : "scroll"}; overflow-y: ${mode === "horizontal" || mode === "none" ? "hidden" : "scroll"}; } html::-webkit-scrollbar { width: 17px; height: 11px; }` : ""}
|
||||
button { position: absolute; padding: 0; border: 0; border-radius: 0; }
|
||||
#probe { left: ${root ? 180 : nested ? 30 : 100}px; top: ${root ? 360 : nested ? 40 : 160}px; width: 60px; height: 20px; }
|
||||
#edge { position: fixed; right: -20px; bottom: -15px; width: 80px; height: 60px; }
|
||||
#outside { position: fixed; left: calc(100% + 2px); top: calc(100% + 2px); width: 10px; height: 10px; }
|
||||
iframe { position: absolute; box-sizing: content-box; width: 420px; height: 320px;
|
||||
left: 340px; top: 400px; border: 6px solid black; padding: 8px; transform: scale(1.2); transform-origin: 0 0; }
|
||||
#nested { left: 150px; top: 210px; width: 200px; height: 120px; border-width: 4px; padding: 6px; transform: scale(0.8); }
|
||||
</style>
|
||||
<button id="probe" data-geometry-probe>OOPIF-SCROLLBARS</button>
|
||||
${!root ? '<button id="edge" data-geometry-probe>EDGE</button><button id="outside" data-geometry-probe>OUTSIDE</button>' : ""}
|
||||
${!nested ? `<iframe id="${root ? "cross" : "nested"}" name="${root ? "cross" : "nested"}" title="${root ? "outer" : "nested"} cross-site frame"></iframe>` : ""}
|
||||
`,
|
||||
script: `
|
||||
history.scrollRestoration = "manual";
|
||||
const child = document.querySelector("iframe");
|
||||
if (child) {
|
||||
const url = new URL(${JSON.stringify(withRun(root ? "/oopif-scrollbars/frame" : "/oopif-scrollbars/nested", runId, { scrollbars: mode }))}, location.href);
|
||||
url.hostname = location.hostname === "127.0.0.1" ? "localhost" : "127.0.0.1";
|
||||
child.src = url.href;
|
||||
}
|
||||
document.addEventListener("click", event => {
|
||||
const probe = event.target.closest("[data-geometry-probe]");
|
||||
if (probe) browserEval.send("geometry.clicked", { probe: probe.id });
|
||||
});
|
||||
window.addEventListener("load", () => {
|
||||
scrollTo(${root ? "80, 240" : nested ? "10, 20" : "40, 100"});
|
||||
requestAnimationFrame(() => requestAnimationFrame(() => {
|
||||
document.documentElement.dataset.geometryReady = "true";
|
||||
if (!${root}) browserEval.send("geometry.scrollbars", {
|
||||
vertical: innerWidth > document.documentElement.clientWidth,
|
||||
horizontal: innerHeight > document.documentElement.clientHeight,
|
||||
});
|
||||
browserEval.send("geometry.ready", { root: ${root} });
|
||||
}));
|
||||
});
|
||||
`,
|
||||
});
|
||||
},
|
||||
};
|
||||
@@ -33,9 +33,12 @@ BSK_AUTO_UPDATE=off pnpm eval:browser smoke --case snapshot-coordinates --bsk ./
|
||||
Smoke alone does **not** certify coordinate accuracy; CLI observations do not expose raw boxes.
|
||||
Use the geometric test above for the regression's numeric assertions.
|
||||
|
||||
## Related scrollbar regression
|
||||
## Separate existing boundary
|
||||
|
||||
The unit-conversion fixture keeps non-occupying OOPIF scrollbars by default. The same
|
||||
browser test also runs the dedicated [OOPIF scrollbar fixture](../oopif-scrollbars/README.md),
|
||||
which covers occupied scrollbars, two OOPIF boundaries, clipping and real clicks.
|
||||
Append `&classic-scrollbars` to this fixture's URL to enable its normal OOPIF scrollbars.
|
||||
The OOPIF root uses non-occupying scrollbars in the unit-conversion regression. Root and
|
||||
same-process frames retain normal scrollbars. Append `&classic-scrollbars` to the fixture URL
|
||||
to reproduce the separate existing OOPIF projection issue: `targetProjection()` maps the CSS
|
||||
layout viewport (which excludes occupying scrollbars) onto the entire owner content quad.
|
||||
This inflates the projected coordinates when scrollbars occupy space. Main already has that
|
||||
mapping; fixing it also changes shared live geometry and is outside this snapshot-unit fix.
|
||||
The test does not relax its numeric tolerance to absorb that error.
|
||||
@@ -41,23 +41,22 @@ test("case manifests are discovered, ordered, and grouped into suites", () => {
|
||||
"diagnostics",
|
||||
"mobile-emulation",
|
||||
"generated-form",
|
||||
"oopif-scrollbars",
|
||||
"snapshot-coordinates",
|
||||
],
|
||||
);
|
||||
assert.deepEqual(repositorySummary(cases, fixtureRegistry).suites, {
|
||||
core: 6,
|
||||
matrix: 1,
|
||||
regression: 2,
|
||||
regression: 1,
|
||||
});
|
||||
});
|
||||
|
||||
test("repository validation links every case to a fixture and valid workflow evidence", () => {
|
||||
assert.deepEqual(validateRepositoryCases(cases, fixtureRegistry), []);
|
||||
const summary = repositorySummary(cases, fixtureRegistry);
|
||||
assert.equal(summary.cases, 9);
|
||||
assert.equal(summary.fixtureModules, 10);
|
||||
assert.equal(summary.fixtureRoutes, 18);
|
||||
assert.equal(summary.cases, 8);
|
||||
assert.equal(summary.fixtureModules, 9);
|
||||
assert.equal(summary.fixtureRoutes, 15);
|
||||
});
|
||||
|
||||
test("manifest validation rejects unknown operations and incomplete workflow steps", () => {
|
||||
|
||||
+34
-57
@@ -38,17 +38,11 @@ function Write-Die {
|
||||
# ── Platform / architecture detection ─────────────────────────────────────────
|
||||
|
||||
function Get-PlatformTriple {
|
||||
# RuntimeInformation.ProcessArchitecture can be unavailable in Windows PowerShell 5.1.
|
||||
# WOW64 exposes the native architecture separately from the 32-bit process.
|
||||
$arch = $env:PROCESSOR_ARCHITEW6432
|
||||
if (-not $arch) { $arch = $env:PROCESSOR_ARCHITECTURE }
|
||||
if (-not $arch) {
|
||||
Write-Die "could not detect Windows architecture: PROCESSOR_ARCHITEW6432 and PROCESSOR_ARCHITECTURE are empty"
|
||||
}
|
||||
$arch = [System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture
|
||||
|
||||
switch ($arch) {
|
||||
"AMD64" { $archId = "x64" }
|
||||
"ARM64" { $archId = "arm64" }
|
||||
"X64" { $archId = "x64" }
|
||||
"Arm64" { $archId = "arm64" }
|
||||
default { Write-Die "unsupported architecture: $arch (x64 and ARM64 only)" }
|
||||
}
|
||||
|
||||
@@ -73,21 +67,25 @@ function Add-ToUserPath {
|
||||
|
||||
$currentUserPath = @([Environment]::GetEnvironmentVariable("PATH", "User") -split ";" | Where-Object { $_ })
|
||||
|
||||
$newUserPath = (@($Dir) + @($currentUserPath | Where-Object { $_ -ine $Dir })) -join ";"
|
||||
if (($currentUserPath -join ";") -ceq $newUserPath) {
|
||||
Write-Log "$Dir is already first in your user PATH"
|
||||
if ($currentUserPath -contains $Dir) {
|
||||
Write-Log "$Dir is already in your user PATH"
|
||||
return
|
||||
}
|
||||
|
||||
$newUserPath = ($currentUserPath + $Dir) -join ";"
|
||||
[Environment]::SetEnvironmentVariable("PATH", $newUserPath, "User")
|
||||
Write-Log "placed ${Dir} first in user PATH"
|
||||
Write-Log "added ${Dir} to user PATH"
|
||||
}
|
||||
|
||||
function Add-ToSessionPath {
|
||||
param([string]$Dir)
|
||||
|
||||
$pathEntries = @($env:PATH -split ";" | Where-Object { $_ -and $_ -ine $Dir })
|
||||
$env:PATH = (@($Dir) + $pathEntries) -join ";"
|
||||
$pathEntries = $env:PATH -split ";" | Where-Object { $_ }
|
||||
if ($pathEntries -contains $Dir) {
|
||||
return
|
||||
}
|
||||
|
||||
$env:PATH = "$Dir;$env:PATH"
|
||||
}
|
||||
|
||||
# ── Git Bash (bash environment) PATH helper ──────────────────────────────────
|
||||
@@ -128,19 +126,14 @@ function Install-Binary {
|
||||
$staged = "$Target.install-$([Guid]::NewGuid().ToString('N'))"
|
||||
try {
|
||||
[System.IO.File]::Copy($Source, $staged)
|
||||
# The running daemon may come from another installation directory.
|
||||
# Use the downloaded CLI: older versions have broken Windows liveness checks.
|
||||
# Stop verifies daemon identity and uses the current BSK_HOME.
|
||||
# Fail closed for both new installs and replacements; never discard daemon metadata here.
|
||||
& $Source daemon stop
|
||||
if ($LASTEXITCODE -ne 0) {
|
||||
$daemonHome = if ($env:BSK_HOME) { $env:BSK_HOME } else { Join-Path $HOME ".bsk" }
|
||||
$daemonInfoPath = $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath((Join-Path $daemonHome "daemon.json"))
|
||||
throw "could not stop bsk daemon; installation was not changed. Stop any running bsk daemon, remove '$daemonInfoPath', then retry the installer."
|
||||
}
|
||||
if ([System.IO.File]::Exists($Target)) {
|
||||
# Use the downloaded CLI: older versions have broken Windows
|
||||
# liveness checks. Stop verifies daemon identity before terminating it.
|
||||
& $Source daemon stop
|
||||
if ($LASTEXITCODE -ne 0) { throw "could not stop bsk daemon; existing installation was not replaced" }
|
||||
# PowerShell 5.1 converts $null to an empty path for string parameters.
|
||||
[System.IO.File]::Replace($staged, $Target, [NullString]::Value)
|
||||
Write-Log "daemon will restart automatically on the next browser command"
|
||||
}
|
||||
else {
|
||||
[System.IO.File]::Move($staged, $Target)
|
||||
@@ -173,20 +166,14 @@ function Main {
|
||||
Write-Log "latest version is ${version}"
|
||||
}
|
||||
|
||||
$platformKey = $platform.PlatformKey
|
||||
$asset = $null
|
||||
if ($manifest -and $manifest.assets) {
|
||||
$asset = $manifest.assets.$platformKey
|
||||
}
|
||||
# ARM64 is not in the current release matrix. Require a published entry
|
||||
# before attempting it, while preserving legacy x64 installs without a manifest.
|
||||
if ($platform.ArchId -eq "arm64" -and -not $asset) {
|
||||
Write-Die "version.json does not list a Windows ARM64 package for bsk $version"
|
||||
}
|
||||
|
||||
$archiveName = "bsk-v${version}-$($platform.TargetTriple).zip"
|
||||
$downloadUrl = "${GitHub}/releases/download/${tag}/${archiveName}"
|
||||
$expectedSha = if ($asset) { $asset.sha256 } else { $null }
|
||||
|
||||
$expectedSha = $null
|
||||
$platformKey = $platform.PlatformKey
|
||||
if ($manifest -and $manifest.assets) {
|
||||
$expectedSha = $manifest.assets.$platformKey.sha256
|
||||
}
|
||||
if (-not $expectedSha) {
|
||||
if (-not $manifest) {
|
||||
Write-Log "warning: could not fetch version.json; skipping checksum verification"
|
||||
@@ -197,21 +184,17 @@ function Main {
|
||||
}
|
||||
|
||||
$tempDir = Join-Path ([System.IO.Path]::GetTempPath()) ([System.IO.Path]::GetRandomFileName())
|
||||
[System.IO.Directory]::CreateDirectory($tempDir) | Out-Null
|
||||
New-Item -ItemType Directory -Path $tempDir -Force | Out-Null
|
||||
|
||||
try {
|
||||
$archivePath = Join-Path $tempDir $archiveName
|
||||
|
||||
Write-Log "downloading ${downloadUrl}"
|
||||
# PowerShell 5.1's -OutFile treats brackets as wildcards. Write raw HTTP bytes literally.
|
||||
$response = Invoke-WebRequest -Uri $downloadUrl -UseBasicParsing -ErrorAction Stop
|
||||
try {
|
||||
[System.IO.File]::WriteAllBytes($archivePath, $response.RawContentStream.ToArray())
|
||||
} finally { $response.RawContentStream.Dispose() }
|
||||
Invoke-WebRequest -Uri $downloadUrl -OutFile $archivePath -UseBasicParsing -ErrorAction Stop
|
||||
|
||||
if ($expectedSha) {
|
||||
Write-Log "verifying checksum"
|
||||
$actualSha = (Get-FileHash -Algorithm SHA256 -LiteralPath $archivePath).Hash
|
||||
$actualSha = (Get-FileHash -Algorithm SHA256 -Path $archivePath).Hash
|
||||
if ($actualSha -ieq $expectedSha) {
|
||||
Write-Log "checksum OK"
|
||||
}
|
||||
@@ -221,15 +204,15 @@ function Main {
|
||||
}
|
||||
|
||||
Write-Log "extracting ${archiveName}"
|
||||
# PowerShell 5.1's Expand-Archive treats the destination as a wildcard path.
|
||||
Add-Type -AssemblyName System.IO.Compression.FileSystem
|
||||
[System.IO.Compression.ZipFile]::ExtractToDirectory($archivePath, $tempDir)
|
||||
Expand-Archive -Path $archivePath -DestinationPath $tempDir -Force
|
||||
|
||||
if (-not (Test-Path -LiteralPath (Join-Path $tempDir "bsk.exe"))) {
|
||||
if (-not (Test-Path (Join-Path $tempDir "bsk.exe"))) {
|
||||
Write-Die "bsk.exe not found in archive"
|
||||
}
|
||||
|
||||
[System.IO.Directory]::CreateDirectory($InstallDir) | Out-Null
|
||||
if (-not (Test-Path $InstallDir)) {
|
||||
New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null
|
||||
}
|
||||
|
||||
Install-Binary -Source (Join-Path $tempDir "bsk.exe") -Target (Join-Path $InstallDir "bsk.exe")
|
||||
|
||||
@@ -249,18 +232,12 @@ function Main {
|
||||
& $bskPath --version
|
||||
if ($LASTEXITCODE -ne 0) { throw "installed bsk failed verification" }
|
||||
|
||||
$command = Get-Command bsk -ErrorAction SilentlyContinue
|
||||
if (-not $command -or $command.CommandType -ne "Application" -or $command.Source -ine $bskPath) {
|
||||
Write-Log "warning: 'bsk' does not resolve to $bskPath in this session; check Get-Command bsk -All for a conflicting command"
|
||||
}
|
||||
|
||||
Write-Log "done"
|
||||
Write-Host ""
|
||||
Write-Host "This PATH check covers the current session only; a new terminal may prefer a Machine PATH entry or alias."
|
||||
Write-Host "In a new PowerShell terminal, run Get-Command bsk -All and confirm the first result is $bskPath."
|
||||
Write-Host "Open a new terminal (PowerShell / Git Bash) for PATH changes to take full effect."
|
||||
}
|
||||
finally {
|
||||
Remove-Item -LiteralPath $tempDir -Recurse -Force -ErrorAction SilentlyContinue
|
||||
Remove-Item -Recurse -Force $tempDir -ErrorAction SilentlyContinue
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,11 +1,8 @@
|
||||
#Requires -Version 5.1
|
||||
param(
|
||||
[string]$BskPath = (Join-Path $PSScriptRoot "../target/debug/bsk.exe"),
|
||||
[switch]$HelpersOnly
|
||||
)
|
||||
param([string]$BskPath = (Join-Path $PSScriptRoot "../target/debug/bsk.exe"))
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
# Load definitions without running Main. Registry PATH writes are isolated below.
|
||||
# Load definitions, never Main: no downloads or changes to the real user PATH.
|
||||
$installer = Join-Path $PSScriptRoot "../install.ps1"
|
||||
$tokens = $null
|
||||
$errors = $null
|
||||
@@ -24,88 +21,27 @@ foreach ($statement in $ast.EndBlock.Statements) {
|
||||
function Assert-Equal($Actual, $Expected) {
|
||||
if ($Actual -cne $Expected) { throw "expected [$Expected], got [$Actual]" }
|
||||
}
|
||||
function Assert-Fails([scriptblock]$Action, [string]$MessageContains) {
|
||||
function Assert-Fails([scriptblock]$Action) {
|
||||
$failed = $false
|
||||
try { & $Action } catch {
|
||||
$failed = $true
|
||||
if ($MessageContains -and -not $_.Exception.Message.Contains($MessageContains)) { throw }
|
||||
}
|
||||
try { & $Action } catch { $failed = $true }
|
||||
if (-not $failed) { throw "expected failure" }
|
||||
}
|
||||
|
||||
# Isolate the fatal-error stub and restore the real process environment.
|
||||
& {
|
||||
function Write-Die([string]$Message) { throw $Message }
|
||||
$oldProcessArch = $env:PROCESSOR_ARCHITECTURE
|
||||
$oldNativeArch = $env:PROCESSOR_ARCHITEW6432
|
||||
try {
|
||||
$cases = @(
|
||||
@{ Process = 'AMD64'; Native = $null; Arch = 'x64'; Triple = 'x86_64-pc-windows-msvc' }
|
||||
@{ Process = 'ARM64'; Native = $null; Arch = 'arm64'; Triple = 'aarch64-pc-windows-msvc' }
|
||||
@{ Process = 'amd64'; Native = $null; Arch = 'x64'; Triple = 'x86_64-pc-windows-msvc' }
|
||||
@{ Process = 'x86'; Native = 'AMD64'; Arch = 'x64'; Triple = 'x86_64-pc-windows-msvc' }
|
||||
@{ Process = 'x86'; Native = 'ARM64'; Arch = 'arm64'; Triple = 'aarch64-pc-windows-msvc' }
|
||||
@{ Process = $null; Native = 'AMD64'; Arch = 'x64'; Triple = 'x86_64-pc-windows-msvc' }
|
||||
@{ Process = 'x86'; Native = $null; Error = 'unsupported architecture: x86 (x64 and ARM64 only)' }
|
||||
@{ Process = 'AMD64'; Native = 'IA64'; Error = 'unsupported architecture: IA64 (x64 and ARM64 only)' }
|
||||
@{ Process = $null; Native = $null; Error = 'could not detect Windows architecture: PROCESSOR_ARCHITEW6432 and PROCESSOR_ARCHITECTURE are empty' }
|
||||
)
|
||||
foreach ($case in $cases) {
|
||||
$env:PROCESSOR_ARCHITECTURE = $case.Process
|
||||
$env:PROCESSOR_ARCHITEW6432 = $case.Native
|
||||
if ($case.Error) {
|
||||
$message = $null
|
||||
try { Get-PlatformTriple | Out-Null } catch { $message = $_.Exception.Message }
|
||||
Assert-Equal $message $case.Error
|
||||
}
|
||||
else {
|
||||
$platform = Get-PlatformTriple
|
||||
Assert-Equal $platform.ArchId $case.Arch
|
||||
Assert-Equal $platform.TargetTriple $case.Triple
|
||||
Assert-Equal $platform.PlatformKey "windows-$($case.Arch)"
|
||||
}
|
||||
}
|
||||
Write-Host "Windows installer architecture regressions passed ($($PSVersionTable.PSVersion))"
|
||||
}
|
||||
finally {
|
||||
$env:PROCESSOR_ARCHITECTURE = $oldProcessArch
|
||||
$env:PROCESSOR_ARCHITEW6432 = $oldNativeArch
|
||||
}
|
||||
}
|
||||
$dir = 'C:\Users\Alice\.local\bin'
|
||||
$pathCases = @(
|
||||
@{ Existing = ''; Expected = $dir }
|
||||
@{ Existing = 'C:\WindowsApps'; Expected = "$dir;C:\WindowsApps" }
|
||||
@{ Existing = 'C:\A;C:\B'; Expected = "$dir;C:\A;C:\B" }
|
||||
@{ Existing = "C:\old-bsk;$dir;C:\B;$($dir.ToUpperInvariant())"; Expected = "$dir;C:\old-bsk;C:\B" }
|
||||
)
|
||||
$oldPath = $env:PATH
|
||||
try {
|
||||
foreach ($case in $pathCases) {
|
||||
$script:UserPath = $case.Existing
|
||||
$env:PATH = $case.Existing
|
||||
foreach ($attempt in 1..2) {
|
||||
Add-ToUserPath $dir
|
||||
Add-ToSessionPath $dir
|
||||
Assert-Equal $script:UserPath $case.Expected
|
||||
Assert-Equal $env:PATH $case.Expected
|
||||
}
|
||||
}
|
||||
} finally { $env:PATH = $oldPath }
|
||||
if ($HelpersOnly) {
|
||||
Write-Host "Windows installer helper regressions passed ($($PSVersionTable.PSVersion))"
|
||||
return
|
||||
foreach ($existing in @('', 'C:\WindowsApps', 'C:\A;C:\B')) {
|
||||
$script:UserPath = $existing
|
||||
Add-ToUserPath $dir
|
||||
$expected = if ($existing) { "$existing;$dir" } else { $dir }
|
||||
Assert-Equal $script:UserPath $expected
|
||||
Add-ToUserPath $dir
|
||||
Assert-Equal $script:UserPath $expected
|
||||
}
|
||||
|
||||
$root = Join-Path ([IO.Path]::GetTempPath()) ("bsk-install-test-" + [Guid]::NewGuid().ToString('N'))
|
||||
[IO.Directory]::CreateDirectory($root) | Out-Null
|
||||
$oldBskHome = $env:BSK_HOME
|
||||
$oldAutoUpdate = $env:BSK_AUTO_UPDATE
|
||||
$oldVersion = $env:BSK_VERSION
|
||||
$oldProcessArch = $env:PROCESSOR_ARCHITECTURE
|
||||
$oldNativeArch = $env:PROCESSOR_ARCHITEW6432
|
||||
$daemon = $null
|
||||
$script:DownloadServer = $null
|
||||
try {
|
||||
$utf8 = New-Object System.Text.UTF8Encoding($false)
|
||||
$bashRc = Join-Path $root ".bashrc"
|
||||
@@ -130,7 +66,7 @@ try {
|
||||
if ($LASTEXITCODE -ne 0) { throw "Git Bash failed" }
|
||||
Assert-Equal $actual ('/c' + $special.Substring(2).Replace('\', '/'))
|
||||
|
||||
$env:BSK_HOME = Join-Path $root "home [state]"
|
||||
$env:BSK_HOME = Join-Path $root "home"
|
||||
$env:BSK_AUTO_UPDATE = "off"
|
||||
[IO.Directory]::CreateDirectory($env:BSK_HOME) | Out-Null
|
||||
$sourceDir = Join-Path $root "download"
|
||||
@@ -140,8 +76,7 @@ try {
|
||||
$targetDir = Join-Path $root "中文 space [x] & install"
|
||||
[IO.Directory]::CreateDirectory($targetDir) | Out-Null
|
||||
$target = Join-Path $targetDir "bsk.exe"
|
||||
$firstInstallOutput = Install-Binary $source $target 6>&1 | Out-String
|
||||
if ($firstInstallOutput -match 'daemon will restart') { throw 'fresh install reported a daemon restart' }
|
||||
Install-Binary $source $target
|
||||
Assert-Equal (Get-FileHash -LiteralPath $target).Hash (Get-FileHash -LiteralPath $source).Hash
|
||||
|
||||
$daemon = Start-Process -FilePath $target -ArgumentList @('daemon', 'start', '--foreground', '--port', '0') -WindowStyle Hidden -PassThru
|
||||
@@ -164,165 +99,18 @@ try {
|
||||
& $target --version
|
||||
if ($LASTEXITCODE -ne 0) { throw "replacement is not executable" }
|
||||
|
||||
# Installing into a new directory must also stop a daemon from the old one.
|
||||
$newTargetDir = Join-Path $root "new install"
|
||||
[IO.Directory]::CreateDirectory($newTargetDir) | Out-Null
|
||||
$newTarget = Join-Path $newTargetDir "bsk.exe"
|
||||
$before = (Get-FileHash -LiteralPath $target).Hash
|
||||
$daemon = Start-Process -FilePath $target -ArgumentList @('daemon', 'start', '--foreground', '--port', '0') -WindowStyle Hidden -PassThru
|
||||
$deadline = [DateTime]::UtcNow.AddSeconds(15)
|
||||
while (-not [IO.File]::Exists($infoPath)) {
|
||||
if ($daemon.HasExited -or [DateTime]::UtcNow -gt $deadline) { throw "old-directory daemon failed to start" }
|
||||
Start-Sleep -Milliseconds 50
|
||||
}
|
||||
Install-Binary $source $newTarget
|
||||
if (-not $daemon.WaitForExit(5000)) { throw "new-directory install left the old daemon running" }
|
||||
Assert-Equal (Get-FileHash -LiteralPath $target).Hash $before
|
||||
Assert-Equal (Get-FileHash -LiteralPath $newTarget).Hash (Get-FileHash -LiteralPath $source).Hash
|
||||
& $newTarget --version
|
||||
if ($LASTEXITCODE -ne 0) { throw "new-directory installation is not executable" }
|
||||
if (@(Get-ChildItem -LiteralPath $newTargetDir -Filter "*.install-*").Count) { throw "new-directory staging files leaked" }
|
||||
|
||||
# Refuse replacement when daemon identity cannot be verified.
|
||||
[IO.File]::WriteAllText($infoPath, 'invalid daemon metadata')
|
||||
$before = (Get-FileHash -LiteralPath $target).Hash
|
||||
Assert-Fails { Install-Binary $source $target } -MessageContains $infoPath
|
||||
Assert-Fails { Install-Binary $source $target }
|
||||
Assert-Equal (Get-FileHash -LiteralPath $target).Hash $before
|
||||
|
||||
# A failed stop must also prevent installation to a previously empty target.
|
||||
$blockedTarget = Join-Path $newTargetDir "blocked.exe"
|
||||
Assert-Fails { Install-Binary $source $blockedTarget } -MessageContains $infoPath
|
||||
if (Test-Path -LiteralPath $blockedTarget) { throw "failed stop created an installation" }
|
||||
if (@(Get-ChildItem -LiteralPath $newTargetDir -Filter "*.install-*").Count) { throw "failed stop leaked staging files" }
|
||||
Assert-Equal ([IO.File]::ReadAllText($infoPath)) 'invalid daemon metadata'
|
||||
# Following the reported recovery path must allow the same installation to succeed.
|
||||
[IO.File]::Delete($infoPath)
|
||||
Install-Binary $source $blockedTarget
|
||||
Assert-Equal (Get-FileHash -LiteralPath $blockedTarget).Hash (Get-FileHash -LiteralPath $source).Hash
|
||||
|
||||
# A remaining lock must fail without truncation or staging debris.
|
||||
$lock = [IO.File]::Open($target, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::None)
|
||||
try { Assert-Fails { Install-Binary $source $target } } finally { $lock.Dispose() }
|
||||
Assert-Equal (Get-FileHash -LiteralPath $target).Hash $before
|
||||
if (@(Get-ChildItem -LiteralPath $targetDir -Filter "*.install-*").Count) { throw "staging files leaked" }
|
||||
|
||||
# Exercise Main with real ZIPs/executables, isolating network and user state.
|
||||
& {
|
||||
$fixtureTemp = Join-Path $root 'temp [literal]'
|
||||
[IO.Directory]::CreateDirectory($fixtureTemp) | Out-Null
|
||||
$mainDefinition = ($ast.EndBlock.Statements | Where-Object {
|
||||
$_ -is [System.Management.Automation.Language.FunctionDefinitionAst] -and $_.Name -eq 'Main'
|
||||
}).Extent.Text.Replace('[System.IO.Path]::GetTempPath()', '$fixtureTemp')
|
||||
Invoke-Expression $mainDefinition
|
||||
function Write-Die([string]$Message) { throw $Message }
|
||||
$bashProfile = (Get-Command Add-ToBashProfile).ScriptBlock
|
||||
function Add-ToBashProfile([string]$Dir) {
|
||||
& $bashProfile $Dir (Join-Path $root 'flow.bashrc')
|
||||
}
|
||||
$fixtureArchive = Join-Path $root 'release.zip'
|
||||
Compress-Archive -LiteralPath $source -DestinationPath $fixtureArchive -CompressionLevel Fastest
|
||||
# Serve the ZIP over loopback HTTP. Only the URL is redirected below;
|
||||
# Invoke-WebRequest and the installer's disk writes remain real.
|
||||
$script:DownloadServer = Start-Job -ArgumentList $fixtureArchive -ScriptBlock {
|
||||
param($Archive)
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$body = [IO.File]::ReadAllBytes($Archive)
|
||||
$listener = [Net.Sockets.TcpListener]::new([Net.IPAddress]::Loopback, 0)
|
||||
try {
|
||||
$listener.Start()
|
||||
Write-Output $listener.LocalEndpoint.Port
|
||||
while ($true) {
|
||||
if (-not $listener.Pending()) { Start-Sleep -Milliseconds 50; continue }
|
||||
$client = $listener.AcceptTcpClient()
|
||||
try {
|
||||
$stream = $client.GetStream()
|
||||
$stream.ReadTimeout = 5000
|
||||
$stream.WriteTimeout = 5000
|
||||
$reader = [IO.StreamReader]::new($stream)
|
||||
while (($line = $reader.ReadLine()) -and $line.Length) { }
|
||||
$header = [Text.Encoding]::ASCII.GetBytes("HTTP/1.1 200 OK`r`nContent-Type: application/octet-stream`r`nContent-Length: $($body.Length)`r`nConnection: close`r`n`r`n")
|
||||
$stream.Write($header, 0, $header.Length)
|
||||
$stream.Write($body, 0, $body.Length)
|
||||
} finally { $client.Dispose() }
|
||||
}
|
||||
} finally { $listener.Stop() }
|
||||
}
|
||||
$serverPort = $null
|
||||
$deadline = [DateTime]::UtcNow.AddSeconds(15)
|
||||
while (-not $serverPort) {
|
||||
$serverPort = Receive-Job $script:DownloadServer
|
||||
if ($script:DownloadServer.State -ne 'Running' -or [DateTime]::UtcNow -gt $deadline) {
|
||||
throw 'download fixture failed to start'
|
||||
}
|
||||
if (-not $serverPort) { Start-Sleep -Milliseconds 50 }
|
||||
}
|
||||
$asset = @{ sha256 = (Get-FileHash -LiteralPath $fixtureArchive).Hash }
|
||||
$fixtureManifest = @{ version = '9.8.7'; assets = @{ 'windows-x64' = $asset } }
|
||||
$downloads = New-Object 'System.Collections.Generic.List[string]'
|
||||
function Invoke-RestMethod([string]$Uri) {
|
||||
if (-not $fixtureManifest) { throw 'fixture manifest unavailable' }
|
||||
return $fixtureManifest
|
||||
}
|
||||
function Invoke-WebRequest {
|
||||
[CmdletBinding()]
|
||||
param([string]$Uri, [string]$OutFile, [switch]$UseBasicParsing)
|
||||
$downloads.Add($Uri)
|
||||
$PSBoundParameters['Uri'] = "http://127.0.0.1:$serverPort/release.zip"
|
||||
Microsoft.PowerShell.Utility\Invoke-WebRequest @PSBoundParameters -TimeoutSec 15
|
||||
}
|
||||
$GitHub = 'https://example.invalid/fixture'
|
||||
$InstallDir = Join-Path $root 'installed [literal]'
|
||||
$installed = Join-Path $InstallDir 'bsk.exe'
|
||||
$env:BSK_VERSION = $null
|
||||
$env:PROCESSOR_ARCHITECTURE = 'AMD64'
|
||||
$env:PROCESSOR_ARCHITEW6432 = $null
|
||||
$script:UserPath = "$targetDir;$InstallDir;$($InstallDir.ToUpperInvariant())"
|
||||
$env:PATH = "$targetDir;$InstallDir;$oldPath"
|
||||
Assert-Equal (Get-Command bsk).Source $target
|
||||
$installOutput = Main 6>&1 | Out-String
|
||||
if ($installOutput -notmatch 'current session only' -or
|
||||
$installOutput -notmatch 'Machine PATH' -or $installOutput -notmatch 'Get-Command bsk -All') {
|
||||
throw 'install did not explain PATH verification in a new terminal'
|
||||
}
|
||||
Assert-Equal $downloads.Count 1
|
||||
Assert-Equal (Get-Command bsk).Source $installed
|
||||
Assert-Equal $script:UserPath "$InstallDir;$targetDir"
|
||||
Assert-Equal (Get-FileHash -LiteralPath $installed).Hash (Get-FileHash -LiteralPath $source).Hash
|
||||
Assert-Equal @(Get-ChildItem -LiteralPath $fixtureTemp -Force).Count 0
|
||||
|
||||
# ARM64 must be listed in the manifest before any archive is requested.
|
||||
$env:PROCESSOR_ARCHITECTURE = 'ARM64'
|
||||
$downloads.Clear()
|
||||
$message = $null
|
||||
try { Main } catch { $message = $_.Exception.Message }
|
||||
Assert-Equal $message 'version.json does not list a Windows ARM64 package for bsk 9.8.7'
|
||||
Assert-Equal $downloads.Count 0
|
||||
$env:BSK_VERSION = '9.8.7'
|
||||
$fixtureManifest = $null
|
||||
$message = $null
|
||||
try { Main } catch { $message = $_.Exception.Message }
|
||||
Assert-Equal $message 'version.json does not list a Windows ARM64 package for bsk 9.8.7'
|
||||
Assert-Equal $downloads.Count 0
|
||||
|
||||
# Keep pinned x64 installs compatible with older releases without manifests.
|
||||
$env:PROCESSOR_ARCHITECTURE = 'AMD64'
|
||||
Main
|
||||
Assert-Equal $downloads.Count 1
|
||||
Assert-Equal @(Get-ChildItem -LiteralPath $fixtureTemp -Force).Count 0
|
||||
|
||||
# A listed ARM64 archive remains selectable (the fixture uses the host EXE).
|
||||
$fixtureManifest = @{ version = '9.8.7'; assets = @{ 'windows-arm64' = $asset } }
|
||||
$env:PROCESSOR_ARCHITECTURE = 'ARM64'
|
||||
Main
|
||||
Assert-Equal $downloads[$downloads.Count - 1] "$GitHub/releases/download/cli-v9.8.7/bsk-v9.8.7-aarch64-pc-windows-msvc.zip"
|
||||
|
||||
# A checksum failure must clean the bracketed temp path and preserve the install.
|
||||
$before = (Get-FileHash -LiteralPath $installed).Hash
|
||||
$fixtureManifest.assets['windows-arm64'] = @{ sha256 = '0' * 64 }
|
||||
Assert-Fails { Main }
|
||||
Assert-Equal (Get-FileHash -LiteralPath $installed).Hash $before
|
||||
Assert-Equal @(Get-ChildItem -LiteralPath $fixtureTemp -Force).Count 0
|
||||
}
|
||||
Write-Host "Windows installer regressions passed ($($PSVersionTable.PSVersion))"
|
||||
}
|
||||
catch {
|
||||
@@ -331,20 +119,12 @@ catch {
|
||||
throw
|
||||
}
|
||||
finally {
|
||||
if ($script:DownloadServer) {
|
||||
Stop-Job $script:DownloadServer
|
||||
Remove-Job $script:DownloadServer
|
||||
}
|
||||
if ($daemon -and -not $daemon.HasExited) {
|
||||
Stop-Process -Id $daemon.Id -Force
|
||||
$daemon.WaitForExit(5000) | Out-Null
|
||||
}
|
||||
$env:BSK_HOME = $oldBskHome
|
||||
$env:BSK_AUTO_UPDATE = $oldAutoUpdate
|
||||
$env:BSK_VERSION = $oldVersion
|
||||
$env:PROCESSOR_ARCHITECTURE = $oldProcessArch
|
||||
$env:PROCESSOR_ARCHITEW6432 = $oldNativeArch
|
||||
$env:PATH = $oldPath
|
||||
Remove-Item Env:BSK_TEST_RC -ErrorAction SilentlyContinue
|
||||
# Resolve and verify before recursive cleanup; only this fixture is removed.
|
||||
$resolvedRoot = [IO.Path]::GetFullPath($root)
|
||||
|
||||
Reference in new issue
Block a user