rea-agents 6.0.0 → 6.2.0

package/dist/artifacts/inventory/ArtifactGraphConstruction.js

@@ -1,5 +1,7 @@
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
 import { canonicalDigest } from "../../domain/comparisonSemantics.js";
-import { zipPackageFormatForPath } from "../../domain/zipPackageFormat.js";
+import { artifactEdgeId, artifactIdForContent, occurrenceIdForLocation, } from "../../domain/artifactIdentity.js";
+import { hasZipSignature, zipPackageFormatForPath, } from "../../domain/zipPackageFormat.js";
 import { mzWindowsHeaderOffset, parseDosMzHeader } from "../../domain/dosMz.js";
 /** Index the first occurrence for each canonical logical path. */
 export const indexOccurrencesByPath = (occurrences) => {
@@ -15,6 +17,14 @@ export const createOccurrence = (entry, path, parent) => ({
     parent_occurrence_id: parent,
     logical_path: path,
     entry_kind: entry.kind,
+    artifact_kind: entry.kind === "directory"
+        ? path.toLowerCase().endsWith(".framework")
+            ? "framework"
+            : "container"
+        : classifyArtifactPath(path).kind,
+    artifact_format: entry.kind === "directory"
+        ? "directory"
+        : classifyArtifactPath(path).format,
     declared_size: entry.declaredSize,
     compressed_size: entry.compressedSize,
     executable: entry.executable,
@@ -25,15 +35,8 @@ export const createOccurrence = (entry, path, parent) => ({
         : { offset: entry.byteOffset, length: entry.declaredSize },
     limitations: [...entry.limitations],
 });
-/** Preserve collation order and break distinct-name ties by UTF-16 code units. */
-export const compareDirectoryChildNames = (left, right) => {
-    const collated = left.localeCompare(right);
-    if (collated !== 0)
-        return collated;
-    if (left < right)
-        return -1;
-    return left > right ? 1 : 0;
-};
+/** Compare exact child names independently of host locale and traversal order. */
+export const compareDirectoryChildNames = compareCodePoints;
 export const materializeDirectoryNodes = (occurrences, nodes) => {
     const directories = occurrences
         .filter(({ entry_kind: kind }) => kind === "directory")
@@ -60,15 +63,10 @@ export const materializeDirectoryNodes = (occurrences, nodes) => {
         const node = createArtifactNode({
             sha256: canonicalDigest({ kind: "directory", children }, "Artifact"),
             size: 0,
-            kind: directory.logical_path.toLowerCase().endsWith(".framework")
-                ? "framework"
-                : "container",
             format: "directory",
-            executable: false,
             contentState: "virtual",
         });
-        const existing = nodes.get(node.artifact_id);
-        nodes.set(node.artifact_id, existing?.kind === "framework" ? existing : node);
+        nodes.set(node.artifact_id, node);
         directory.artifact_id = node.artifact_id;
         directory.hash_status = "verified";
     }
@@ -77,43 +75,47 @@ export const createRootNode = (input) => createArtifactNode({
     sha256: input.digest?.sha256 ??
         canonicalDigest({
             kind: "directory-root",
-            children: input.occurrences.map(({ logical_path, artifact_id }) => ({
+            children: input.occurrences
+                .map(({ logical_path, artifact_id }) => ({
                 logical_path,
                 artifact_id,
-            })),
+            }))
+                .sort((left, right) => compareDirectoryChildNames(left.logical_path, right.logical_path)),
         }, "Artifact"),
     size: input.digest?.bytes ?? 0,
-    kind: input.directory ||
-        ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(input.format)
-        ? "container"
-        : input.format === "dos-mz"
-            ? "executable"
-            : classifyArtifactPath(input.path).kind,
-    format: input.format,
-    executable: false,
+    format: input.digest === null
+        ? "directory"
+        : classifyArtifactBytes(input.digest.prefix, input.digest.bytes),
     contentState: "materialized",
 });
 export const createArtifactNode = (input) => ({
-    artifact_id: `art_${canonicalDigest({ sha256: input.sha256 }, "Artifact")}`,
-    kind: input.kind,
+    artifact_id: artifactIdForContent(input.sha256),
     format: input.format,
     sha256: input.sha256,
     size: input.size,
     media_type: null,
     architecture: null,
-    executable: input.executable,
     content_state: input.contentState,
-    limitations: [...(input.limitations ?? [])],
+    limitations: [],
 });
-export const rootOccurrenceFor = (node, declaredSize) => ({
-    occurrence_id: `occ_${canonicalDigest({ root: node.artifact_id }, "Artifact")}`,
+export const rootOccurrenceFor = (node, metadata) => ({
+    occurrence_id: occurrenceIdForLocation({
+        rootArtifactId: node.artifact_id,
+        logicalPath: ".",
+        entryKind: metadata.format === "directory" ? "directory" : "file",
+    }),
     artifact_id: node.artifact_id,
     parent_occurrence_id: null,
     logical_path: ".",
-    entry_kind: node.format === "directory" ? "directory" : "file",
-    declared_size: declaredSize,
+    entry_kind: metadata.format === "directory" ? "directory" : "file",
+    artifact_kind: metadata.format === "directory" ||
+        ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(metadata.format)
+        ? "container"
+        : artifactRoleForFormat(metadata.path, metadata.format).kind,
+    artifact_format: metadata.format,
+    declared_size: metadata.size,
     compressed_size: null,
-    executable: node.executable,
+    executable: metadata.executable,
     encrypted: false,
     hash_status: "verified",
     source_location: null,
@@ -122,11 +124,11 @@ export const rootOccurrenceFor = (node, declaredSize) => ({
 export const rekeyOccurrences = (rootArtifactId, occurrences) => {
     const replacements = new Map();
     for (const occurrence of occurrences)
-        replacements.set(occurrence.occurrence_id, `occ_${canonicalDigest({
-            root_artifact_id: rootArtifactId,
-            logical_path: occurrence.logical_path,
-            entry_kind: occurrence.entry_kind,
-        }, "Artifact")}`);
+        replacements.set(occurrence.occurrence_id, occurrenceIdForLocation({
+            rootArtifactId,
+            logicalPath: occurrence.logical_path,
+            entryKind: occurrence.entry_kind,
+        }));
     for (const occurrence of occurrences) {
         occurrence.occurrence_id =
             replacements.get(occurrence.occurrence_id) ?? occurrence.occurrence_id;
@@ -160,7 +162,7 @@ export const createArtifactEdges = (rootArtifactId, occurrences, producer) => {
             logical_path: occurrence.logical_path,
         };
         edges.push({
-            edge_id: `edge_${canonicalDigest(semantic, "Artifact")}`,
+            edge_id: artifactEdgeId(semantic),
             ...semantic,
             producer: occurrence.entry_kind === "slice" ? (producer ?? null) : null,
             ordinal: edges.length,
@@ -206,34 +208,48 @@ export const classifyArtifactPath = (path) => {
 };
 /** Classify executable formats from bytes while retaining path-specific roles. */
 export const classifyArtifactContent = (path, prefix, fileSize = prefix.length) => {
+    return artifactRoleForFormat(path, classifyArtifactBytes(prefix, fileSize));
+};
+const artifactRoleForFormat = (path, format) => {
     const byPath = classifyArtifactPath(path);
+    if (format === "file" || format === byPath.format)
+        return byPath;
+    if (format === "unknown")
+        return { kind: "unknown", format };
+    if (format === "zip")
+        return {
+            kind: "container",
+            format: zipPackageFormatForPath(path) ?? format,
+        };
+    if (format === "plist")
+        return { kind: "plist", format };
+    return {
+        kind: ["native-addon", "dynamic-library"].includes(byPath.kind)
+            ? byPath.kind
+            : "executable",
+        format,
+    };
+};
+/** Classify storage bytes independently of path names, roles, and permissions. */
+export const classifyArtifactBytes = (prefix, fileSize = prefix.length) => {
+    if (hasZipSignature(prefix))
+        return "zip";
+    if (prefix.subarray(0, 8).equals(Buffer.from("bplist00")))
+        return "plist";
     if (prefix.length >= 4) {
         const magic = prefix.readUInt32BE(0);
         if ([0xcafebabe, 0xbebafeca, 0xcafebabf, 0xbfbafeca].includes(magic))
-            return {
-                kind: byPath.kind === "native-addon" ? "native-addon" : "executable",
-                format: "mach-o-universal",
-            };
+            return "mach-o-universal";
         if ([0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe].includes(magic))
-            return {
-                kind: ["native-addon", "dynamic-library"].includes(byPath.kind)
-                    ? byPath.kind
-                    : "executable",
-                format: "mach-o",
-            };
+            return "mach-o";
         if (prefix.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])))
-            return {
-                kind: ["native-addon", "dynamic-library"].includes(byPath.kind)
-                    ? byPath.kind
-                    : "executable",
-                format: "elf",
-            };
+            return "elf";
     }
     if (prefix.length >= 2 && prefix[0] === 0x4d && prefix[1] === 0x5a) {
         if (!Number.isSafeInteger(fileSize) ||
             fileSize < prefix.length ||
             prefix.length < Math.min(fileSize, 64))
-            return { kind: "unknown", format: "unknown" };
+            return "unknown";
         const windowsOffset = mzWindowsHeaderOffset(prefix);
         if (windowsOffset !== null) {
             if (windowsOffset >= 64 &&
@@ -241,18 +257,13 @@ export const classifyArtifactContent = (path, prefix, fileSize = prefix.length)
                 prefix
                     .subarray(windowsOffset, windowsOffset + 4)
                     .equals(Buffer.from([0x50, 0x45, 0, 0])))
-                return {
-                    kind: byPath.kind === "native-addon" ? "native-addon" : "executable",
-                    format: "pe",
-                };
-        }
-        else if (parseDosMzHeader(prefix, fileSize).ok) {
-            return { kind: "executable", format: "dos-mz" };
+                return "pe";
         }
-        // Missing bounded evidence and malformed MZ bytes both remain unclassified.
-        return { kind: "unknown", format: "unknown" };
+        else if (parseDosMzHeader(prefix, fileSize).ok)
+            return "dos-mz";
+        return "unknown";
     }
-    return byPath;
+    return "file";
 };
 const relationFor = (path) => {
     const lower = path.toLowerCase();

package/dist/artifacts/inventory/ArtifactInventory.js

@@ -2,7 +2,6 @@ import { realpath } from "node:fs/promises";
 import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
 import { abortIfNeeded } from "../ArtifactHash.js";
 import { scanCanonicalArtifactInventory } from "./scanCanonical.js";
-export { scanCanonicalArtifactInventory } from "./scanCanonical.js";
 /** Inventory one local artifact and return every graph collection inline. */
 export const inventoryArtifact = async (inputPath, options = {}) => {
     const snapshot = await scanArtifactInventory(inputPath, options);

package/dist/artifacts/inventory/reader.js

@@ -3,7 +3,7 @@ import { DirectoryArtifactReader } from "../DirectoryArtifactReader.js";
 import { MachOSliceArtifactReader } from "../MachOSliceArtifactReader.js";
 import { NativeDmgArtifactReader } from "../NativeDmgArtifactReader.js";
 import { ZipArtifactReader } from "../ZipArtifactReader.js";
-export const createReader = async (path, format, signal) => {
+export const createReader = async (path, format, environment, signal) => {
     switch (format) {
         case "directory":
             return new DirectoryArtifactReader(path);
@@ -17,12 +17,12 @@ export const createReader = async (path, format, signal) => {
             return new AsarArtifactReader(path);
         case "mach-o-universal":
             return process.platform === "darwin"
-                ? new MachOSliceArtifactReader(path)
+                ? new MachOSliceArtifactReader(path, environment)
                 : undefined;
         case "dmg":
             if (process.platform !== "darwin")
                 return undefined;
-            return NativeDmgArtifactReader.create(path, signal);
+            return NativeDmgArtifactReader.create(path, environment, signal);
         default:
             return undefined;
     }

package/dist/artifacts/inventory/scanCanonical.js

@@ -1,53 +1,73 @@
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
 import { createReadStream } from "node:fs";
 import { lstat } from "node:fs/promises";
 import { ArtifactReaderFailure, } from "../ArtifactReader.js";
 import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
 import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "./ArtifactGraphConstruction.js";
-import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { artifactContradictionId, artifactGraphDigest, artifactManifestId, } from "../../domain/artifactIdentity.js";
 import { classifyRoot } from "./classify.js";
 import { hashReadable } from "../ArtifactHash.js";
 import { createReader, inventoryLimitations } from "./reader.js";
 import { scanReader, } from "./scanReader.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
-export const scanCanonicalArtifactInventory = async (path, options = {}) => {
+export const scanCanonicalArtifactInventory = async (path, options = {}, readerFactory = createReader) => {
     const integrity = options.integrity ?? STRICT_INTEGRITY_POLICY;
     const metadata = await lstat(path);
     const rootFormat = await classifyRoot(path, metadata.isDirectory());
     const rootDigest = metadata.isDirectory()
         ? null
         : await hashReadable(createReadStream(path), options.signal);
-    const reader = await createReader(path, rootFormat, options.signal);
+    const reader = await readerFactory(path, rootFormat, options.environment ?? {}, options.signal);
+    let outcome;
     try {
         const { nodes, occurrences, pendingContradictions } = await scanReader(reader, options.signal, integrity);
-        return await buildInventorySnapshot({
-            path,
-            metadata,
-            rootFormat,
-            rootDigest,
-            reader,
-            signal: options.signal,
-            nodes,
-            occurrences,
-            pendingContradictions,
-        });
+        outcome = {
+            kind: "completed",
+            snapshot: await buildInventorySnapshot({
+                path,
+                metadata,
+                rootFormat,
+                rootDigest,
+                reader,
+                signal: options.signal,
+                nodes,
+                occurrences,
+                pendingContradictions,
+            }),
+        };
     }
-    finally {
+    catch (cause) {
+        outcome = { kind: "failed", cause };
+    }
+    try {
         await reader?.close();
     }
+    catch (cleanupCause) {
+        const cleanup = ArtifactReaderFailure.cleanupObservation(cleanupCause, `artifact reader for ${path}`);
+        const primary = outcome.kind === "failed" ? outcome.cause : cleanupCause;
+        throw ArtifactReaderFailure.withCleanup(primary, cleanup, outcome.kind === "completed"
+            ? { kind: "artifact-inventory", inventory: outcome.snapshot }
+            : undefined);
+    }
+    if (outcome.kind === "failed")
+        throw outcome.cause;
+    return outcome.snapshot;
 };
 const buildInventorySnapshot = async (input) => {
     const { path, metadata, rootFormat, rootDigest, reader, signal } = input;
     materializeDirectoryNodes(input.occurrences, input.nodes);
     const rootNode = createRootNode({
-        path,
-        format: rootFormat,
-        directory: metadata.isDirectory(),
         digest: rootDigest,
         occurrences: input.occurrences,
     });
     input.nodes.set(rootNode.artifact_id, rootNode);
     rekeyOccurrences(rootNode.artifact_id, input.occurrences);
-    const rootOccurrence = rootOccurrenceFor(rootNode, metadata.size);
+    const rootOccurrence = rootOccurrenceFor(rootNode, {
+        size: metadata.size,
+        executable: (metadata.mode & 0o111) !== 0,
+        format: rootFormat,
+        path,
+    });
     for (const occurrence of input.occurrences)
         if (occurrence.parent_occurrence_id === null)
             occurrence.parent_occurrence_id = rootOccurrence.occurrence_id;
@@ -61,16 +81,20 @@ const buildInventorySnapshot = async (input) => {
     const edges = createArtifactEdges(rootNode.artifact_id, input.occurrences, reader?.provenance()[0]);
     const orderedNodes = sortNodes([...input.nodes.values()]);
     const orderedOccurrences = sortOccurrences(input.occurrences);
-    const orderedEdges = sortEdges(edges);
+    const orderedEdges = sortEdges(edges).map((edge, ordinal) => ({
+        ...edge,
+        ordinal,
+    }));
     await verifyRootDigest(path, rootDigest, signal);
-    const graphSha256 = canonicalDigest({
+    const graphSha256 = artifactGraphDigest({
         nodes: orderedNodes,
         occurrences: orderedOccurrences,
         edges: orderedEdges,
-        integrity_contradictions: integrityContradictions,
-    }, "Artifact");
+        contradictions: integrityContradictions,
+    });
     const manifest = buildManifest({
         rootNode,
+        rootFormat,
         graphSha256,
         orderedNodes,
         orderedOccurrences,
@@ -95,12 +119,12 @@ const buildIntegrityContradictions = (pending, occurrenceByPath, occurrenceById,
         : occurrenceById.get(occurrence.parent_occurrence_id);
     const parentArtifactId = parent?.artifact_id ?? rootNode.artifact_id;
     return {
-        contradiction_id: `ic_${canonicalDigest({
-            root_artifact_id: rootNode.artifact_id,
-            logical_path: contradiction.logicalPath,
-            declared_sha256: contradiction.declaredSha256,
-            observed_sha256: contradiction.observedSha256,
-        }, "Artifact")}`,
+        contradiction_id: artifactContradictionId({
+            rootArtifactId: rootNode.artifact_id,
+            logicalPath: contradiction.logicalPath,
+            declaredSha256: contradiction.declaredSha256,
+            observedSha256: contradiction.observedSha256,
+        }),
         occurrence_id: occurrence.occurrence_id,
         parent_artifact_id: parentArtifactId,
         logical_path: contradiction.logicalPath,
@@ -123,17 +147,14 @@ const verifyRootDigest = async (path, rootDigest, signal) => {
         verified.bytes !== rootDigest.bytes)
         throw new ArtifactReaderFailure("integrity", "Root artifact changed during inventory");
 };
-const sortNodes = (nodes) => nodes.sort((left, right) => left.artifact_id.localeCompare(right.artifact_id));
-const sortOccurrences = (occurrences) => occurrences.sort((left, right) => left.logical_path.localeCompare(right.logical_path, "en"));
-const sortEdges = (edges) => edges.sort((left, right) => left.edge_id.localeCompare(right.edge_id));
-const buildManifest = ({ rootNode, graphSha256, orderedNodes, orderedOccurrences, orderedEdges, }) => artifactInventoryResultSchema.shape.manifest.parse({
-    manifest_id: `agm_${canonicalDigest({
-        root_artifact_id: rootNode.artifact_id,
-        graph_sha256: graphSha256,
-    }, "Artifact")}`,
+const sortNodes = (nodes) => nodes.sort((left, right) => compareCodePoints(left.artifact_id, right.artifact_id));
+const sortOccurrences = (occurrences) => occurrences.sort((left, right) => compareCodePoints(left.logical_path, right.logical_path));
+const sortEdges = (edges) => edges.sort((left, right) => compareCodePoints(left.edge_id, right.edge_id));
+const buildManifest = ({ rootNode, rootFormat, graphSha256, orderedNodes, orderedOccurrences, orderedEdges, }) => artifactInventoryResultSchema.shape.manifest.parse({
+    manifest_id: artifactManifestId(rootNode.artifact_id, graphSha256),
     root_artifact_id: rootNode.artifact_id,
     root_sha256: rootNode.sha256,
-    root_format: rootNode.format,
+    root_format: rootFormat,
     graph_sha256: graphSha256,
     node_count: orderedNodes.length,
     occurrence_count: orderedOccurrences.length,

package/dist/artifacts/inventory/scanReader.js

@@ -2,7 +2,7 @@ import { isAbsolute } from "node:path";
 import { ArtifactPathRegistry, normalizeArtifactPath, } from "../ArtifactPaths.js";
 import { ArtifactReaderFailure, } from "../ArtifactReader.js";
 import { AsarArtifactReader } from "../AsarArtifactReader.js";
-import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "./ArtifactGraphConstruction.js";
+import { classifyArtifactContent, classifyArtifactBytes, createArtifactNode, createOccurrence, nearestParent, } from "./ArtifactGraphConstruction.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
 import { hashReadable } from "../ArtifactHash.js";
 const UNAVAILABLE_UNPACKED_LIMITATION = "ASAR unpacked companion bytes were unavailable; no content hash or child artifact was produced.";
@@ -71,6 +71,8 @@ const visitArtifactEntries = async (context, currentReader, prefix) => {
             if (digested !== undefined) {
                 context.nodes.set(digested.node.artifact_id, digested.node);
                 occurrence.artifact_id = digested.node.artifact_id;
+                occurrence.artifact_kind = digested.classification.kind;
+                occurrence.artifact_format = digested.classification.format;
                 occurrence.hash_status = digested.mismatched
                     ? "mismatched"
                     : "verified";
@@ -129,17 +131,11 @@ const digestArtifactEntry = async (context, currentReader, entry, logicalPath) =
         node: createArtifactNode({
             sha256: digest.sha256,
             size: digest.bytes,
-            kind: classified.kind,
-            format: classified.format,
-            executable: entry.executable,
+            format: classifyArtifactBytes(digest.prefix, digest.bytes),
             contentState: "embedded",
-            limitations: mismatched
-                ? [
-                    "Observed content contradicts declared integrity metadata and is untrusted.",
-                ]
-                : [],
         }),
         mismatched,
+        classification: classified,
     };
 };
 const isExpandableAsar = (entry, logicalPath) => entry.kind === "file" &&

package/dist/artifacts/javascript/JavaScriptArtifactFiles.js

@@ -125,7 +125,11 @@ const readText = async (context, input) => {
     try {
         return {
             included: true,
-            value: new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+            value: new TextDecoder("utf-8", {
+                fatal: true,
+                ignoreBOM: input.expected.kind === "javascript" ||
+                    input.expected.kind === "html",
+            }).decode(bytes),
         };
     }
     catch (cause) {
@@ -204,7 +208,7 @@ const relevantKind = (path) => {
         return "package-json";
     if (lower.endsWith(".json"))
         return "json";
-    if (/\.(?:cjs|mjs|js|jsx|ts|tsx)$/u.test(lower))
+    if (/\.(?:cjs|cts|mjs|mts|js|jsx|ts|tsx)$/u.test(lower))
         return "javascript";
     if (/\.html?$/u.test(lower))
         return "html";

package/dist/browser/BrowserScenarioPartialObservation.js

@@ -0,0 +1,106 @@
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
+const OPERATION = "capture_browser_scenario";
+const browserScenarioLimitations = (session) => [
+    "Event sequence records provider receipt order; simultaneous browser causality is not inferred.",
+    "Network content is retained only when selected; response bytes are browser-decoded, not compressed wire bytes.",
+    "Request bytes are limited to what Playwright exposes; not_exposed does not establish body absence or multipart file coverage.",
+    "Network content reads settle within 5 seconds each and never wait for unfinished responses or refetch them.",
+    "Playwright scenario events do not expose request initiator stacks; receipt order does not prove causality.",
+    "Storage values are hashed only after declared-secret redaction.",
+    ...(session.eventLimitations?.() ?? []),
+    ...(session.mode === "connect"
+        ? [
+            "CDP attachment cannot recover pre-attach events or guarantee launch-time context options.",
+        ]
+        : []),
+];
+/** Project one session into the common capture fields used by success and failure. */
+export const browserScenarioCaptureData = (input) => ({
+    browser: {
+        mode: input.session.mode,
+        process_ownership: input.session.processOwnership,
+        cleanup: input.cleanup,
+        product: input.session.product,
+        version: input.session.version,
+    },
+    scenario: {
+        start_origin: new URL(input.scenario.start_url.url).origin,
+        action_count: input.scenario.actions.length,
+        secret_references: input.scenario.secrets
+            .map(({ secret_id: id }) => id)
+            .sort(),
+        network_content: input.scenario.capture.network,
+    },
+    duration_ms: Date.now() - input.startedAt,
+    steps: [...input.steps],
+    events: input.session.events(),
+    limitations: [
+        ...browserScenarioLimitations(input.session),
+        ...(input.limitations ?? []),
+    ],
+});
+/** Describe the cleanup failure without discarding its resource evidence. */
+export const browserScenarioCleanupObservation = (cause) => cause instanceof AnalysisError && cause.cleanup !== undefined
+    ? cause.cleanup
+    : {
+        reason: cause instanceof Error ? cause.message : String(cause),
+        resources: cause instanceof AnalysisError && cause.cleanupResources.length > 0
+            ? cause.cleanupResources
+            : ["browser_transport"],
+    };
+/** Retain operation diagnostics and capture data after cleanup settles. */
+export const browserScenarioOperationFailure = (cause, partialObservation, cleanupFailure) => {
+    const primary = cause instanceof AnalysisError
+        ? cause
+        : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION, { cause });
+    const primaryProjection = projectAnalysisError(primary);
+    const cleanupCause = cleanupFailure === undefined
+        ? undefined
+        : cleanupFailure.cause instanceof AnalysisError
+            ? cleanupFailure.cause
+            : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, "close_browser_scenario", { cause: cleanupFailure.cause });
+    const cleanupObservation = cleanupFailure === undefined
+        ? undefined
+        : browserScenarioCleanupObservation(cleanupFailure.cause);
+    const retainedOptions = {
+        cause: primary,
+        partialObservation,
+        ...(primary.capturedOutput === undefined
+            ? {}
+            : { capturedOutput: primary.capturedOutput }),
+        ...(primary.cleanup === undefined ? {} : { cleanup: primary.cleanup }),
+    };
+    if (cleanupCause === undefined) {
+        if (primary instanceof AnalysisCancelledError)
+            return new AnalysisCancelledError(primary.operation, retainedOptions);
+        if (primary instanceof AnalysisTimeoutError)
+            return new AnalysisTimeoutError(primary.operation, primary.timeoutMs, retainedOptions);
+        if (primary instanceof BrowserObservationError)
+            return new BrowserObservationError(primary.operation, primary.reason, {
+                ...retainedOptions,
+                ...(primary.userMessage === undefined
+                    ? {}
+                    : { detail: primary.userMessage }),
+            });
+    }
+    const cleanup = cleanupObservation ?? primary.cleanup;
+    return new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION, {
+        ...retainedOptions,
+        cause: cleanupCause === undefined
+            ? primary
+            : new AggregateError([primary, cleanupCause], "Browser scenario operation and cleanup both failed", { cause: primary }),
+        userMessage: primaryProjection.message,
+        ...(cleanup === undefined ? {} : { cleanup }),
+        diagnostics: {
+            primary_error: primaryProjection,
+            ...(cleanupCause === undefined
+                ? {}
+                : { cleanup_error: projectAnalysisError(cleanupCause) }),
+        },
+    });
+};

package/dist/browser/CdpBrowserProvider.js

@@ -1,4 +1,5 @@
-import { browserTargetListSchema, sanitizeBrowserUrl, webPageInspectionSchema, } from "../domain/browserObservation.js";
+import { sanitizeBrowserUrl, } from "../domain/browserObservation.js";
+import { browserTargetListSchema, webPageInspectionSchema, } from "../domain/browserObservationSchemas.js";
 import { analyzeCapturedWebBundle } from "../domain/webBundleAnalyzer.js";
 import { webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { webObservationSessionSchema, } from "../domain/browserSession.js";
@@ -19,8 +20,6 @@ import { observeCdpSession } from "./CdpObservationSession.js";
 import { discoverWebMcp } from "./CdpWebMcpDiscovery.js";
 import { captureCdpScreenshot } from "./CdpScreenshot.js";
 import { comparePngScreenshots } from "./PngVisualDiff.js";
-/** Public identity committed by passive browser observations. */
-export { CDP_BROWSER_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { CDP_BROWSER_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const IDENTITY = CDP_BROWSER_PROVIDER_IDENTITY;
 const CLEANUP_DOMAINS = ["Network", "Debugger", "Runtime", "Page"];

package/dist/browser/CdpCaptureCompleteness.js

@@ -44,6 +44,8 @@ export class CdpCaptureCompleteness {
         if (reason === "provider_unavailable" ||
             reason === "invalid_protocol_value")
             this.#unavailable.add(section);
+        if (reason === "resource_budget_exhausted")
+            this.#truncated.add(section);
         const key = `${section}\0${reason}`;
         const existing = this.#excluded.get(key);
         const combined = count === null || existing?.count === null