Files
reverse-engineering-anything/tests/acceptance/webSourceLocationCli.test.ts
T
morluto 858ff73880 perf(tests): give MCP test clients the shared lazy schema validation (#10960)
* perf(tests): give MCP test clients the shared lazy schema validation

The MCP SDK client compiles every listed tool's output schema on its
first tool call. With the SDK's default Ajv options, REA's catalog costs
gigabytes of allocation per client (inspect_analysis_view alone: 1.7 s and
~500 MiB retained), so native MCP files peaked at 1-2 GiB per worker.

tests/fixtures/mcpSchemaValidation already owns lazy, reference-preserving
validation. Route the native MCP, process-boundary and shared harness
clients through it, share compiled validators across clients in a worker
(bounded LRU keyed by schema text), and add a counted architecture guard so
default-validation test clients cannot spread; the remaining copies are the
baseline.

* fix(guards): read call arguments past parentheses inside string literals

* perf(tests): give MCP boundary test clients the shared schema validation (#11022)

* perf(tests): give MCP boundary test clients the shared schema validation

* perf(tests): give the remaining MCP test clients the shared schema validation (#11025)

* fix(guards): read an MCP client's validator option from parsed code

The default-validation counter searched each new Client(...) call's text for jsonSchemaValidator, so an inline comment, a string literal or a client name naming the option hid a default client. Parse the source with @babel/parser and count NewExpressions of Client whose object-literal arguments have no jsonSchemaValidator property; a source that does not parse counts every textual call. The guard reads raw test sources, and the generated-child-script allowlist entry, which no longer counts as a call, is removed.

* fix(guards): read an MCP client's options only from a whole object-literal argument

The default-validation counter skipped files without the text
'new Client(', so a comment between the tokens hid a client, and it took
any depth-two key as an option, so 'enabled ? { jsonSchemaValidator } : {}'
passed while its false branch uses the SDK default. The skip now only
requires the name Client, and the validator counts only when it is a key
of an object literal that is a whole argument; anything else counts as the
default.
2026-11-15 21:53:53 -05:00

861 lines
27 KiB
TypeScript

import { connectLocalToolsMcp } from "../fixtures/localToolsMcp.js";
import { parseMcpToolError } from "../fixtures/mcpToolError.js";
import { expect, onTestFinished } from "vitest";
import { Client } from "@modelcontextprotocol/client";
import {
StdioClientTransport,
getDefaultEnvironment,
} from "@modelcontextprotocol/client/stdio";
import { fileURLToPath } from "node:url";
import { createHash } from "node:crypto";
import { mkdir, symlink, writeFile, readFile, unlink } from "node:fs/promises";
import { join } from "node:path";
import { webSourceLocationFixture } from "../fixtures/webSourceLocation.js";
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
import { cliTest, type TestCli } from "../support/cli/cliFixture.js";
import { createMcpSchemaValidation } from "../fixtures/mcpSchemaValidation.js";
const expectRetainedSourceMap = async (
path: string,
evidenceId: string,
sha256: string,
) => {
const bytes = await readFile(path);
const bundle = JSON.parse(bytes.toString("utf8")) as {
records: {
evidence_id: string;
raw_result: { source_map_text?: string } | null;
}[];
};
const parent = bundle.records.find(
(record) => record.evidence_id === evidenceId,
);
expect(parent?.evidence_id).toBe(evidenceId);
expect(
createHash("sha256")
.update(parent?.raw_result?.source_map_text ?? "")
.digest("hex"),
).toBe(sha256);
return bytes.length;
};
const expectEqualPositionSummary = async (
client: Client,
input: Record<string, unknown>,
) => {
const compact = await client.callTool({
name: "trace_web_source_location",
arguments: {
...input,
detail: "summary",
},
});
expect(compact.isError).not.toBe(true);
expect(compact.structuredContent).toMatchObject({
normalized_result: {
summary: {
match_count: 2,
matches: [
{ match_index: 0, source_index: 0 },
{ match_index: 1, source_index: 1 },
],
},
},
});
expect(JSON.stringify(compact.structuredContent)).not.toContain('"text":');
};
const expectCliSourceLocationSummary = async (
cli: TestCli,
arguments_: readonly string[],
expected: { bundlePath: string; evidenceId: string; sha256: string },
) => {
const { bundlePath, evidenceId, sha256 } = expected;
const missingSink = await cli.run({
arguments: [...arguments_, "--detail", "summary"],
});
expect(missingSink.exitCode).toBe(1);
expect(missingSink.json).toMatchObject({
code: "invalid_request",
details: { issues: [{ path: ["evidence_output"] }] },
});
const summary = await cli.run({
arguments: [
...arguments_,
"--detail",
"summary",
"--evidence_output",
bundlePath,
],
});
expect(summary.exitCode, summary.stderr).toBe(0);
expect(summary.stdout.length).toBeLessThan(30000);
const retainedBytes = await expectRetainedSourceMap(
bundlePath,
evidenceId,
sha256,
);
expect(summary.json).toMatchObject({
evidence_bundle: { path: bundlePath, bytes: retainedBytes },
summary: {
normalized_result: {
parent_evidence_id: evidenceId,
summary: {
match_count: 1,
matches: [
{
match_index: 0,
source_index: 0,
content: { state: "embedded", code_units: 8 },
},
],
},
},
},
});
};
const expectInvalidSourceLocation = (
json: unknown,
manifest: string,
root: string,
map: string,
sourceMapText: string,
) => {
expect(json).toMatchObject({
code: "invalid_request",
details: {
issues: [
{
path: ["generated_position", "line"],
reason: "out_of_range",
maximum: 1,
},
],
partial_observation: {
kind: "web-trace-observation",
analysis: "incomplete",
manifest: { path: manifest },
source: { path: join(root, "files", "modules", "main.js") },
source_map: {
path: map,
sha256: createHash("sha256").update(sourceMapText).digest("hex"),
},
},
},
});
};
const expectSourceLocationLimitations = (json: unknown) => {
const limitation =
"Source names and sourceRoot are reported declarations. REA derives resolved URLs using WHATWG URL resolution; the pinned upstream codec decodes mappings. No original source is fetched or executed.";
expect(json).toMatchObject({
limitations: expect.arrayContaining([limitation]),
normalized_result: { limitations: expect.arrayContaining([limitation]) },
});
};
const expectColumnOutOfRange = (
response: Parameters<typeof parseMcpToolError>[0],
sourceLength: number,
) => {
expect(parseMcpToolError(response).error).toMatchObject({
code: "invalid_request",
details: {
issues: [
{
path: ["generated_position", "column"],
reason: "out_of_range",
maximum: sourceLength,
},
],
},
});
};
/**
* The CLI renders native separators; MCP keeps the caller's spelling and still
* selects the same manifest root from a forward-slash Windows path (#1078).
*/
const expectForwardSlashManifestTrace = async (
client: Client,
input: { readonly manifest_path: string } & Record<string, unknown>,
cliJson: unknown,
) => {
const forwardSlash = input.manifest_path.replaceAll("\\", "/");
const forward = await client.callTool({
name: "trace_web_source_location",
arguments: { ...input, manifest_path: forwardSlash },
});
expect(forward.isError, JSON.stringify(forward)).not.toBe(true);
const { manifest: _manifest, ...cliRest } = (
cliJson as { normalized_result: Record<string, unknown> }
).normalized_result;
expect(forward.structuredContent).toMatchObject({
normalized_result: { ...cliRest, manifest: { path: forwardSlash } },
});
};
cliTest(
"accepts numeric UTF-16 coordinates and runs the actual owned source-map codec without a browser",
// Allow cold CLI and MCP ownership preparation across the full parity sequence.
{ tags: ["long-running"] },
async ({ cli }) => {
const root = await createTestTempDirectory("rea-source-map-cli-");
const fixture = webSourceLocationFixture(
JSON.stringify({
version: 3,
sources: ["dir/original.ts", "dir//original.ts"],
sourcesContent: ["original", "second"],
names: [],
mappings: "AAAA,ACAA",
}),
);
await mkdir(join(root, "files", "modules"), { recursive: true });
await writeFile(join(root, "files", "modules", "main.js"), fixture.source);
let manifest = join(root, "manifest.json");
const map = join(root, "app.js.map");
await writeFile(manifest, JSON.stringify(fixture.manifest));
if (process.platform !== "win32") {
await mkdir(join(root, "lexical"));
await mkdir(join(root, "nested"));
await symlink(join(root, "nested"), join(root, "lexical", "link"));
manifest = `${root}/lexical/link/../manifest.json`;
}
await writeFile(map, fixture.sourceMap.text);
const response = await cli.run({
arguments: [
"trace-web-source-location",
process.platform === "win32"
? "manifest.json"
: "lexical/link/../manifest.json",
"0",
"app.js.map",
fixture.sourceMap.url,
"1",
"0",
"--json",
],
cwd: root,
environment: {
REA_LOG_LEVEL: "silent",
REA_BROWSER_EXECUTABLE: "relative-unconfigured-browser",
CLANG_MODULE_CACHE_PATH: map,
},
});
expect(response.exitCode, response.stdout + response.stderr).toBe(0);
expect(response.json).toMatchObject({
normalized_result: {
manifest: {
path: manifest,
reported_output_directory: fixture.manifest.output_directory,
},
source: {
script_index: 0,
path: join(root, "files", "modules", "main.js"),
},
source_map: { association: "caller-selected" },
generated_offset: 0,
execution: "unknown",
matches: [
{
source_index: 0,
resolved_url: "https://app.test/dir/original.ts",
content: { text: "original" },
},
{
source_index: 1,
resolved_url: "https://app.test/dir//original.ts",
content: { text: "second" },
},
],
runtime: {
id: process.versions.bun === undefined ? "node-v8" : "bun",
},
},
});
expectSourceLocationLimitations(response.json);
const transport = new StdioClientTransport({
command: process.execPath,
args: [
fileURLToPath(new URL("../../scripts/rea.mjs", import.meta.url)),
"mcp",
],
env: {
...getDefaultEnvironment(),
REA_LOG_LEVEL: "silent",
CLANG_MODULE_CACHE_PATH: map,
},
stderr: "pipe",
});
const client = new Client(
{
name: "source-location-cli-parity",
version: "1",
},
{ jsonSchemaValidator: createMcpSchemaValidation() },
);
onTestFinished(async () => {
try {
await client.close();
} finally {
await transport.close();
}
});
await client.connect(transport);
const input = {
manifest_path: manifest,
script_index: 0,
source_map: { path: map, url: fixture.sourceMap.url },
generated_position: { line: 1, column: 0 },
};
const mcpResponse = await client.callTool({
name: "trace_web_source_location",
arguments: input,
});
expect(mcpResponse.isError, JSON.stringify(mcpResponse)).not.toBe(true);
expect(mcpResponse.structuredContent).toEqual(response.json);
await expectForwardSlashManifestTrace(client, input, response.json);
await expectEqualPositionSummary(client, input);
const pastColumn = await client.callTool({
name: "trace_web_source_location",
arguments: {
manifest_path: manifest,
script_index: 0,
source_map: { path: map, url: fixture.sourceMap.url },
generated_position: { line: 1, column: 10 },
},
});
expectColumnOutOfRange(pastColumn, fixture.source.length);
const invalid = await cli.run({
arguments: [
"trace-web-source-location",
manifest,
"0",
map,
fixture.sourceMap.url,
"2",
"0",
"--json",
],
environment: { REA_LOG_LEVEL: "silent" },
});
expect(invalid.exitCode).toBe(1);
expectInvalidSourceLocation(
invalid.json,
manifest,
root,
map,
fixture.sourceMap.text,
);
},
);
cliTest(
"applies the shared version constraint to nested indexed maps through CLI and stdio MCP",
{ tags: ["long-running"] },
async ({ cli }) => {
const root = await createTestTempDirectory("rea-indexed-map-version-");
const fixture = webSourceLocationFixture();
await mkdir(join(root, "files", "modules"), { recursive: true });
await writeFile(join(root, "files", "modules", "main.js"), fixture.source);
const manifest = join(root, "manifest.json");
await writeFile(manifest, JSON.stringify(fixture.manifest));
const { call } = await connectLocalToolsMcp({
REA_BROWSER_EXECUTABLE: "relative-unconfigured-browser",
});
const leaf: unknown = JSON.parse(fixture.sourceMap.text);
for (const [index, version] of [3, 2, null, undefined, "3"].entries()) {
const text = JSON.stringify({
version: 3,
sections: [
{
offset: { line: 0, column: 0 },
map: {
version,
sections: [{ offset: { line: 0, column: 0 }, map: leaf }],
},
},
],
});
const path = join(root, `nested-${index}.map`);
await writeFile(path, text);
const result = await cli.run({
arguments: [
"trace-web-source-location",
manifest,
"0",
path,
fixture.sourceMap.url,
"1",
"0",
"--json",
],
environment: {
REA_LOG_LEVEL: "silent",
REA_BROWSER_EXECUTABLE: "relative-unconfigured-browser",
},
});
const response = await call("trace_web_source_location", {
manifest_path: manifest,
script_index: 0,
source_map: { path, url: fixture.sourceMap.url },
generated_position: { line: 1, column: 0 },
});
if (version === 3) {
expect(result.exitCode, result.stderr).toBe(0);
expect(result.json).toMatchObject({
normalized_result: {
matches: [
{
state: "mapped",
section_path: [0, 0],
content: { text: "original" },
},
],
},
});
expect(response.isError, JSON.stringify(response)).not.toBe(true);
expect(response.structuredContent).toEqual(result.json);
} else {
const failure = {
code: "invalid_request",
details: {
partial_observation: {
kind: "web-trace-observation",
analysis: "incomplete",
manifest: {
path: manifest,
sha256: createHash("sha256")
.update(JSON.stringify(fixture.manifest))
.digest("hex"),
},
source: {
path: join(root, "files", "modules", "main.js"),
sha256: createHash("sha256")
.update(fixture.source)
.digest("hex"),
},
source_map: {
path,
sha256: createHash("sha256").update(text).digest("hex"),
bytes: Buffer.byteLength(text),
},
},
issues: [
{
path: ["source_map", "path"],
reason: "invalid_format",
message: expect.stringContaining(
"not a version 3 map. Section path: [0].",
),
},
],
},
};
expect(result.exitCode).toBe(1);
expect(result.json).toMatchObject(failure);
expect(result.json).not.toHaveProperty("normalized_result");
expect(parseMcpToolError(response).error).toMatchObject(failure);
expect(response.structuredContent).toBeUndefined();
}
}
},
);
cliTest(
"traces empty equal-offset sections while rejecting decreasing offsets and represented overlaps",
{ tags: ["long-running"] },
async ({ cli }) => {
const root = await createTestTempDirectory("rea-empty-indexed-map-");
const fixture = webSourceLocationFixture();
await mkdir(join(root, "files", "modules"), { recursive: true });
await writeFile(join(root, "files", "modules", "main.js"), fixture.source);
const manifest = join(root, "manifest.json");
await writeFile(manifest, JSON.stringify(fixture.manifest));
const { call } = await connectLocalToolsMcp();
const leaf: unknown = JSON.parse(fixture.sourceMap.text);
const empty = { version: 3, sources: [], names: [], mappings: "" };
const nestedEmpty = {
version: 3,
sections: [{ offset: { line: 0, column: 0 }, map: empty }],
};
for (const [index, sample] of [
{ first: empty, firstColumn: 0, nextColumn: 0, succeeds: true },
{ first: nestedEmpty, firstColumn: 0, nextColumn: 0, succeeds: true },
{ first: empty, firstColumn: 0, nextColumn: 1, succeeds: true },
{ first: leaf, firstColumn: 0, nextColumn: 0, succeeds: false },
{ first: empty, firstColumn: 1, nextColumn: 0, succeeds: false },
].entries()) {
const path = join(root, `empty-${index}.map`);
await writeFile(
path,
JSON.stringify({
version: 3,
sections: [
{
offset: { line: 0, column: sample.firstColumn },
map: sample.first,
},
{ offset: { line: 0, column: sample.nextColumn }, map: leaf },
],
}),
);
const result = await cli.run({
arguments: [
"trace-web-source-location",
manifest,
"0",
path,
fixture.sourceMap.url,
"1",
String(sample.nextColumn),
"--json",
],
environment: { REA_LOG_LEVEL: "silent" },
});
const response = await call("trace_web_source_location", {
manifest_path: manifest,
script_index: 0,
source_map: { path, url: fixture.sourceMap.url },
generated_position: { line: 1, column: sample.nextColumn },
});
if (sample.succeeds) {
expect(result.exitCode, result.stderr).toBe(0);
expect(result.json).toMatchObject({
normalized_result: {
lookup: {
matched_generated_position: {
line: 1,
column: sample.nextColumn,
},
},
matches: [
{
state: "mapped",
section_path: [1],
content: { text: "original" },
},
],
},
});
expect(response.isError, JSON.stringify(response)).not.toBe(true);
expect(response.structuredContent).toEqual(result.json);
} else {
const failure = {
code: "invalid_request",
details: {
issues: [
{
path: ["source_map", "path"],
reason: "invalid_format",
message: expect.stringMatching(/overlap|nondecreasing/u),
},
],
},
};
expect(result.exitCode).toBe(1);
expect(result.json).toMatchObject(failure);
expect(parseMcpToolError(response).error).toMatchObject(failure);
}
}
},
);
cliTest(
"resolves empty-sourceRoot sources against the map URL through CLI and stdio MCP",
{ tags: ["long-running"] },
async ({ cli }) => {
const root = await createTestTempDirectory("rea-empty-source-root-");
// webpack 5 and tsc emit `"sourceRoot": ""` for map-relative sources.
const text = JSON.stringify({
version: 3,
sourceRoot: "",
sources: ["../src/a.ts", "webpack://app/./src/b.ts", "dir//c.ts"],
sourcesContent: ["a", "b", "c"],
names: [],
mappings: "AAAA,ACAA,ACAA",
});
const fixture = webSourceLocationFixture(text);
await mkdir(join(root, "files", "modules"), { recursive: true });
await writeFile(join(root, "files", "modules", "main.js"), fixture.source);
const manifest = join(root, "manifest.json");
await writeFile(manifest, JSON.stringify(fixture.manifest));
const map = join(root, "app.js.map");
await writeFile(map, text);
const url = "https://cdn.test/npm/app@1/dist/app.js.map";
const result = await cli.run({
arguments: [
"trace-web-source-location",
manifest,
"0",
map,
url,
"1",
"0",
"--json",
],
environment: {
REA_LOG_LEVEL: "silent",
REA_BROWSER_EXECUTABLE: "relative-unconfigured-browser",
},
});
expect(result.exitCode, result.stdout + result.stderr).toBe(0);
expect(result.json).toMatchObject({
normalized_result: {
matches: [
{
source_index: 0,
reported_source_root: "",
resolved_url: "https://cdn.test/npm/app@1/src/a.ts",
},
{
source_index: 1,
reported_source_root: "",
resolved_url: "webpack://app/src/b.ts",
},
{
source_index: 2,
reported_source_root: "",
resolved_url: "https://cdn.test/npm/app@1/dist/dir//c.ts",
},
],
},
});
const { call } = await connectLocalToolsMcp({
REA_BROWSER_EXECUTABLE: "relative-unconfigured-browser",
});
const response = await call("trace_web_source_location", {
manifest_path: manifest,
script_index: 0,
source_map: { path: map, url },
generated_position: { line: 1, column: 0 },
});
expect(response.isError, JSON.stringify(response)).not.toBe(true);
expect(response.structuredContent).toEqual(result.json);
},
);
cliTest(
"raises local source-map admission and recovers the same complete map through the owned codec",
async ({ cli }) => {
const root = await createTestTempDirectory("rea-source-map-budget-cli-");
const fixture = webSourceLocationFixture(
JSON.stringify({
version: 3,
sources: ["original.ts"],
sourcesContent: ["original"],
names: [],
mappings: "AAAA",
x_padding: "x".repeat(1024),
}),
);
await mkdir(join(root, "files", "modules"), { recursive: true });
await writeFile(join(root, "files", "modules", "main.js"), fixture.source);
const manifest = join(root, "manifest.json");
const map = join(root, "app.js.map");
await writeFile(manifest, JSON.stringify(fixture.manifest));
await writeFile(map, fixture.sourceMap.text);
const args = [
"trace-web-source-location",
manifest,
"0",
map,
fixture.sourceMap.url,
"1",
"0",
"--format",
"json",
];
const refused = await cli.run({
arguments: [...args, "--source-map-bytes", "128"],
});
expect(refused.exitCode).toBe(1);
expect((refused.json as { code?: unknown }).code).toBe("truncated");
expect(refused.json).toMatchObject({
code: "truncated",
details: {
detail: expect.stringContaining("source_map_limits.map_bytes"),
},
});
const recovered = await cli.run({
arguments: [
...args,
"--source-map-bytes",
String(Buffer.byteLength(fixture.sourceMap.text)),
],
});
expect(recovered.exitCode, recovered.stderr).toBe(0);
expect(recovered.json).toMatchObject({
parameters: {
source_map_limits: {
map_bytes: Buffer.byteLength(fixture.sourceMap.text),
},
},
normalized_result: {
source_map: {
sha256: createHash("sha256")
.update(fixture.sourceMap.text)
.digest("hex"),
},
matches: [
{ reported_source: "original.ts", content: { text: "original" } },
],
},
});
},
);
cliTest(
"admits a complete map above 4 MiB by default while honoring a smaller caller budget",
{ tags: ["long-running"] },
async ({ cli }) => {
const root = await createTestTempDirectory("rea-map-default-admission-");
const fixture = webSourceLocationFixture(
JSON.stringify({
version: 3,
sources: ["original.ts"],
sourcesContent: ["original"],
names: [],
mappings: "AAAA",
x_retained_extension: "x".repeat(6 * 1024 * 1024),
}),
);
await mkdir(join(root, "files", "modules"), { recursive: true });
await writeFile(join(root, "files", "modules", "main.js"), fixture.source);
const manifest = join(root, "manifest.json");
const map = join(root, "app.js.map");
await writeFile(manifest, JSON.stringify(fixture.manifest));
await writeFile(map, fixture.sourceMap.text);
const arguments_ = [
"trace-web-source-location",
manifest,
"0",
map,
fixture.sourceMap.url,
"1",
"0",
"--json",
];
const refused = await cli.run({
arguments: [...arguments_, "--source-map-bytes", "4194304"],
});
expect(refused.exitCode).toBe(1);
expect(JSON.stringify(refused.json)).toContain(
"source_map_limits.map_bytes",
);
const completed = await cli.run({
arguments: arguments_,
});
expect(completed.exitCode, completed.stderr).toBe(0);
const evidence = completed.json as {
evidence_id: string;
normalized_result: unknown;
raw_result: { source_map_text: string };
};
expect(evidence.normalized_result).toMatchObject({
source_map: { sha256: fixture.sourceMap.file.sha256 },
matches: [{ source_index: 0, content: { text: "original" } }],
});
expect(
createHash("sha256")
.update(evidence.raw_result.source_map_text)
.digest("hex"),
).toBe(fixture.sourceMap.file.sha256);
await expectCliSourceLocationSummary(cli, arguments_, {
bundlePath: join(root, "cli-complete.json"),
evidenceId: evidence.evidence_id,
sha256: fixture.sourceMap.file.sha256,
});
const { call } = await connectLocalToolsMcp();
const input = {
manifest_path: manifest,
script_index: 0,
source_map: { path: map, url: fixture.sourceMap.url },
generated_position: { line: 1, column: 0 },
};
const overflow = await call("trace_web_source_location", input);
expect(parseMcpToolError(overflow).error).toMatchObject({
code: "resource_constraint",
details: {
reported_limits: {
boundary: "mcp-response",
evidence_reference: {
kind: "retained-evidence",
evidence_id: evidence.evidence_id,
},
continuation: {
name: "inspect_analysis_view",
arguments: {
view: { kind: "source-location", collection: "matches" },
},
},
},
},
});
await unlink(map);
const source = {
kind: "retained-evidence",
evidence_id: evidence.evidence_id,
};
const page = await call("inspect_analysis_view", {
source,
view: {
kind: "source-location",
collection: "matches",
offset: 0,
limit: 1,
},
});
expect(page.isError).not.toBe(true);
expect(page.structuredContent).toMatchObject({
normalized_result: {
items: [
{
match_index: 0,
source_index: 0,
original_position: { line: 1, column: 0 },
},
],
coverage: { total: 1, exhausted: true },
},
});
const text = await call("inspect_analysis_view", {
source,
view: {
kind: "source-location",
collection: "source-text",
match_index: 0,
offset: 0,
limit: 8,
},
});
expect(text.isError).not.toBe(true);
expect(text.structuredContent).toMatchObject({
normalized_result: { item: { text: "original" } },
});
const exportPath = join(root, "session-complete.json");
expect(
(await call("export_evidence_bundle", { path: exportPath })).isError,
).not.toBe(true);
await expectRetainedSourceMap(
exportPath,
evidence.evidence_id,
fixture.sourceMap.file.sha256,
);
const emptyMap = '{"version":3,"sources":[],"names":[],"mappings":""}';
await writeFile(map, emptyMap);
const empty = await call("trace_web_source_location", {
...input,
detail: "summary",
});
expect(empty.isError).not.toBe(true);
expect(empty.structuredContent).toMatchObject({
normalized_result: {
summary: { match_count: 0, matches: [] },
coverage: { status: "empty", total: 0, exhausted: true },
},
});
},
);