rea-agents 6.1.0 → 6.3.0

package/dist/browser/CdpElectronInspection.js

@@ -1,4 +1,4 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { delayWithCancellation, numberValue, recordValue, recordsValue, requiredRecord, cdpStringValue, } from "./CdpCaptureValues.js";
@@ -176,7 +176,7 @@ const captureResources = async (context, completeness) => {
                     ? null
                     : Math.max(0, numberValue(resource.contentSize) ?? 0),
             };
-            const resourceKey = `electron_resource_${canonicalDigest(item, "CDP capture")}`;
+            const resourceKey = `electron_resource_${digestCanonicalValue(item, "CDP capture")}`;
             if (seen.has(resourceKey))
                 continue;
             seen.add(resourceKey);

package/dist/browser/CdpElectronProvider.js

@@ -8,14 +8,11 @@ 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. */
 export class CdpElectronProvider {
     identity() {
-        return IDENTITY;
+        return CDP_ELECTRON_PROVIDER_IDENTITY;
     }
     async listTargets(input, options = {}) {
         try {
@@ -108,4 +105,6 @@ const providerError = (cause, operation) => cause instanceof BrowserObservationE
     ? new BrowserObservationError(operation, cause.reason, { cause })
     : cause instanceof AnalysisError
         ? cause
-        : new ProviderAdapterError(IDENTITY.id, operation, { cause });
+        : new ProviderAdapterError(CDP_ELECTRON_PROVIDER_IDENTITY.id, operation, {
+            cause,
+        });

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 { digestCanonicalValue } from "../domain/canonicalDigest.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) => {
@@ -27,7 +27,7 @@ export const captureElectronScripts = async (input) => {
             is_module: script.isModule,
             language: script.language,
         };
-        const scriptKey = `electron_script_${canonicalDigest(identity, "CDP capture")}`;
+        const scriptKey = `electron_script_${digestCanonicalValue(identity, "CDP capture")}`;
         if (seen.has(scriptKey))
             continue;
         seen.add(scriptKey);
@@ -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/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/CdpWebMcpDiscovery.js

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
-import { inferJsonShape } from "../domain/jsonShape.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
+import { compositeKey } from "../domain/unicodeCodePointOrder.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { allowedSanitizedUrl, delayWithCancellation, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
@@ -265,6 +267,10 @@ const normalizeTool = (value, input, frames, completeness) => {
     }
     const description = cdpStringValue(value.description) ?? "";
     const annotations = recordValue(value.annotations);
+    const declaration = jsonValueSchema.safeParse(value.inputSchema);
+    if (!declaration.success)
+        completeness.exclude("webmcp_tools", "invalid_protocol_value");
+    const schema = declaration.success ? declaration.data : null;
     return {
         tool_key: toolKey(frame.url, frameId, name),
         name,
@@ -275,7 +281,10 @@ const normalizeTool = (value, input, frames, completeness) => {
         declaration_kind: numberValue(value.backendNodeId) === undefined
             ? "imperative"
             : "declarative",
-        input_schema_shape: schemaShape(value.inputSchema),
+        input_schema: schema,
+        input_schema_sha256: declaration.success
+            ? digestCanonicalValue(schema)
+            : null,
         annotations: {
             read_only: booleanOrNull(annotations?.readOnly),
             untrusted_content: booleanOrNull(annotations?.untrustedContent),
@@ -285,15 +294,6 @@ const normalizeTool = (value, input, frames, completeness) => {
         trust: "page-declared-untrusted",
     };
 };
-const schemaShape = (value) => {
-    if (recordValue(value) === undefined)
-        return null;
-    const encoded = JSON.stringify(value);
-    const shape = inferJsonShape(encoded);
-    if (shape === null)
-        throw new BrowserObservationError("inspect_web_page", "protocol_error");
-    return shape;
-};
 const registrationSource = (stack, allowedOrigins) => {
     const frame = recordsValue(stack?.callFrames)[0];
     const url = allowedSanitizedUrl(frame?.url, allowedOrigins);
@@ -327,8 +327,11 @@ const buildWebMcpResult = (options) => {
 };
 const toolKey = (frameUrl, frameId, name) => 
 // Registrations without a known admitted frame are excluded above, so the
-// frame ID here always distinguishes owners and keys cannot collapse.
-`webmcp_${createHash("sha256").update(`${frameUrl}\0${frameId}\0${name}`).digest("hex")}`;
+// frame ID here always distinguishes owners. Composite tuple keeps a NUL
+// inside one field from collapsing two registrations before hashing.
+`webmcp_${createHash("sha256")
+    .update(compositeKey([frameUrl, frameId, name]))
+    .digest("hex")}`;
 const booleanOrNull = (value) => typeof value === "boolean" ? value : null;
 const integerOrNull = (value) => {
     const number = numberValue(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",
@@ -141,13 +135,13 @@ const globalCompleteness = (scenario, session, steps) => {
         missing.push("events");
     return classifyBrowserScenarioCompleteness(missing, truncated);
 };
-const runScenario = async (factory, scenario, options) => {
+const runScenario = async (openSession, scenario, options) => {
     if (options.signal?.aborted === true)
         throw new BrowserObservationError(OPERATION, "cancelled");
     const startedAt = Date.now();
-    const session = await factory.open(scenario, options.signal === undefined ? {} : { signal: options.signal });
+    const session = await openSession(scenario, options.signal === undefined ? {} : { signal: options.signal });
     const steps = [];
-    let cleanup;
+    let operationOutcome = { ok: true };
     try {
         steps.push(await initialStep({
             session,
@@ -169,57 +163,78 @@ 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) {
-        this.factory = factory;
+    openSession;
+    constructor(openSession) {
+        this.openSession = openSession;
     }
     identity() {
         return PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY;
     }
     async captureScenario(scenario, options = {}) {
         try {
-            return ok(await runScenario(this.factory, scenario, options));
+            return ok(await runScenario(this.openSession, scenario, options));
         }
         catch (cause) {
             if (cause instanceof AnalysisError)

package/dist/browser/PlaywrightElectronActiveActions.js

@@ -1,63 +1,9 @@
 import { z } from "zod";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { electronActiveTimelineEventSchema, } from "../domain/javascript/electronActiveObservation.js";
 const OPERATION = "capture_electron_scenario";
-const hookEventSchema = z.strictObject({
-    sequence: z.number().int().min(1),
-    correlation_id: z.string().nullable(),
-    kind: z.enum([
-        "main-handler-invocation",
-        "main-event-invocation",
-        "utility-process-fork",
-        "utility-process-message",
-        "ipc-main-to-renderer",
-        "ipc-utility-to-main",
-        "ipc-renderer-send",
-        "ipc-renderer-invoke",
-        "ipc-renderer-post-message",
-        "app-lifecycle",
-        "window-lifecycle",
-        "web-contents-lifecycle",
-        "navigation",
-        "shell-attempt",
-        "process-lifecycle",
-        "permission",
-        "popup-attempt",
-        "download",
-        "protocol",
-        "preload",
-        "native-addon",
-        "updater",
-        "error",
-    ]),
-    event: z.string().nullable(),
-    phase: z.enum(["attempted", "completed", "blocked", "failed", "observed"]),
-    channel: z.string().nullable(),
-    direction: z
-        .enum([
-        "renderer-to-main",
-        "main-to-renderer",
-        "main-to-utility",
-        "utility-to-main",
-    ])
-        .nullable(),
-    sender: z.string().nullable(),
-    receiver: z.string().nullable(),
-    frame: z.string().nullable(),
-    target: z.string().nullable(),
-    argument_shapes: z.array(z.string()),
-    result_shape: z.string().nullable(),
-    process_type: z.string().nullable(),
-    source: z.string(),
-    capture_method: z.enum(["api-wrapper", "event-emitter", "process-hook"]),
-    artifact_path: z.string().nullable(),
-    artifact_sha256: z
-        .string()
-        .regex(/^[a-f0-9]{64}$/u)
-        .nullable(),
-    error: z.boolean(),
-});
 const hookSnapshotSchema = z.strictObject({
-    events: z.array(hookEventSchema),
+    events: z.array(electronActiveTimelineEventSchema),
     retention_budget_bytes: z.number().int().min(0),
     estimated_retained_bytes: z.number().int().min(0),
     event_serialized_byte_upper_bound: z.number().int().min(0),

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -14,12 +14,16 @@ import { runElectronActions, readApplicationState, runWithExecutionLimits, } fro
 import { projectElectronActiveCapture } from "./PlaywrightElectronActiveProjection.js";
 const OPERATION = "capture_electron_scenario";
 const STARTUP_TIMEOUT_MS = 60_000;
-/** Public identity for provider-owned Electron runtime experiments. */
-export { PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const hookPath = fileURLToPath(new URL("../../scripts/electron-active-hook.cjs", import.meta.url));
 /** Launch an owned Electron application through the official Playwright API. */
 export class PlaywrightElectronActiveProvider {
+    environment;
+    launch;
+    constructor(environment, launch = (options) => electron.launch(options)) {
+        this.environment = environment;
+        this.launch = launch;
+    }
     identity() {
         return PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY;
     }
@@ -42,10 +46,10 @@ export class PlaywrightElectronActiveProvider {
             const captureBaseline = await systemProcessOwnershipHost.captureBaseline?.(options.signal);
             if (options.signal?.aborted)
                 throw new BrowserObservationError(OPERATION, "cancelled");
-            application = await electron.launch({
+            application = await this.launch({
                 executablePath: paths.executable,
                 cwd: paths.root,
-                env: safeElectronEnvironment(runId),
+                env: safeElectronEnvironment(this.environment, runId),
                 args: ["-r", hookPath, paths.application, ...input.args],
                 timeout: Math.max(1, startupDeadline - Date.now()),
             });
@@ -258,7 +262,7 @@ const canonicalPaths = async (input) => {
         : await realpath(input.application_root);
     return { executable, application, root };
 };
-const safeElectronEnvironment = (runId) => Object.fromEntries([
+const safeElectronEnvironment = (environment, runId) => Object.fromEntries([
     ...[
         "HOME",
         "LANG",
@@ -269,7 +273,7 @@ const safeElectronEnvironment = (runId) => Object.fromEntries([
         "DISPLAY",
         "WAYLAND_DISPLAY",
     ]
-        .map((name) => [name, process.env[name]])
+        .map((name) => [name, environment[name]])
         .filter((entry) => entry[1] !== undefined),
     ["REA_PROCESS_RUN_ID", runId],
 ]);

package/dist/browser/PlaywrightScenarioArtifacts.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
-import { browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
+import { browserStepArtifactsSchema, } from "../domain/browserScenarioCaptureValues.js";
 const historyValueSchema = z.strictObject({
     length: z.number().int().min(0),
     navigation_entries: z.array(z.strictObject({