Files
reverse-engineering-anything/src/domain/analysisView/playwrightTraceView.ts
T
morluto 4bd578cc08 refactor(views): give complete-within-view coverage only the returned count (#11132)
* refactor(views): give complete-within-view coverage only the returned count

* test(views): keep only the item-view coverage assertion whose fixture distinguishes it
2026-11-15 21:30:45 +08:00

352 lines
9.1 KiB
TypeScript

import {
analysisTextPage,
analysisTextPageItemSchema,
} from "./analysisViewText.js";
import { z } from "zod";
import {
playwrightTraceSchema,
traceEventSchema,
traceSourceSchema,
traceMemberSchema,
traceStreamSchema,
traceDiagnosticSchema,
PLAYWRIGHT_TRACE_OPERATION,
type PlaywrightTrace,
} from "../playwrightTrace/playwrightTrace.js";
import { playwrightTraceViewRequestSchema } from "../playwrightTrace/playwrightTraceQuery.js";
import type { JsonValue } from "../jsonValue.js";
import { err, ok } from "../result.js";
import {
createAnalysisViewResultReader,
type AnalysisViewParent,
} from "./analysisViewParent.js";
import {
ownedView,
type AdmittedView,
type SummaryAnalysisView,
} from "./analysisViewShape.js";
import {
analysisViewCoverageSchema,
boundedViewMessages,
completeWithinViewCoverage,
pageViewCoverage,
} from "./analysisViewCoverage.js";
import { selectViewRows } from "./selectViewRows.js";
import { analysisViewInputError } from "./analysisViewErrors.js";
export const playwrightTraceViewContextSchema = playwrightTraceSchema
.omit({
streams: true,
members: true,
events: true,
diagnostics: true,
limitations: true,
})
.extend({
counts: z.strictObject({
streams: z.int().nonnegative(),
members: z.int().nonnegative(),
diagnostics: z.int().nonnegative(),
}),
});
export const playwrightTraceViewItemsSchema = z.union([
z.array(
analysisTextPageItemSchema.extend({
event_id: traceEventSchema.shape.event_id,
source: traceSourceSchema,
}),
),
z.array(
traceEventSchema
.partial()
.required({
event_id: true,
stream_id: true,
ordinal: true,
source: true,
kind: true,
credential_redacted: true,
})
.extend({
text_preview: analysisTextPageItemSchema
.extend({ coverage: analysisViewCoverageSchema })
.nullable()
.optional(),
}),
),
z.array(
traceMemberSchema.partial().required({
member_id: true,
path: true,
logical_path: true,
kind: true,
encrypted: true,
decoded: true,
limitations: true,
}),
),
z.array(
traceStreamSchema.partial().required({
stream_id: true,
member_id: true,
role: true,
version: true,
state: true,
}),
),
z.array(
traceDiagnosticSchema.partial().required({
diagnostic_id: true,
member_id: true,
line: true,
code: true,
}),
),
]);
const readReport = createAnalysisViewResultReader(playwrightTraceSchema);
const values = (selected: readonly string[] | undefined) =>
selected === undefined ? undefined : new Set(selected);
const allows = (
selection: ReadonlySet<string> | undefined,
value: string | null,
) => selection === undefined || (value !== null && selection.has(value));
const fields = (row: object, selected: readonly string[]) =>
Object.fromEntries(
selected.map((key) => [key, (row as Record<string, JsonValue>)[key]!]),
);
type View = z.output<typeof playwrightTraceViewRequestSchema>;
const eventFields = (
row: PlaywrightTrace["events"][number],
view: Extract<View, { collection: "events" }>,
) => {
const selected = view.fields?.filter((field) => field !== "text_preview") ?? [
"call_id",
"page_id",
"time",
"method",
"url",
"status",
"selector",
"resource_references",
];
const preview =
view.fields === undefined || view.fields.includes("text_preview");
let text_preview:
| (z.output<typeof analysisTextPageItemSchema> & {
coverage: z.output<typeof analysisViewCoverageSchema>;
})
| null = null;
if (preview && row.text !== null) {
const page = analysisTextPage(row.text, 0, 256, "Recorded event text");
if (!page.ok) throw page.error;
text_preview = { ...page.value.item, coverage: page.value.coverage };
}
return {
...fields(row, selected),
...(preview ? { text_preview } : {}),
event_id: row.event_id,
stream_id: row.stream_id,
ordinal: row.ordinal,
source: row.source,
kind: row.kind,
credential_redacted: row.credential_redacted,
};
};
const selectRows = (
report: PlaywrightTrace,
view: Exclude<View, { collection: "event-text" }>,
) => {
if (view.collection === "events") {
const ids = values(view.event_ids),
streams = values(view.stream_ids),
kinds = values(view.kinds),
calls = values(view.call_ids);
return selectViewRows(
report.events,
view,
(row) =>
allows(ids, row.event_id) &&
allows(streams, row.stream_id) &&
allows(kinds, row.kind) &&
allows(calls, row.call_id),
(row) => eventFields(row, view),
);
}
if (view.collection === "members") {
const ids = values(view.member_ids),
paths = values(view.paths);
return selectViewRows(
report.members,
view,
(row) => allows(ids, row.member_id) && allows(paths, row.path),
(row) => ({
...fields(
row,
view.fields ?? ["declared_bytes", "declared_compressed_bytes"],
),
member_id: row.member_id,
path: row.path,
logical_path: row.logical_path,
kind: row.kind,
encrypted: row.encrypted,
decoded: row.decoded,
limitations: row.limitations,
}),
);
}
if (view.collection === "streams") {
const ids = values(view.stream_ids);
return selectViewRows(
report.streams,
view,
(row) => allows(ids, row.stream_id),
(row) => ({
...fields(
row,
view.fields ?? ["producer", "lines", "supported_events"],
),
stream_id: row.stream_id,
member_id: row.member_id,
role: row.role,
version: row.version,
state: row.state,
}),
);
}
const codes = values(view.codes);
return selectViewRows(
report.diagnostics,
view,
(row) => allows(codes, row.code),
(row) => ({
...fields(row, view.fields ?? ["message"]),
diagnostic_id: row.diagnostic_id,
member_id: row.member_id,
line: row.line,
code: row.code,
}),
);
};
const selectEventText = (
report: PlaywrightTrace,
view: Extract<View, { collection: "event-text" }>,
) => {
const event = report.events.find((row) => row.event_id === view.event_id);
if (event === undefined || event.text === null)
return err(
analysisViewInputError([
{
path: ["view", "event_id"],
reason: "invalid_value",
message:
"Choose a retained event with interpreted text; events without a text value remain unknown.",
},
]),
);
const page = analysisTextPage(
event.text,
view.offset,
view.limit,
"Recorded event text",
);
if (!page.ok) return page;
return ok({
items: [
{ ...page.value.item, event_id: event.event_id, source: event.source },
],
coverage: page.value.coverage,
});
};
/** Counts do not materialize stream/member/event arrays into the initial agent response. */
export const projectPlaywrightTraceView = (
parent: AnalysisViewParent,
admitted: AdmittedView,
) => {
const view = ownedView<SummaryAnalysisView | View>(
admitted,
"summary",
"playwright-trace",
);
if (view === undefined)
return err(
analysisViewInputError([
{
path: ["view"],
reason: "invalid_value",
message:
"Playwright trace inventories support summary and playwright-trace pages.",
},
]),
);
const parsed = readReport(parent);
if (!parsed.ok) return parsed;
const {
streams,
members,
events: _events,
diagnostics,
limitations,
...metadata
} = parsed.value;
const context = {
...metadata,
counts: {
streams: streams.length,
members: members.length,
diagnostics: diagnostics.length,
},
};
const shared = {
parent_evidence_id: parent.evidenceId,
parent_operation: PLAYWRIGHT_TRACE_OPERATION,
parent_digest: parent.evidenceId.slice(3),
limitations: boundedViewMessages(
[...parent.limitations, ...limitations],
parent.evidenceId,
"limitations",
),
unknowns: [
"Recording completeness and cross-stream ordering remain unknown. Resource contents are not decoded.",
],
};
if (view.kind === "summary")
return ok({
...shared,
kind: "summary" as const,
view,
artifact: {
path: context.artifact.path,
sha256: context.artifact.sha256,
},
summary: context,
coverage: completeWithinViewCoverage(1),
});
if (view.collection === "event-text") {
const text = selectEventText(parsed.value, view);
return text.ok
? ok({
...shared,
...context,
kind: "playwright-trace" as const,
view,
...text.value,
})
: text;
}
const selected = selectRows(parsed.value, view);
return ok({
...shared,
...context,
kind: "playwright-trace" as const,
view,
items: selected.rows,
coverage: pageViewCoverage(
view.offset,
selected.rows.length,
selected.total,
),
});
};