rea-agents 6.0.0 → 6.2.0

package/dist/browser/CdpCaptureEventHandlers.js

@@ -1,8 +1,9 @@
 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";
 export const handleExecutionContextCreated = (state, params) => {
     const context = recordValue(params.context);
     const identifier = numberValue(context?.id);
@@ -27,30 +28,67 @@ export const handleScriptParsed = (state, params) => {
         state.completeness.exclude("scripts", "invalid_protocol_value");
         return;
     }
+    const replacedBytes = state.scriptMetadataBytesById.get(scriptId) ?? 0;
+    state.scriptMetadataBudgetOmissionsById.delete(scriptId);
+    if (replacedBytes > 0) {
+        state.scripts.delete(scriptId);
+        state.scriptMetadataBytesById.delete(scriptId);
+        state.retainedScriptMetadataBytes -= replacedBytes;
+    }
     if (sanitized === undefined) {
         state.completeness.exclude("scripts", exclusionReasonForUrl(rawUrl));
         return;
     }
-    const sourceMap = sourceMapForScript(params.sourceMapURL, rawUrl, state);
-    const script = {
+    const baseScript = {
         scriptId,
         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,
-        sourceMapUrl: sourceMap.sanitized,
-        sourceMapRawUrl: sourceMap.raw,
         executionContextKey: executionContextKey(params.executionContextId),
     };
+    const baseBytes = scriptMetadataStringBytes(baseScript);
+    const sourceMapDeclared = typeof params.sourceMapURL === "string" && params.sourceMapURL.length > 0;
+    if (state.scripts.size >= CDP_CAPTURE_SCRIPT_METADATA_LIMITS.scripts ||
+        baseBytes >
+            CDP_CAPTURE_SCRIPT_METADATA_LIMITS.retainedBytes -
+                state.retainedScriptMetadataBytes) {
+        state.rejectedScriptMetadataBudgetCount += 1;
+        if (sourceMapDeclared)
+            state.rejectedSourceMapMetadataBudgetCount += 1;
+        return;
+    }
+    const sourceMap = sourceMapForScript(params.sourceMapURL, rawUrl, state, CDP_CAPTURE_SCRIPT_METADATA_LIMITS.retainedBytes -
+        state.retainedScriptMetadataBytes -
+        baseBytes);
+    const { budgetExhausted, ...sourceMapFields } = sourceMap;
+    const script = { ...baseScript, ...sourceMapFields };
+    if (budgetExhausted)
+        state.scriptMetadataBudgetOmissionsById.set(scriptId, true);
+    const retainedBytes = baseBytes +
+        stringByteLength(sourceMap.sourceMapUrl) +
+        stringByteLength(sourceMap.sourceMapRawUrl);
+    state.retainedScriptMetadataBytes += retainedBytes;
+    state.scriptMetadataBytesById.set(scriptId, retainedBytes);
     state.scripts.set(scriptId, script);
 };
-const sourceMapForScript = (value, scriptUrl, state) => {
+const scriptMetadataStringBytes = (script) => stringByteLength(script.scriptId) +
+    stringByteLength(script.rawUrl) +
+    stringByteLength(script.url) +
+    stringByteLength(script.origin) +
+    stringByteLength(script.hash) +
+    stringByteLength(script.language) +
+    stringByteLength(script.executionContextKey);
+const stringByteLength = (value) => value === null ? 0 : Buffer.byteLength(value, "utf8");
+const sourceMapForScript = (value, scriptUrl, state, remainingBytes) => {
     const declaredUrl = cdpStringValue(value);
     if (declaredUrl === undefined || declaredUrl === "")
-        return { sanitized: null, raw: null };
+        return {
+            sourceMapUrl: null,
+            sourceMapRawUrl: null,
+            budgetExhausted: false,
+        };
     let rawUrl;
     try {
         rawUrl = new URL(declaredUrl, scriptUrl).href;
@@ -59,13 +97,34 @@ const sourceMapForScript = (value, scriptUrl, state) => {
         // Unparseable URLs are recorded as unsupported, not as failures.
         void cause;
         state.completeness.exclude("source_maps", "unsupported_url");
-        return { sanitized: null, raw: null };
+        return {
+            sourceMapUrl: null,
+            sourceMapRawUrl: null,
+            budgetExhausted: false,
+        };
     }
     const sanitized = allowedSanitizedUrl(rawUrl, state.allowedOrigins);
-    if (sanitized !== undefined)
-        return { sanitized: sanitized.url, raw: rawUrl };
+    if (sanitized !== undefined) {
+        if (stringByteLength(rawUrl) + stringByteLength(sanitized.url) >
+            remainingBytes) {
+            return {
+                sourceMapUrl: null,
+                sourceMapRawUrl: null,
+                budgetExhausted: true,
+            };
+        }
+        return {
+            sourceMapUrl: sanitized.url,
+            sourceMapRawUrl: rawUrl,
+            budgetExhausted: false,
+        };
+    }
     state.completeness.exclude("source_maps", exclusionReasonForUrl(rawUrl));
-    return { sanitized: null, raw: null };
+    return {
+        sourceMapUrl: null,
+        sourceMapRawUrl: null,
+        budgetExhausted: false,
+    };
 };
 export const handleRequestWillBeSent = (state, params) => {
     const requestId = cdpStringValue(params.requestId);
@@ -76,6 +135,11 @@ export const handleRequestWillBeSent = (state, params) => {
     }
     if (state.malformedRedirectRequestIds.has(requestId))
         return;
+    const previous = state.network.get(requestId);
+    if (!Object.hasOwn(params, "redirectResponse") &&
+        previous !== undefined &&
+        preserveMalformedRedirectEvidence(state, requestId, previous))
+        return;
     if (request === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         state.network.delete(requestId);
@@ -89,7 +153,6 @@ export const handleRequestWillBeSent = (state, params) => {
         state.networkRequestTimestamps.delete(requestId);
         return;
     }
-    const previous = state.network.get(requestId);
     const redirectResponse = recordValue(params.redirectResponse);
     if (Object.hasOwn(params, "redirectResponse") &&
         redirectResponse === undefined &&

package/dist/browser/CdpCaptureEventTypes.js

@@ -1 +1,5 @@
-export {};
+/** Bounds retained CDP script identities independently from source text capture. */
+export const CDP_CAPTURE_SCRIPT_METADATA_LIMITS = {
+    retainedBytes: 8 * 1024 * 1024,
+    scripts: 50_000,
+};

package/dist/browser/CdpCaptureEvents.js

@@ -3,10 +3,15 @@ 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;
     scripts = new Map();
+    scriptMetadataBudgetOmissionsById = new Map();
+    rejectedScriptMetadataBudgetCount = 0;
+    rejectedSourceMapMetadataBudgetCount = 0;
+    scriptMetadataBytesById = new Map();
+    retainedScriptMetadataBytes = 0;
     executionContextFrames = new Map();
     network = new Map();
     networkRequestTimestamps = new Map();
@@ -39,6 +44,12 @@ export class CdpCaptureEvents {
         this.navigationDuringCapture = false;
         this.committedDocument = undefined;
         this.scripts.clear();
+        this.scriptMetadataBudgetOmissionsById.clear();
+        this.rejectedScriptMetadataBudgetCount = 0;
+        this.rejectedSourceMapMetadataBudgetCount = 0;
+        this.scriptMetadataBytesById.clear();
+        this.retainedScriptMetadataBytes = 0;
+        this.#scriptMetadataBudgetExclusionsRecorded = false;
         this.executionContextFrames.clear();
         this.network.clear();
         this.networkRequestTimestamps.clear();
@@ -67,6 +78,19 @@ export class CdpCaptureEvents {
         // compared against itself rather than the document we just left.
         this.committedDocument = undefined;
     }
+    /** Record final script metadata omissions after all scriptParsed replacements. */
+    recordScriptMetadataBudgetExclusions() {
+        if (this.#scriptMetadataBudgetExclusionsRecorded)
+            return;
+        this.#scriptMetadataBudgetExclusionsRecorded = true;
+        const omittedScripts = this.rejectedScriptMetadataBudgetCount;
+        const omittedSourceMaps = this.rejectedSourceMapMetadataBudgetCount +
+            this.scriptMetadataBudgetOmissionsById.size;
+        if (omittedScripts > 0)
+            this.completeness.exclude("scripts", "resource_budget_exhausted", omittedScripts);
+        if (omittedSourceMaps > 0)
+            this.completeness.exclude("source_maps", "resource_budget_exhausted", omittedSourceMaps);
+    }
     ingest(event) {
         const params = recordValue(event.params);
         if (params === undefined)

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/CdpConnection.js

@@ -48,7 +48,7 @@ export class CdpConnection {
     /** Subscribe to an unexpected transport loss while an operation is active. */
     onDisconnect(listener) {
         if (this.#closed) {
-            listener();
+            listener(this.#transportError(this.#transportFailure));
             return () => undefined;
         }
         this.#disconnectListeners.add(listener);
@@ -85,6 +85,7 @@ export class CdpConnection {
             signal?.addEventListener("abort", onAbort, { once: true });
             this.#pending.set(id, {
                 method,
+                ...(sessionId === undefined ? {} : { sessionId }),
                 resolve,
                 reject,
                 removeAbort: () => signal?.removeEventListener("abort", onAbort),
@@ -171,17 +172,34 @@ export class CdpConnection {
         const pending = this.#pending.get(id);
         if (pending === undefined)
             return;
-        this.#complete(id, pending);
-        if ("error" in message) {
-            const reported = message.error;
-            pending.reject(new CdpCommandRejection(this.operation, pending.method, isRecord(reported) && typeof reported.code === "number"
-                ? reported.code
-                : null, isRecord(reported) && typeof reported.message === "string"
-                ? reported.message
-                : null));
+        const hasResult = "result" in message;
+        const hasError = "error" in message;
+        if (("sessionId" in message &&
+            (typeof message.sessionId !== "string" ||
+                message.sessionId !== pending.sessionId)) ||
+            hasResult === hasError) {
+            this.#failPending("protocol_error");
             return;
         }
-        pending.resolve("result" in message ? message.result : {});
+        if (hasResult) {
+            if (!isRecord(message.result)) {
+                this.#failPending("protocol_error");
+                return;
+            }
+            this.#complete(id, pending);
+            pending.resolve(message.result);
+            return;
+        }
+        const reported = message.error;
+        if (!isRecord(reported) ||
+            typeof reported.code !== "number" ||
+            !Number.isSafeInteger(reported.code) ||
+            typeof reported.message !== "string") {
+            this.#failPending("protocol_error");
+            return;
+        }
+        this.#complete(id, pending);
+        pending.reject(new CdpCommandRejection(this.operation, pending.method, reported.code, reported.message));
     }
     #complete(id, pending) {
         pending.removeAbort();
@@ -211,8 +229,9 @@ export class CdpConnection {
         this.#failPending(reason);
         if (wasClosed)
             return;
+        const error = this.#transportError(reason);
         for (const listener of this.#disconnectListeners)
-            listener();
+            listener(error);
         this.#disconnectListeners.clear();
     }
     #transportError(reason) {

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,

package/dist/browser/CdpOptionalCommand.js

@@ -1,4 +1,4 @@
-import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { CdpCommandRejection } from "./CdpCommandRejection.js";
 import { CdpConnection } from "./CdpConnection.js";
 /** Execute an optional CDP method while preserving transport and cancellation failures. */
 export const optionalCdpCommand = async (context, method, parameters, limitations) => {
@@ -6,8 +6,7 @@ export const optionalCdpCommand = async (context, method, parameters, limitation
         return await context.connection.send(method, parameters, context.sessionId, context.signal);
     }
     catch (cause) {
-        if (!(cause instanceof BrowserObservationError) ||
-            cause.reason !== "protocol_error")
+        if (!(cause instanceof CdpCommandRejection) || cause.code !== -32_601)
             throw cause;
         limitations.push(`${method} was unavailable from this browser target.`);
         return undefined;

package/dist/browser/CdpPageCapture.js

@@ -6,6 +6,7 @@ import { CdpCaptureEvents } from "./CdpCaptureEvents.js";
 import { authorizedMainFrame } from "./CdpAuthorizedMainFrame.js";
 import { captureStorage } from "./CdpCaptureStorage.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
+import { CdpCommandRejection } from "./CdpCommandRejection.js";
 import { captureAccessibility, captureDom, captureFrames, captureResources, mainFrameUrl, } from "./CdpCaptureDocuments.js";
 import { allowedSanitizedUrl, delayWithCancellation, } from "./CdpCaptureValues.js";
 import { captureScripts } from "./CdpPageCaptureScripts.js";
@@ -85,6 +86,7 @@ const captureAuthorizedPage = async (state) => {
     if (state.events.navigationDuringCapture || completedUrl !== attachedUrl)
         throw new BrowserObservationError("inspect_web_page", "target_changed");
     await report(context.progress, 3, "Normalizing browser evidence");
+    state.events.recordScriptMetadataBudgetExclusions();
     return {
         inspection: normalizedInspection(state, {
             attachedUrl,
@@ -105,7 +107,27 @@ const captureJsonResponseBodies = async (state) => {
         const requestId = requestIds[index];
         if (requestId === undefined)
             continue;
-        const result = await optionalCdpCommand(state.context, "Network.getResponseBody", { requestId }, state.limitations);
+        const request = state.events.network.get(requestId);
+        if (request === undefined)
+            continue;
+        if (request.encoded_data_length === null) {
+            state.events.responseBodyUnavailable(requestId);
+            continue;
+        }
+        let result;
+        try {
+            result = await optionalCdpCommand(state.context, "Network.getResponseBody", { requestId }, state.limitations);
+        }
+        catch (cause) {
+            if (!(cause instanceof CdpCommandRejection) ||
+                cause.command !== "Network.getResponseBody" ||
+                cause.code !== -32_000 ||
+                cause.reportedMessage === null)
+                throw cause;
+            state.events.responseBodyUnavailable(requestId);
+            state.limitations.push(`Response body unavailable for request ${requestId}: ${cause.userMessage}`);
+            continue;
+        }
         if (result !== undefined) {
             state.events.ingestResponseBody(requestId, result);
             continue;

package/dist/browser/CdpPageCaptureScripts.js

@@ -1,5 +1,5 @@
 import { reconcileCapturedWebScript, stableWebScriptKey, } from "../domain/webInventory.js";
-import { requiredRecord, sourceExcluded, sourceResult, cdpStringValue, } from "./CdpCaptureValues.js";
+import { requiredScriptSource, sourceExcluded, sourceResult, } from "./CdpCaptureValues.js";
 export const captureScripts = async (options) => {
     const { context, events, rawResources, resources, frameIds } = options;
     const state = {
@@ -42,8 +42,7 @@ const buildScriptDraft = async (script, state) => {
 };
 const captureScriptSource = async (script, state) => {
     const { context } = state;
-    const result = requiredRecord(await context.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, context.sessionId, context.signal));
-    const content = cdpStringValue(result.scriptSource) ?? "";
+    const content = requiredScriptSource(await context.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, context.sessionId, context.signal), context.operation);
     return sourceResult(content);
 };
 const keyAndBuildInventory = (drafts, scriptCount) => {

package/dist/browser/CdpSafeMetadata.js

@@ -56,7 +56,7 @@ const parseCsp = (value, baseUrl, allowedOrigins) => {
     for (const rawDirective of (value ?? "").split(";")) {
         const [rawName, ...tokens] = rawDirective.trim().split(/\s+/u);
         const name = (rawName ?? "").toLowerCase();
-        if (!/^[a-z][a-z0-9-]*$/u.test(name))
+        if (!/^[a-z][a-z0-9\x2d]*$/u.test(name))
             continue;
         const sources = [];
         for (const token of tokens) {
@@ -79,9 +79,9 @@ const parseCsp = (value, baseUrl, allowedOrigins) => {
 };
 const cspSource = (token, baseUrl, allowedOrigins) => {
     const lower = token.toLowerCase();
-    if (/^'[a-z0-9-]+'$/u.test(lower))
+    if (/^'[a-z0-9\x2d]+'$/u.test(lower))
         return { kind: "keyword", value: lower };
-    if (/^[a-z][a-z0-9+.-]*:$/u.test(lower))
+    if (/^[a-z][a-z0-9+.\x2d]*:$/u.test(lower))
         return { kind: "scheme", value: lower };
     const hostOrigin = cspHostSourceOrigin(token, baseUrl);
     if (hostOrigin === undefined)
@@ -98,14 +98,14 @@ const cspSource = (token, baseUrl, allowedOrigins) => {
  * `undefined` when the token is not a host-source at all.
  */
 const cspHostSourceOrigin = (token, baseUrl) => {
-    const match = /^(?:([a-z][a-z0-9+.-]*):\/\/)?([^/?#]+)(?:\/[^?#]*)?$/iu.exec(token);
+    const match = /^(?:([a-z][a-z0-9+.\x2d]*):\/\/)?([^\x2f?#]+)(?:\/[^?#]*)?$/iu.exec(token);
     const authority = match?.[2];
     if (authority === undefined || authority.length === 0)
         return undefined;
     const scheme = (match?.[1] ?? schemeOf(baseUrl))?.toLowerCase();
-    if (scheme === undefined || !/^[a-z][a-z0-9+.-]*$/u.test(scheme))
+    if (scheme === undefined || !/^[a-z][a-z0-9+.\x2d]*$/u.test(scheme))
         return undefined;
-    if (!/^(?:\*|(?:\*\.)?[a-z0-9-]+(?:\.[a-z0-9-]+)*\.?)(?::(?:\*|\d+))?$/iu.test(authority))
+    if (!/^(?:\*|(?:\*\.)?[a-z0-9\x2d]+(?:\.[a-z0-9\x2d]+)*\.?)(?::(?:\*|\d+))?$/iu.test(authority))
         return undefined;
     if (authority.includes("*"))
         return null;
@@ -194,7 +194,7 @@ const linkParameters = (value) => {
         const name = (separator < 0 ? raw : raw.slice(0, separator))
             .trim()
             .toLowerCase();
-        if (!/^[a-z][a-z0-9-]*$/u.test(name))
+        if (!/^[a-z][a-z0-9\x2d]*$/u.test(name))
             continue;
         const parameter = separator < 0 ? "" : raw.slice(separator + 1).trim();
         parameters.set(name, unquote(parameter));
@@ -221,7 +221,7 @@ const permissionFeatures = (value) => [
     ...new Set((value ?? "")
         .split(",")
         .map((entry) => entry.split("=", 1)[0]?.trim().toLowerCase() ?? "")
-        .filter((feature) => /^[a-z][a-z0-9-]*$/u.test(feature))),
+        .filter((feature) => /^[a-z][a-z0-9\x2d]*$/u.test(feature))),
 ].sort();
 const wellKnownHint = (url) => {
     try {
@@ -259,7 +259,7 @@ const referrerPolicy = (value) => {
         const token = raw.trim().toLowerCase();
         if (token === "")
             continue;
-        if (!/^[a-z-]+$/u.test(token))
+        if (!/^[a-z\x2d]+$/u.test(token))
             return null;
         if (referrerPolicies.has(token))
             policy = token;
@@ -268,7 +268,7 @@ const referrerPolicy = (value) => {
 };
 const policyToken = (value) => {
     const token = (value ?? "").trim().toLowerCase();
-    return /^[a-z][a-z0-9_.-]*$/u.test(token) ? token : null;
+    return /^[a-z][a-z0-9_.\x2d]*$/u.test(token) ? token : null;
 };
 const nonnegativeInteger = (value) => {
     const number = numberValue(value === undefined ? undefined : Number(value));

package/dist/browser/PlaywrightBrowserScenarioProvider.js

@@ -1,17 +1,11 @@
-import { browserScenarioCaptureSchema, classifyBrowserScenarioCompleteness, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
+import { browserScenarioCaptureSchema, } from "../domain/browserScenarioCapture.js";
+import { classifyBrowserScenarioCompleteness, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCaptureValues.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
+import { browserScenarioCleanupObservation, browserScenarioOperationFailure, browserScenarioCaptureData, } from "./BrowserScenarioPartialObservation.js";
 const OPERATION = "capture_browser_scenario";
-let defaultFactory;
-const lazyPlaywrightFactory = {
-    async open(scenario, options) {
-        defaultFactory ??= import("./PlaywrightScenarioSession.js").then(({ PlaywrightScenarioSessionFactory }) => new PlaywrightScenarioSessionFactory());
-        return (await defaultFactory).open(scenario, options);
-    },
-};
-export { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const SNAPSHOT_KINDS = [
     "screenshot",
@@ -147,7 +141,7 @@ const runScenario = async (factory, scenario, options) => {
     const startedAt = Date.now();
     const session = await factory.open(scenario, options.signal === undefined ? {} : { signal: options.signal });
     const steps = [];
-    let cleanup;
+    let operationOutcome = { ok: true };
     try {
         steps.push(await initialStep({
             session,
@@ -169,49 +163,70 @@ const runScenario = async (factory, scenario, options) => {
             failed ||= step.status !== "completed";
         }
     }
-    finally {
-        cleanup = await session.close();
+    catch (cause) {
+        operationOutcome = { ok: false, cause };
+    }
+    let cleanupOutcome;
+    try {
+        cleanupOutcome = { ok: true, cleanup: await session.close() };
+    }
+    catch (cause) {
+        cleanupOutcome = { ok: false, cause };
     }
-    const events = session.events();
+    if (!cleanupOutcome.ok) {
+        const cleanup = browserScenarioCleanupObservation(cleanupOutcome.cause);
+        const partialObservation = {
+            kind: "browser-scenario-observation",
+            capture: browserScenarioCaptureData({
+                session,
+                scenario,
+                startedAt,
+                steps,
+                cleanup: "incomplete",
+                limitations: [
+                    "Scenario observations are partial because browser cleanup could not be confirmed.",
+                ],
+            }),
+        };
+        if (!operationOutcome.ok)
+            throw browserScenarioOperationFailure(operationOutcome.cause, partialObservation, { cause: cleanupOutcome.cause });
+        throw new BrowserObservationError(OPERATION, "cleanup_failed", {
+            cause: cleanupOutcome.cause,
+            cleanup,
+            partialObservation,
+            detail: `Browser scenario cleanup could not be confirmed: ${cleanup.reason}. Collected steps and events are retained in partial_observation. Review the reported resources before retrying.`,
+        });
+    }
+    if (!operationOutcome.ok)
+        throw browserScenarioOperationFailure(operationOutcome.cause, {
+            kind: "browser-scenario-observation",
+            capture: browserScenarioCaptureData({
+                session,
+                scenario,
+                startedAt,
+                steps,
+                cleanup: cleanupOutcome.cleanup,
+                limitations: [
+                    "Scenario capture ended after an operation failed; uncollected steps are not represented.",
+                ],
+            }),
+        });
     const completeness = globalCompleteness(scenario, session, steps);
     return browserScenarioCaptureSchema.parse({
-        browser: {
-            mode: session.mode,
-            process_ownership: session.processOwnership,
-            cleanup,
-            product: session.product,
-            version: session.version,
-        },
-        scenario: {
-            start_origin: new URL(scenario.start_url.url).origin,
-            action_count: scenario.actions.length,
-            secret_references: scenario.secrets.map(({ secret_id: id }) => id).sort(),
-            network_content: scenario.capture.network,
-        },
-        duration_ms: Date.now() - startedAt,
-        steps,
-        events,
+        ...browserScenarioCaptureData({
+            session,
+            scenario,
+            startedAt,
+            steps,
+            cleanup: cleanupOutcome.cleanup,
+        }),
         completeness,
-        limitations: [
-            "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.",
-                ]
-                : []),
-        ],
     });
 };
 /** Controlled Playwright/CDP scenario driver with exact process ownership. */
 export class PlaywrightBrowserScenarioProvider {
     factory;
-    constructor(factory = lazyPlaywrightFactory) {
+    constructor(factory) {
         this.factory = factory;
     }
     identity() {