Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(evidence): validate closure projections and browser body coverage
morlutoaada0ca8126b
diff --git a/src/application/ReconstructionObligationLedger.closure.test.ts b/src/application/ReconstructionObligationLedger.closure.test.tsindex e11bffadd..86dc84474 100644--- a/src/application/ReconstructionObligationLedger.closure.test.ts+++ b/src/application/ReconstructionObligationLedger.closure.test.ts@@ -9,6 +9,8 @@ import {request,reviewedObligation,} from "./ReconstructionObligationLedger.fixture.js";+import { deriveReconstructionObligationCandidates } from "./ReconstructionObligationCandidates.js";+import { evaluateReconstructionObligationLedger } from "./ReconstructionObligationLedgerEvaluation.js";describe("reconstruction obligation ledger", () => {it("emits the complete deterministic ledger and closure identity", () => {@@ -86,6 +88,34 @@ describe("reconstruction obligation ledger", () => {});});+describe("reconstruction obligation ledger Evidence provenance", () => {+ it("links observed-case Evidence separately from authority references", () => {+ const capture = processEvidence();+ const caseEvidence = proofEvidence("distinct-original-case");+ const bundle = request([capture, caseEvidence]).evidence_bundle;+ const generated = deriveReconstructionObligationCandidates(bundle, []);+ const candidates = generated.candidates.map((candidate) => ({+ ...candidate,+ observed_cases: candidate.observed_cases.map((observedCase) => ({+ ...observedCase,+ evidence_id: caseEvidence.evidence_id,+ })),+ }));++ const result = evaluateReconstructionObligationLedger({+ candidates,+ bundle,+ manifest: { bindings: [], contradictions: [] },+ generationLimitations: [],+ });++ expect(result.obligations[0]?.authority_references[0]?.evidence_id).toBe(+ capture.evidence_id,+ );+ expect(result.evidence_links).toContain(caseEvidence.evidence_id);+ });+});+describe("reconstruction obligation ledger case closure", () => {it("keeps unobserved original cases open", () => {const capture = processEvidence();@@ -166,45 +196,44 @@ describe("reconstruction obligation ledger case closure", () => {verifier_ids: ["verifier.packaged"],claim_ids: ["claim.process"],});- const result = build(- request([capture, proof], {- manifest: {- bindings: [- {- obligation_id: obligation.obligation_id,- owner: {- module_path: "src/processOwner.ts",- symbol: "runProcess",- owner_sha256: "2".repeat(64),- },- parser_type: null,- original_cases: originalCases(obligation, capture.evidence_id),- fixtures: obligation.required_case_kinds.map((caseKind) => ({- fixture_id: `packaged.${caseKind}`,- case_kind: caseKind,- authority: "packaged-process",- evidence_ids: [proof.evidence_id],- })),- verifier: {- verifier_id: "verifier.packaged",- claim_id: "claim.process",- command: "npm run verify:package -- process",- authority: "packaged-process",- status: "pass",- result_evidence_id: proof.evidence_id,- enumerated_obligation_ids: [obligation.obligation_id],- nondeterminism: {- mode: "partial-order",- specification:- "Startup precedes teardown; worker completion is unordered.",- },+ const ledgerRequest = request([capture, proof], {+ manifest: {+ bindings: [+ {+ obligation_id: obligation.obligation_id,+ owner: {+ module_path: "src/processOwner.ts",+ symbol: "runProcess",+ owner_sha256: "2".repeat(64),+ },+ parser_type: null,+ original_cases: originalCases(obligation, capture.evidence_id),+ fixtures: obligation.required_case_kinds.map((caseKind) => ({+ fixture_id: `packaged.${caseKind}`,+ case_kind: caseKind,+ authority: "packaged-process",+ evidence_ids: [proof.evidence_id],+ })),+ verifier: {+ verifier_id: "verifier.packaged",+ claim_id: "claim.process",+ command: "npm run verify:package -- process",+ authority: "packaged-process",+ status: "pass",+ result_evidence_id: proof.evidence_id,+ enumerated_obligation_ids: [obligation.obligation_id],+ nondeterminism: {+ mode: "partial-order",+ specification:+ "Startup precedes teardown; worker completion is unordered.",},},- ],- contradictions: [],- },- }),- );+ },+ ],+ contradictions: [],+ },+ });+ const result = build(ledgerRequest);expect(result.obligations[0]).toMatchObject({status: "verified",@@ -212,5 +241,19 @@ describe("reconstruction obligation ledger case closure", () => {});expect(result.status).toBe("ready");expect(result.summary.required_open).toBe(0);++ const generated = deriveReconstructionObligationCandidates(+ ledgerRequest.evidence_bundle,+ ledgerRequest.reviewed_obligations,+ );+ const limited = evaluateReconstructionObligationLedger({+ candidates: generated.candidates,+ bundle: ledgerRequest.evidence_bundle,+ manifest: ledgerRequest.manifest,+ generationLimitations: ["A supplementary source was unavailable."],+ });+ expect(limited.obligations[0]?.status).toBe("verified");+ expect(limited.status).toBe("unknown");+ expect(limited.coverage.status).toBe("partial");});});diff --git a/src/application/ReconstructionObligationLedgerDiagnostics.ts b/src/application/ReconstructionObligationLedgerDiagnostics.tsindex 7d6d84637..5d53d8f4a 100644--- a/src/application/ReconstructionObligationLedgerDiagnostics.ts+++ b/src/application/ReconstructionObligationLedgerDiagnostics.ts@@ -57,11 +57,6 @@ export const uniqueObligationDiagnostics = (),);-export const hasObligationDiagnostic = (- diagnostics: readonly Diagnostic[],- code: Diagnostic["code"],-): boolean => diagnostics.some((diagnostic) => diagnostic.code === code);-export const contradictionDiagnostics = (obligationId: string,contradictions: ReadonlyMap<string, readonly string[]>,diff --git a/src/application/ReconstructionObligationLedgerEvaluation.ts b/src/application/ReconstructionObligationLedgerEvaluation.tsindex fe7626344..a9366c331 100644--- a/src/application/ReconstructionObligationLedgerEvaluation.ts+++ b/src/application/ReconstructionObligationLedgerEvaluation.ts@@ -9,6 +9,17 @@ import {type ReconstructionObligationLedger,type ReconstructionObligationManifest,} from "../domain/reconstructionObligationLedgerSchemas.js";+import { digestCanonicalValue } from "../domain/canonicalDigest.js";+import {+ reconstructionObligationCoverage,+ reconstructionObligationDependencyGraph,+ reconstructionObligationLedgerClosureDigest,+ reconstructionObligationLedgerStatus,+ hasReconstructionObligationDiagnostic as hasDiagnostic,+ reconstructionObligationOwnershipGraph,+ reconstructionObligationReports,+ summarizeReconstructionObligations,+} from "../domain/reconstructionObligationLedgerIntegrity.js";import type { ReconstructionObligationCandidate } from "./ReconstructionObligationCandidates.js";import {evidenceAuthoritySupportsProof,@@ -20,22 +31,13 @@ import {contradictionDiagnostics,groupManifestBindings,groupManifestContradictions,- hasObligationDiagnostic as hasDiagnostic,uniqueObligationDiagnostics as uniqueDiagnostics,} from "./ReconstructionObligationLedgerDiagnostics.js";import {originalCaseDiagnostics,originalCasesFor,} from "./ReconstructionObligationOriginalCases.js";-import {- digestObligationLedgerValue,- obligationLedgerCoverage,- obligationEdgeOrder,- obligationLedgerEvidenceLinks,- obligationLedgerStatus,- obligationReports,- summarizeObligations,-} from "./ReconstructionObligationLedgerProjection.js";+import { obligationLedgerEvidenceLinks } from "./ReconstructionObligationLedgerProjection.js";import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";type Diagnostic = ReconstructionObligation["diagnostics"][number];@@ -70,64 +72,41 @@ export const evaluateReconstructionObligationLedger = ({candidates.map((candidate) => evaluateObligation(candidate, context)),context,);- const ownershipGraph = obligations- .flatMap((obligation) =>- obligation.binding === null- ? []- : [- {- obligation_id: obligation.obligation_id,- module_path: obligation.binding.owner.module_path,- symbol: obligation.binding.owner.symbol,- },- ],- )- .sort(obligationEdgeOrder);- const dependencyGraph = obligations- .flatMap((obligation) =>- obligation.dependency_obligation_ids.map((dependencyId) => ({- obligation_id: obligation.obligation_id,- depends_on_obligation_id: dependencyId,- })),- )- .sort(obligationEdgeOrder);+ const ownershipGraph = reconstructionObligationOwnershipGraph(obligations);+ const dependencyGraph = reconstructionObligationDependencyGraph(obligations);const evidenceLinks = obligationLedgerEvidenceLinks(obligations, manifest);const limitations = ledgerLimitations(generationLimitations,allCandidates.length,orphanManifestIds,);- const coverage = obligationLedgerCoverage(limitations.length > 0);+ const coverage = reconstructionObligationCoverage(limitations);const semantic = {coverage,- summary: summarizeObligations(obligations),- reports: obligationReports(obligations),+ summary: summarizeReconstructionObligations(obligations),+ reports: reconstructionObligationReports(obligations),ownership_graph: ownershipGraph,dependency_graph: dependencyGraph,obligations,evidence_links: evidenceLinks,limitations,};- const evaluatedStatus = obligationLedgerStatus(obligations);- const status =- evaluatedStatus === "failed"- ? evaluatedStatus- : limitations.length > 0- ? "unknown"- : evaluatedStatus;- const closureDigest = digestObligationLedgerValue({- schema: "ReconstructionObligationClosure",+ const status = reconstructionObligationLedgerStatus(obligations, limitations);+ const closureDigest = reconstructionObligationLedgerClosureDigest({status,...semantic,});return reconstructionObligationLedgerSchema.parse({schema: "ReconstructionObligationLedger",- ledger_id: `rol_${digestObligationLedgerValue({- schema: "ReconstructionObligationLedger",- evidence_ids: bundle.records.map(({ evidence_id: id }) => id),- obligation_ids: obligations.map(({ obligation_id: id }) => id),- closure_digest: closureDigest,- })}`,+ ledger_id: `rol_${digestCanonicalValue(+ {+ schema: "ReconstructionObligationLedger",+ evidence_ids: bundle.records.map(({ evidence_id: id }) => id),+ obligation_ids: obligations.map(({ obligation_id: id }) => id),+ closure_digest: closureDigest,+ },+ "Reconstruction obligation ledger",+ )}`,closure_digest: closureDigest,status,...semantic,diff --git a/src/application/ReconstructionObligationLedgerProjection.ts b/src/application/ReconstructionObligationLedgerProjection.tsindex f77a6c9d1..4976465bf 100644--- a/src/application/ReconstructionObligationLedgerProjection.ts+++ b/src/application/ReconstructionObligationLedgerProjection.ts@@ -1,83 +1,9 @@-import { createHash } from "node:crypto";--import canonicalize from "canonicalize";--import { canonicalJson } from "../domain/comparisonSemantics.js";-import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";-import type {ReconstructionObligation,- ReconstructionObligationLedger,ReconstructionObligationManifest,} from "../domain/reconstructionObligationLedgerSchemas.js";--type DiagnosticCode = ReconstructionObligation["diagnostics"][number]["code"];--export const obligationLedgerCoverage = (- incomplete: boolean,-): ReconstructionObligationLedger["coverage"] => ({- status: incomplete ? "partial" : "complete",-});--export const summarizeObligations = (- obligations: readonly ReconstructionObligation[],-): ReconstructionObligationLedger["summary"] => ({- total: obligations.length,- required: obligations.filter(({ required }) => required).length,- verified: obligations.filter(({ status }) => status === "verified").length,- required_open: obligations.filter(- ({ required, status }) => required && status !== "verified",- ).length,- by_status: countBy(- obligations,- [- "unowned",- "characterized",- "implemented",- "verified",- "contradicted",- "blocked",- "out-of-scope",- "unknown",- ],- ({ status }) => status,- ),- by_application_layer: countBy(- obligations,- [- "cli",- "protocol",- "electron",- "persistence",- "process",- "runtime",- "packaging",- "native-abi",- "application",- "other",- ],- ({ application_layer: layer }) => layer,- ),- by_evidence_authority: countBy(- obligations,- ["candidate", "observed", "reviewed", "unknown"],- ({ source_state: state }) => state,- ),-});--export const obligationReports = (- obligations: readonly ReconstructionObligation[],-): ReconstructionObligationLedger["reports"] => ({- missing_owner_obligation_ids: obligationIdsWith(obligations, "missing-owner"),- missing_verifier_obligation_ids: obligationIdsWith(- obligations,- "missing-verifier",- ),- contradicted_obligation_ids: obligationIdsWith(obligations, "contradiction"),- residual_unknown_ids: [- ...new Set(obligations.flatMap(({ residual_unknown_ids: ids }) => ids)),- ].sort(),-});+import { reconstructionObligationEvidenceIds } from "../domain/reconstructionObligationLedgerIntegrity.js";+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";export const obligationLedgerEvidenceLinks = (obligations: readonly ReconstructionObligation[],@@ -85,9 +11,7 @@ export const obligationLedgerEvidenceLinks = (): string[] =>[...new Set([- ...obligations.flatMap(({ authority_references: references }) =>- references.map(({ evidence_id: id }) => id),- ),+ ...reconstructionObligationEvidenceIds(obligations),...manifest.bindings.flatMap((binding) => [...binding.original_cases.map(({ evidence_id: id }) => id),...binding.fixtures.flatMap(({ evidence_ids: ids }) => ids),@@ -97,62 +21,4 @@ export const obligationLedgerEvidenceLinks = (]),...manifest.contradictions.flatMap(({ evidence_ids: ids }) => ids),]),- ].sort();--export const obligationLedgerStatus = (- obligations: readonly ReconstructionObligation[],-): ReconstructionObligationLedger["status"] => {- if (obligations.length === 0) return "unknown";- const requiredOpen = obligations.filter(- ({ required, status }) => required && status !== "verified",- );- if (- requiredOpen.some(- ({ status, diagnostics }) =>- status === "contradicted" ||- hasDiagnostic(diagnostics, "verifier-failed"),- )- )- return "failed";- if (requiredOpen.some(({ status }) => status === "unknown")) return "unknown";- return requiredOpen.length === 0 ? "ready" : "open";-};--export const obligationEdgeOrder = (- left: { readonly obligation_id: string },- right: { readonly obligation_id: string },-): number =>- compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right));--export const digestObligationLedgerValue = (value: unknown): string => {- const encoded = canonicalize(value);- if (encoded === undefined)- throw new TypeError(- "Reconstruction obligation ledger is not canonical JSON",- );- return createHash("sha256").update(encoded).digest("hex");-};--const countBy = <Value extends string, Item>(- items: readonly Item[],- values: readonly Value[],- valueFor: (item: Item) => Value,-): { key: Value; count: number }[] =>- values.map((value) => ({- key: value,- count: items.filter((item) => valueFor(item) === value).length,- }));--const obligationIdsWith = (- obligations: readonly ReconstructionObligation[],- code: DiagnosticCode,-): string[] =>- obligations- .filter(({ diagnostics }) => hasDiagnostic(diagnostics, code))- .map(({ obligation_id: id }) => id)- .sort();--const hasDiagnostic = (- diagnostics: ReconstructionObligation["diagnostics"],- code: DiagnosticCode,-): boolean => diagnostics.some((diagnostic) => diagnostic.code === code);+ ].sort(compareUnicodeCodePoints);diff --git a/src/browser/CdpCaptureEventBodyShapes.ts b/src/browser/CdpCaptureEventBodyShapes.tsindex 53882a819..f3b22bfe7 100644--- a/src/browser/CdpCaptureEventBodyShapes.ts+++ b/src/browser/CdpCaptureEventBodyShapes.ts@@ -15,19 +15,19 @@ export const ingestResponseBodyShape = (): void => {const result = recordValue(value);const body = cdpStringValue(result?.body);- if (body === undefined) {+ const base64Encoded = result?.base64Encoded;+ if (body === undefined || typeof base64Encoded !== "boolean") {invalidResponseBodyShape(state, requestId);return;}- const decoded =- result?.base64Encoded === true- ? decodeBase64(body)?.toString("utf8")- : body;+ const decoded = base64Encoded ? decodeBase64(body)?.toString("utf8") : body;if (decoded === undefined) {invalidResponseBodyShape(state, requestId);return;}- updateResponseBodyShape(state, requestId, inferJsonShape(decoded));+ const shape = inferJsonShape(decoded);+ if (shape === null) state.completeness.unavailable("json_body_shapes");+ updateResponseBodyShape(state, requestId, shape);};export const requestBodyShape = (@@ -40,6 +40,7 @@ export const requestBodyShape = (if (!isJsonContentType(recordValue(request.headers)) || body === undefined)return { status: "unavailable", request: null, response: null };const shape = inferJsonShape(body);+ if (shape === null) state.completeness.unavailable("json_body_shapes");return {status: shape === null ? "unavailable" : "included",request: shape,diff --git a/src/contracts/reconstructionReadinessExample.ts b/src/contracts/reconstructionReadinessExample.tsindex 0b81cf60b..124ce2a05 100644--- a/src/contracts/reconstructionReadinessExample.ts+++ b/src/contracts/reconstructionReadinessExample.ts@@ -4,6 +4,8 @@ import {READINESS_REQUIRED_CHECKS,READINESS_STAGE_IDS,} from "../domain/reconstructionReadinessJourneyFindings.js";+import { reconstructionObligationLedgerClosureDigest } from "../domain/reconstructionObligationLedgerIntegrity.js";+import type { ReconstructionObligationLedger } from "../domain/reconstructionObligationLedgerSchemas.js";import type { ReconstructionReadinessInput } from "../domain/reconstructionReadinessSchemas.js";const HASH = "a".repeat(64);@@ -69,6 +71,129 @@ const EVIDENCE_STATES = ["reviewed","unknown",] as const;+const READINESS_OBLIGATION_LEDGER = (() => {+ const ledger: Omit<ReconstructionObligationLedger, "closure_digest"> = {+ schema: "ReconstructionObligationLedger",+ ledger_id: `rol_${HASH}`,+ status: "ready",+ coverage: {+ status: "complete",+ },+ summary: {+ total: 1,+ required: 1,+ verified: 1,+ required_open: 0,+ by_status: STATUSES.map((key) => ({+ key,+ count: key === "verified" ? 1 : 0,+ })),+ by_application_layer: LAYERS.map((key) => ({+ key,+ count: key === "process" ? 1 : 0,+ })),+ by_evidence_authority: EVIDENCE_STATES.map((key) => ({+ key,+ count: key === "observed" ? 1 : 0,+ })),+ },+ reports: {+ missing_owner_obligation_ids: [],+ missing_verifier_obligation_ids: [],+ contradicted_obligation_ids: [],+ residual_unknown_ids: [],+ },+ ownership_graph: [+ {+ obligation_id: "obl.readiness",+ module_path: "src/readiness.ts",+ symbol: "runReadiness",+ },+ ],+ dependency_graph: [],+ obligations: [+ {+ obligation_id: "obl.readiness",+ obligation_version: 1,+ title: "Preserve the packaged readiness fixture lifecycle",+ origin: "reviewed",+ application_layer: "process",+ family: "packaged-process-lifecycle",+ target: {+ artifact_sha256: HASH,+ application_node_id: null,+ semantic_node_id: null,+ location: "/fixture",+ },+ authority_references: [+ {+ evidence_id: EVIDENCE_ID,+ authority: "controlled-replay",+ state: "observed",+ location: "/fixture",+ },+ ],+ source_state: "observed",+ observed_cases: CASES.map((kind) => ({+ kind,+ evidence_id: EVIDENCE_ID,+ location: `/original/${kind}`,+ })),+ required: true,+ required_case_kinds: [...CASES],+ required_original_authority: "process",+ required_fixture_authority: "packaged-process",+ required_verifier_authority: "packaged-process",+ requires_parser_type: false,+ dependency_obligation_ids: [],+ residual_unknown_ids: [],+ unavailable_authority: [],+ required_next_evidence: [],+ binding: {+ obligation_id: "obl.readiness",+ owner: {+ module_path: "src/readiness.ts",+ symbol: "runReadiness",+ owner_sha256: HASH,+ },+ parser_type: null,+ original_cases: CASES.map((kind) => ({+ kind,+ evidence_id: EVIDENCE_ID,+ location: `/original/${kind}`,+ })),+ fixtures: CASES.map((kind) => ({+ fixture_id: `fixture.${kind}`,+ case_kind: kind,+ authority: "packaged-process",+ evidence_ids: [EVIDENCE_ID],+ })),+ verifier: {+ verifier_id: "verifier.readiness",+ claim_id: "claim.readiness",+ command: "npm run verify:readiness",+ authority: "packaged-process",+ status: "pass",+ result_evidence_id: EVIDENCE_ID,+ enumerated_obligation_ids: ["obl.readiness"],+ nondeterminism: {+ mode: "partial-order",+ specification: "Startup precedes teardown.",+ },+ },+ },+ status: "verified",+ diagnostics: [],+ },+ ],+ evidence_links: [EVIDENCE_ID],+ limitations: [],+ };+ return {+ ...ledger,+ closure_digest: reconstructionObligationLedgerClosureDigest(ledger),+ };+})();/** Complete synthetic input shared by docs, tests, CLI, MCP, and verifier. */export const RECONSTRUCTION_READINESS_EXAMPLE: ReconstructionReadinessInput = {@@ -217,124 +342,7 @@ export const RECONSTRUCTION_READINESS_EXAMPLE: ReconstructionReadinessInput = {evidence_ids: [EVIDENCE_ID, CONTRADICTING_SOURCE.evidence_id],},],- obligation_ledger: {- schema: "ReconstructionObligationLedger",- ledger_id: `rol_${HASH}`,- closure_digest: HASH,- status: "ready",- coverage: {- status: "complete",- },- summary: {- total: 1,- required: 1,- verified: 1,- required_open: 0,- by_status: STATUSES.map((key) => ({- key,- count: key === "verified" ? 1 : 0,- })),- by_application_layer: LAYERS.map((key) => ({- key,- count: key === "process" ? 1 : 0,- })),- by_evidence_authority: EVIDENCE_STATES.map((key) => ({- key,- count: key === "observed" ? 1 : 0,- })),- },- reports: {- missing_owner_obligation_ids: [],- missing_verifier_obligation_ids: [],- contradicted_obligation_ids: [],- residual_unknown_ids: [],- },- ownership_graph: [- {- obligation_id: "obl.readiness",- module_path: "src/readiness.ts",- symbol: "runReadiness",- },- ],- dependency_graph: [],- obligations: [- {- obligation_id: "obl.readiness",- obligation_version: 1,- title: "Preserve the packaged readiness fixture lifecycle",- origin: "reviewed",- application_layer: "process",- family: "packaged-process-lifecycle",- target: {- artifact_sha256: HASH,- application_node_id: null,- semantic_node_id: null,- location: "/fixture",- },- authority_references: [- {- evidence_id: EVIDENCE_ID,- authority: "controlled-replay",- state: "observed",- location: "/fixture",- },- ],- source_state: "observed",- observed_cases: CASES.map((kind) => ({- kind,- evidence_id: EVIDENCE_ID,- location: `/original/${kind}`,- })),- required: true,- required_case_kinds: [...CASES],- required_original_authority: "process",- required_fixture_authority: "packaged-process",- required_verifier_authority: "packaged-process",- requires_parser_type: false,- dependency_obligation_ids: [],- residual_unknown_ids: [],- unavailable_authority: [],- required_next_evidence: [],- binding: {- obligation_id: "obl.readiness",- owner: {- module_path: "src/readiness.ts",- symbol: "runReadiness",- owner_sha256: HASH,- },- parser_type: null,- original_cases: CASES.map((kind) => ({- kind,- evidence_id: EVIDENCE_ID,- location: `/original/${kind}`,- })),- fixtures: CASES.map((kind) => ({- fixture_id: `fixture.${kind}`,- case_kind: kind,- authority: "packaged-process",- evidence_ids: [EVIDENCE_ID],- })),- verifier: {- verifier_id: "verifier.readiness",- claim_id: "claim.readiness",- command: "npm run verify:readiness",- authority: "packaged-process",- status: "pass",- result_evidence_id: EVIDENCE_ID,- enumerated_obligation_ids: ["obl.readiness"],- nondeterminism: {- mode: "partial-order",- specification: "Startup precedes teardown.",- },- },- },- status: "verified",- diagnostics: [],- },- ],- evidence_links: [EVIDENCE_ID],- limitations: [],- },+ obligation_ledger: READINESS_OBLIGATION_LEDGER,operation_outcomes: [{sequence: 0,@@ -404,7 +412,7 @@ export const RECONSTRUCTION_READINESS_EXAMPLE: ReconstructionReadinessInput = {},{sequence: 1,- ledger_digest: HASH,+ ledger_digest: READINESS_OBLIGATION_LEDGER.closure_digest,status: "ready",required_open: 0,newly_verified_obligation_ids: ["obl.readiness"],diff --git a/src/domain/reconstructionObligationLedgerIntegrity.ts b/src/domain/reconstructionObligationLedgerIntegrity.tsnew file mode 100644index 000000000..c0f9dd099--- /dev/null+++ b/src/domain/reconstructionObligationLedgerIntegrity.ts@@ -0,0 +1,212 @@+import { digestCanonicalValue } from "./canonicalDigest.js";+import { canonicalJson } from "./comparisonSemantics.js";+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";++import type {+ ReconstructionObligation,+ ReconstructionObligationLedger,+} from "./reconstructionObligationLedgerSchemas.js";++/** Derive the ledger summary from the obligation facts. */+export const summarizeReconstructionObligations = (+ obligations: readonly ReconstructionObligation[],+): ReconstructionObligationLedger["summary"] => ({+ total: obligations.length,+ required: obligations.filter(({ required }) => required).length,+ verified: obligations.filter(({ status }) => status === "verified").length,+ required_open: obligations.filter(+ ({ required, status }) => required && status !== "verified",+ ).length,+ by_status: countBy(+ obligations,+ [+ "unowned",+ "characterized",+ "implemented",+ "verified",+ "contradicted",+ "blocked",+ "out-of-scope",+ "unknown",+ ],+ ({ status }) => status,+ ),+ by_application_layer: countBy(+ obligations,+ [+ "cli",+ "protocol",+ "electron",+ "persistence",+ "process",+ "runtime",+ "packaging",+ "native-abi",+ "application",+ "other",+ ],+ ({ application_layer }) => application_layer,+ ),+ by_evidence_authority: countBy(+ obligations,+ ["candidate", "observed", "reviewed", "unknown"],+ ({ source_state }) => source_state,+ ),+});++/** Derive closure status from required obligations and their diagnostic facts. */+export const reconstructionObligationLedgerStatus = (+ obligations: readonly ReconstructionObligation[],+ limitations: readonly string[],+): ReconstructionObligationLedger["status"] => {+ if (obligations.length === 0) return "unknown";+ const requiredOpen = obligations.filter(+ ({ required, status }) => required && status !== "verified",+ );+ if (+ requiredOpen.some(+ ({ status, diagnostics }) =>+ status === "contradicted" ||+ hasReconstructionObligationDiagnostic(diagnostics, "verifier-failed"),+ )+ )+ return "failed";+ if (limitations.length > 0) return "unknown";+ if (requiredOpen.some(({ status }) => status === "unknown")) return "unknown";+ return requiredOpen.length === 0 ? "ready" : "open";+};++export const reconstructionObligationCoverage = (+ limitations: readonly string[],+): ReconstructionObligationLedger["coverage"] => ({+ status: limitations.length === 0 ? "complete" : "partial",+});++export const reconstructionObligationReports = (+ obligations: readonly ReconstructionObligation[],+): ReconstructionObligationLedger["reports"] => ({+ missing_owner_obligation_ids: obligationIdsWith(obligations, "missing-owner"),+ missing_verifier_obligation_ids: obligationIdsWith(+ obligations,+ "missing-verifier",+ ),+ contradicted_obligation_ids: obligationIdsWith(obligations, "contradiction"),+ residual_unknown_ids: [+ ...new Set(obligations.flatMap(({ residual_unknown_ids: ids }) => ids)),+ ].sort(compareUnicodeCodePoints),+});++export const reconstructionObligationOwnershipGraph = (+ obligations: readonly ReconstructionObligation[],+): ReconstructionObligationLedger["ownership_graph"] =>+ obligations+ .flatMap((obligation) =>+ obligation.binding === null+ ? []+ : [+ {+ obligation_id: obligation.obligation_id,+ module_path: obligation.binding.owner.module_path,+ symbol: obligation.binding.owner.symbol,+ },+ ],+ )+ .sort(obligationEdgeOrder);++export const reconstructionObligationDependencyGraph = (+ obligations: readonly ReconstructionObligation[],+): ReconstructionObligationLedger["dependency_graph"] =>+ obligations+ .flatMap((obligation) =>+ obligation.dependency_obligation_ids.map((dependencyId) => ({+ obligation_id: obligation.obligation_id,+ depends_on_obligation_id: dependencyId,+ })),+ )+ .sort(obligationEdgeOrder);++/** Evidence attached to facts serialized on an obligation. */+export const reconstructionObligationEvidenceIds = (+ obligations: readonly ReconstructionObligation[],+): string[] =>+ [+ ...new Set(+ obligations.flatMap((obligation) => [+ ...obligation.authority_references.map(({ evidence_id: id }) => id),+ ...obligation.observed_cases.map(({ evidence_id: id }) => id),+ ...(obligation.binding === null+ ? []+ : [+ ...obligation.binding.original_cases.map(+ ({ evidence_id: id }) => id,+ ),+ ...obligation.binding.fixtures.flatMap(+ ({ evidence_ids: ids }) => ids,+ ),+ ...(obligation.binding.verifier === null+ ? []+ : [obligation.binding.verifier.result_evidence_id]),+ ]),+ ]),+ ),+ ].sort(compareUnicodeCodePoints);++const obligationEdgeOrder = (+ left: { readonly obligation_id: string },+ right: { readonly obligation_id: string },+): number =>+ compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right));++const obligationIdsWith = (+ obligations: readonly ReconstructionObligation[],+ code: ReconstructionObligation["diagnostics"][number]["code"],+): string[] =>+ obligations+ .filter(({ diagnostics }) =>+ hasReconstructionObligationDiagnostic(diagnostics, code),+ )+ .map(({ obligation_id: id }) => id)+ .sort(compareUnicodeCodePoints);++export const hasReconstructionObligationDiagnostic = (+ diagnostics: Readonly<ReconstructionObligation["diagnostics"]>,+ code: ReconstructionObligation["diagnostics"][number]["code"],+): boolean => diagnostics.some((diagnostic) => diagnostic.code === code);++/** Recompute the closure commitment from the fields carried by a ledger. */+export const reconstructionObligationLedgerClosureDigest = (ledger: {+ readonly status: ReconstructionObligationLedger["status"];+ readonly coverage: ReconstructionObligationLedger["coverage"];+ readonly summary: ReconstructionObligationLedger["summary"];+ readonly reports: ReconstructionObligationLedger["reports"];+ readonly ownership_graph: ReconstructionObligationLedger["ownership_graph"];+ readonly dependency_graph: ReconstructionObligationLedger["dependency_graph"];+ readonly obligations: ReconstructionObligationLedger["obligations"];+ readonly evidence_links: ReconstructionObligationLedger["evidence_links"];+ readonly limitations: ReconstructionObligationLedger["limitations"];+}): string =>+ digestCanonicalValue(+ {+ schema: "ReconstructionObligationClosure",+ status: ledger.status,+ coverage: ledger.coverage,+ summary: ledger.summary,+ reports: ledger.reports,+ ownership_graph: ledger.ownership_graph,+ dependency_graph: ledger.dependency_graph,+ obligations: ledger.obligations,+ evidence_links: ledger.evidence_links,+ limitations: ledger.limitations,+ },+ "Reconstruction obligation ledger",+ );++const countBy = <Value extends string, Item>(+ items: readonly Item[],+ values: readonly Value[],+ valueFor: (item: Item) => Value,+): { key: Value; count: number }[] =>+ values.map((value) => ({+ key: value,+ count: items.filter((item) => valueFor(item) === value).length,+ }));diff --git a/src/domain/reconstructionObligationLedgerSchemas.test.ts b/src/domain/reconstructionObligationLedgerSchemas.test.tsindex c2aedd024..005758210 100644--- a/src/domain/reconstructionObligationLedgerSchemas.test.ts+++ b/src/domain/reconstructionObligationLedgerSchemas.test.ts@@ -3,7 +3,12 @@ import { describe, expect, it } from "vitest";import {reconstructionObligationLedgerSchema,reconstructionObligationManifestSchema,+ type ReconstructionObligationLedger,} from "./reconstructionObligationLedgerSchemas.js";+import {+ reconstructionObligationLedgerClosureDigest,+ summarizeReconstructionObligations,+} from "./reconstructionObligationLedgerIntegrity.js";const digest = "a".repeat(64);@@ -32,20 +37,13 @@ describe("reconstruction obligation ledger schemas", () => {reconstructionObligationManifestSchema.parse(manifest).bindings,).toHaveLength(10_001);- const ledger = {+ const ledgerBase: Omit<ReconstructionObligationLedger, "closure_digest"> = {schema: "ReconstructionObligationLedger",ledger_id: `rol_${digest}`,- closure_digest: digest,- status: "ready",+ status: "unknown",coverage: { status: "complete" },summary: {- total: 0,- required: 0,- verified: 0,- required_open: 0,- by_status: [],- by_application_layer: [],- by_evidence_authority: [],+ ...summarizeReconstructionObligations([]),},reports: {missing_owner_obligation_ids: [],@@ -62,6 +60,10 @@ describe("reconstruction obligation ledger schemas", () => {),limitations: [],};+ const ledger = {+ ...ledgerBase,+ closure_digest: reconstructionObligationLedgerClosureDigest(ledgerBase),+ };expect(reconstructionObligationLedgerSchema.parse(ledger).evidence_links,diff --git a/src/domain/reconstructionObligationLedgerSchemas.ts b/src/domain/reconstructionObligationLedgerSchemas.tsindex bc61969a8..6d3403c8d 100644--- a/src/domain/reconstructionObligationLedgerSchemas.ts+++ b/src/domain/reconstructionObligationLedgerSchemas.ts@@ -5,11 +5,42 @@ import { STABLE_IDENTIFIER_PATTERN } from "./stringPatterns.js";import { evidenceBundleSchema } from "./evidenceBundle.js";import { digestSchema } from "./../domain/digests.js";import { prefixedDigestSchema } from "./../domain/digests.js";+import { canonicalJson } from "./comparisonSemantics.js";+import {+ reconstructionObligationCoverage,+ reconstructionObligationDependencyGraph,+ reconstructionObligationLedgerClosureDigest,+ reconstructionObligationLedgerStatus,+ reconstructionObligationEvidenceIds,+ reconstructionObligationOwnershipGraph,+ reconstructionObligationReports,+ summarizeReconstructionObligations,+} from "./reconstructionObligationLedgerIntegrity.js";const evidenceIdSchema = prefixedDigestSchema("ev");const stableIdSchema = z.string().regex(STABLE_IDENTIFIER_PATTERN);const textSchema = z.string().trim().min(1);+const sameProjection = <Value>(+ actual: readonly Value[],+ expected: readonly Value[],+): boolean => {+ if (actual.length !== expected.length) return false;+ const counts = new Map<string, number>();+ for (const value of actual) {+ const key = canonicalJson(value, "Reconstruction obligation ledger");+ counts.set(key, (counts.get(key) ?? 0) + 1);+ }+ for (const value of expected) {+ const key = canonicalJson(value, "Reconstruction obligation ledger");+ const count = counts.get(key);+ if (count === undefined) return false;+ if (count === 1) counts.delete(key);+ else counts.set(key, count - 1);+ }+ return counts.size === 0;+};+export const obligationStatusSchema = z.enum(["unowned","characterized",@@ -236,48 +267,174 @@ const countBySchema = <Schema extends z.ZodType>(}),);-export const reconstructionObligationLedgerSchema = z.strictObject({- schema: z.literal("ReconstructionObligationLedger"),- ledger_id: prefixedDigestSchema("rol"),- closure_digest: digestSchema,- status: z.enum(["ready", "open", "failed", "unknown"]),- coverage: z.strictObject({- status: z.enum(["complete", "partial"]),- }),- summary: z.strictObject({- total: z.number().int().min(0),- required: z.number().int().min(0),- verified: z.number().int().min(0),- required_open: z.number().int().min(0),- by_status: countBySchema(obligationStatusSchema),- by_application_layer: countBySchema(obligationLayerSchema),- by_evidence_authority: countBySchema(- z.enum(["candidate", "observed", "reviewed", "unknown"]),- ),- }),- reports: z.strictObject({- missing_owner_obligation_ids: z.array(stableIdSchema),- missing_verifier_obligation_ids: z.array(stableIdSchema),- contradicted_obligation_ids: z.array(stableIdSchema),- residual_unknown_ids: z.array(stableIdSchema),- }),- ownership_graph: z.array(- z.strictObject({- obligation_id: stableIdSchema,- module_path: textSchema,- symbol: textSchema,+const countEntriesMatch = (+ actual: readonly { readonly key: string; readonly count: number }[],+ expected: readonly { readonly key: string; readonly count: number }[],+): boolean => {+ const actualCounts = new Map(actual.map(({ key, count }) => [key, count]));+ return (+ actualCounts.size === actual.length &&+ actual.length === expected.length &&+ expected.every(({ key, count }) => actualCounts.get(key) === count)+ );+};++const obligationSummariesMatch = (+ actual: ReconstructionObligationLedger["summary"],+ expected: ReconstructionObligationLedger["summary"],+): boolean =>+ actual.total === expected.total &&+ actual.required === expected.required &&+ actual.verified === expected.verified &&+ actual.required_open === expected.required_open &&+ countEntriesMatch(actual.by_status, expected.by_status) &&+ countEntriesMatch(+ actual.by_application_layer,+ expected.by_application_layer,+ ) &&+ countEntriesMatch(+ actual.by_evidence_authority,+ expected.by_evidence_authority,+ );++export const reconstructionObligationLedgerSchema = z+ .strictObject({+ schema: z.literal("ReconstructionObligationLedger"),+ ledger_id: prefixedDigestSchema("rol"),+ closure_digest: digestSchema,+ status: z.enum(["ready", "open", "failed", "unknown"]),+ coverage: z.strictObject({+ status: z.enum(["complete", "partial"]),}),- ),- dependency_graph: z.array(- z.strictObject({- obligation_id: stableIdSchema,- depends_on_obligation_id: stableIdSchema,+ summary: z.strictObject({+ total: z.number().int().min(0),+ required: z.number().int().min(0),+ verified: z.number().int().min(0),+ required_open: z.number().int().min(0),+ by_status: countBySchema(obligationStatusSchema),+ by_application_layer: countBySchema(obligationLayerSchema),+ by_evidence_authority: countBySchema(+ z.enum(["candidate", "observed", "reviewed", "unknown"]),+ ),}),- ),- obligations: z.array(reconstructionObligationSchema),- evidence_links: z.array(evidenceIdSchema),- limitations: z.array(textSchema),-});+ reports: z.strictObject({+ missing_owner_obligation_ids: z.array(stableIdSchema),+ missing_verifier_obligation_ids: z.array(stableIdSchema),+ contradicted_obligation_ids: z.array(stableIdSchema),+ residual_unknown_ids: z.array(stableIdSchema),+ }),+ ownership_graph: z.array(+ z.strictObject({+ obligation_id: stableIdSchema,+ module_path: textSchema,+ symbol: textSchema,+ }),+ ),+ dependency_graph: z.array(+ z.strictObject({+ obligation_id: stableIdSchema,+ depends_on_obligation_id: stableIdSchema,+ }),+ ),+ obligations: z.array(reconstructionObligationSchema),+ evidence_links: z.array(evidenceIdSchema),+ limitations: z.array(textSchema),+ })+ .superRefine((ledger, context) => {+ if (+ ledger.status !==+ reconstructionObligationLedgerStatus(+ ledger.obligations,+ ledger.limitations,+ )+ )+ context.addIssue({+ code: "custom",+ path: ["status"],+ message: "Ledger status does not match its obligations",+ });+ if (+ !obligationSummariesMatch(+ ledger.summary,+ summarizeReconstructionObligations(ledger.obligations),+ )+ )+ context.addIssue({+ code: "custom",+ path: ["summary"],+ message: "Ledger summary does not match its obligations",+ });+ if (+ ledger.closure_digest !==+ reconstructionObligationLedgerClosureDigest(ledger)+ )+ context.addIssue({+ code: "custom",+ path: ["closure_digest"],+ message: "Ledger closure digest does not match its contents",+ });+ if (+ ledger.coverage.status !==+ reconstructionObligationCoverage(ledger.limitations).status+ )+ context.addIssue({+ code: "custom",+ path: ["coverage"],+ message: "Ledger coverage does not match its limitations",+ });+ const expectedReports = reconstructionObligationReports(ledger.obligations);+ for (const key of [+ "missing_owner_obligation_ids",+ "missing_verifier_obligation_ids",+ "contradicted_obligation_ids",+ "residual_unknown_ids",+ ] as const)+ if (!sameProjection(ledger.reports[key], expectedReports[key]))+ context.addIssue({+ code: "custom",+ path: ["reports", key],+ message: "Ledger report does not match its obligations",+ });+ if (+ !sameProjection(+ ledger.ownership_graph,+ reconstructionObligationOwnershipGraph(ledger.obligations),+ )+ )+ context.addIssue({+ code: "custom",+ path: ["ownership_graph"],+ message: "Ownership graph does not match its obligations",+ });+ if (+ !sameProjection(+ ledger.dependency_graph,+ reconstructionObligationDependencyGraph(ledger.obligations),+ )+ )+ context.addIssue({+ code: "custom",+ path: ["dependency_graph"],+ message: "Dependency graph does not match its obligations",+ });+ const ledgerEvidenceIds = new Set(ledger.evidence_links);+ if (ledgerEvidenceIds.size !== ledger.evidence_links.length)+ context.addIssue({+ code: "custom",+ path: ["evidence_links"],+ message: "Evidence links must be unique",+ });+ if (+ reconstructionObligationEvidenceIds(ledger.obligations).some(+ (evidenceId) => !ledgerEvidenceIds.has(evidenceId),+ )+ )+ context.addIssue({+ code: "custom",+ path: ["evidence_links"],+ message: "Evidence links omit Evidence referenced by an obligation",+ });+ });export const reconstructionObligationLedgerInputSchema = z.strictObject({evidence_bundle: evidenceBundleSchema,diff --git a/src/domain/reconstructionReadiness.test.ts b/src/domain/reconstructionReadiness.test.tsindex df0d5e2a0..9418f0dd1 100644--- a/src/domain/reconstructionReadiness.test.ts+++ b/src/domain/reconstructionReadiness.test.ts@@ -2,6 +2,12 @@ import { describe, expect, it } from "vitest";import { RECONSTRUCTION_READINESS_EXAMPLE } from "../contracts/reconstructionReadinessExample.js";import { createReconstructionReadinessReport } from "./reconstructionReadiness.js";+import {+ reconstructionObligationLedgerClosureDigest,+ reconstructionObligationLedgerStatus,+ summarizeReconstructionObligations,+} from "./reconstructionObligationLedgerIntegrity.js";+import { reconstructionObligationLedgerSchema } from "./reconstructionObligationLedgerSchemas.js";import {reconstructionReadinessInputSchema,type ReconstructionReadinessInput,@@ -86,7 +92,96 @@ describe("reconstruction readiness report", () => {nondeterministic_replay_count: 0,});});+});++describe("readiness obligation ledger integrity", () => {+ it("rejects a required obligation changed behind the old ledger commitment", () => {+ const value = input();+ expect(+ reconstructionObligationLedgerSchema.parse(value.obligation_ledger),+ ).toEqual(value.obligation_ledger);+ const obligation = value.obligation_ledger.obligations[0];+ if (obligation === undefined)+ throw new TypeError("Missing reconstruction obligation");+ value.obligation_ledger.obligations[0] = {+ ...obligation,+ status: "blocked",+ };++ expect(() => createReconstructionReadinessReport(value)).toThrow(+ /Ledger status does not match its obligations/u,+ );+ });++ it("rejects a recomputed commitment over a false obligation summary", () => {+ const ledger = structuredClone(input().obligation_ledger);+ ledger.summary.required_open = 1;+ ledger.closure_digest = reconstructionObligationLedgerClosureDigest(ledger);++ expect(() => reconstructionObligationLedgerSchema.parse(ledger)).toThrow(+ /Ledger summary does not match its obligations/u,+ );+ });++ it("accepts reordered summary count entries with the same keyed values", () => {+ const ledger = structuredClone(input().obligation_ledger);+ ledger.summary.by_status.reverse();+ ledger.closure_digest = reconstructionObligationLedgerClosureDigest(ledger);++ expect(reconstructionObligationLedgerSchema.parse(ledger)).toEqual(ledger);+ });++ it.each([+ [+ "reports",+ (ledger: ReconstructionReadinessInput["obligation_ledger"]) => {+ ledger.reports.missing_owner_obligation_ids.push("obl.extra");+ },+ /Ledger report does not match its obligations/u,+ ],+ [+ "ownership graph",+ (ledger: ReconstructionReadinessInput["obligation_ledger"]) => {+ const owner = ledger.ownership_graph[0];+ if (owner === undefined)+ throw new TypeError("Missing owner graph edge");+ owner.symbol = "tamperedOwner";+ },+ /Ownership graph does not match its obligations/u,+ ],+ [+ "dependency graph",+ (ledger: ReconstructionReadinessInput["obligation_ledger"]) => {+ ledger.dependency_graph.push({+ obligation_id: "obl.readiness",+ depends_on_obligation_id: "obl.extra",+ });+ },+ /Dependency graph does not match its obligations/u,+ ],+ [+ "evidence links",+ (ledger: ReconstructionReadinessInput["obligation_ledger"]) => {+ ledger.evidence_links = [];+ },+ /Evidence links omit Evidence referenced by an obligation/u,+ ],+ ] as const)(+ "rejects recomputed commitments over tampered %s",+ (_, mutate, expected) => {+ const ledger = structuredClone(input().obligation_ledger);+ mutate(ledger);+ ledger.closure_digest =+ reconstructionObligationLedgerClosureDigest(ledger);+ expect(() => reconstructionObligationLedgerSchema.parse(ledger)).toThrow(+ expected,+ );+ },+ );+});++describe("readiness failure semantics", () => {it("rejects equivalence over truncated concurrent evidence", () => {const value = input();const comparison = value.comparisons[0];@@ -110,14 +205,28 @@ describe("reconstruction readiness report", () => {it("keeps green stages unknown while one reconstruction obligation is open", () => {const value = input();- value.obligation_ledger = {+ const obligation = value.obligation_ledger.obligations[0];+ if (obligation === undefined)+ throw new TypeError("Missing reconstruction obligation");+ const obligations = [{ ...obligation, status: "blocked" as const }];+ const uncommitted = {...value.obligation_ledger,+ obligations,+ status: reconstructionObligationLedgerStatus(obligations, []),+ summary: summarizeReconstructionObligations(obligations),+ };+ value.obligation_ledger = {+ ...uncommitted,+ closure_digest: reconstructionObligationLedgerClosureDigest(uncommitted),+ };+ const latest = value.closure_history.at(-1);+ if (latest === undefined) throw new TypeError("Missing closure history");+ value.closure_history[value.closure_history.length - 1] = {+ ...latest,+ ledger_digest: value.obligation_ledger.closure_digest,status: "open",- summary: {- ...value.obligation_ledger.summary,- verified: 0,- required_open: 1,- },+ required_open: 1,+ newly_verified_obligation_ids: [],};const report = createReconstructionReadinessReport(value);diff --git a/tests/boundary/browser/cdpBrowserProvider.network.test.ts b/tests/boundary/browser/cdpBrowserProvider.network.test.tsindex a1e967122..65ed14180 100644--- a/tests/boundary/browser/cdpBrowserProvider.network.test.ts+++ b/tests/boundary/browser/cdpBrowserProvider.network.test.ts@@ -131,6 +131,178 @@ it("preserves unavailable response observations and captures completed peers", a).toEqual(["missing-body", "available"]);});+it("marks malformed JSON body shapes unavailable while preserving partial request shapes", async () => {+ const browser = await startFakeCdpBrowser({+ commandEvents(command, origin) {+ if (command.method !== "Network.enable") return undefined;+ const session =+ command.sessionId === undefined ? {} : { sessionId: command.sessionId };+ return ["unavailable", "partial"].flatMap((requestId) => {+ const url = `${origin}/${requestId}`;+ return [+ {+ ...session,+ method: "Network.requestWillBeSent",+ params: {+ requestId,+ request: {+ url,+ method: requestId === "partial" ? "POST" : "GET",+ ...(requestId === "partial"+ ? {+ headers: { "Content-Type": "application/json" },+ postData: '{"request":true}',+ }+ : {}),+ },+ initiator: { type: "other" },+ },+ },+ {+ ...session,+ method: "Network.responseReceived",+ params: {+ requestId,+ response: { url, status: 200, mimeType: "application/json" },+ },+ },+ {+ ...session,+ method: "Network.loadingFinished",+ params: { requestId, encodedDataLength: 0 },+ },+ ];+ });+ },+ commandResult(command) {+ return command.method === "Network.getResponseBody"+ ? { body: "{", base64Encoded: false }+ : undefined;+ },+ });+ trackBrowser(browser);+ const result = await new CdpBrowserProvider().inspectPage(+ inspectWebPageInputSchema.parse({+ cdp_endpoint: browser.endpoint,+ allowed_origins: [browser.allowedOrigin],+ target_id: "allowed-page",+ observation_ms: 20,+ include_json_body_shapes: true,+ }),+ );++ if (!result.ok) throw result.error;+ expect(result.value.network.requests).toEqual([+ expect.objectContaining({+ request_id: "unavailable",+ body_shapes: { status: "unavailable", request: null, response: null },+ }),+ expect.objectContaining({+ request_id: "partial",+ body_shapes: {+ status: "partial",+ request: expect.any(Object),+ response: null,+ },+ }),+ ]);+ expect(result.value.completeness.unavailable_sections).toContain(+ "json_body_shapes",+ );+ expect(result.value.completeness.excluded).not.toContainEqual(+ expect.objectContaining({+ section: "json_body_shapes",+ reason: "invalid_protocol_value",+ }),+ );+});++it("rejects malformed response-body envelopes and preserves request shapes", async () => {+ const browser = await startFakeCdpBrowser({+ commandEvents(command, origin) {+ if (command.method !== "Network.enable") return undefined;+ const session =+ command.sessionId === undefined ? {} : { sessionId: command.sessionId };+ return ["missing-encoding-flag", "invalid-encoding-flag"].flatMap(+ (requestId) => {+ const url = `${origin}/${requestId}`;+ return [+ {+ ...session,+ method: "Network.requestWillBeSent",+ params: {+ requestId,+ request: {+ url,+ method:+ requestId === "invalid-encoding-flag" ? "POST" : "GET",+ ...(requestId === "invalid-encoding-flag"+ ? {+ headers: { "Content-Type": "application/json" },+ postData: '{"request":true}',+ }+ : {}),+ },+ initiator: { type: "other" },+ },+ },+ {+ ...session,+ method: "Network.responseReceived",+ params: {+ requestId,+ response: { url, status: 200, mimeType: "application/json" },+ },+ },+ {+ ...session,+ method: "Network.loadingFinished",+ params: { requestId, encodedDataLength: 0 },+ },+ ];+ },+ );+ },+ commandResult(command) {+ if (command.method !== "Network.getResponseBody") return undefined;+ return command.params.requestId === "missing-encoding-flag"+ ? { body: '{"response":true}' }+ : { body: '{"response":true}', base64Encoded: "false" };+ },+ });+ trackBrowser(browser);+ const result = await new CdpBrowserProvider().inspectPage(+ inspectWebPageInputSchema.parse({+ cdp_endpoint: browser.endpoint,+ allowed_origins: [browser.allowedOrigin],+ target_id: "allowed-page",+ observation_ms: 20,+ include_json_body_shapes: true,+ }),+ );++ if (!result.ok) throw result.error;+ expect(result.value.network.requests).toEqual([+ expect.objectContaining({+ request_id: "missing-encoding-flag",+ body_shapes: { status: "unavailable", request: null, response: null },+ }),+ expect.objectContaining({+ request_id: "invalid-encoding-flag",+ body_shapes: {+ status: "partial",+ request: expect.any(Object),+ response: null,+ },+ }),+ ]);+ expect(result.value.completeness.excluded).toContainEqual({+ section: "json_body_shapes",+ reason: "invalid_protocol_value",+ count: 2,+ });+});+it.each([{options: {