rea-agents 3.0.0 → 3.2.0

package/dist/browser/PlaywrightScenarioEvents.js

@@ -1,40 +1,16 @@
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { browserScenarioEventSchema, } from "../domain/browserScenarioCapture.js";
-/** Bounded, arrival-ordered Playwright event capture with current-step attribution. */
+/** Arrival-ordered Playwright event capture with current-step attribution. */
 export class PlaywrightScenarioEvents {
     items = [];
-    truncated = new Set();
-    admitted = {
-        frames: new WeakSet(),
-        workers: new WeakSet(),
-        popups: new WeakSet(),
-        websockets: new WeakSet(),
-    };
-    rejected = {
-        frames: new WeakSet(),
-        workers: new WeakSet(),
-        popups: new WeakSet(),
-        websockets: new WeakSet(),
-    };
-    counts = {
-        frames: 0,
-        workers: 0,
-        popups: 0,
-        websockets: 0,
-    };
-    dropped = 0;
     stepIndex = 0;
     sequence = 0;
     enabled;
-    limits;
     secrets;
-    budget;
     allowedOrigins;
     constructor(options) {
         this.enabled = options.enabled;
-        this.limits = options.limits;
         this.secrets = options.secrets;
-        this.budget = options.budget;
         this.allowedOrigins = new Set(options.allowedOrigins);
         this.observePage(options.page);
     }
@@ -50,49 +26,19 @@ export class PlaywrightScenarioEvents {
     result() {
         return {
             retained: this.items.length,
-            dropped: this.dropped,
+            dropped: 0,
             items: this.items,
         };
     }
-    truncationSections() {
-        return [...this.truncated].sort();
-    }
     push(event) {
         this.sequence += 1;
-        if (this.items.length >= this.limits.max_events) {
-            this.dropped += 1;
-            this.truncated.add("events");
-            return;
-        }
         const parsed = browserScenarioEventSchema.parse({
             ...event,
             sequence: this.sequence,
             step_index: this.stepIndex,
         });
-        if (!this.budget.claimMetadata(Buffer.byteLength(JSON.stringify(parsed)))) {
-            this.dropped += 1;
-            this.truncated.add("events");
-            return;
-        }
         this.items.push(parsed);
     }
-    admit(section, value, maximum) {
-        if (this.admitted[section].has(value))
-            return true;
-        if (this.rejected[section].has(value))
-            return false;
-        if (this.counts[section] >= maximum) {
-            this.rejected[section].add(value);
-            this.sequence += 1;
-            this.dropped += 1;
-            this.truncated.add("events");
-            this.truncated.add(section);
-            return false;
-        }
-        this.admitted[section].add(value);
-        this.counts[section] += 1;
-        return true;
-    }
     observePage(page) {
         if (this.enabled.has("console"))
             page.on("console", (message) => {
@@ -104,10 +50,10 @@ export class PlaywrightScenarioEvents {
                 if (this.pageInScope(page))
                     this.push({
                         kind: "page-error",
-                        message: this.secrets.redact(error.message).slice(0, 65_536),
+                        message: this.secrets.redact(error.message),
                         stack: error.stack === undefined
                             ? null
-                            : this.secrets.redact(error.stack).slice(0, 262_144),
+                            : this.secrets.redact(error.stack),
                     });
             });
         if (this.enabled.has("network")) {
@@ -174,47 +120,51 @@ export class PlaywrightScenarioEvents {
         const location = message.location();
         this.push({
             kind: "console",
-            level: this.secrets.redact(message.type()).slice(0, 64),
-            text: this.secrets.redact(message.text()).slice(0, 65_536),
+            level: this.secrets.redact(message.type()),
+            text: this.secrets.redact(message.text()),
             url: location.url === "" ? null : this.safeUrl(location.url),
         });
     }
     request(kind, request) {
+        const observation = {
+            method: this.secrets.redact(request.method()),
+            url: this.safeUrl(request.url()),
+            resource_type: this.secrets.redact(request.resourceType()),
+            header_names: Object.keys(request.headers())
+                .map((name) => this.secrets.redact(name))
+                .sort(),
+        };
+        if (kind === "request-failed") {
+            this.push({
+                ...observation,
+                kind,
+                status: null,
+                failure: this.secrets.redact(request.failure()?.errorText ?? "unknown"),
+            });
+            return;
+        }
         this.push({
+            ...observation,
             kind,
-            method: this.secrets.redact(request.method()).slice(0, 32),
-            url: this.safeUrl(request.url()),
-            resource_type: this.secrets.redact(request.resourceType()).slice(0, 64),
             status: null,
-            header_names: Object.keys(request.headers())
-                .map((name) => this.secrets.redact(name).slice(0, 256))
-                .sort()
-                .slice(0, 256),
-            failure: kind === "request-failed"
-                ? this.secrets
-                    .redact(request.failure()?.errorText ?? "unknown")
-                    .slice(0, 1_024)
-                : null,
+            failure: null,
         });
     }
     response(response) {
         const request = response.request();
         this.push({
             kind: "response",
-            method: this.secrets.redact(request.method()).slice(0, 32),
+            method: this.secrets.redact(request.method()),
             url: this.safeUrl(response.url()),
-            resource_type: this.secrets.redact(request.resourceType()).slice(0, 64),
+            resource_type: this.secrets.redact(request.resourceType()),
             status: response.status(),
             header_names: Object.keys(response.headers())
-                .map((name) => this.secrets.redact(name).slice(0, 256))
-                .sort()
-                .slice(0, 256),
+                .map((name) => this.secrets.redact(name))
+                .sort(),
             failure: null,
         });
     }
     webSocket(page, socket) {
-        if (!this.admit("websockets", socket, this.limits.max_websockets))
-            return;
         const url = this.safeUrl(socket.url());
         this.push({ kind: "websocket-opened", url });
         socket.on("framesent", ({ payload }) => {
@@ -233,30 +183,35 @@ export class PlaywrightScenarioEvents {
     webSocketFrame(kind, url, payload) {
         const bytes = Buffer.byteLength(payload);
         const isText = typeof payload === "string";
-        const text = isText ? this.secrets.redact(payload).slice(0, 65_536) : null;
+        if (!isText) {
+            this.push({
+                kind,
+                url,
+                payload_type: "binary",
+                payload_bytes: bytes,
+                payload_text: null,
+                truncated: false,
+            });
+            return;
+        }
+        const text = this.secrets.redact(payload);
         this.push({
             kind,
             url,
-            payload_type: isText ? "text" : "binary",
+            payload_type: "text",
             payload_bytes: bytes,
             payload_text: text,
-            truncated: isText && text !== null && text.length < payload.length,
+            truncated: false,
         });
     }
     frame(kind, frame) {
-        if (!this.admit("frames", frame, this.limits.max_frames))
-            return;
         this.push({
             kind,
             url: frame.url() === "" ? null : this.safeUrl(frame.url()),
-            name: frame.name() === ""
-                ? null
-                : this.secrets.redact(frame.name()).slice(0, 1_024),
+            name: frame.name() === "" ? null : this.secrets.redact(frame.name()),
         });
     }
     worker(page, worker) {
-        if (!this.admit("workers", worker, this.limits.max_workers))
-            return;
         const details = {
             url: this.safeUrl(worker.url()),
             name: null,
@@ -272,8 +227,6 @@ export class PlaywrightScenarioEvents {
             void page.close().catch(() => undefined);
             return;
         }
-        if (!this.admit("popups", page, this.limits.max_popups))
-            return;
         const opened = {
             url: page.url() === "" ? null : this.safeUrl(page.url()),
             name: null,
@@ -291,9 +244,7 @@ export class PlaywrightScenarioEvents {
     download(download) {
         this.push({
             kind: "download-cancelled",
-            suggested_filename: this.secrets
-                .redact(download.suggestedFilename())
-                .slice(0, 1_024),
+            suggested_filename: this.secrets.redact(download.suggestedFilename()),
             url: this.safeUrl(download.url()),
         });
         void download.cancel().catch(() => undefined);

package/dist/browser/PlaywrightScenarioSession.js

@@ -3,7 +3,7 @@ import { BrowserObservationError } from "../domain/errors.js";
 import { BrowserScenarioSecrets } from "./BrowserScenarioSecrets.js";
 import { closePlaywrightScenarioBrowser, openPlaywrightScenarioBrowser, } from "./PlaywrightScenarioBrowser.js";
 import { performPlaywrightScenarioAction } from "./PlaywrightScenarioActions.js";
-import { BrowserScenarioCaptureBudget, capturePlaywrightStepArtifacts, } from "./PlaywrightScenarioArtifacts.js";
+import { capturePlaywrightStepArtifacts } from "./PlaywrightScenarioArtifacts.js";
 import { PlaywrightScenarioEvents } from "./PlaywrightScenarioEvents.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 const OPERATION = "capture_browser_scenario";
@@ -133,8 +133,8 @@ const blockAttachedServiceWorkers = async (page) => {
     await page.evaluate(blockRegistration);
 };
 const initializePage = async (context, page, scenario, secrets) => {
-    context.setDefaultTimeout(scenario.limits.action_timeout_ms);
-    context.setDefaultNavigationTimeout(scenario.limits.navigation_timeout_ms);
+    context.setDefaultTimeout(0);
+    context.setDefaultNavigationTimeout(0);
     const ownedPages = new Set([page]);
     if (scenario.browser.mode === "connect")
         await blockAttachedServiceWorkers(page);
@@ -190,43 +190,40 @@ export class PlaywrightScenarioSession {
         this.initialUrl = opened.page.url();
     }
     static async open(scenario, environment, options) {
-        const remaining = () => options.deadlineAt - Date.now();
         if (options.signal?.aborted === true)
             throw new BrowserObservationError(OPERATION, "cancelled");
         const secrets = BrowserScenarioSecrets.resolve(scenario, environment);
         if (secrets === undefined)
             throw new BrowserObservationError(OPERATION, "secret_unavailable");
-        const opening = openPlaywrightScenarioBrowser(scenario, environment, remaining());
+        const opening = openPlaywrightScenarioBrowser(scenario, environment);
         let opened;
         try {
-            opened = await withPlaywrightExecutionBoundary(() => opening, remaining(), options.signal);
+            opened = await withPlaywrightExecutionBoundary(() => opening, undefined, options.signal);
         }
-        catch (error) {
+        catch (cause) {
             void opening
                 .then((lateOpened) => closePlaywrightScenarioBrowser(lateOpened))
                 .catch(() => undefined);
-            throw error;
+            throw cause;
         }
         try {
-            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), remaining(), options.signal);
+            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
             const events = new PlaywrightScenarioEvents({
                 page: opened.page,
                 enabled: new Set(scenario.capture.events),
-                limits: scenario.limits,
                 secrets,
-                budget: options.budget,
                 allowedOrigins: scenario.allowed_origins,
             });
             const session = new PlaywrightScenarioSession(opened, scenario, secrets, events);
             await withPlaywrightExecutionBoundary(() => opened.page.goto(secrets.url(scenario.start_url), {
                 waitUntil: "load",
-                timeout: Math.min(scenario.limits.navigation_timeout_ms, remaining()),
-            }), remaining(), options.signal);
+                timeout: 0,
+            }), undefined, options.signal);
             return session;
         }
-        catch (error) {
+        catch (cause) {
             await closePlaywrightScenarioBrowser(opened);
-            throw error;
+            throw cause;
         }
     }
     currentUrl() {
@@ -244,27 +241,21 @@ export class PlaywrightScenarioSession {
     events() {
         return this.eventCapture.result();
     }
-    eventTruncationSections() {
-        return this.eventCapture.truncationSections();
-    }
-    async perform(action, maximumTimeoutMs, signal) {
+    async perform(action, signal) {
         await withPlaywrightExecutionBoundary(() => performPlaywrightScenarioAction({
             page: this.opened.page,
             action,
             secrets: this.secrets,
-            defaultTimeoutMs: this.scenario.limits.action_timeout_ms,
-            maximumTimeoutMs,
-        }), maximumTimeoutMs, signal);
+        }), "timeout_ms" in action ? action.timeout_ms : undefined, signal);
     }
-    async capture(requested, budget, maximumTimeoutMs, signal) {
+    async capture(requested, signal) {
         return withPlaywrightExecutionBoundary(() => capturePlaywrightStepArtifacts({
             context: this.opened.context,
             page: this.opened.page,
             scenario: this.scenario,
             secrets: this.secrets,
             requested,
-            budget,
-        }), maximumTimeoutMs, signal);
+        }), undefined, signal);
     }
     async close() {
         if (this.closed)
@@ -278,9 +269,7 @@ export class PlaywrightScenarioSession {
             : "disconnected-external";
     }
     redactError(error) {
-        return this.secrets
-            .redact(error instanceof Error ? error.message : "browser action failed")
-            .slice(0, 4_096);
+        return this.secrets.redact(error instanceof Error ? error.message : "browser action failed");
     }
 }
 /** Production Playwright/CDP session factory. */
@@ -290,11 +279,6 @@ export class PlaywrightScenarioSessionFactory {
         this.environment = environment;
     }
     open(scenario, options = {}) {
-        return PlaywrightScenarioSession.open(scenario, this.environment, {
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            budget: options.budget ??
-                new BrowserScenarioCaptureBudget(scenario.limits.max_screenshots, scenario.limits.max_total_metadata_bytes),
-            deadlineAt: options.deadlineAt ?? Date.now() + scenario.limits.max_duration_ms,
-        });
+        return PlaywrightScenarioSession.open(scenario, this.environment, options);
     }
 }

package/dist/browser/PngVisualDiff.js

@@ -1,12 +1,11 @@
 import { inflateSync } from "node:zlib";
 import { decodeCanonicalBase64 } from "../domain/webScreenshot.js";
-/** Compare two validated screenshots using bounded, deterministic RGBA metrics. */
+/** Compare two validated screenshots using deterministic RGBA metrics. */
 export const comparePngScreenshots = (input) => {
-    const before = decodePng(input.before, input.maximum_pixels);
-    const after = decodePng(input.after, input.maximum_pixels);
+    const before = decodePng(input.before);
+    const after = decodePng(input.after);
     if (before.width !== after.width || before.height !== after.height)
         return {
-            schema_version: 1,
             status: "dimension_mismatch",
             before: dimensions(before),
             after: dimensions(after),
@@ -35,21 +34,30 @@ export const comparePngScreenshots = (input) => {
             changedPixels += 1;
     }
     const pixels = before.width * before.height;
-    return {
-        schema_version: 1,
-        status: changedPixels === 0 ? "identical" : "different",
+    const context = {
         before: dimensions(before),
         after: dimensions(after),
         channel_threshold: input.channel_threshold,
         compared_pixels: pixels,
-        changed_pixels: changedPixels,
-        changed_ratio: changedPixels / pixels,
         maximum_channel_delta: maximumDelta,
         mean_absolute_channel_delta: totalDelta / (pixels * 4),
         limitations: limitations(),
     };
+    if (changedPixels === 0)
+        return {
+            ...context,
+            status: "identical",
+            changed_pixels: 0,
+            changed_ratio: 0,
+        };
+    return {
+        ...context,
+        status: "different",
+        changed_pixels: changedPixels,
+        changed_ratio: changedPixels / pixels,
+    };
 };
-const decodePng = (artifact, maximumPixels) => {
+const decodePng = (artifact) => {
     const bytes = decodeCanonicalBase64(artifact.data_base64);
     if (bytes === undefined || !bytes.subarray(0, 8).equals(PNG_SIGNATURE))
         throw new TypeError("Invalid PNG signature");
@@ -68,7 +76,7 @@ const decodePng = (artifact, maximumPixels) => {
             throw new TypeError("Truncated PNG data");
         const data = bytes.subarray(dataStart, dataEnd);
         if (type === "IHDR")
-            header = parseHeader(data, maximumPixels);
+            header = parseHeader(data);
         else if (type === "IDAT")
             compressed.push(data);
         else if (type === "IEND") {
@@ -92,7 +100,7 @@ const decodePng = (artifact, maximumPixels) => {
         rgba: unfilter(raw, header.width, header.height, header.channels),
     };
 };
-const parseHeader = (data, maximumPixels) => {
+const parseHeader = (data) => {
     if (data.byteLength !== 13)
         throw new TypeError("Invalid PNG header");
     const width = data.readUInt32BE(0);
@@ -101,13 +109,13 @@ const parseHeader = (data, maximumPixels) => {
     const colorType = data[9];
     if (width === 0 ||
         height === 0 ||
-        width * height > maximumPixels ||
+        !Number.isSafeInteger(width * height) ||
         bitDepth !== 8 ||
         (colorType !== 2 && colorType !== 6) ||
         data[10] !== 0 ||
         data[11] !== 0 ||
         data[12] !== 0)
-        throw new TypeError("Unsupported or oversized PNG");
+        throw new TypeError("Unsupported PNG");
     return { width, height, channels: colorType === 6 ? 4 : 3 };
 };
 const unfilter = (raw, width, height, channels) => {

package/dist/browser/SensitiveTextCapture.js

@@ -1,4 +1,4 @@
-const SECRET_ASSIGNMENT = /\b(authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret|cookie|session)\b\s*[:=]\s*(?:Bearer\s+[A-Za-z0-9._~+/=-]+|"[^"]*"|'[^']*'|[^\s,;]+)/giu;
+const SECRET_ASSIGNMENT = /\b(authorization|api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|cookie|session)\b\s*[:=]\s*(?:Bearer\s+[A-Za-z0-9._~+/=-]+|"[^"]*"|'[^']*'|[^\s,;]+)/giu;
 const BEARER = /\bBearer\s+[A-Za-z0-9._~+/=-]+/giu;
 const JWT = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/gu;
 /** Redact credential-shaped substrings before approved console text is retained. */
@@ -6,20 +6,3 @@ export const redactSensitiveText = (value) => value
     .replace(SECRET_ASSIGNMENT, (_match, name) => `${name}=[REDACTED]`)
     .replace(BEARER, "Bearer [REDACTED]")
     .replace(JWT, "[REDACTED_JWT]");
-/** Return a UTF-8-bounded prefix without splitting a code point. */
-export const boundedSensitiveText = (value, maximumBytes) => {
-    const redacted = redactSensitiveText(value);
-    const total = Buffer.byteLength(redacted);
-    if (total <= maximumBytes)
-        return { text: redacted, bytes: total, truncated: false };
-    let text = "";
-    let bytes = 0;
-    for (const character of redacted) {
-        const size = Buffer.byteLength(character);
-        if (bytes + size > maximumBytes)
-            break;
-        text += character;
-        bytes += size;
-    }
-    return { text, bytes, truncated: true };
-};

package/dist/browser/V8InspectorCaptureProjection.js

@@ -2,8 +2,6 @@ import { createHash } from "node:crypto";
 import { authorizeRuntimeLocation } from "./JavaScriptRuntimeScope.js";
 /** Empty durable-location exclusion counters. */
 export const createInspectorExclusionCounts = () => ({
-    outside_file_roots: 0,
-    outside_origins: 0,
     unsupported_location: 0,
 });
 /** Stable safety and protocol limitations shared by target-list Evidence. */
@@ -11,14 +9,15 @@ export const describeInspectorTargetLimitations = () => [
     "REA attaches to an already-running exact target and never launches, resumes, evaluates, pauses, or mutates it.",
     "Only Runtime.enable and Debugger.enable are sent; source text, object values, EventEmitter activity, and Electron IPC are not inspected.",
     "Target IDs and locations are authorized, but the Inspector protocol does not authenticate an operating-system process ID or Electron role.",
+    "Every target exposed by the selected Inspector endpoint is eligible for observation; target IDs and locations are not authenticated as operating-system process identity.",
     "No runtime graph depth is traversed because passive Inspector events do not establish require/import caller edges.",
 ];
 /** Canonically authorize, deduplicate, and sort one bounded raw capture. */
-export const finalizeInspectorCapture = async ({ input, runtime, target, roots, state, }) => {
+export const finalizeInspectorCapture = async ({ input, runtime, target, state, }) => {
     const exclusions = createInspectorExclusionCounts();
     const scripts = new Map();
     for (const draft of state.scripts) {
-        const decision = await authorizeRuntimeLocation(draft.rawUrl, roots, input.allowed_origins);
+        const decision = await authorizeRuntimeLocation(draft.rawUrl);
         if (!decision.allowed) {
             exclusions[decision.reason] += 1;
             continue;
@@ -44,15 +43,16 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, roots,
             ? 1
             : 0);
     return {
-        schema_version: 1,
         runtime,
         target: {
             target_id: target.id,
             protocol_type: target.type,
             attached: target.attached,
             location: target.location,
-            runtime_kind: input.runtime_kind,
-            runtime_kind_authority: "caller-declared-unverified",
+            runtime_kind: input.runtime_kind ?? "unknown",
+            runtime_kind_authority: input.runtime_kind === undefined
+                ? "not-declared"
+                : "caller-declared-unverified",
         },
         capture: {
             observation_ms: input.observation_ms,

package/dist/browser/V8InspectorEndpoint.js

@@ -1,30 +1,28 @@
 import { z } from "zod";
 import { BrowserObservationError, } from "../domain/errors.js";
-import { parseCdpEndpointValue, readBoundedCdpJson } from "./CdpEndpoint.js";
-const MAX_VERSION_BYTES = 64 * 1_024;
-const MAX_TARGET_LIST_BYTES = 2 * 1_024 * 1_024;
+import { parseCdpEndpointValue, readCdpJson } from "./CdpEndpoint.js";
 const versionSchema = z
     .object({
-    Browser: z.string().min(1).max(1_024),
-    "Protocol-Version": z.string().min(1).max(100),
-    "V8-Version": z.string().max(1_024).optional(),
+    Browser: z.string().min(1),
+    "Protocol-Version": z.string().min(1),
+    "V8-Version": z.string().optional(),
 })
     .passthrough();
 const targetSchema = z
     .object({
-    id: z.string().min(1).max(256),
-    type: z.string().min(1).max(100),
-    url: z.string().max(65_536),
+    id: z.string().min(1),
+    type: z.string().min(1),
+    url: z.string(),
     attached: z.boolean().default(false),
-    webSocketDebuggerUrl: z.string().min(1).max(2_048),
+    webSocketDebuggerUrl: z.string().min(1),
 })
     .passthrough();
-const targetsSchema = z.array(targetSchema).max(1_000);
-/** Discover bounded Node/Electron Inspector targets from one loopback endpoint. */
+const targetsSchema = z.array(targetSchema);
+/** Discover Node/Electron Inspector targets from one loopback endpoint. */
 export const discoverV8Inspector = async (endpoint, operation, signal) => {
     const [versionInput, targetsInput] = await Promise.all([
-        readBoundedCdpJson(new URL("/json/version", endpoint), MAX_VERSION_BYTES, operation, signal),
-        readBoundedCdpJson(new URL("/json/list", endpoint), MAX_TARGET_LIST_BYTES, operation, signal),
+        readCdpJson(new URL("/json/version", endpoint), operation, signal),
+        readCdpJson(new URL("/json/list", endpoint), operation, signal),
     ]);
     const version = parseCdpEndpointValue(versionSchema, versionInput, operation);
     const targets = parseCdpEndpointValue(targetsSchema, targetsInput, operation);