@nextcommerce/campaigns-os 1.33.0

package/src/polish-capture.mjs

@@ -0,0 +1,1094 @@
+import { createHash } from "node:crypto";
+
+function normalizeString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function normalizedToken(value) {
+  return normalizeString(value)?.toLocaleLowerCase("en-US") || "";
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export const POLISH_ROUTE_CAPTURE_SCHEMA_VERSION = "campaigns-os-polish-route-capture/v0";
+export const POLISH_CAPTURE_PRODUCER = "campaigns-os polish capture";
+export const POLISH_CAPTURE_INTEGRITY_SCHEMA_VERSION = "campaigns-os-polish-route-capture-integrity/v0";
+export const POLISH_CAPTURE_INTEGRITY_ALGORITHM = "sha256";
+export const MAX_PAGE_LOAD_RESOURCE_LEDGER_ENTRIES = 2_048;
+export const MAX_PAGE_LOAD_RESPONSE_RECORDS = 4_096;
+export const MAX_PAGE_LOAD_MEDIA_ELEMENTS = 512;
+export const MAX_PAGE_LOAD_MEDIA_SOURCES_PER_ELEMENT = 32;
+export const MAX_PAGE_LOAD_MEDIA_ANCESTORS = 64;
+export const MAX_POLISH_CAPTURE_URL_LENGTH = 8_192;
+export const POLISH_RESOURCE_TYPES = Object.freeze([
+  "cspviolationreport",
+  "document",
+  "eventsource",
+  "fetch",
+  "font",
+  "image",
+  "manifest",
+  "media",
+  "other",
+  "ping",
+  "prefetch",
+  "preflight",
+  "script",
+  "signedexchange",
+  "stylesheet",
+  "texttrack",
+  "unknown",
+  "websocket",
+  "xhr",
+]);
+export const POLISH_PRELOAD_ATTRIBUTES = Object.freeze([
+  "auto",
+  "empty",
+  "metadata",
+  "missing",
+  "none",
+  "other",
+]);
+
+const KNOWN_RESOURCE_TYPES = new Set(POLISH_RESOURCE_TYPES.filter((value) => value !== "unknown"));
+// Beacon-class resource roles: one-shot programmatic requests whose failure
+// says nothing about what the page renders. This is a deliberate allowlist.
+// A failed cross-origin request in one of these roles is a warning; a failed
+// request in any other role — document, script, stylesheet, image, font,
+// media, and also the roles that are not beacons even though nothing renders
+// from them (a caption track, a manifest, an event stream, a CSP report
+// endpoint, a prefetch hint, a signed exchange, a websocket) — blocks
+// whatever its origin, as does an unknown or ambiguous type. Widening this
+// list is an operator-visible trade-off, not a tidy-up.
+export const POLISH_BEACON_RESOURCE_TYPES = Object.freeze([
+  "fetch",
+  "other",
+  "ping",
+  "preflight",
+  "xhr",
+]);
+const BEACON_RESOURCE_TYPES = new Set(POLISH_BEACON_RESOURCE_TYPES);
+// Problem codes that are recorded on the capture but do not make it
+// incomplete: they carry evidence the operator should see without turning
+// measured-complete evidence into an unwaivable block.
+export const POLISH_CAPTURE_WARNING_PROBLEM_CODES = Object.freeze([
+  "cross_origin_request_failed",
+]);
+const WARNING_PROBLEM_CODES = new Set(POLISH_CAPTURE_WARNING_PROBLEM_CODES);
+
+export function polishCaptureMeasurementStatus(problems) {
+  return (Array.isArray(problems) ? problems : []).some((problem) => !WARNING_PROBLEM_CODES.has(problem?.code))
+    ? "incomplete"
+    : "complete";
+}
+
+// A failed request is attributed to a class by origin and role. Failed
+// requests grouped under one ledger entry share both, so the class can be
+// recomputed from the entry alone (polish-page-load.mjs does exactly that).
+export function failedRequestProblemCode({ crossOrigin, resourceType }) {
+  return crossOrigin && BEACON_RESOURCE_TYPES.has(resourceType)
+    ? "cross_origin_request_failed"
+    : "dependency_request_failed";
+}
+
+// The signature of a production build served over plain HTTP: the document
+// came from an http: origin and a dependency-class request to a DIFFERENT
+// http: origin failed. A protocol-relative vendor loader (`//host/...`, which
+// the starter templates emit outside the development environment) resolves to
+// http://host/... off an http://localhost document and fails there, voiding
+// the capture. Read off the finished ledger, so the recorded checkpoint can
+// name the right action (rebuild in local proof mode) without re-reading the
+// browser. Returns the failing ledger entries, empty when the signature is
+// absent — including for an https: capture, where a failed http: dependency
+// is a page defect rather than an environment mismatch.
+export function plainHttpDependencyFailures(capture) {
+  const captureOrigin = capture?.document_response?.capture_origin;
+  if (typeof captureOrigin !== "string" || !captureOrigin.startsWith("http://")) return [];
+  const entries = Array.isArray(capture?.resource_ledger?.entries) ? capture.resource_ledger.entries : [];
+  return entries.filter((resource) => (
+    (resource?.failed_request_count || 0) > 0
+    && (resource?.cross_origin_request_count || 0) > 0
+    && typeof resource?.url === "string"
+    && resource.url.startsWith("http://")
+    && failedRequestProblemCode({ crossOrigin: true, resourceType: resource.resource_type }) === "dependency_request_failed"
+  ));
+}
+
+function resolvedCaptureUrl(value, { baseUrl } = {}) {
+  if (value === "[url-too-long]" || baseUrl === "[url-too-long]") {
+    return { status: "too_long", canonical: null, projected: "[url-too-long]", origin: null };
+  }
+  if ((typeof value === "string" && value.length > MAX_POLISH_CAPTURE_URL_LENGTH)
+    || (typeof baseUrl === "string" && baseUrl.length > MAX_POLISH_CAPTURE_URL_LENGTH)) {
+    return { status: "too_long", canonical: null, projected: "[url-too-long]", origin: null };
+  }
+  const text = normalizeString(value);
+  if (!text) return { status: "empty", canonical: null, projected: null, origin: null };
+  try {
+    const url = baseUrl ? new URL(text, baseUrl) : new URL(text);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return { status: "non_http", canonical: null, projected: "[non-http-url]", origin: null };
+    }
+    url.hash = "";
+    url.username = "";
+    url.password = "";
+    return {
+      status: "http",
+      canonical: url.href,
+      projected: `${url.origin}${url.pathname}`,
+      origin: url.origin,
+    };
+  } catch {
+    return { status: "malformed", canonical: null, projected: "[malformed-url]", origin: null };
+  }
+}
+
+export function redactCaptureUrl(value, { baseUrl } = {}) {
+  return resolvedCaptureUrl(value, { baseUrl }).projected;
+}
+
+// The one "HTTP(S) origin or null" parser. Every reader that wants a capture
+// URL's origin — the producer, the validator, the text renderer, the browser
+// adapter and the parity capture's credential guard — calls this, so the
+// scheme rule and the length cap exist once. Never throws and never echoes
+// the value: a URL carrying credentials or query data must not reach a log.
+export function captureOrigin(value) {
+  if (typeof value !== "string" || value.length > MAX_POLISH_CAPTURE_URL_LENGTH) return null;
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:" ? url.origin : null;
+  } catch {
+    return null;
+  }
+}
+
+function resourceId(canonicalUrl) {
+  return `sha256:${createHash("sha256").update(canonicalUrl).digest("hex")}`;
+}
+
+// Key-sorted deep copy, so two captures that state the same facts serialize
+// to the same bytes. No cycle guard, deliberately: values reach this module
+// from fresh literals or from JSON.parse, and neither can carry a cycle.
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+export function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+
+function integrityFingerprint(value) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}
+
+function captureAssociationProjection(capture) {
+  return {
+    resources: (Array.isArray(capture?.resource_ledger?.entries) ? capture.resource_ledger.entries : []).map((resource) => ({
+      resource_id: resource?.resource_id,
+      match_resource_ids: Array.isArray(resource?.match_resource_ids) ? resource.match_resource_ids : [],
+    })),
+    media: (Array.isArray(capture?.media) ? capture.media : []).map((media) => ({
+      element_index: media?.element_index,
+      source_references: (Array.isArray(media?.source_references) ? media.source_references : []).map((reference) => ({
+        source_kind: reference?.source_kind,
+        source_index: reference?.source_index,
+        resource_id: reference?.resource_id,
+      })),
+      fetched_resources: (Array.isArray(media?.fetched_resources) ? media.fetched_resources : []).map((resource) => ({
+        resource_id: resource?.resource_id,
+        matched_source_resource_ids: Array.isArray(resource?.matched_source_resource_ids)
+          ? resource.matched_source_resource_ids
+          : [],
+      })),
+    })),
+  };
+}
+
+export function buildPolishCaptureIntegrity(captureProjection) {
+  const { integrity: ignoredIntegrity, ...projection } = captureProjection || {};
+  const associationFingerprint = integrityFingerprint(captureAssociationProjection(projection));
+  // This is a versioned tamper-evidence checksum for package-produced artifacts, not a keyed
+  // signature. A malicious local editor who rewrites the artifact and recalculates both hashes can
+  // forge it; its job is to expose accidental or partial mutation between capture and evaluation.
+  return {
+    schema_version: POLISH_CAPTURE_INTEGRITY_SCHEMA_VERSION,
+    algorithm: POLISH_CAPTURE_INTEGRITY_ALGORITHM,
+    association_fingerprint: associationFingerprint,
+    projection_fingerprint: integrityFingerprint({
+      schema_version: POLISH_CAPTURE_INTEGRITY_SCHEMA_VERSION,
+      association_fingerprint: associationFingerprint,
+      capture: projection,
+    }),
+  };
+}
+
+function resolvedResource(value, { baseUrl } = {}) {
+  const resolved = resolvedCaptureUrl(value, { baseUrl });
+  return {
+    ...resolved,
+    resource_id: resolved.canonical ? resourceId(resolved.canonical) : null,
+  };
+}
+
+function validComputedStyle(style) {
+  return isPlainObject(style)
+    && typeof style.display === "string"
+    && style.display.trim() !== ""
+    && typeof style.visibility === "string"
+    && style.visibility.trim() !== "";
+}
+
+function addProblemCount(problemCounts, code, count = 1) {
+  if (!Number.isInteger(count) || count <= 0) return;
+  problemCounts.set(code, (problemCounts.get(code) || 0) + count);
+}
+
+function projectedProblems(problemCounts) {
+  return [...problemCounts]
+    .map(([code, count]) => ({ code, count }))
+    .sort((a, b) => a.code.localeCompare(b.code));
+}
+
+function normalizeResourceType(value) {
+  const token = normalizedToken(value);
+  return KNOWN_RESOURCE_TYPES.has(token)
+    ? { value: token, status: "known" }
+    : { value: "unknown", status: "unknown" };
+}
+
+// A ledger entry's resource_type_status is "known" exactly when its type is a
+// named role; "unknown" and "ambiguous" both carry the type "unknown".
+export function resourceTypeKnown(resourceType) {
+  return KNOWN_RESOURCE_TYPES.has(resourceType);
+}
+
+// ---------------------------------------------------------------------------
+// The response record: the one shape the browser collector
+// (polish-browser.mjs, createNetworkCollector) emits into `responses[]` and
+// the aggregator below reads. There is exactly one producer, so the
+// aggregator trusts what these constructors build — hop numbering, request
+// identity and sentinel spelling are decided here, once, and never
+// re-validated on the way in. Tests that hand-build records go through the
+// same constructors. The shape is documented in docs/polish-evidence.md.
+//
+//   captureProblemRecord(code)           { capture_problem: code }
+//   singleResponseRecord(id, response)   { request_id: id, ...response }
+//   redirectChainRecord(id, responses)   { request_id: id, redirect_chain:
+//                                          [{ ...response, redirect_hop: 0 }, …] }
+//
+// A response carries `url`, `resource_type`, `status`, `mime_type`,
+// `encoded_data_length` / `declared_data_length`, `canceled`, `source_urls`,
+// the three cache flags below, `from_service_worker` and `failed`; the final
+// main document additionally carries `is_final_main_document` and
+// `document_context_fingerprint`.
+// ---------------------------------------------------------------------------
+
+// The cache observations the collector projects from CDP. A response is
+// cache-served when any of them is true; no other spelling is read.
+export const POLISH_RESPONSE_CACHE_FLAGS = Object.freeze([
+  "from_disk_cache",
+  "from_prefetch_cache",
+  "request_served_from_cache",
+]);
+
+// In-band sentinels: a record that carries a problem instead of a response.
+// The collector emits `response_record_overflow` when it dropped responses
+// past MAX_PAGE_LOAD_RESPONSE_RECORDS and `document_context_changed` when the
+// main frame or loader changed under the capture.
+export const POLISH_CAPTURE_SENTINEL_PROBLEM_CODES = Object.freeze([
+  "document_context_changed",
+  "response_record_overflow",
+]);
+const CAPTURE_SENTINEL_PROBLEM_CODES = new Set(POLISH_CAPTURE_SENTINEL_PROBLEM_CODES);
+
+export function captureProblemRecord(code) {
+  if (!CAPTURE_SENTINEL_PROBLEM_CODES.has(code)) {
+    throw new Error(`Unknown polish capture sentinel problem code: ${String(code)}`);
+  }
+  return { capture_problem: code };
+}
+
+export function captureProblemRecordCode(record) {
+  return isPlainObject(record) && CAPTURE_SENTINEL_PROBLEM_CODES.has(record.capture_problem)
+    ? record.capture_problem
+    : null;
+}
+
+// The constructors are the one place a response is checked to be a record:
+// a non-object hop is a producer bug, so it throws here rather than being
+// read as an observation downstream.
+function assertResponse(response) {
+  if (!isPlainObject(response)) {
+    throw new Error("A polish response record is built from a plain response object.");
+  }
+  return response;
+}
+
+export function singleResponseRecord(requestId, response) {
+  return { request_id: requestId, ...assertResponse(response) };
+}
+
+export function redirectChainRecord(requestId, responses) {
+  return {
+    request_id: requestId,
+    redirect_chain: responses.map((response, redirectHop) => ({ ...assertResponse(response), redirect_hop: redirectHop })),
+  };
+}
+
+// The responses a record stands for, in transfer order: a redirect chain's
+// hops, or the single response itself.
+export function responseRecordResponses(record) {
+  return isPlainObject(record) && Array.isArray(record.redirect_chain) ? record.redirect_chain : [record];
+}
+
+export function responseRecordFromCache(record) {
+  return POLISH_RESPONSE_CACHE_FLAGS.some((flag) => record?.[flag] === true);
+}
+
+// Every observed response with the chain it belongs to, bounded to
+// MAX_PAGE_LOAD_RESPONSE_RECORDS; sentinel records become problem counts.
+function prepareResponseRecords(responses, problemCounts) {
+  const prepared = [];
+  let omittedRecordCount = 0;
+  for (const record of (Array.isArray(responses) ? responses : [])) {
+    const sentinel = captureProblemRecordCode(record);
+    if (sentinel) {
+      addProblemCount(problemCounts, sentinel);
+      continue;
+    }
+    const chain = responseRecordResponses(record);
+    for (const [index, response] of chain.entries()) {
+      if (prepared.length >= MAX_PAGE_LOAD_RESPONSE_RECORDS) {
+        omittedRecordCount += chain.length - index;
+        break;
+      }
+      prepared.push({ record: response, chain });
+    }
+  }
+  if (omittedRecordCount > 0) {
+    addProblemCount(problemCounts, "response_record_overflow", omittedRecordCount);
+  }
+  return prepared;
+}
+
+// The derivations below are the producer's statements about a resource
+// ledger; the ones the page-load validator recomputes are exported so it
+// reads the same function instead of a second spelling of it. They take
+// ledger entries (or media projections) and nothing else.
+
+
+export function resourceLedgerSort(a, b) {
+  return String(a.url).localeCompare(String(b.url)) || String(a.resource_id).localeCompare(String(b.resource_id));
+}
+
+function largestResourceProjection(resources) {
+  const largest = [...resources].sort((a, b) => b.transferred_bytes - a.transferred_bytes || resourceLedgerSort(a, b))[0];
+  return largest ? {
+    resource_id: largest.resource_id,
+    url: largest.url,
+    resource_type: largest.resource_type,
+    transferred_bytes: largest.transferred_bytes,
+    request_count: largest.request_count,
+  } : null;
+}
+
+// The capture's metrics block, summed over the retained ledger entries.
+export function resourceLedgerMetrics(resources) {
+  const sum = (field) => resources.reduce((total, resource) => total + resource[field], 0);
+  return {
+    total_transferred_bytes: sum("transferred_bytes"),
+    request_count: sum("request_count"),
+    largest_resource: largestResourceProjection(resources),
+    cross_origin_request_count: sum("cross_origin_request_count"),
+    cache_request_count: sum("cache_request_count"),
+    service_worker_request_count: sum("service_worker_request_count"),
+  };
+}
+
+// The problem counts a ledger implies on its own: one per cached, service-
+// worker and unmeasured request, one per ambiguous or unknown-typed entry,
+// and the failed requests attributed by origin and role. Every request under
+// one entry shares the entry's origin relation and resolved type, so the
+// entry decides the class for all of its failed requests.
+export function ledgerProblemCounts(entries) {
+  const counts = {
+    cache_observed: 0,
+    service_worker_observed: 0,
+    transfer_size_unavailable: 0,
+    resource_type_ambiguous: 0,
+    resource_type_unknown: 0,
+    cross_origin_request_failed: 0,
+    dependency_request_failed: 0,
+  };
+  for (const resource of entries) {
+    counts.cache_observed += resource.cache_request_count;
+    counts.service_worker_observed += resource.service_worker_request_count;
+    counts.transfer_size_unavailable += resource.unmeasured_request_count;
+    if (resource.resource_type_status === "ambiguous") counts.resource_type_ambiguous += 1;
+    if (resource.resource_type_status === "unknown") counts.resource_type_unknown += 1;
+    if (resource.failed_request_count > 0) {
+      counts[failedRequestProblemCode({
+        crossOrigin: resource.cross_origin_request_count > 0,
+        resourceType: resource.resource_type,
+      })] += resource.failed_request_count;
+    }
+  }
+  return counts;
+}
+
+function documentResponseIdentity(value, { baseUrl } = {}) {
+  const resolved = resolvedCaptureUrl(value, { baseUrl });
+  if (resolved.status !== "http" || !resolved.canonical) return null;
+  try {
+    const url = new URL(resolved.canonical);
+    url.hash = "";
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+
+function normalizedDocumentMimeType(value) {
+  const token = typeof value === "string" ? value.split(";", 1)[0].trim().toLowerCase() : "";
+  if (token === "text/html") return "html";
+  if (token === "application/xhtml+xml") return "xhtml";
+  return token ? "other" : "unknown";
+}
+
+// Whether the document the browser settled on shares the origin the capture
+// was asked for; null on either side is a mismatch.
+export function originMatchesCapture(captureOrigin, finalOrigin) {
+  return Boolean(captureOrigin && finalOrigin && captureOrigin === finalOrigin);
+}
+
+// A final document response is complete only as a 200 HTML/XHTML page on the
+// requested origin; anything else is an error.
+export function documentResponseAcceptable({ http_status, mime_type, origin_matches_capture }) {
+  return http_status === 200
+    && (mime_type === "html" || mime_type === "xhtml")
+    && origin_matches_capture === true;
+}
+
+function assessFinalDocumentResponse(prepared, {
+  documentUrl,
+  requestedDocumentUrl,
+  problemCounts,
+}) {
+  const finalIdentity = documentResponseIdentity(documentUrl);
+  const projectedUrl = redactCaptureUrl(documentUrl);
+  const requestedOrigin = captureOrigin(requestedDocumentUrl);
+  const finalOrigin = captureOrigin(documentUrl);
+  const empty = (status) => ({
+    status,
+    url: projectedUrl,
+    resource_id: null,
+    http_status: null,
+    mime_type: "unknown",
+    context_fingerprint: null,
+    capture_origin: requestedOrigin,
+    final_origin: finalOrigin,
+    origin_matches_capture: originMatchesCapture(requestedOrigin, finalOrigin),
+  });
+  if (!finalIdentity) {
+    addProblemCount(problemCounts, "document_response_missing");
+    return empty("missing");
+  }
+  const matches = prepared.filter(({ record }) => {
+    const resourceType = normalizeResourceType(record?.resource_type);
+    return record?.is_final_main_document === true
+      && /^sha256:[a-f0-9]{64}$/.test(record?.document_context_fingerprint || "")
+      && resourceType.value === "document"
+      && resourceType.status === "known"
+      && documentResponseIdentity(record?.url, { baseUrl: documentUrl }) === finalIdentity;
+  });
+  if (matches.length === 0) {
+    addProblemCount(problemCounts, "document_response_missing");
+    return empty("missing");
+  }
+  if (matches.length > 1) {
+    addProblemCount(problemCounts, "document_response_ambiguous");
+    return empty("ambiguous");
+  }
+  const record = matches[0].record;
+  const resolved = resolvedResource(record.url, { baseUrl: documentUrl });
+  const projection = {
+    status: "complete",
+    url: resolved.projected,
+    resource_id: resolved.resource_id,
+    http_status: Number.isInteger(record?.status) ? record.status : null,
+    mime_type: normalizedDocumentMimeType(record?.mime_type),
+    context_fingerprint: record.document_context_fingerprint,
+    capture_origin: requestedOrigin,
+    final_origin: finalOrigin,
+    origin_matches_capture: originMatchesCapture(requestedOrigin, finalOrigin),
+  };
+  if (record?.failed === true || !documentResponseAcceptable(projection)) {
+    addProblemCount(problemCounts, "document_response_error");
+    projection.status = "error";
+  }
+  return projection;
+}
+
+export function aggregateCdpResponses(responses, {
+  documentUrl,
+  requestedDocumentUrl,
+  requireFinalDocumentResponse = false,
+} = {}) {
+  const problemCounts = new Map();
+  const documentOrigin = captureOrigin(documentUrl);
+  const groups = new Map();
+  let unattributedRequestCount = 0;
+  const prepared = prepareResponseRecords(responses, problemCounts);
+  const documentResponse = requireFinalDocumentResponse
+    ? assessFinalDocumentResponse(prepared, { documentUrl, requestedDocumentUrl, problemCounts })
+    : null;
+
+  for (const { record, chain } of prepared) {
+    const resolved = resolvedResource(record?.url, { baseUrl: documentUrl });
+    if (resolved.status === "non_http" && record?.failed !== true) {
+      // A data:, blob: or about: response is not a network resource: nothing
+      // was transferred, so there is nothing to attribute to the ledger and
+      // nothing the operator could repair. It is counted as unattributed
+      // (evidence) and is not a problem. Video controls, inline icons and
+      // authored data: images produce these on ordinary pages. A non-http
+      // load that failed (a revoked blob: URL behind a script or image) is
+      // still a dependency the page could not load; it has no ledger entry
+      // to carry the failure, so it stays an unresolvable response below.
+      unattributedRequestCount += 1;
+      continue;
+    }
+    if (resolved.status !== "http") {
+      if (resolved.status === "too_long") addProblemCount(problemCounts, "url_length_overflow");
+      addProblemCount(problemCounts, "resource_url_unresolvable");
+      unattributedRequestCount += 1;
+      continue;
+    }
+    const transferredBytes = record?.encoded_data_length;
+    const canceled = record?.canceled === true;
+    const declaredBytes = canceled && Number.isSafeInteger(record?.declared_data_length)
+      && record.declared_data_length >= 0 ? record.declared_data_length : null;
+    const resourceType = normalizeResourceType(record?.resource_type);
+    const cacheObserved = responseRecordFromCache(record);
+    const fromServiceWorker = Boolean(record?.from_service_worker);
+    const failed = Boolean(record?.failed);
+    const crossOrigin = Boolean(documentOrigin && resolved.origin !== documentOrigin);
+    const sourceUrls = record?.source_urls == null ? [] : record.source_urls;
+    if (!Array.isArray(sourceUrls)) addProblemCount(problemCounts, "resource_aliases_invalid");
+
+    const matchResources = [resolved];
+    for (const alias of (Array.isArray(sourceUrls) ? sourceUrls : [])) {
+      const aliasResource = resolvedResource(alias, { baseUrl: documentUrl });
+      if (aliasResource.status !== "http") {
+        if (aliasResource.status === "too_long") addProblemCount(problemCounts, "url_length_overflow");
+        addProblemCount(problemCounts, "resource_aliases_invalid");
+      }
+      else matchResources.push(aliasResource);
+    }
+    for (const hop of chain) {
+      const hopResource = resolvedResource(hop?.url, { baseUrl: documentUrl });
+      if (hopResource.status === "http") matchResources.push(hopResource);
+    }
+
+    const transferMeasured = Number.isInteger(transferredBytes) && transferredBytes >= 0;
+    const sizeAccounted = transferMeasured || declaredBytes !== null;
+
+    const group = groups.get(resolved.resource_id) || {
+      resource_id: resolved.resource_id,
+      url: resolved.projected,
+      resource_type: resourceType.value,
+      resource_type_status: resourceType.status,
+      observed_resource_types: new Set(),
+      transferred_bytes: 0,
+      declared_bytes: 0,
+      request_count: 0,
+      canceled_request_count: 0,
+      declared_request_count: 0,
+      unmeasured_request_count: 0,
+      failed_request_count: 0,
+      statuses: new Set(),
+      partial_request_count: 0,
+      cross_origin_request_count: 0,
+      cache_request_count: 0,
+      service_worker_request_count: 0,
+      match_resource_ids: new Set([resolved.resource_id]),
+    };
+    group.observed_resource_types.add(resourceType.value);
+    if (resourceType.status === "unknown") group.resource_type_status = "unknown";
+    if (transferMeasured) group.transferred_bytes += transferredBytes;
+    // A failed request has no transfer size by definition; its failure is
+    // attributed once the entry's type is resolved and is not also an
+    // unavailable measurement.
+    else if (!sizeAccounted && !failed) group.unmeasured_request_count += 1;
+    if (canceled) group.canceled_request_count += 1;
+    if (declaredBytes !== null) {
+      group.declared_bytes = Math.max(group.declared_bytes, declaredBytes);
+      group.declared_request_count += 1;
+    }
+    group.request_count += 1;
+    if (failed) group.failed_request_count += 1;
+    if (Number.isInteger(record?.status)) group.statuses.add(record.status);
+    if (record?.status === 206) group.partial_request_count += 1;
+    if (crossOrigin) group.cross_origin_request_count += 1;
+    if (cacheObserved) group.cache_request_count += 1;
+    if (fromServiceWorker) group.service_worker_request_count += 1;
+    for (const match of matchResources) group.match_resource_ids.add(match.resource_id);
+    groups.set(resolved.resource_id, group);
+  }
+
+  const allResources = [...groups.values()].map((group) => {
+    // CORS preflights share the URL of the request they authorize; observing
+    // preflight alongside the real type is expected, not ambiguity. fetch and
+    // xhr are likewise one programmatic-call class — which transport API a
+    // page used is not a resource-identity conflict. Only explicit preflight
+    // records are set aside (the collector classifies older-protocol OPTIONS
+    // legs as preflight at the source) and only the fetch-class transports
+    // are merged; any pairing outside those, "other" included, remains a
+    // genuine identity conflict.
+    const substantiveTypes = [...new Set(group.observed_resource_types)].filter((value) => value !== "preflight");
+    const canonicalTypes = [...new Set(substantiveTypes.map((value) => (value === "xhr" ? "fetch" : value)))];
+    const observedTypes = canonicalTypes.length ? canonicalTypes : [...group.observed_resource_types];
+    if (observedTypes.length === 1) {
+      // The xhr → fetch mapping exists only to keep the two transports from
+      // reading as an identity conflict; a resource observed under a single
+      // transport keeps the type it was actually observed with.
+      const preferred = substantiveTypes.length === 1 ? substantiveTypes[0] : observedTypes[0];
+      if (group.resource_type !== preferred) {
+        group.resource_type = preferred;
+        group.resource_type_status = KNOWN_RESOURCE_TYPES.has(preferred) ? "known" : "unknown";
+      }
+    }
+    if (observedTypes.length > 1) {
+      group.resource_type = "unknown";
+      group.resource_type_status = "ambiguous";
+    } else if (group.resource_type_status === "unknown") {
+      group.resource_type = "unknown";
+    }
+    const { observed_resource_types: ignored, statuses, match_resource_ids: matchIds, ...projection } = group;
+    return {
+      ...projection,
+      statuses: [...statuses].sort((a, b) => a - b),
+      match_resource_ids: [...matchIds].sort(),
+    };
+  }).sort(resourceLedgerSort);
+  // The ledger-implied problems are read off the finished entries (types
+  // resolved, failures attributed) so the codes match what the ledger says,
+  // which is what the shape rules recompute from.
+  for (const [code, count] of Object.entries(ledgerProblemCounts(allResources))) {
+    addProblemCount(problemCounts, code, count);
+  }
+
+  const resources = allResources.slice(0, MAX_PAGE_LOAD_RESOURCE_LEDGER_ENTRIES);
+  const omittedResources = allResources.slice(MAX_PAGE_LOAD_RESOURCE_LEDGER_ENTRIES);
+  if (omittedResources.length) {
+    addProblemCount(problemCounts, "resource_ledger_overflow", omittedResources.length);
+  }
+  const problems = projectedProblems(problemCounts);
+
+  return {
+    measurement_status: polishCaptureMeasurementStatus(problems),
+    observed_response_count: prepared.length,
+    unattributed_request_count: unattributedRequestCount,
+    ...resourceLedgerMetrics(resources),
+    resources,
+    resource_ledger: {
+      limit: MAX_PAGE_LOAD_RESOURCE_LEDGER_ENTRIES,
+      total_resource_count: allResources.length,
+      omitted_resource_count: omittedResources.length,
+      omitted_request_count: omittedResources.reduce((sum, resource) => sum + resource.request_count, 0),
+    },
+    document_response: documentResponse,
+    problems,
+  };
+}
+
+function normalizedPreloadAttribute(value) {
+  if (value === null) return "missing";
+  if (value === "") return "empty";
+  const token = value.toLowerCase();
+  return token === "auto" || token === "metadata" || token === "none" ? token : "other";
+}
+
+function sourceReference(value, sourceKind, sourceIndex, documentUrl) {
+  if (value === null || (typeof value === "string" && value.trim() === "")) return null;
+  const resolved = resolvedResource(value, { baseUrl: documentUrl });
+  return {
+    source_kind: sourceKind,
+    source_index: sourceIndex,
+    url: resolved.projected,
+    resource_id: resolved.resource_id,
+  };
+}
+
+export function sourceReferenceSort(a, b) {
+  const ranks = { current_src: 0, src_attribute: 1, source_src_attribute: 2, observed_source: 3 };
+  return (ranks[a.source_kind] ?? 99) - (ranks[b.source_kind] ?? 99)
+    || a.source_index - b.source_index
+    || String(a.resource_id).localeCompare(String(b.resource_id));
+}
+
+// Only the two explicit deferral tokens keep a hidden element from fetching
+// eagerly; "auto", an empty or missing attribute and anything else do not.
+export function preloadDefersFetch(preloadAttribute) {
+  return preloadAttribute === "none" || preloadAttribute === "metadata";
+}
+
+export function normalizeMediaElement(element, { documentUrl, elementIndex = 0 } = {}) {
+  const tagName = normalizedToken(element?.tag_name);
+  if (tagName !== "video" && tagName !== "audio") {
+    throw new Error("Page-load media capture accepts only video or audio elements.");
+  }
+  if (!Number.isInteger(elementIndex) || elementIndex < 0
+    || !Object.hasOwn(element, "current_src")
+    || (element.current_src !== null && typeof element.current_src !== "string")
+    || !Object.hasOwn(element, "src_attribute")
+    || (element.src_attribute !== null && typeof element.src_attribute !== "string")
+    || !Array.isArray(element.source_src_attributes)
+    || element.source_src_attributes.some((source) => typeof source !== "string")
+    || (Object.hasOwn(element, "observed_source_urls")
+      && (!Array.isArray(element.observed_source_urls)
+        || element.observed_source_urls.some((source) => typeof source !== "string")))
+    || !Object.hasOwn(element, "preload_attribute")
+    || (element.preload_attribute !== null && typeof element.preload_attribute !== "string")
+    || !validComputedStyle(element.computed_style)
+    || !Array.isArray(element.ancestor_styles)
+    || element.ancestor_styles.some((style) => !validComputedStyle(style))) {
+    throw new Error("Page-load media capture needs complete source and computed-style measurements.");
+  }
+
+  const styles = [element.computed_style, ...element.ancestor_styles];
+  const hiddenBy = new Set();
+  for (const style of styles) {
+    if (normalizedToken(style.display) === "none") hiddenBy.add("display_none");
+    if (normalizedToken(style.visibility) === "hidden") hiddenBy.add("visibility_hidden");
+    if (normalizedToken(style.visibility) === "collapse") hiddenBy.add("visibility_collapse");
+  }
+  const currentSrc = sourceReference(element.current_src, "current_src", 0, documentUrl);
+  const srcAttribute = sourceReference(element.src_attribute, "src_attribute", 0, documentUrl);
+  const sourceSrcAttributes = element.source_src_attributes
+    .map((source, index) => sourceReference(source, "source_src_attribute", index, documentUrl));
+  const observedSourceUrls = (Array.isArray(element.observed_source_urls) ? element.observed_source_urls : [])
+    .map((source, index) => sourceReference(source, "observed_source", index, documentUrl));
+  const sourceReferences = [currentSrc, srcAttribute, ...sourceSrcAttributes, ...observedSourceUrls]
+    .filter(Boolean)
+    .sort(sourceReferenceSort);
+  const preloadAttribute = normalizedPreloadAttribute(element.preload_attribute);
+  const width = Number(element?.bounding_box?.width);
+  const height = Number(element?.bounding_box?.height);
+
+  return {
+    tag_name: tagName,
+    element_index: elementIndex,
+    current_src: currentSrc?.url || null,
+    src_attribute: srcAttribute?.url || null,
+    source_src_attributes: sourceSrcAttributes.map((source) => source?.url || null),
+    observed_source_urls: observedSourceUrls.map((source) => source?.url || null),
+    source_references: sourceReferences,
+    preload_attribute: preloadAttribute,
+    preload_defers_fetch: preloadDefersFetch(preloadAttribute),
+    hidden_at_load: hiddenBy.size > 0,
+    hidden_by: [...hiddenBy].sort(),
+    zero_size_at_load: Number.isFinite(width) && Number.isFinite(height) ? (width <= 0 || height <= 0) : null,
+  };
+}
+
+export function normalizePageLoadRoute(value) {
+  const text = normalizeString(value);
+  if (!text) return null;
+  try {
+    const url = new URL(text, "https://capture.invalid/");
+    return url.pathname.startsWith("/") ? url.pathname : `/${url.pathname}`;
+  } catch {
+    return null;
+  }
+}
+
+export function normalizedNetworkidle(value) {
+  const status = normalizedToken(value?.status);
+  const durationMs = value?.duration_ms;
+  if ((status !== "settled" && status !== "timeout")
+    || !Number.isInteger(durationMs)
+    || durationMs < 0) return { status: "invalid", duration_ms: null };
+  return { status, duration_ms: durationMs };
+}
+
+export function normalizedViewport(value) {
+  const token = normalizeString(value)?.toLocaleLowerCase("en-US") || null;
+  return token && /^[a-z0-9][a-z0-9_-]{0,63}$/.test(token) ? token : null;
+}
+
+export function normalizedBuildFingerprint(value) {
+  const fingerprint = normalizeString(value);
+  return fingerprint && /^sha256:[a-f0-9]{64}$/.test(fingerprint) ? fingerprint : null;
+}
+
+export function normalizedCampaignSlug(value) {
+  const slug = normalizeString(value);
+  return slug && /^[a-z0-9][a-z0-9_-]{0,127}$/i.test(slug) ? slug : null;
+}
+
+function captureSubject({ buildFingerprint, slug, requestedRoute, finalDocumentUrl, viewport }) {
+  return {
+    build_fingerprint: normalizedBuildFingerprint(buildFingerprint),
+    campaign_slug: normalizedCampaignSlug(slug),
+    requested_route: normalizePageLoadRoute(requestedRoute),
+    final_document_route: resolvedCaptureUrl(finalDocumentUrl).status === "http"
+      ? normalizePageLoadRoute(finalDocumentUrl)
+      : null,
+    viewport: normalizedViewport(viewport),
+  };
+}
+
+// The ledger entries a media element fetched: every entry whose identity set
+// meets one of the element's resolved source references.
+export function mediaFetchedResources(media, resources) {
+  const sourceIds = new Set(media.source_references
+    .map((reference) => reference.resource_id)
+    .filter(Boolean));
+  return resources.flatMap((resource) => {
+    const matchedSourceIds = resource.match_resource_ids.filter((id) => sourceIds.has(id));
+    if (!matchedSourceIds.length) return [];
+    return [{
+      resource_id: resource.resource_id,
+      url: resource.url,
+      resource_type: resource.resource_type,
+      transferred_bytes: resource.transferred_bytes,
+      request_count: resource.request_count,
+      ...(Object.hasOwn(resource, "declared_bytes") ? { declared_bytes: resource.declared_bytes } : {}),
+      matched_source_resource_ids: matchedSourceIds.sort(),
+    }];
+  }).sort(resourceLedgerSort);
+}
+
+// The element's byte and request totals over its fetched resources.
+export function mediaFetchTotals(fetchedResources) {
+  return {
+    fetched_bytes: fetchedResources.reduce((sum, resource) => sum + resource.transferred_bytes, 0),
+    fetched_request_count: fetchedResources.reduce((sum, resource) => sum + resource.request_count, 0),
+    declared_bytes: fetchedResources.reduce((sum, resource) => sum + (resource.declared_bytes || 0), 0),
+  };
+}
+
+// A hidden element that fetches eagerly and names a source the ledger cannot
+// identify: the measurement cannot say what it loaded.
+export function hiddenEagerSourceUnresolved(media) {
+  return media.hidden_at_load
+    && !media.preload_defers_fetch
+    && media.source_references.some((reference) => reference.resource_id === null);
+}
+
+// Media transfers no element claims: bytes the page moved that the media
+// measurement cannot attribute.
+export function unattributedMediaTransfers(media, resources) {
+  const attributedResourceIds = new Set(media.flatMap((item) => item.fetched_resources)
+    .map((resource) => resource.resource_id));
+  return resources.filter((resource) => resource.resource_type === "media"
+    && resource.transferred_bytes > 0
+    && !attributedResourceIds.has(resource.resource_id));
+}
+
+// The capture-level statuses stated beside the problems that justify them.
+const PRODUCER_FAILURE_PROBLEM_CODES = Object.freeze([
+  "browser_unavailable",
+  "producer_failed",
+  "producer_timeout",
+]);
+
+export function producerStatus(problems) {
+  return problems.some((problem) => PRODUCER_FAILURE_PROBLEM_CODES.includes(problem.code)) ? "failed" : "complete";
+}
+
+export function responseCollectionProblemCode(status) {
+  if (status === "failed") return "response_collection_failed";
+  return status === "complete" ? null : "response_collection_status_invalid";
+}
+
+export function mediaCollectionStatus({
+  failed_element_count,
+  omitted_element_count,
+  source_overflow_element_count,
+  ancestor_overflow_element_count,
+}) {
+  return failed_element_count > 0 || omitted_element_count > 0
+    || source_overflow_element_count > 0 || ancestor_overflow_element_count > 0 ? "partial" : "complete";
+}
+
+export function buildPageLoadCapture({
+  buildFingerprint,
+  slug,
+  requestedRoute,
+  viewport,
+  finalDocumentUrl,
+  requestedDocumentUrl,
+  responseCollectionStatus,
+  networkidle,
+  mediaElements,
+  responses,
+  producerError,
+  producerProblem,
+} = {}) {
+  const network = aggregateCdpResponses(responses, {
+    documentUrl: finalDocumentUrl,
+    requestedDocumentUrl,
+    requireFinalDocumentResponse: true,
+  });
+  const problemCounts = new Map(network.problems.map(({ code, count }) => [code, count]));
+  const addCaptureProblem = (code, count = 1) => addProblemCount(problemCounts, code, count);
+  const subject = captureSubject({ buildFingerprint, slug, requestedRoute, finalDocumentUrl, viewport });
+  for (const value of [requestedDocumentUrl, finalDocumentUrl, requestedRoute]) {
+    if (typeof value === "string" && value.length > MAX_POLISH_CAPTURE_URL_LENGTH) {
+      addCaptureProblem("url_length_overflow");
+    }
+  }
+  if (Object.values(subject).some((value) => value === null)) addCaptureProblem("capture_subject_invalid");
+  if (subject.requested_route && subject.final_document_route
+    && subject.requested_route !== subject.final_document_route) {
+    addCaptureProblem("final_document_route_mismatch");
+  }
+  if (!Array.isArray(mediaElements)) addCaptureProblem("media_collection_unavailable");
+  if (!Array.isArray(responses)) addCaptureProblem("response_collection_unavailable");
+  // The browser collector reports whether it observed the network faithfully.
+  // Whether a failed request voids the collection is decided here, from the
+  // attributed ledger: a dependency failure (document, first-party, or any
+  // script/stylesheet/media) fails it; a cross-origin beacon-class failure is
+  // recorded as a warning and leaves the measurement complete.
+  const reportedCollectionStatus = normalizedToken(responseCollectionStatus);
+  const dependencyFailed = (problemCounts.get("dependency_request_failed") || 0) > 0;
+  const collectionStatus = reportedCollectionStatus === "complete" && dependencyFailed
+    ? "failed"
+    : reportedCollectionStatus;
+  const collectionProblem = responseCollectionProblemCode(collectionStatus);
+  if (collectionProblem) addCaptureProblem(collectionProblem);
+  if (collectionStatus === "complete" && Array.isArray(responses) && network.observed_response_count === 0) {
+    addCaptureProblem("response_collection_empty");
+  }
+  const normalizedProducerProblem = producerProblem === "browser_unavailable"
+    ? "browser_unavailable"
+    : producerProblem === "producer_timeout"
+      ? "producer_timeout"
+      : producerProblem === "producer_failed" || producerError ? "producer_failed" : null;
+  if (normalizedProducerProblem) addCaptureProblem(normalizedProducerProblem);
+
+  const media = [];
+  let failedMediaElementCount = 0;
+  const rawMediaElements = Array.isArray(mediaElements) ? mediaElements : [];
+  const declaredObservedElementCount = Number.isInteger(rawMediaElements.observed_element_count)
+    && rawMediaElements.observed_element_count >= rawMediaElements.length
+    ? rawMediaElements.observed_element_count
+    : rawMediaElements.length;
+  const boundedMediaElements = rawMediaElements.slice(0, MAX_PAGE_LOAD_MEDIA_ELEMENTS);
+  const omittedMediaElementCount = Math.max(0, declaredObservedElementCount - boundedMediaElements.length);
+  if (omittedMediaElementCount > 0) addCaptureProblem("media_element_overflow", omittedMediaElementCount);
+  let sourceOverflowElementCount = 0;
+  let ancestorOverflowElementCount = 0;
+  for (const [elementIndex, element] of boundedMediaElements.entries()) {
+    try {
+      const sourceOverflow = (Array.isArray(element?.source_src_attributes)
+        && element.source_src_attributes.length > MAX_PAGE_LOAD_MEDIA_SOURCES_PER_ELEMENT)
+        || (Array.isArray(element?.observed_source_urls)
+          && element.observed_source_urls.length > MAX_PAGE_LOAD_MEDIA_SOURCES_PER_ELEMENT)
+        || (Number.isInteger(element?.source_overflow_count) && element.source_overflow_count > 0);
+      const ancestorOverflow = (Array.isArray(element?.ancestor_styles)
+        && element.ancestor_styles.length > MAX_PAGE_LOAD_MEDIA_ANCESTORS)
+        || (Number.isInteger(element?.ancestor_overflow_count) && element.ancestor_overflow_count > 0);
+      if (sourceOverflow) sourceOverflowElementCount += 1;
+      if (ancestorOverflow) ancestorOverflowElementCount += 1;
+      const mediaSourceValues = [element?.current_src, element?.src_attribute,
+        ...(Array.isArray(element?.source_src_attributes)
+          ? element.source_src_attributes.slice(0, MAX_PAGE_LOAD_MEDIA_SOURCES_PER_ELEMENT) : []),
+        ...(Array.isArray(element?.observed_source_urls)
+          ? element.observed_source_urls.slice(0, MAX_PAGE_LOAD_MEDIA_SOURCES_PER_ELEMENT) : [])];
+      const overlongSourceCount = mediaSourceValues.filter((value) => typeof value === "string"
+        && value.length > MAX_POLISH_CAPTURE_URL_LENGTH).length
+        + (Number.isInteger(element?.url_overflow_count) && element.url_overflow_count > 0
+          ? element.url_overflow_count : 0);
+      if (overlongSourceCount > 0) addCaptureProblem("url_length_overflow", overlongSourceCount);
+      const boundedElement = isPlainObject(element) ? {
+        ...element,
+        source_src_attributes: Array.isArray(element.source_src_attributes)
+          ? element.source_src_attributes.slice(0, MAX_PAGE_LOAD_MEDIA_SOURCES_PER_ELEMENT)
+          : element.source_src_attributes,
+        ...(Array.isArray(element.observed_source_urls) ? {
+          observed_source_urls: element.observed_source_urls.slice(0, MAX_PAGE_LOAD_MEDIA_SOURCES_PER_ELEMENT),
+        } : {}),
+        ancestor_styles: Array.isArray(element.ancestor_styles)
+          ? element.ancestor_styles.slice(0, MAX_PAGE_LOAD_MEDIA_ANCESTORS)
+          : element.ancestor_styles,
+      } : element;
+      const normalized = normalizeMediaElement(boundedElement, { documentUrl: finalDocumentUrl, elementIndex });
+      if (hiddenEagerSourceUnresolved(normalized)) addCaptureProblem("media_source_unresolvable");
+      const fetchedResources = mediaFetchedResources(normalized, network.resources);
+      const hasDeclaredShape = network.resources.some((resource) => Object.hasOwn(resource, "declared_bytes"));
+      const { declared_bytes: declaredBytes, ...fetchTotals } = mediaFetchTotals(fetchedResources);
+      media.push({
+        ...normalized,
+        ...fetchTotals,
+        ...(hasDeclaredShape ? { declared_bytes: declaredBytes } : {}),
+        fetched_resources: fetchedResources,
+      });
+    } catch {
+      failedMediaElementCount += 1;
+      addCaptureProblem("media_measurement_failed");
+    }
+  }
+  if (sourceOverflowElementCount > 0) {
+    addCaptureProblem("media_source_overflow", sourceOverflowElementCount);
+  }
+  if (ancestorOverflowElementCount > 0) {
+    addCaptureProblem("media_ancestor_overflow", ancestorOverflowElementCount);
+  }
+  const unattributedTransfers = unattributedMediaTransfers(media, network.resources);
+  if (unattributedTransfers.length) addCaptureProblem("media_transfer_unattributed", unattributedTransfers.length);
+  const settled = normalizedNetworkidle(networkidle);
+  if (settled.status === "invalid") addCaptureProblem("networkidle_measurement_invalid");
+  const problems = projectedProblems(problemCounts);
+  const mediaCollectionCounts = {
+    failed_element_count: failedMediaElementCount,
+    omitted_element_count: omittedMediaElementCount,
+    source_overflow_element_count: sourceOverflowElementCount,
+    ancestor_overflow_element_count: ancestorOverflowElementCount,
+  };
+
+  const capture = {
+    schema_version: POLISH_ROUTE_CAPTURE_SCHEMA_VERSION,
+    performed_by: POLISH_CAPTURE_PRODUCER,
+    subject,
+    measurement_status: polishCaptureMeasurementStatus(problems),
+    producer_status: producerStatus(problems),
+    response_collection: {
+      status: collectionStatus === "complete" || collectionStatus === "failed" ? collectionStatus : "invalid",
+      observed_response_count: network.observed_response_count,
+      unattributed_response_count: network.unattributed_request_count,
+    },
+    media_collection: {
+      status: !Array.isArray(mediaElements) ? "failed" : mediaCollectionStatus(mediaCollectionCounts),
+      observed_element_count: Array.isArray(mediaElements) ? declaredObservedElementCount : 0,
+      ...mediaCollectionCounts,
+    },
+    networkidle: settled,
+    document_response: network.document_response,
+    resource_ledger: {
+      ...network.resource_ledger,
+      entries: network.resources,
+    },
+    metrics: {
+      total_transferred_bytes: network.total_transferred_bytes,
+      request_count: network.request_count,
+      largest_resource: network.largest_resource,
+      cross_origin_request_count: network.cross_origin_request_count,
+      cache_request_count: network.cache_request_count,
+      service_worker_request_count: network.service_worker_request_count,
+    },
+    media,
+    problems,
+  };
+  return {
+    ...capture,
+    integrity: buildPolishCaptureIntegrity(capture),
+  };
+}