rea-agents 6.1.0 → 6.2.0

package/dist/artifacts/inventory/ArtifactGraphConstruction.js

@@ -1,6 +1,7 @@
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
 import { canonicalDigest } from "../../domain/comparisonSemantics.js";
 import { artifactEdgeId, artifactIdForContent, occurrenceIdForLocation, } from "../../domain/artifactIdentity.js";
-import { zipPackageFormatForPath } from "../../domain/zipPackageFormat.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) => {
@@ -16,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,
@@ -26,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")
@@ -61,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";
     }
@@ -78,47 +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: artifactIdForContent(input.sha256),
-    kind: input.kind,
     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) => ({
+export const rootOccurrenceFor = (node, metadata) => ({
     occurrence_id: occurrenceIdForLocation({
         rootArtifactId: node.artifact_id,
         logicalPath: ".",
-        entryKind: node.format === "directory" ? "directory" : "file",
+        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,
@@ -211,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 &&
@@ -246,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",
-                };
+                return "pe";
         }
-        else if (parseDosMzHeader(prefix, fileSize).ok) {
-            return { kind: "executable", format: "dos-mz" };
-        }
-        // 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,3 +1,4 @@
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
 import { createReadStream } from "node:fs";
 import { lstat } from "node:fs/promises";
 import { ArtifactReaderFailure, } from "../ArtifactReader.js";
@@ -9,45 +10,64 @@ 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,7 +81,10 @@ 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 = artifactGraphDigest({
         nodes: orderedNodes,
@@ -71,6 +94,7 @@ const buildInventorySnapshot = async (input) => {
     });
     const manifest = buildManifest({
         rootNode,
+        rootFormat,
         graphSha256,
         orderedNodes,
         orderedOccurrences,
@@ -123,14 +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({
+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/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/CdpCaptureEventHandlers.js

@@ -1,6 +1,6 @@
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { safeResponseMetadata } from "./CdpSafeMetadata.js";
-import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, scriptMetadataValues, cdpStringValue, } from "./CdpCaptureValues.js";
 import { requestBodyShape, updateResponseBodyShape, } from "./CdpCaptureEventBodyShapes.js";
 import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, isJsonMediaType, isMainFrameNavigation, } from "./CdpCaptureEventHelpers.js";
 import { CDP_CAPTURE_SCRIPT_METADATA_LIMITS, } from "./CdpCaptureEventTypes.js";
@@ -44,9 +44,7 @@ export const handleScriptParsed = (state, params) => {
         rawUrl,
         url: sanitized.url,
         origin: sanitized.origin,
-        hash: cdpStringValue(params.hash) ?? "",
-        length: Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(numberValue(params.length) ?? 0))),
-        isModule: params.isModule === true,
+        ...scriptMetadataValues(params),
         language: cdpStringValue(params.scriptLanguage) ?? null,
         executionContextKey: executionContextKey(params.executionContextId),
     };

package/dist/browser/CdpCaptureEvents.js

@@ -3,7 +3,6 @@ import * as bodyShapes from "./CdpCaptureEventBodyShapes.js";
 import * as handlers from "./CdpCaptureEventHandlers.js";
 import { isJsonMediaType } from "./CdpCaptureEventHelpers.js";
 import { recordValue } from "./CdpCaptureValues.js";
-export {} from "./CdpCaptureEventTypes.js";
 /** Event accumulator that validates and normalizes payloads at ingestion. */
 export class CdpCaptureEvents {
     #scriptMetadataBudgetExclusionsRecorded = false;

package/dist/browser/CdpCaptureValues.js

@@ -13,12 +13,32 @@ export const recordsValue = (value) => Array.isArray(value)
     : [];
 export const cdpStringValue = (value) => typeof value === "string" ? value : undefined;
 export const numberValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+/** Preserve partial script declarations; omitted or invalid fields remain unknown. */
+export const scriptMetadataValues = (value) => {
+    const length = numberValue(value?.length);
+    return {
+        hash: cdpStringValue(value?.hash) ?? null,
+        length: length !== undefined && Number.isSafeInteger(length) && length >= 0
+            ? length
+            : null,
+        isModule: typeof value?.isModule === "boolean" ? value.isModule : null,
+    };
+};
 export const requiredRecord = (value) => {
     const record = recordValue(value);
     if (record === undefined)
         throw new BrowserObservationError("inspect_web_page", "protocol_error");
     return record;
 };
+/** Require producer source text; an absent source is distinct from an empty script. */
+export const requiredScriptSource = (value, operation) => {
+    const source = cdpStringValue(recordValue(value)?.scriptSource);
+    if (source === undefined)
+        throw new BrowserObservationError(operation, "protocol_error", {
+            detail: "Debugger.getScriptSource returned malformed source text: scriptSource must be a string.",
+        });
+    return source;
+};
 export const isHttpUrl = (value) => {
     if (value === undefined)
         return false;

package/dist/browser/CdpElectronProvider.js

@@ -8,8 +8,6 @@ import { discoverCdpEndpoint, hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
 import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession.js";
 import { inspectCdpElectronPage } from "./CdpElectronInspection.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
-/** Public identity committed by passive Electron observations. */
-export { CDP_ELECTRON_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { CDP_ELECTRON_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const IDENTITY = CDP_ELECTRON_PROVIDER_IDENTITY;
 /** Passive Electron provider for local file pages exposed by loopback CDP. */

package/dist/browser/CdpElectronScriptEvents.js

@@ -1,5 +1,5 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { numberValue, recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { numberValue, recordValue, scriptMetadataValues, cdpStringValue, } from "./CdpCaptureValues.js";
 /** Retain script/frame metadata from passive Electron events. */
 export const ingestElectronScriptEvent = (input) => {
     if (input.event.method === "Runtime.executionContextsCleared") {
@@ -33,9 +33,7 @@ export const ingestElectronScriptEvent = (input) => {
     input.scripts.push({
         scriptId,
         rawUrl,
-        hash: cdpStringValue(value?.hash) ?? "",
-        length: nonnegativeInteger(value?.length),
-        isModule: value?.isModule === true,
+        ...scriptMetadataValues(value),
         language: cdpStringValue(value?.scriptLanguage) ?? null,
         executionContextKey: executionContextKey(value?.executionContextId),
     });
@@ -49,10 +47,6 @@ const retainExecutionContext = (event, frames) => {
         return;
     frames.set(contextKey, frameId);
 };
-const nonnegativeInteger = (value) => {
-    const number = numberValue(value);
-    return number === undefined ? 0 : Math.max(0, Math.trunc(number));
-};
 const executionContextKey = (value) => {
     const identifier = numberValue(value);
     return identifier !== undefined && Number.isSafeInteger(identifier)

package/dist/browser/CdpElectronScripts.js

@@ -1,7 +1,7 @@
 import { canonicalDigest } from "../domain/comparisonSemantics.js";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { requiredRecord, cdpStringValue } from "./CdpCaptureValues.js";
+import { requiredScriptSource } from "./CdpCaptureValues.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 /** Normalize local script metadata and optionally approved source. */
 export const captureElectronScripts = async (input) => {
@@ -54,8 +54,7 @@ const captureScriptSource = async (input, script) => {
                 reason: "source capture was not selected",
             },
         };
-    const result = requiredRecord(await input.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, input.sessionId, input.signal));
-    const text = cdpStringValue(result.scriptSource) ?? "";
+    const text = requiredScriptSource(await input.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, input.sessionId, input.signal), "inspect_electron_page");
     return {
         source: {
             included: true,