Files
reverse-engineering-anything/tests/boundary/browser/webCaptureDiff.test.ts
T

1429 lines
50 KiB
TypeScript

import { afterEach, describe, expect, it } from "vitest";
import { CdpBrowserProvider } from "../../../src/browser/CdpBrowserProvider.js";
import { inspectWebPageInputSchema } from "../../../src/domain/browserObservation.js";
import {
type WebPageInspection,
webPageInspectionSchema,
} from "../../../src/domain/browserObservationSchemas.js";
import { discoverWebMcpToolsInputSchema } from "../../../src/domain/webMcpDiscovery.js";
import { compareWebCaptures } from "../../../src/domain/webCaptureDiff.js";
import {
compareWebCapturesInputSchema,
webCaptureDiffSchema,
} from "../../../src/domain/webCaptureDiffSchemas.js";
import {
startFakeCdpBrowser,
type FakeCdpBrowser,
} from "../../fixtures/fakeCdpBrowser.js";
const browsers: FakeCdpBrowser[] = [];
const inspectStorage = async (
browser: FakeCdpBrowser,
fingerprints = false,
) => {
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
include_storage_keys: true,
include_storage_fingerprints: fingerprints,
}),
);
if (!captured.ok) throw captured.error;
return captured.value;
};
const compareStorage = (left: WebPageInspection, right: WebPageInspection) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: left },
after: { inspection: right },
}),
).dimensions.storage;
it.each([
["local", "DOMStorage.getDOMStorageItems", { entries: [null] }],
[
"session",
"DOMStorage.getDOMStorageItems",
{ entries: [["known", "value"], null] },
],
["indexed", "IndexedDB.requestDatabaseNames", { databaseNames: [null] }],
["cache", "CacheStorage.requestCacheNames", { caches: [null] }],
] as const)(
"does not invent membership changes after an incomplete %s inventory",
async (kind, method, malformed) => {
let failure: "unsupported" | "malformed" | undefined;
const matches = (command: {
method: string;
params: Record<string, unknown>;
}) => {
if (command.method !== method) return false;
if (kind !== "local" && kind !== "session") return true;
return (
(command.params.storageId as { isLocalStorage: boolean })
.isLocalStorage ===
(kind === "local")
);
};
const browser = await startFakeCdpBrowser({
commandError: (command) =>
failure === "unsupported" && matches(command)
? { code: -32601, message: "Method not found" }
: undefined,
commandResult: (command) =>
failure === "malformed" && matches(command) ? malformed : undefined,
});
browsers.push(browser);
const before = await inspectStorage(browser);
expect(before.completeness.unavailable_sections).not.toContain(
"storage_keys",
);
for (const [mode, reason] of [
["unsupported", "provider_unavailable"],
["malformed", "invalid_protocol_value"],
] as const) {
failure = mode;
const after = await inspectStorage(browser);
expect(after.completeness.excluded).toContainEqual({
section: "storage_keys",
reason,
count: null,
});
expect(after.completeness.unavailable_sections).toContain("storage_keys");
for (const [left, right] of [
[before, after],
[after, before],
] as const)
expect(compareStorage(left, right)).toMatchObject({
status: "unknown",
total_changes: 0,
changes: [],
});
if (kind === "session" && mode === "malformed")
expect(after.storage.session_storage_keys).toEqual(["known"]);
}
},
);
it("preserves shared content changes when a peer inventory is unavailable", async () => {
let value = "before";
const browser = await startFakeCdpBrowser({
unsupportedMethods: ["CacheStorage.requestCacheNames"],
commandResult: (command) =>
command.method === "DOMStorage.getDOMStorageItems"
? { entries: [["shared-key", value]] }
: undefined,
});
browsers.push(browser);
const before = await inspectStorage(browser, true);
expect(before.completeness.unavailable_sections).toContain("storage_keys");
expect(compareStorage(before, before)).toMatchObject({
status: "unknown",
total_changes: 0,
});
value = "after";
const after = await inspectStorage(browser, true);
for (const [left, right] of [
[before, after],
[after, before],
] as const)
expect(compareStorage(left, right)).toMatchObject({
status: "changed",
total_changes: 2,
changes: [
expect.objectContaining({ change: "modified" }),
expect.objectContaining({ change: "modified" }),
],
});
for (const fingerprint of after.storage.content_fingerprints)
if (["local_storage", "session_storage"].includes(fingerprint.scope))
fingerprint.complete = false;
expect(compareStorage(before, after)).toMatchObject({
status: "unknown",
total_changes: 0,
});
});
it("reports complete storage key additions and removals without content fingerprints", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const before = await inspectStorage(browser);
expect(before.storage.fingerprints_complete).toBe(false);
const after = structuredClone(before);
after.storage.local_storage_keys.push("new-local");
after.storage.session_storage_keys.push("new-session");
after.storage.indexed_db_names.push("new-db");
after.storage.cache_names.push("new-cache");
const identities = [
"storage:cache:new-cache",
"storage:indexed_db:new-db",
"storage:local_storage:new-local",
"storage:session_storage:new-session",
];
for (const [left, right, change] of [
[before, after, "added"],
[after, before, "removed"],
] as const) {
expect(compareStorage(left, right)).toMatchObject({
status: "changed",
total_changes: 4,
changes: identities.map((identity) => ({ identity, change })),
});
}
expect(compareStorage(after, after)).toMatchObject({
status: "unknown",
total_changes: 0,
});
const missingQuota = structuredClone(after);
missingQuota.storage.quota_bytes = null;
expect(compareStorage(before, missingQuota)).toMatchObject({
status: "changed",
total_changes: 4,
});
const partialInventory = structuredClone(after);
partialInventory.completeness.unavailable_sections.push("storage_keys");
expect(compareStorage(before, partialInventory)).toMatchObject({
status: "unknown",
total_changes: 0,
});
expect(compareStorage(partialInventory, before)).toMatchObject({
status: "unknown",
total_changes: 0,
});
});
const expectInvalidDiff = (input: unknown): void => {
expect(webCaptureDiffSchema.safeParse(input).success).toBe(false);
};
afterEach(async () => {
await Promise.all(browsers.splice(0).map(async (browser) => browser.close()));
});
it("compares consequential annotations only when both values are retained", async () => {
const browser = await startFakeCdpBrowser({ webMcpTools: true });
browsers.push(browser);
const provider = new CdpBrowserProvider();
const request = {
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
};
const inspection = await provider.inspectPage(
inspectWebPageInputSchema.parse(request),
);
if (!inspection.ok) throw inspection.error;
const discovery = await provider.discoverWebMcpTools(
discoverWebMcpToolsInputSchema.parse(request),
);
if (!discovery.ok) throw discovery.error;
markSectionsComplete(discovery.value, ["webmcp_tools"]);
for (const [left, right, editDescription, status] of [
[undefined, false, false, "unknown"],
[true, undefined, false, "unknown"],
[undefined, false, true, "changed"],
[true, undefined, true, "changed"],
[true, false, false, "changed"],
[null, false, false, "changed"],
] as const) {
const before = structuredClone(discovery.value);
const after = structuredClone(discovery.value);
const beforeTool = before.tools.items[0];
const afterTool = after.tools.items[0];
if (beforeTool === undefined || afterTool === undefined)
throw new Error("Expected a discovered WebMCP tool");
if (left === undefined) delete beforeTool.annotations.consequential;
else beforeTool.annotations.consequential = left;
if (right === undefined) delete afterTool.annotations.consequential;
else afterTool.annotations.consequential = right;
if (editDescription) afterTool.description += " changed";
const dimension = compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: inspection.value, webmcp: before },
after: { inspection: inspection.value, webmcp: after },
}),
).dimensions.webmcp;
expect(dimension).toMatchObject({
status,
total_changes: status === "changed" ? 1 : 0,
changes:
status === "changed"
? [expect.objectContaining({ change: "modified" })]
: [],
});
}
});
describe("web capture dimension uncertainty", () => {
it("reports stable observed changes while preserving unknown dimensions", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
markSectionsComplete(captured.value, ["scripts", "dom", "frames"]);
const after = structuredClone(captured.value);
after.scripts.items = [];
const request = after.network.requests[0];
if (request !== undefined) {
request.status = 204;
request.redirects = [
{
url: `${browser.allowedOrigin}/prior`,
response_url: `${browser.allowedOrigin}/prior`,
method: "GET",
resource_type: "Fetch",
status: 302,
mime_type: "text/plain",
encoded_data_length: 12,
request_timestamp: 1,
redirect_event_timestamp: 2,
},
];
}
const compareAfter = () =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: captured.value },
after: { inspection: after },
}),
);
const node = after.dom.nodes[0];
if (node === undefined) throw new Error("Expected a retained DOM node");
node.node_name = "MAIN";
expect(compareAfter().dimensions.dom_structure).toMatchObject({
status: "changed",
total_changes: 1,
changes: [{ identity: "document", change: "modified" }],
});
after.completeness.truncated_sections.push("dom");
const result = compareAfter();
expect(result.dimensions.dom_structure).toMatchObject({
status: "unknown",
total_changes: 0,
changes: [],
});
expect(result.overall_status).toBe("changed");
expect(result.dimensions.scripts).toMatchObject({
status: "changed",
total_changes: 1,
changes: [expect.objectContaining({ change: "removed" })],
});
expect(result.dimensions.network).toMatchObject({
status: "unknown",
total_changes: 0,
changes: [],
});
expect(result.dimensions.webmcp).toMatchObject({
status: "unknown",
total_changes: 0,
});
expectInvalidDiff({ ...result, overall_status: "unchanged" });
expectInvalidDiff({
...result,
dimensions: {
...result.dimensions,
webmcp: { ...result.dimensions.webmcp, reason: null },
},
});
expectInvalidDiff({
...result,
dimensions: {
...result.dimensions,
scripts: { ...result.dimensions.scripts, total_changes: 2 },
},
});
const { accessibility: _accessibility, ...missingAccessibility } =
result.dimensions;
expectInvalidDiff({
...result,
dimensions: missingAccessibility,
});
const { storage: _storage, ...missingStorage } = result.dimensions;
expectInvalidDiff({ ...result, dimensions: missingStorage });
});
});
describe("web capture WebSocket comparison", () => {
it("compares complete ordered WebSocket streams by source URL, not request IDs", async () => {
const browser = await startFakeCdpBrowser({ binaryWebSocketEvent: true });
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
include_websocket_shapes: true,
}),
);
if (!captured.ok) throw captured.error;
const before = structuredClone(captured.value);
markSectionsComplete(before, [
"network_requests",
"websocket_connections",
"websocket_frames",
"websocket_shapes",
]);
expect(before.network.websocket_connections).toHaveLength(1);
expect(before.network.websocket_connections[0]?.url).toBe(
`ws://${new URL(browser.allowedOrigin).host}/live?token=websocket-url-secret`,
);
expect(before.network.websocket_connections[0]?.events).toHaveLength(2);
const idOnlyChange = structuredClone(before);
const idOnlyConnection = idOnlyChange.network.websocket_connections[0];
if (idOnlyConnection === undefined)
throw new Error("Missing captured WebSocket connection");
idOnlyConnection.request_id = "capture-local-id-2";
expect(compareNetwork(before, idOnlyChange)).toMatchObject({
status: "unchanged",
total_changes: 0,
});
for (const patch of [
{ direction: "received" },
{ opcode: 2 },
{ payload_shape: { format: "binary", json_shape: null } },
] as const) {
const changed = structuredClone(before);
const frame = changed.network.websocket_connections[0]?.events[0];
if (frame === undefined)
throw new Error("Expected a retained WebSocket frame");
Object.assign(frame, patch);
expect(compareNetwork(before, changed)).toMatchObject({
status: "changed",
changes: [expect.objectContaining({ change: "modified" })],
});
}
const reordered = structuredClone(before);
reordered.network.websocket_connections[0]?.events.reverse();
expect(compareNetwork(before, reordered)).toMatchObject({
status: "changed",
changes: [expect.objectContaining({ change: "modified" })],
});
const addedEmptyConnection = structuredClone(before);
addedEmptyConnection.network.websocket_connections.push({
request_id: "new-empty-connection",
url: before.network.websocket_connections[0]!.url,
events: [],
});
expect(compareNetwork(before, addedEmptyConnection)).toMatchObject({
status: "changed",
changes: [expect.objectContaining({ change: "modified" })],
});
});
});
it("preserves WebSocket stream correlation and compares only shared payload evidence", async () => {
const browser = await startFakeCdpBrowser({ binaryWebSocketEvent: true });
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
include_websocket_shapes: true,
}),
);
if (!captured.ok) throw captured.error;
const known = captured.value;
markSectionsComplete(known, [
"network_requests",
"websocket_connections",
"websocket_frames",
"websocket_shapes",
]);
const baseConnection = known.network.websocket_connections[0];
if (baseConnection === undefined)
throw new Error("Expected a WebSocket connection");
const shape = (root_type: "string" | "number") => ({
format: "json" as const,
json_shape: {
root_type,
node_count: 1,
max_depth_observed: 0,
properties: [],
},
});
const stringShape = shape("string");
const numberShape = shape("number");
const streams = (
...rows: readonly (readonly [typeof stringShape, typeof stringShape])[]
) => {
const capture = structuredClone(known);
capture.network.websocket_connections = rows.map(
([first, second], index) => {
const stream = structuredClone(baseConnection);
stream.request_id = `socket-${String(index)}`;
const [sent, received] = stream.events;
if (sent === undefined || received === undefined)
throw new Error("Expected two retained WebSocket frames");
sent.payload_shape = first;
received.payload_shape = second;
return stream;
},
);
return capture;
};
const editFrame = (
capture: WebPageInspection,
frameIndex: number,
patch: Partial<(typeof baseConnection.events)[number]>,
connectionIndex = 0,
) => {
const copy = structuredClone(capture);
const frame =
copy.network.websocket_connections[connectionIndex]?.events[frameIndex];
if (frame === undefined)
throw new Error("Expected a retained WebSocket frame");
Object.assign(frame, patch);
return copy;
};
const correlated = streams(
[stringShape, stringShape],
[numberShape, numberShape],
);
expect(
compareNetwork(
correlated,
streams([numberShape, numberShape], [stringShape, stringShape]),
).status,
).toBe("unchanged");
// Both positions have the same marginal shapes, but the pairing within each connection changed.
expect(
compareNetwork(
correlated,
streams([stringShape, numberShape], [numberShape, stringShape]),
).status,
).toBe("changed");
const unknown = { status: "unknown", total_changes: 0, changes: [] };
const partial = editFrame(correlated, 1, { payload_shape: null });
expect(
compareNetwork(
partial,
editFrame(partial, 1, { payload_shape: stringShape }, 1),
),
).toMatchObject(unknown);
expect(
compareNetwork(
partial,
editFrame(partial, 0, { payload_shape: numberShape }),
).status,
).toBe("changed");
const unavailable = structuredClone(known);
unavailable.completeness.unavailable_sections.push("websocket_shapes");
for (const { events } of unavailable.network.websocket_connections)
for (const frame of events) frame.payload_shape = null;
expect(compareNetwork(unavailable, unavailable)).toMatchObject(unknown);
expect(
compareNetwork(unavailable, editFrame(known, 0, { opcode: 2 })).status,
).toBe("changed");
const truncated = editFrame(known, 0, { payload_shape: null });
truncated.completeness.truncated_sections.push("websocket_shapes");
const unknownBytes = editFrame(known, 1, { payload_bytes: null });
for (const limited of [unavailable, truncated, unknownBytes]) {
expect(compareNetwork(known, limited)).toMatchObject(unknown);
expect(compareNetwork(limited, known)).toMatchObject(unknown);
}
expect(
compareNetwork(
unknownBytes,
editFrame(unknownBytes, 1, { direction: "sent" }),
).status,
).toBe("changed");
const size = baseConnection.events[1]?.payload_bytes;
if (size === null || size === undefined)
throw new Error("Expected a captured WebSocket byte count");
expect(
compareNetwork(known, editFrame(known, 1, { payload_bytes: size + 1 }))
.status,
).toBe("changed");
});
describe("web capture diff", () => {
it("reports request membership changes when selected body shapes are unavailable", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const before = structuredClone(captured.value);
const after = structuredClone(captured.value);
const original = before.network.requests[0];
if (original === undefined) throw new Error("Missing request fixture");
after.network.requests.push({
...structuredClone(original),
request_id: `${original.request_id}-added`,
url: `${browser.allowedOrigin}/added`,
});
for (const inspection of [before, after]) {
markSectionsComplete(inspection, [
"network_requests",
"websocket_connections",
"websocket_frames",
]);
for (const request of inspection.network.requests)
request.body_shapes.status = "unavailable";
}
expect(compareNetwork(before, after)).toMatchObject({
status: "changed",
total_changes: 1,
changes: [expect.objectContaining({ change: "added" })],
});
});
it.each(["status", "mime_type"] as const)(
"keeps an independently unavailable HTTP %s unknown",
async (field) => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const observed = structuredClone(captured.value);
const request = observed.network.requests[0];
if (request === undefined) throw new Error("Missing network request");
request.status = 200;
request.mime_type = "application/json";
request.encoded_data_length = 100;
markSectionsComplete(observed, [
"network_requests",
"websocket_connections",
"websocket_frames",
"json_body_shapes",
]);
for (const item of observed.network.requests)
item.body_shapes.status = "not_approved";
expect(compareNetwork(observed, observed).status).toBe("unchanged");
const partial = structuredClone(observed);
partial.network.requests[0]![field] = null;
for (const [left, right] of [
[partial, observed],
[observed, partial],
[partial, partial],
] as const)
expect(compareNetwork(left, right)).toMatchObject({
status: "unknown",
total_changes: 0,
changes: [],
});
},
);
it("ignores transient request IDs and capture-approval state", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const after = structuredClone(captured.value);
const request = after.network.requests[0];
if (request !== undefined) request.request_id = "different-cdp-request-id";
const response = after.metadata.responses[0];
if (response !== undefined)
response.request_id = "different-cdp-request-id";
const script = after.scripts.items[0];
if (script !== undefined && !script.source.included)
script.source.reason = "different approval explanation";
markSectionsComplete(captured.value, ["scripts", "metadata"]);
markSectionsComplete(after, ["scripts", "metadata"]);
const result = compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: captured.value },
after: { inspection: after },
}),
);
expect(result.dimensions.scripts.status).toBe("unchanged");
expect(result.dimensions.metadata.status).toBe("unchanged");
expect(result.dimensions.network.status).toBe("unknown");
expect(result.dimensions.network.total_changes).toBe(0);
});
});
describe("web capture redirect comparison", () => {
it("ignores redirect event times but compares redirect semantics", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const before = structuredClone(captured.value);
const beforeRequest = before.network.requests[0];
if (beforeRequest === undefined) throw new Error("Missing network request");
beforeRequest.redirects = [
{
url: `${browser.allowedOrigin}/prior`,
response_url: `${browser.allowedOrigin}/prior`,
method: "GET",
resource_type: "Fetch",
status: 302,
mime_type: "text/plain",
encoded_data_length: 12,
request_timestamp: 1,
redirect_event_timestamp: 2,
},
];
markSectionsComplete(before, [
"network_requests",
"websocket_connections",
"websocket_frames",
]);
const after = structuredClone(before);
const afterRequest = after.network.requests[0];
if (afterRequest === undefined) throw new Error("Missing network request");
const hop = afterRequest.redirects?.[0];
if (hop === undefined) throw new Error("Missing redirect hop");
hop.request_timestamp = 10;
hop.redirect_event_timestamp = 20;
const compare = (inspection: typeof before) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: before },
after: { inspection },
}),
).dimensions.network;
expect(compare(after)).toMatchObject({
status: "unchanged",
total_changes: 0,
});
const changed = structuredClone(after);
const changedHop = changed.network.requests[0]?.redirects?.[0];
if (changedHop === undefined) throw new Error("Missing redirect hop");
changedHop.status = 307;
expect(compare(changed)).toMatchObject({
status: "changed",
changes: [expect.objectContaining({ change: "modified" })],
});
});
it.each([
["status", 302],
["mime_type", "text/plain"],
["encoded_data_length", 12],
] as const)(
"keeps unavailable redirect %s evidence unknown without suppressing known changes",
async (field, knownValue) => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const before = structuredClone(captured.value);
const beforeRequest = before.network.requests[0];
if (beforeRequest === undefined)
throw new Error("Missing network request");
beforeRequest.redirects = [
{
url: `${browser.allowedOrigin}/prior`,
response_url: `${browser.allowedOrigin}/prior`,
method: "GET",
resource_type: "Fetch",
status: 302,
mime_type: "text/plain",
encoded_data_length: 12,
request_timestamp: 1,
redirect_event_timestamp: 2,
},
];
markSectionsComplete(before, [
"network_requests",
"websocket_connections",
"websocket_frames",
]);
const compare = (left: typeof before, right: typeof before) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: left },
after: { inspection: right },
}),
).dimensions.network;
for (const missingOnRight of [false, true]) {
const known = structuredClone(before);
const missing = structuredClone(before);
const knownHop = known.network.requests[0]?.redirects?.[0];
const missingHop = missing.network.requests[0]?.redirects?.[0];
if (knownHop === undefined || missingHop === undefined)
throw new Error("Missing redirect fixture");
Reflect.set(knownHop, field, knownValue);
Reflect.set(missingHop, field, null);
const result = missingOnRight
? compare(known, missing)
: compare(missing, known);
expect(result).toMatchObject({
status: "unknown",
total_changes: 0,
reason: expect.stringContaining("redirect"),
});
expect(compare(missing, missing)).toMatchObject({
status: "unknown",
total_changes: 0,
reason: expect.stringContaining("redirect"),
});
}
const changed = structuredClone(before);
const changedHop = changed.network.requests[0]?.redirects?.[0];
if (changedHop === undefined) throw new Error("Missing redirect fixture");
changedHop.status = 307;
expect(compare(before, changed)).toMatchObject({
status: "changed",
changes: [expect.objectContaining({ change: "modified" })],
});
},
);
});
describe("web capture diff incomplete inventories", () => {
it("compares observed script facts without treating excluded map declarations as absent", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const known = structuredClone(captured.value);
markSectionsComplete(known, ["scripts", "source_maps"]);
known.completeness.excluded = known.completeness.excluded.filter(
(item) => item.section !== "source_maps",
);
const script = known.scripts.items[0];
if (script === undefined) throw new Error("Missing captured script");
script.source_map_url = "https://cdn.example.test/app.js.map";
script.cdp_hash = "a".repeat(64);
script.length = 10;
script.is_module = false;
script.language = "JavaScript";
const excluded = structuredClone(known);
excluded.scripts.items[0]!.source_map_url = null;
excluded.completeness.policy_filtered_sections.push("source_maps");
excluded.completeness.excluded.push({
section: "source_maps",
reason: "disallowed_origin",
count: 1,
});
const absent = structuredClone(known);
absent.scripts.items[0]!.source_map_url = null;
const changed = structuredClone(excluded);
changed.scripts.items[0]!.cdp_hash = "b".repeat(64);
const different = structuredClone(known);
different.scripts.items[0]!.source_map_url =
"https://cdn.example.test/other.map";
const unavailableBody = structuredClone(known);
unavailableBody.completeness.unavailable_sections.push("source_maps");
const compare = (before: typeof known, after: typeof known) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: before },
after: { inspection: after },
}),
).dimensions.scripts;
for (const [left, right] of [
[known, excluded],
[excluded, known],
[excluded, excluded],
[absent, excluded],
] as const)
expect(compare(left, right)).toMatchObject({
status: "unknown",
total_changes: 0,
});
const repeated = structuredClone(excluded);
repeated.scripts.items.push(structuredClone(known.scripts.items[0]!));
const completeRepeated = structuredClone(different);
completeRepeated.scripts.items.push(
structuredClone(different.scripts.items[0]!),
);
for (const [left, right] of [
[repeated, completeRepeated],
[completeRepeated, repeated],
] as const)
expect(compare(left, right)).toMatchObject({
status: "changed",
total_changes: 1,
});
const linkedBefore = structuredClone(repeated);
linkedBefore.scripts.items[0]!.cdp_hash = "b".repeat(64);
const linkedAfter = structuredClone(linkedBefore);
linkedAfter.scripts.items[1]!.source_map_url =
"https://cdn.example.test/new.map";
for (const [left, right] of [
[linkedBefore, linkedAfter],
[linkedAfter, linkedBefore],
] as const)
expect(compare(left, right)).toMatchObject({
status: "changed",
total_changes: 1,
});
const ambiguous = structuredClone(linkedAfter);
ambiguous.scripts.items[0]!.cdp_hash = "a".repeat(64);
const ambiguousBefore = structuredClone(linkedBefore);
ambiguousBefore.scripts.items[0]!.cdp_hash = "a".repeat(64);
expect(compare(ambiguousBefore, ambiguous)).toMatchObject({
status: "unknown",
total_changes: 0,
});
const incompleteRepeated = structuredClone(repeated);
incompleteRepeated.completeness.truncated_sections.push("scripts");
expect(compare(incompleteRepeated, completeRepeated)).toMatchObject({
status: "changed",
total_changes: 1,
});
const possibleMatch = structuredClone(completeRepeated);
possibleMatch.scripts.items[1]!.source_map_url = null;
possibleMatch.completeness.policy_filtered_sections.push("source_maps");
expect(compare(repeated, possibleMatch)).toMatchObject({
status: "unknown",
total_changes: 0,
});
for (const reason of [
"unsupported_url",
"invalid_protocol_value",
"resource_budget_exhausted",
] as const) {
const omission = structuredClone(absent);
omission.completeness.excluded.push({
section: "source_maps",
reason,
count: 1,
});
expect(compare(known, omission)).toMatchObject({
status: "unknown",
total_changes: 0,
});
}
for (const [left, right] of [
[known, known],
[absent, absent],
[known, unavailableBody],
] as const)
expect(compare(left, right)).toMatchObject({
status: "unchanged",
total_changes: 0,
});
for (const [left, right] of [
[known, different],
[absent, known],
[excluded, changed],
] as const)
expect(compare(left, right)).toMatchObject({
status: "changed",
total_changes: 1,
});
});
});
describe("web capture diff partial script metadata", () => {
it("proves a map change that a different hash or declaration cannot explain", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const known = structuredClone(captured.value);
markSectionsComplete(known, ["scripts", "source_maps"]);
known.completeness.excluded = known.completeness.excluded.filter(
(item) => item.section !== "source_maps",
);
const script = known.scripts.items[0];
if (script === undefined) throw new Error("Missing captured script");
script.source_map_url = "https://cdn.example.test/app.js.map";
script.cdp_hash = "a".repeat(64);
script.length = 10;
script.is_module = false;
script.language = "JavaScript";
const unknownDeclaration = structuredClone(script);
unknownDeclaration.cdp_hash = "b".repeat(64);
unknownDeclaration.source_map_url = null;
const unknownHash = structuredClone(script);
unknownHash.cdp_hash = null;
unknownHash.source_map_url = "https://cdn.example.test/third.js.map";
const before = structuredClone(known);
before.scripts.items.push(unknownDeclaration, unknownHash);
before.completeness.policy_filtered_sections.push("source_maps");
const after = structuredClone(before);
after.scripts.items[0]!.source_map_url =
"https://cdn.example.test/new.js.map";
const compare = (left: typeof known, right: typeof known) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: left },
after: { inspection: right },
}),
).dimensions.scripts;
expect(compare(before, structuredClone(before))).toMatchObject({
status: "unknown",
total_changes: 0,
});
expect(compare(before, after)).toMatchObject({
status: "changed",
total_changes: 1,
});
});
});
describe("web capture diff repeated source-map declarations", () => {
it("keeps empty and absent declarations distinct during partial matching", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const template = captured.value.scripts.items[0];
if (template === undefined) throw new Error("Missing captured script");
const script = (hash: string, declaration: string | null) => ({
...structuredClone(template),
cdp_hash: hash,
source_map_url: declaration,
});
const partial = structuredClone(captured.value);
const complete = structuredClone(captured.value);
for (const value of [partial, complete])
markSectionsComplete(value, ["scripts", "source_maps"]);
partial.completeness.policy_filtered_sections.push("source_maps");
partial.scripts.items = [
script("hash-a", ""),
script("hash-b", null),
script("hash-a", null),
];
complete.scripts.items = [
script("hash-a", null),
script("hash-a", ""),
script("hash-b", "https://cdn.example.test/b.js.map"),
];
for (const [before, after] of [
[partial, complete],
[complete, partial],
] as const)
expect(
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: before },
after: { inspection: after },
}),
).dimensions.scripts,
).toMatchObject({ status: "unknown", total_changes: 0 });
});
it("proves differences that declaration counts cannot explain", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const template = captured.value.scripts.items[0];
if (template === undefined) throw new Error("Missing captured script");
const copies = (count: number, sourceMapUrl: string | null) =>
Array.from({ length: count }, () => {
const script = structuredClone(template);
script.source_map_url = sourceMapUrl;
return script;
});
const inspection = (
items: typeof captured.value.scripts.items,
omitDeclarations: boolean,
) => {
const value = structuredClone(captured.value);
markSectionsComplete(value, ["scripts", "source_maps"]);
value.scripts.items = items;
if (omitDeclarations)
value.completeness.policy_filtered_sections.push("source_maps");
return value;
};
const compare = (
left: typeof captured.value,
right: typeof captured.value,
) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: left },
after: { inspection: right },
}),
).dimensions.scripts;
const map = (name: string) => `https://cdn.example.test/${name}.js.map`;
const nineX = inspection(
[...copies(9, map("x")), ...copies(1, null)],
true,
);
const tenY = inspection(copies(10, map("y")), false);
const sevenA = inspection(
[...copies(7, map("a")), ...copies(1, map("b")), ...copies(1, null)],
true,
);
const twelveA = inspection(copies(12, map("a")), false);
expect(compare(nineX, structuredClone(nineX))).toMatchObject({
status: "unknown",
total_changes: 0,
});
expect(compare(nineX, tenY)).toMatchObject({
status: "changed",
total_changes: 1,
});
expect(compare(sevenA, twelveA)).toMatchObject({
status: "changed",
total_changes: 1,
});
const repeated = inspection(
[...copies(2_000, map("a")), ...copies(1, null)],
true,
);
expect(compare(repeated, structuredClone(repeated))).toMatchObject({
status: "unknown",
total_changes: 0,
});
});
});
describe("web capture diff script inventory coverage", () => {
it.each(["truncated_sections", "unavailable_sections"] as const)(
"does not infer script additions or removals from %s",
async (section) => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const captured = await new CdpBrowserProvider().inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
}),
);
if (!captured.ok) throw captured.error;
const complete = structuredClone(captured.value);
markSectionsComplete(complete, ["scripts"]);
expect(complete.scripts.items).toHaveLength(1);
const incomplete = structuredClone(complete);
incomplete.scripts.items = [];
incomplete.completeness[section].push("scripts");
const compare = (before: typeof complete, after: typeof complete) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: before },
after: { inspection: after },
}),
).dimensions.scripts;
expect(compare(complete, incomplete)).toMatchObject({
status: "unknown",
total_changes: 0,
changes: [],
});
expect(compare(incomplete, complete)).toMatchObject({
status: "unknown",
total_changes: 0,
changes: [],
});
markSectionsComplete(incomplete, ["scripts"]);
expect(compare(complete, incomplete).changes).toEqual([
expect.objectContaining({ change: "removed" }),
]);
expect(compare(incomplete, complete).changes).toEqual([
expect.objectContaining({ change: "added" }),
]);
const modified = structuredClone(complete);
modified.completeness[section].push("scripts");
const script = modified.scripts.items[0];
if (script === undefined) throw new Error("Missing captured script");
script.url = `${script.url}?revision=2`;
expect(compare(complete, modified).changes).toEqual([
expect.objectContaining({ change: "added" }),
]);
},
);
});
it("compares retained accessibility and storage facts across incomplete captures", async () => {
const browser = await startFakeCdpBrowser({ extraCollections: true });
browsers.push(browser);
const provider = new CdpBrowserProvider();
const inspect = async (selection: {
include_accessibility_text: boolean;
include_storage_keys?: boolean;
include_storage_fingerprints?: boolean;
}) => {
const result = await provider.inspectPage(
inspectWebPageInputSchema.parse({
cdp_endpoint: browser.endpoint,
allowed_origins: [browser.allowedOrigin],
target_id: "allowed-page",
observation_ms: 0,
...selection,
}),
);
if (!result.ok) throw result.error;
return result.value;
};
const observed = await inspect({
include_accessibility_text: true,
include_storage_keys: true,
include_storage_fingerprints: true,
});
const withheld = await inspect({ include_accessibility_text: false });
expect(withheld.completeness.policy_filtered_sections).toContain(
"accessibility",
);
expect(withheld.completeness.excluded).toContainEqual(
expect.objectContaining({
section: "accessibility",
reason: "not_approved",
}),
);
const compare = (after: WebPageInspection) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: observed },
after: { inspection: after },
}),
).dimensions;
const identical = compare(observed);
for (const dimension of [identical.accessibility, identical.storage])
expect(dimension).toMatchObject({
status: "unchanged",
total_changes: 0,
changes: [],
});
const edit = (
capture: WebPageInspection,
change: (copy: WebPageInspection) => void,
) => {
const copy = structuredClone(capture);
change(copy);
return copy;
};
const changedTree = {
status: "changed",
total_changes: 1,
changes: [{ identity: "accessibility_tree", change: "modified" }],
};
const unknown = { status: "unknown", total_changes: 0, changes: [] };
for (const patch of [{ role: "menuitem" }, { name: "Send report" }]) {
const after = edit(observed, ({ accessibility }) => {
const node = accessibility.nodes[0];
if (node === undefined) throw new Error("Expected accessibility node");
Object.assign(node, patch);
});
expect(compare(after).accessibility).toMatchObject(changedTree);
}
const stateChanged = edit(observed, ({ accessibility }) => {
const state = accessibility.nodes[0]?.states.find(
({ name }) => name === "disabled",
);
if (state === undefined) throw new Error("Expected the disabled state");
state.value = true;
});
expect(compare(stateChanged).accessibility).toMatchObject(changedTree);
const reparent = ({ accessibility }: WebPageInspection) => {
const child = accessibility.nodes[1];
if (child === undefined) throw new Error("Expected accessibility child");
child.parent_id = null;
};
expect(compare(edit(observed, reparent)).accessibility).toMatchObject(
changedTree,
);
expect(compare(withheld).accessibility).toMatchObject(unknown);
expect(compare(edit(withheld, reparent)).accessibility).toMatchObject(
changedTree,
);
const withoutRole = edit(observed, ({ accessibility }) => {
const node = accessibility.nodes[0];
if (node === undefined)
throw new Error("Expected a node with an observed role");
node.role = null;
});
expect(compare(withoutRole).accessibility).toMatchObject(unknown);
expect(compare(edit(withoutRole, reparent)).accessibility).toMatchObject(
changedTree,
);
const treeChanged = edit(observed, reparent);
const partial = edit(treeChanged, ({ completeness }) => {
completeness.truncated_sections.push("accessibility");
});
const missingNode = edit(treeChanged, ({ accessibility }) => {
accessibility.total_nodes++;
});
expect(compare(partial).accessibility).toMatchObject(unknown);
expect(compare(missingNode).accessibility).toMatchObject(unknown);
const keyAdded = edit(observed, ({ storage }) => {
storage.local_storage_keys.push("new-key");
});
expect(compare(keyAdded).storage.changes).toEqual([
{ identity: "storage:local_storage:new-key", change: "added" },
]);
const fingerprintIndex = observed.storage.content_fingerprints.findIndex(
({ complete, value_sha256 }) => complete && value_sha256 !== null,
);
const changedFingerprint = edit(observed, ({ storage }) => {
const fingerprint = storage.content_fingerprints[fingerprintIndex];
if (fingerprint === undefined)
throw new Error("Expected a complete storage fingerprint");
fingerprint.value_sha256 = "f".repeat(64);
});
const contentChange = {
status: "changed",
total_changes: 1,
changes: [expect.objectContaining({ change: "modified" })],
};
expect(compare(changedFingerprint).storage).toMatchObject(contentChange);
const omitInventoryProof = ({ storage }: WebPageInspection) => {
storage.fingerprints_complete = false;
};
expect(
compare(edit(changedFingerprint, omitInventoryProof)).storage,
).toMatchObject(contentChange);
expect(compare(edit(observed, omitInventoryProof)).storage).toMatchObject(
unknown,
);
const unverifiedValue = edit(changedFingerprint, (capture) => {
omitInventoryProof(capture);
const fingerprint = capture.storage.content_fingerprints[fingerprintIndex];
if (fingerprint === undefined)
throw new Error("Expected a retained storage fingerprint");
fingerprint.complete = false;
});
expect(compare(unverifiedValue).storage).toMatchObject(unknown);
});
it("refuses an IndexedDB schema fingerprint without its projection version", async () => {
const browser = await startFakeCdpBrowser();
browsers.push(browser);
const current = await inspectStorage(browser, true);
const index = current.storage.content_fingerprints.findIndex(
({ scope }) => scope === "indexed_db_schema",
);
const schema = current.storage.content_fingerprints[index];
if (schema?.scope !== "indexed_db_schema")
throw new Error("Expected an IndexedDB schema fingerprint");
expect(schema.projection_version).toBe(2);
const { projection_version: _version, ...withoutVersion } = schema;
const unmarked = structuredClone(current);
(unmarked.storage.content_fingerprints as unknown[])[index] = withoutVersion;
expect(
webPageInspectionSchema.safeParse(unmarked).error?.issues,
).toMatchObject([
{
path: ["storage", "content_fingerprints", index, "projection_version"],
},
]);
});
const markSectionsComplete = (
inspection: {
completeness: {
policy_filtered_sections: string[];
attach_limited_sections: string[];
truncated_sections: string[];
unavailable_sections: string[];
};
},
sections: readonly string[],
): void => {
const completed = new Set(sections);
for (const key of [
"policy_filtered_sections",
"attach_limited_sections",
"truncated_sections",
"unavailable_sections",
] as const)
inspection.completeness[key] = inspection.completeness[key].filter(
(section) => !completed.has(section),
);
};
const compareNetwork = (before: WebPageInspection, after: WebPageInspection) =>
compareWebCaptures(
compareWebCapturesInputSchema.parse({
before: { inspection: before },
after: { inspection: after },
}),
).dimensions.network;