rea-agents 6.3.0 → 6.4.0

package/dist/artifacts/inventory/hashStableRootArtifact.js

@@ -1,32 +1,65 @@
 import { lstat } from "node:fs/promises";
+import { readFileHandleChunks } from "../../filesystem/readFileHandleChunks.js";
+import { OwnedFileHandle } from "../../filesystem/OwnedFileHandle.js";
 import { ArtifactReaderFailure } from "../ArtifactReader.js";
-import { NonRegularFileReadError, openRegularFile, sameRegularFileState, } from "../../filesystem/RegularFile.js";
+import { NonRegularFileReadError, RegularFileAdmissionFailure, openRegularFile, sameRegularFileState, } from "../../filesystem/RegularFile.js";
 import { abortIfNeeded, hashReadable, } from "../ArtifactHash.js";
-/** Hash one stable regular root file from the same descriptor that was checked. */
-export const hashStableRootArtifact = async (path, signal) => {
-    let handle;
+/** Admit a root descriptor without losing ownership when validation cleanup fails. */
+export const openRootArtifact = async (path, resourceScope, signal) => {
     try {
-        handle = await openRegularFile(path, {
-            symlinks: "reject",
-            signal,
-        });
+        return new OwnedFileHandle(await openRegularFile(path, { symlinks: "reject", signal }));
     }
     catch (cause) {
-        if (cause instanceof NonRegularFileReadError)
-            throw new ArtifactReaderFailure("format", `Artifact root is not a regular file: ${path}`, { cause });
-        throw cause;
+        const primary = cause instanceof RegularFileAdmissionFailure ? cause.cause : cause;
+        const failure = primary instanceof NonRegularFileReadError
+            ? new ArtifactReaderFailure("format", `Artifact root is not a regular file: ${path}`, { cause: primary })
+            : primary;
+        if (cause instanceof RegularFileAdmissionFailure) {
+            const resource = `root artifact descriptor for ${path}`;
+            const cleanup = await resourceScope.release({
+                kind: "file-handle",
+                resource,
+                handle: cause.owner,
+            });
+            if (cleanup.kind === "failed")
+                throw ArtifactReaderFailure.withCleanup(failure, ArtifactReaderFailure.cleanupObservation(cleanup.cause, resource));
+        }
+        throw failure;
     }
+};
+/** Hash one stable regular root file from the same descriptor that was checked. */
+export const hashStableRootArtifact = async (path, resourceScope, signal) => {
+    const owner = await openRootArtifact(path, resourceScope, signal);
+    const handle = owner.handle;
+    let outcome;
     try {
         const initial = await handle.stat();
-        return await hashStableRootArtifactHandle(path, handle, initial, signal);
+        outcome = {
+            kind: "completed",
+            value: await hashStableRootArtifactHandle(path, handle, initial, signal),
+        };
     }
-    finally {
-        await handle.close();
+    catch (cause) {
+        outcome = { kind: "failed", cause };
     }
+    const resource = `root artifact descriptor for ${path}`;
+    const cleanup = await resourceScope.release({
+        kind: "file-handle",
+        resource,
+        handle: owner,
+    });
+    if (cleanup.kind === "failed")
+        throw ArtifactReaderFailure.withCleanup(outcome.kind === "failed" ? outcome.cause : cleanup.cause, ArtifactReaderFailure.cleanupObservation(cleanup.cause, resource));
+    if (outcome.kind === "failed")
+        throw outcome.cause;
+    return outcome.value;
 };
 /** Hash and revalidate the same open descriptor used for root classification. */
 export const hashStableRootArtifactHandle = async (path, handle, initial, signal) => {
-    const digest = await hashReadable(handle.createReadStream({ autoClose: false }), signal);
+    const digest = await hashReadable(
+    // Read at most the admitted extent plus one byte to detect growth without
+    // following an actively appended file indefinitely.
+    readFileHandleChunks(handle, { start: 0, end: initial.size }), signal);
     abortIfNeeded(signal);
     const [opened, currentPath] = await Promise.all([handle.stat(), lstat(path)]);
     if (!sameRegularFileState(initial, opened) ||

package/dist/artifacts/inventory/reader.js

@@ -3,7 +3,8 @@ 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, environment, signal) => {
+import { ZIP_NON_ENTRY_TAIL_LIMITATION } from "../../domain/zipPackageFormat.js";
+export const createReader = (path, format, environment, rootSource) => {
     switch (format) {
         case "directory":
             return new DirectoryArtifactReader(path);
@@ -12,24 +13,31 @@ export const createReader = async (path, format, environment, signal) => {
         case "apk":
         case "msix":
         case "appx":
-            return new ZipArtifactReader(path, format);
+            return new ZipArtifactReader(path, format, undefined, rootSource);
         case "asar":
             return new AsarArtifactReader(path);
         case "mach-o-universal":
             return process.platform === "darwin"
-                ? new MachOSliceArtifactReader(path, environment)
+                ? new MachOSliceArtifactReader(path, environment, undefined, rootSource)
                 : undefined;
         case "dmg":
             if (process.platform !== "darwin")
                 return undefined;
-            return NativeDmgArtifactReader.create(path, environment, signal);
+            return new NativeDmgArtifactReader(path, environment);
         default:
             return undefined;
     }
 };
 export const inventoryLimitations = (format, reader) => {
     if (reader !== undefined)
-        return [];
+        return reader.format === "zip" ||
+            reader.format === "ipa" ||
+            reader.format === "apk" ||
+            reader.format === "msix" ||
+            reader.format === "appx"
+            ? [ZIP_NON_ENTRY_TAIL_LIMITATION]
+            : [];
+    // dmg and pkg reach here only after classifyRootFormat matched their bytes.
     if (format === "dmg" || format === "pkg")
         return [
             `${format.toUpperCase()} root hash is observed; child inventory requires a native macOS adapter.`,

package/dist/artifacts/inventory/scanCanonical.js

@@ -5,23 +5,33 @@ import { ArtifactReaderFailure, } from "../ArtifactReader.js";
 import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
 import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "./ArtifactGraphConstruction.js";
 import { artifactContradictionId, artifactGraphDigest, artifactManifestId, } from "../../domain/artifactIdentity.js";
-import { classifyAndHashRoot } from "./classify.js";
+import { classifyAndHashRootForInventory } from "./classify.js";
 import {} from "../ArtifactHash.js";
-import { hashStableRootArtifact } from "./hashStableRootArtifact.js";
+import { hashStableRootArtifact, hashStableRootArtifactHandle, } from "./hashStableRootArtifact.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 = {}, readerFactory = createReader) => {
+export const scanCanonicalArtifactInventory = async (path, options, readerFactory = createReader) => options.resourceScope.run(() => scanCanonicalArtifactInventoryInScope(path, options, readerFactory));
+export const scanCanonicalArtifactInventoryInScope = async (path, options, readerFactory = createReader) => {
     const integrity = options.integrity ?? STRICT_INTEGRITY_POLICY;
     const metadata = await lstat(path);
-    const { format: rootFormat, digest: rootDigest } = await classifyAndHashRoot(path, metadata.isDirectory(), metadata, options.signal);
-    const reader = await readerFactory(path, rootFormat, options.environment ?? {}, options.signal);
+    const { format: rootFormat, digest: rootDigest, rootSource, } = await classifyAndHashRootForInventory(path, metadata.isDirectory(), metadata, options);
+    let reader;
+    let readerCreationFailure;
+    try {
+        reader = readerFactory(path, rootFormat, options.environment ?? {}, rootSource);
+    }
+    catch (cause) {
+        readerCreationFailure = { cause };
+    }
     const ownedReaders = reader === undefined ? [] : [reader];
     let outcome;
     try {
+        if (readerCreationFailure !== undefined)
+            throw readerCreationFailure.cause;
         if (reader instanceof AsarArtifactReader)
             await reader.prepareContainer(rootDigest?.sha256, options.signal);
-        const { nodes, occurrences, pendingContradictions } = await scanReader(reader, ownedReaders, options.signal, integrity);
+        const { nodes, occurrences, pendingContradictions, caseCollisionLimitation, } = await scanReader(reader, ownedReaders, options.signal, integrity);
         outcome = {
             kind: "completed",
             snapshot: await buildInventorySnapshot({
@@ -29,38 +39,62 @@ export const scanCanonicalArtifactInventory = async (path, options = {}, readerF
                 metadata,
                 rootFormat,
                 rootDigest,
+                rootSource,
+                resourceScope: options.resourceScope,
                 reader,
                 signal: options.signal,
                 nodes,
                 occurrences,
                 pendingContradictions,
+                caseCollisionLimitation,
             }),
         };
     }
     catch (cause) {
         outcome = { kind: "failed", cause };
     }
-    let cleanupFailure;
-    for (const owned of ownedReaders.reverse()) {
-        try {
-            await owned.close();
-        }
-        catch (cleanupCause) {
-            const cleanup = ArtifactReaderFailure.cleanupObservation(cleanupCause, `artifact reader for ${path}`);
-            cleanupFailure = ArtifactReaderFailure.withCleanup(cleanupFailure ??
-                (outcome.kind === "failed" ? outcome.cause : cleanupCause), cleanup, outcome.kind === "completed"
-                ? { kind: "artifact-inventory", inventory: outcome.snapshot }
-                : undefined);
-        }
-    }
+    const cleanupFailure = await cleanupInventoryOwners({
+        path,
+        options,
+        rootSource,
+        ownedReaders,
+        outcome,
+    });
     if (cleanupFailure !== undefined)
         throw cleanupFailure;
     if (outcome.kind === "failed")
         throw outcome.cause;
     return outcome.snapshot;
 };
+const cleanupInventoryOwners = async ({ path, options, rootSource, ownedReaders, outcome, }) => {
+    let cleanupFailure;
+    const owners = [...ownedReaders]
+        .reverse()
+        .map((reader) => ({
+        kind: "reader",
+        reader,
+        resource: `artifact reader for ${path}`,
+    }));
+    if (rootSource !== undefined)
+        owners.push({
+            kind: "file-handle",
+            handle: rootSource.owner,
+            resource: `root artifact descriptor for ${path}`,
+        });
+    for (const owner of owners) {
+        const attempt = await options.resourceScope.release(owner);
+        if (attempt.kind === "released")
+            continue;
+        const primary = cleanupFailure ??
+            (outcome.kind === "failed" ? outcome.cause : attempt.cause);
+        cleanupFailure = ArtifactReaderFailure.withCleanup(primary, ArtifactReaderFailure.cleanupObservation(attempt.cause, owner.resource), outcome.kind === "completed"
+            ? { kind: "artifact-inventory", inventory: outcome.snapshot }
+            : undefined);
+    }
+    return cleanupFailure;
+};
 const buildInventorySnapshot = async (input) => {
-    const { path, metadata, rootFormat, rootDigest, reader, signal } = input;
+    const { path, metadata, rootFormat, rootDigest, rootSource, reader, signal } = input;
     materializeDirectoryNodes(input.occurrences, input.nodes);
     const rootNode = createRootNode({
         digest: rootDigest,
@@ -91,7 +125,7 @@ const buildInventorySnapshot = async (input) => {
         ...edge,
         ordinal,
     }));
-    await verifyRootDigest(path, rootDigest, signal);
+    await verifyRootDigest(path, rootDigest, rootSource, input.resourceScope, signal);
     const graphSha256 = artifactGraphDigest({
         nodes: orderedNodes,
         occurrences: orderedOccurrences,
@@ -113,7 +147,7 @@ const buildInventorySnapshot = async (input) => {
         edges: orderedEdges,
         provenance: reader?.provenance() ?? [],
         integrity_contradictions: integrityContradictions,
-        limitations: buildLimitations(rootFormat, reader, integrityContradictions),
+        limitations: buildLimitations(rootFormat, reader, integrityContradictions, input.caseCollisionLimitation),
     };
 };
 const buildIntegrityContradictions = (pending, occurrenceByPath, occurrenceById, rootNode) => pending.map((contradiction) => {
@@ -145,10 +179,12 @@ const buildIntegrityContradictions = (pending, occurrenceByPath, occurrenceById,
         ],
     };
 });
-const verifyRootDigest = async (path, rootDigest, signal) => {
+const verifyRootDigest = async (path, rootDigest, rootSource, resourceScope, signal) => {
     if (rootDigest === null)
         return;
-    const verified = await hashStableRootArtifact(path, signal);
+    const verified = rootSource === undefined
+        ? await hashStableRootArtifact(path, resourceScope, signal)
+        : await hashStableRootArtifactHandle(path, rootSource.handle, rootSource.initial, signal);
     if (verified.sha256 !== rootDigest.sha256 ||
         verified.bytes !== rootDigest.bytes)
         throw new ArtifactReaderFailure("integrity", "Root artifact changed during inventory");
@@ -166,8 +202,9 @@ const buildManifest = ({ rootNode, rootFormat, graphSha256, orderedNodes, ordere
     occurrence_count: orderedOccurrences.length,
     edge_count: orderedEdges.length,
 });
-const buildLimitations = (rootFormat, reader, integrityContradictions) => [
+const buildLimitations = (rootFormat, reader, integrityContradictions, caseCollisionLimitation) => [
     ...inventoryLimitations(rootFormat, reader),
+    ...(caseCollisionLimitation === undefined ? [] : [caseCollisionLimitation]),
     ...(integrityContradictions.length === 0
         ? []
         : [

package/dist/artifacts/inventory/scanReader.js

@@ -1,8 +1,8 @@
 import { isAbsolute } from "node:path";
-import { ArtifactPathRegistry, normalizeArtifactPath, } from "../ArtifactPaths.js";
+import { annotateEnglishUnicodeCaseCollisions, ArtifactPathRegistry, normalizeArtifactPath, } from "../ArtifactPaths.js";
 import { ArtifactReaderFailure, } from "../ArtifactReader.js";
 import { AsarArtifactReader } from "../AsarArtifactReader.js";
-import { classifyArtifactContent, classifyArtifactBytes, createArtifactNode, createOccurrence, nearestParent, } from "./ArtifactGraphConstruction.js";
+import { classifyArtifactContent, classifyArtifactBytes, createArtifactNode, createOccurrence, noteUnreadContainerSuffix, resolveOccurrenceParents, } 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.";
@@ -10,7 +10,12 @@ const emptyScan = () => ({ nodes: new Map(), occurrences: [], pendingContradicti
 export const scanReader = async (reader, ownedReaders, signal, integrity = STRICT_INTEGRITY_POLICY) => {
     const { nodes, occurrences, pendingContradictions } = emptyScan();
     if (reader === undefined)
-        return { nodes, occurrences, pendingContradictions };
+        return {
+            nodes,
+            occurrences,
+            pendingContradictions,
+            caseCollisionLimitation: undefined,
+        };
     const context = {
         reader,
         signal,
@@ -26,10 +31,13 @@ export const scanReader = async (reader, ownedReaders, signal, integrity = STRIC
     await visitArtifactEntries(context, reader, "");
     // Archive directories may appear after their children. Resolve containment
     // against the complete index before directory identities are materialized.
-    for (const occurrence of occurrences)
-        occurrence.parent_occurrence_id =
-            nearestParent(occurrence.logical_path, context.occurrenceByPath, context.expandedContainerIds)?.occurrence_id ?? null;
-    return { nodes, occurrences, pendingContradictions };
+    resolveOccurrenceParents(occurrences, context.occurrenceByPath, context.expandedContainerIds);
+    return {
+        nodes,
+        occurrences,
+        pendingContradictions,
+        caseCollisionLimitation: annotateEnglishUnicodeCaseCollisions(occurrences),
+    };
 };
 const visitArtifactEntries = async (context, currentReader, prefix) => {
     const stack = [
@@ -39,6 +47,7 @@ const visitArtifactEntries = async (context, currentReader, prefix) => {
             iterator: currentReader.entries(context.signal)[Symbol.asyncIterator](),
         },
     ];
+    let failure;
     try {
         while (stack.length > 0) {
             const frame = stack.at(-1);
@@ -66,7 +75,9 @@ const visitArtifactEntries = async (context, currentReader, prefix) => {
                 occurrence.hash_status = "unavailable";
                 occurrence.limitations.push(UNAVAILABLE_UNPACKED_LIMITATION);
             }
-            if (digested !== undefined) {
+            if (digested === undefined)
+                noteUnreadContainerSuffix(occurrence);
+            else {
                 context.nodes.set(digested.node.artifact_id, digested.node);
                 occurrence.artifact_id = digested.node.artifact_id;
                 occurrence.artifact_kind = digested.classification.kind;
@@ -79,7 +90,10 @@ const visitArtifactEntries = async (context, currentReader, prefix) => {
             }
             context.occurrences.push(occurrence);
             context.occurrenceByPath.set(logicalPath, occurrence);
-            if (expandableAsar && digested !== undefined && !digested.mismatched) {
+            if (expandableAsar &&
+                digested !== undefined &&
+                digested.classification.format === "asar" &&
+                !digested.mismatched) {
                 const nested = new AsarArtifactReader(entry.adapterKey);
                 context.ownedReaders.push(nested);
                 await nested.prepareContainer(digested.node.sha256, context.signal);
@@ -93,11 +107,24 @@ const visitArtifactEntries = async (context, currentReader, prefix) => {
             }
         }
     }
+    catch (cause) {
+        failure = { cause };
+    }
     finally {
         // Readers remain owned by the inventory until its complete observation is built.
-        for (const { iterator } of stack)
-            await iterator.return?.();
+        for (const { iterator, prefix, reader } of stack.reverse()) {
+            try {
+                await iterator.return?.();
+            }
+            catch (cause) {
+                failure = {
+                    cause: ArtifactReaderFailure.withCleanup(failure === undefined ? cause : failure.cause, ArtifactReaderFailure.cleanupObservation(cause, `artifact traversal for ${prefix || reader.format}`)),
+                };
+            }
+        }
     }
+    if (failure !== undefined)
+        throw failure.cause;
 };
 const digestArtifactEntry = async (context, currentReader, entry, logicalPath) => {
     if ((entry.kind !== "file" && entry.kind !== "slice") || entry.encrypted)

package/dist/artifacts/javascript/JavaScriptArtifactFiles.js

@@ -7,7 +7,7 @@ import { ArtifactReaderFailure, } from "../ArtifactReader.js";
 import { streamChunkToBuffer } from "../StreamBytes.js";
 import { hashReadable } from "../ArtifactHash.js";
 /** Read all relevant textual entries through an already-inventoried reader. */
-export const readJavaScriptArtifactFiles = async (reader, snapshot, signal) => {
+export const readJavaScriptArtifactFiles = async (reader, snapshot, resources, signal) => {
     if (reader instanceof AsarArtifactReader) {
         const root = snapshot.nodes.find(({ artifact_id }) => artifact_id === snapshot.manifest.root_artifact_id);
         if (root === undefined)
@@ -17,6 +17,7 @@ export const readJavaScriptArtifactFiles = async (reader, snapshot, signal) => {
     const inventory = expectedInventory(snapshot);
     const expected = inventory.files;
     const context = {
+        resources,
         expected,
         expectedContainers: inventory.containers,
         registry: new ArtifactPathRegistry(),
@@ -81,7 +82,7 @@ const visitReader = async (reader, prefix, containerSha256, context) => {
                 await verifyEntryBytes(await frame.reader.open(entry, context.signal), inventory, context.signal);
                 context.containers.push(inventory);
                 const nested = new AsarArtifactReader(entry.adapterKey);
-                ownedReaders.push(nested);
+                ownedReaders.push({ reader: nested, path });
                 stack.push({
                     reader: nested,
                     prefix: path,
@@ -115,21 +116,26 @@ const visitReader = async (reader, prefix, containerSha256, context) => {
         failure = { cause };
     }
     finally {
-        for (const { iterator } of stack) {
+        for (const { iterator, prefix, reader } of stack.reverse()) {
             try {
                 await iterator.return?.();
             }
             catch (cause) {
-                failure ??= { cause };
+                failure = {
+                    cause: ArtifactReaderFailure.withCleanup(failure === undefined ? cause : failure.cause, ArtifactReaderFailure.cleanupObservation(cause, `JavaScript artifact traversal for ${prefix || reader.format}`)),
+                };
             }
         }
         for (const owned of ownedReaders.reverse()) {
-            try {
-                await owned.close();
-            }
-            catch (cause) {
+            const resource = `nested ASAR reader for ${owned.path}`;
+            const cleanup = await context.resources.release({
+                kind: "reader",
+                reader: owned.reader,
+                resource,
+            });
+            if (cleanup.kind === "failed") {
                 failure = {
-                    cause: ArtifactReaderFailure.withCleanup(failure?.cause ?? cause, ArtifactReaderFailure.cleanupObservation(cause, `nested ASAR reader for ${prefix}`)),
+                    cause: ArtifactReaderFailure.withCleanup(failure === undefined ? cleanup.cause : failure.cause, ArtifactReaderFailure.cleanupObservation(cleanup.cause, resource)),
                 };
             }
         }

package/dist/artifacts/javascript/JavaScriptSourceAnalysis.js

@@ -0,0 +1,3 @@
+import { JavaScriptAnalysisWorker } from "../../javascript/analysis/JavaScriptAnalysisWorker.js";
+/** Construct the inert artifact analyzer; resources are acquired on the first source. */
+export const createJavaScriptSourceAnalysis = (limits, sourceCount) => new JavaScriptAnalysisWorker(limits, undefined, sourceCount);

package/dist/browser/BrowserScenarioPartialObservation.js

@@ -5,13 +5,19 @@ 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) => [
+const browserScenarioLimitations = (session, scenario) => [
     "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.",
+    ...(scenario.storage.local_storage.length === 0 &&
+        scenario.storage.session_storage.length === 0
+        ? []
+        : [
+            "Non-cookie storage seeds use CDP pre-script instrumentation; only pauses in the scenario's private seed script are resumed by this observer.",
+        ]),
     ...(session.eventLimitations?.() ?? []),
     ...(session.mode === "connect"
         ? [
@@ -40,7 +46,7 @@ export const browserScenarioCaptureData = (input) => ({
     steps: [...input.steps],
     events: input.session.events(),
     limitations: [
-        ...browserScenarioLimitations(input.session),
+        ...browserScenarioLimitations(input.session, input.scenario),
         ...(input.limitations ?? []),
     ],
 });

package/dist/browser/BrowserScenarioSecrets.js

@@ -6,6 +6,36 @@ const encodedSecretValues = (secret) => new Set([
     encodeURIComponent(secret),
     new URLSearchParams([["value", secret]]).toString().slice("value=".length),
 ]);
+const secretSpellings = (secret, spellings) => {
+    if (secret === "")
+        return [];
+    if (spellings === "raw")
+        return [secret];
+    const values = [...encodedSecretValues(secret)];
+    if (spellings === "bytes")
+        values.push(JSON.stringify(secret).slice(1, -1));
+    return [...new Set(values)].filter((value) => value !== "");
+};
+const declaredLiterals = (values, spellings) => [
+    ...new Set([...values.values()].flatMap((secret) => secretSpellings(secret, spellings))),
+];
+/** Pick a marker that does not itself contain a declared secret spelling. */
+const redactionMarker = (id, literals) => [`${REDACTION_PREFIX}${id}]`, "[REDACTED]", "…", ""].find((candidate) => literals.every((literal) => !candidate.includes(literal))) ?? "";
+const replaceSecretLiterals = (value, values, spellings, literals) => {
+    const replacements = [...values]
+        .flatMap(([id, secret]) => secretSpellings(secret, spellings).map((text) => ({ id, text })))
+        .sort((left, right) => right.text.length - left.text.length ||
+        (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+    let output = value;
+    for (const replacement of replacements)
+        output = output.replaceAll(replacement.text, redactionMarker(replacement.id, literals));
+    return output;
+};
+const secretNeedles = (values, literals) => [...values].flatMap(([id, secret]) => secretSpellings(secret, "bytes").map((text) => ({
+    id,
+    needle: Buffer.from(text),
+    marker: Buffer.from(redactionMarker(id, literals)),
+})));
 /** Resolved secret values kept only for one in-memory scenario session. */
 export class BrowserScenarioSecrets {
     values;
@@ -38,35 +68,18 @@ export class BrowserScenarioSecrets {
         return url.href;
     }
     redact(value) {
-        let output = value;
-        const replacements = [...this.values].sort(([leftId, left], [rightId, right]) => right.length - left.length ||
-            (leftId < rightId ? -1 : leftId > rightId ? 1 : 0));
-        for (const [id, secret] of replacements)
-            if (secret !== "")
-                output = output.replaceAll(secret, `${REDACTION_PREFIX}${id}]`);
-        return output;
+        const literals = declaredLiterals(this.values, "raw");
+        const output = replaceSecretLiterals(value, this.values, "raw", literals);
+        return literals.some((literal) => output.includes(literal)) ? "" : output;
     }
     /** Replace declared UTF-8, URI/form, and JSON-escaped secrets without decoding binary data. */
     redactBytes(value) {
-        const candidates = [...this.values]
-            .flatMap(([id, secret]) => {
-            if (secret === "")
-                return [];
-            return [
-                ...new Set([
-                    ...encodedSecretValues(secret),
-                    JSON.stringify(secret).slice(1, -1),
-                ]),
-            ].map((text) => {
-                const needle = Buffer.from(text);
-                return {
-                    id,
-                    needle,
-                    marker: Buffer.from(`${REDACTION_PREFIX}${id}]`),
-                    index: value.indexOf(needle),
-                };
-            });
-        })
+        const literals = declaredLiterals(this.values, "bytes");
+        const candidates = secretNeedles(this.values, literals)
+            .map((candidate) => ({
+            ...candidate,
+            index: value.indexOf(candidate.needle),
+        }))
             .sort((left, right) => right.needle.length - left.needle.length ||
             (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
         const parts = [];
@@ -88,20 +101,22 @@ export class BrowserScenarioSecrets {
         if (parts.length === 0)
             return value;
         parts.push(value.subarray(offset));
-        return Buffer.concat(parts);
+        const redacted = Buffer.concat(parts);
+        return literals.some((literal) => redacted.includes(Buffer.from(literal)))
+            ? Buffer.alloc(0)
+            : redacted;
     }
     /** Remove only declared secret values from one URL and report that action. */
     sanitizeUrl(value) {
-        let output = value;
-        const replacements = [...this.values].sort(([leftId, left], [rightId, right]) => right.length - left.length ||
-            (leftId < rightId ? -1 : leftId > rightId ? 1 : 0));
-        for (const [id, secret] of replacements) {
-            if (secret === "")
-                continue;
-            const marker = `${REDACTION_PREFIX}${id}]`;
-            for (const candidate of encodedSecretValues(secret))
-                output = output.replaceAll(candidate, marker);
-        }
+        const literals = declaredLiterals(this.values, "url");
+        const output = replaceSecretLiterals(value, this.values, "url", literals);
+        if (literals.some((literal) => output.includes(literal)))
+            return {
+                url: "",
+                origin: null,
+                query_parameter_names: [],
+                redacted: true,
+            };
         const sanitized = sanitizeBrowserUrl(output);
         return {
             ...sanitized,

package/dist/browser/CdpBrowserProvider.js

@@ -7,6 +7,7 @@ import { webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
 import { browserCaptureComparisonSchema, compareBrowserCaptures, } from "../domain/browserCaptureComparison.js";
 import { webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import {} from "../domain/browserObservationErrors.js";
@@ -173,6 +174,10 @@ export class CdpBrowserProvider {
             return ok(webScreenshotDiffSchema.parse(comparePngScreenshots(input)));
         }
         catch (cause) {
+            if (cause instanceof TypeError)
+                return err(new AnalysisInputError("compare_web_screenshots", { cause }, [
+                    { path: [], reason: "invalid_format", message: cause.message },
+                ]));
             return err(providerError(cause, "compare_web_screenshots"));
         }
     }