rea-agents 3.0.0 → 3.2.0

package/dist/browser/CdpElectronProvider.js

@@ -4,7 +4,7 @@ import { err, ok } from "../domain/result.js";
 import { discoverCdpEndpoint, hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
 import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession.js";
 import { inspectCdpElectronPage } from "./CdpElectronInspection.js";
-import { authorizedElectronFile, canonicalElectronRoots, } from "./ElectronFileScope.js";
+import { authorizedElectronFile } from "./ElectronFileScope.js";
 /** Public identity committed by passive Electron observations. */
 export const CDP_ELECTRON_PROVIDER_IDENTITY = Object.freeze({
     id: "rea-cdp-electron",
@@ -12,17 +12,15 @@ export const CDP_ELECTRON_PROVIDER_IDENTITY = Object.freeze({
     version: "1",
 });
 const IDENTITY = CDP_ELECTRON_PROVIDER_IDENTITY;
-/** Passive Electron provider with canonical file-root confinement. */
+/** Passive Electron provider for local file pages exposed by loopback CDP. */
 export class CdpElectronProvider {
     identity() {
         return IDENTITY;
     }
     async listTargets(input, options = {}) {
         try {
-            const roots = await canonicalElectronRoots(input.allowed_file_roots);
             const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "list_electron_targets", options.signal);
             const allowed = [];
-            let outsideRoot = 0;
             let unsupportedUrl = 0;
             let nonPage = 0;
             let unconnectable = 0;
@@ -31,12 +29,9 @@ export class CdpElectronProvider {
                     nonPage += 1;
                     continue;
                 }
-                const path = await authorizedElectronFile(target.url, roots);
+                const path = await authorizedElectronFile(target.url);
                 if (path === undefined) {
-                    if (isFileUrl(target.url))
-                        outsideRoot += 1;
-                    else
-                        unsupportedUrl += 1;
+                    unsupportedUrl += 1;
                     continue;
                 }
                 if (!hasCdpTargetWebSocket(discovery, target)) {
@@ -46,32 +41,21 @@ export class CdpElectronProvider {
                 allowed.push({
                     target_id: target.id,
                     type: target.type,
-                    title: target.title.slice(0, 16_384),
+                    title: target.title,
                     file_path: path,
                     attached: target.attached,
                 });
             }
             allowed.sort((left, right) => left.target_id.localeCompare(right.target_id));
-            const items = allowed.slice(input.offset, input.offset + input.limit);
-            const next = input.offset + items.length;
             return ok(electronTargetListSchema.parse({
-                schema_version: 1,
                 browser: discovery.version,
-                targets: {
-                    items,
-                    offset: input.offset,
-                    limit: input.limit,
-                    total: allowed.length,
-                    next_offset: next < allowed.length ? next : null,
-                    has_more: next < allowed.length,
-                },
+                targets: allowed,
                 excluded: {
-                    outside_root: outsideRoot,
                     unsupported_url: unsupportedUrl,
                     non_page: nonPage,
                 },
                 limitations: [
-                    "Only page targets whose canonical file path is contained by an approved root are listed.",
+                    "Every local file page exposed by the selected loopback CDP endpoint is eligible for listing.",
                     ...(unconnectable === 0
                         ? []
                         : [
@@ -87,9 +71,8 @@ export class CdpElectronProvider {
     async inspectPage(input, options = {}) {
         let targetSession;
         try {
-            const roots = await canonicalElectronRoots(input.allowed_file_roots);
             const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "inspect_electron_page", options.signal);
-            const target = await authorizeTarget(discovery.targets, input.target_id, roots);
+            const target = await authorizeTarget(discovery.targets, input.target_id);
             targetSession = await openCdpTargetSession(discovery, target, "inspect_electron_page", options.signal);
             return ok(electronPageInspectionSchema.parse(await inspectCdpElectronPage({
                 connection: targetSession.connection,
@@ -116,23 +99,15 @@ export class CdpElectronProvider {
         }
     }
 }
-const authorizeTarget = async (targets, targetId, roots) => {
+const authorizeTarget = async (targets, targetId) => {
     const target = targets.find(({ id }) => id === targetId);
     if (target === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_found");
     if (target.type !== "page" ||
-        (await authorizedElectronFile(target.url, roots)) === undefined)
+        (await authorizedElectronFile(target.url)) === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     return target;
 };
-const isFileUrl = (value) => {
-    try {
-        return new URL(value).protocol === "file:";
-    }
-    catch {
-        return false;
-    }
-};
 const providerError = (cause, operation) => cause instanceof BrowserObservationError && cause.operation !== operation
     ? new BrowserObservationError(operation, cause.reason, { cause })
     : cause instanceof AnalysisError

package/dist/browser/CdpElectronScriptEvents.js

@@ -1,6 +1,6 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { boundedText, numberValue, recordValue, stringValue, } from "./CdpCaptureValues.js";
-/** Retain only bounded script/frame metadata from passive Electron events. */
+import { numberValue, recordValue, stringValue } from "./CdpCaptureValues.js";
+/** Retain script/frame metadata from passive Electron events. */
 export const ingestElectronScriptEvent = (input) => {
     if (input.event.method === "Runtime.executionContextsCleared") {
         input.executionContextFrames.clear();
@@ -14,7 +14,7 @@ export const ingestElectronScriptEvent = (input) => {
         return;
     }
     if (input.event.method === "Runtime.executionContextCreated") {
-        retainExecutionContext(input.event, input.executionContextFrames, input.completeness);
+        retainExecutionContext(input.event, input.executionContextFrames);
         return;
     }
     if (input.event.method !== "Debugger.scriptParsed")
@@ -22,7 +22,7 @@ export const ingestElectronScriptEvent = (input) => {
     const value = recordValue(input.event.params);
     const scriptId = stringValue(value?.scriptId);
     const rawUrl = stringValue(value?.url);
-    if (scriptId === undefined || scriptId.length > 256) {
+    if (scriptId === undefined) {
         input.completeness.exclude("scripts", "invalid_protocol_value");
         return;
     }
@@ -30,31 +30,23 @@ export const ingestElectronScriptEvent = (input) => {
         input.completeness.exclude("scripts", "unattributed_origin");
         return;
     }
-    if (input.scripts.length >= 2_000) {
-        input.completeness.drop("scripts");
-        return;
-    }
     input.scripts.push({
         scriptId,
         rawUrl,
-        hash: (stringValue(value?.hash) ?? "").slice(0, 512),
+        hash: stringValue(value?.hash) ?? "",
         length: nonnegativeInteger(value?.length),
         isModule: value?.isModule === true,
-        language: boundedText(value?.scriptLanguage, 100),
+        language: stringValue(value?.scriptLanguage) ?? null,
         executionContextKey: executionContextKey(value?.executionContextId),
     });
 };
-const retainExecutionContext = (event, frames, completeness) => {
+const retainExecutionContext = (event, frames) => {
     const parameters = recordValue(event.params);
     const runtimeContext = recordValue(parameters?.context);
     const contextKey = executionContextKey(runtimeContext?.id);
     const frameId = stringValue(recordValue(runtimeContext?.auxData)?.frameId);
-    if (contextKey === null || frameId === undefined || frameId.length > 256)
+    if (contextKey === null || frameId === undefined)
         return;
-    if (frames.size >= 2_000 && !frames.has(contextKey)) {
-        completeness.truncate("scripts");
-        return;
-    }
     frames.set(contextKey, frameId);
 };
 const nonnegativeInteger = (value) => {

package/dist/browser/CdpElectronScripts.js

@@ -1,17 +1,15 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
+import { canonicalJsonDigest } from "./CdpCanonicalJsonDigest.js";
 import { requiredRecord, stringValue } from "./CdpCaptureValues.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
-/** Normalize root-confined script metadata and optionally approved source. */
+/** Normalize local script metadata and optionally approved source. */
 export const captureElectronScripts = async (input) => {
     let total = 0;
-    let sourceBytes = 0;
     const items = [];
     const seen = new Set();
     for (const script of input.scripts) {
-        const path = await authorizedElectronFile(script.rawUrl, input.roots);
+        const path = await authorizedElectronFile(script.rawUrl);
         if (path === undefined) {
             input.completeness.exclude("scripts", "out_of_target_scope");
             continue;
@@ -29,17 +27,12 @@ export const captureElectronScripts = async (input) => {
             is_module: script.isModule,
             language: script.language,
         };
-        const scriptKey = `electron_script_${digest(identity)}`;
+        const scriptKey = `electron_script_${canonicalJsonDigest(identity)}`;
         if (seen.has(scriptKey))
             continue;
         seen.add(scriptKey);
         total += 1;
-        if (items.length >= input.request.limits.max_scripts) {
-            input.completeness.drop("scripts");
-            continue;
-        }
-        const capturedSource = await captureScriptSource(input, script, sourceBytes);
-        sourceBytes += capturedSource.bytes;
+        const capturedSource = await captureScriptSource(input, script);
         items.push({
             script_key: scriptKey,
             ...identity,
@@ -53,42 +46,20 @@ export const captureElectronScripts = async (input) => {
         items: items.sort((left, right) => left.script_key.localeCompare(right.script_key)),
     };
 };
-const captureScriptSource = async (input, script, sourceBytes) => {
+const captureScriptSource = async (input, script) => {
     if (!input.request.include_script_sources)
         return {
             source: {
                 included: false,
                 reason: "source capture was not approved",
             },
-            bytes: 0,
         };
-    if (sourceLimitReached(input.request.limits, script.length, sourceBytes))
-        return sourceLimitResult(input.completeness);
     const result = requiredRecord(await input.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, input.sessionId, input.signal));
     const text = stringValue(result.scriptSource) ?? "";
-    const bytes = Buffer.byteLength(text);
-    if (sourceLimitReached(input.request.limits, bytes, sourceBytes))
-        return sourceLimitResult(input.completeness);
     return {
         source: {
             included: true,
             artifact: createWebTextArtifact(text, "text/javascript"),
         },
-        bytes,
-    };
-};
-const sourceLimitReached = (limits, bytes, previousBytes) => bytes > limits.max_script_source_bytes ||
-    previousBytes + bytes > limits.max_total_script_source_bytes;
-const sourceLimitResult = (completeness) => {
-    completeness.truncate("script_sources");
-    return {
-        source: { included: false, reason: "script source byte limit reached" },
-        bytes: 0,
     };
 };
-const digest = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Expected canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};

package/dist/browser/CdpElectronWorkers.js

@@ -1,8 +1,8 @@
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { boundedText, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { recordValue, recordsValue, stringValue } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
-/** Inventory root-confined worker targets without attaching to them. */
+/** Inventory local worker targets without attaching to them. */
 export const captureElectronWorkers = async (input) => {
     const result = await optionalCdpCommand({
         connection: input.connection,
@@ -25,15 +25,11 @@ export const captureElectronWorkers = async (input) => {
             input.completeness.exclude("workers", "out_of_target_scope");
             continue;
         }
-        const path = await authorizedElectronFile(stringValue(target.url) ?? "", input.roots);
+        const path = await authorizedElectronFile(stringValue(target.url) ?? "");
         if (path === undefined) {
             input.completeness.exclude("workers", "out_of_target_scope");
             continue;
         }
-        if (workers.length >= input.request.limits.max_workers) {
-            input.completeness.truncate("workers");
-            continue;
-        }
         const targetId = boundedTargetField(target.targetId);
         if (targetId === null) {
             input.completeness.exclude("workers", "invalid_protocol_value");
@@ -41,7 +37,7 @@ export const captureElectronWorkers = async (input) => {
         }
         workers.push({
             target_id: targetId,
-            type: type.slice(0, 100),
+            type,
             file_path: path,
             attached: target.attached === true,
             opener_target_id: openerTargetId,
@@ -51,6 +47,6 @@ export const captureElectronWorkers = async (input) => {
     return workers.sort((left, right) => left.target_id.localeCompare(right.target_id));
 };
 const boundedTargetField = (value) => {
-    const field = boundedText(value, 256);
-    return field === null || field === "" ? null : field;
+    const field = stringValue(value);
+    return field === undefined || field === "" ? null : field;
 };

package/dist/browser/CdpEndpoint.js

@@ -1,31 +1,28 @@
 import { request } from "node:http";
 import { z } from "zod";
-import { AnalysisCancelledError, AnalysisError, AnalysisTimeoutError, BrowserObservationError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisError, BrowserObservationError, } from "../domain/errors.js";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
-const HTTP_TIMEOUT_MS = 5_000;
-const MAX_VERSION_BYTES = 64 * 1_024;
-const MAX_TARGET_LIST_BYTES = 2 * 1_024 * 1_024;
 const endpointVersionSchema = z.object({
-    Browser: z.string().min(1).max(1_024),
-    "Protocol-Version": z.string().min(1).max(100),
-    "User-Agent": z.string().max(16_384),
-    "V8-Version": z.string().max(1_024),
-    "WebKit-Version": z.string().max(1_024),
-    webSocketDebuggerUrl: z.string().min(1).max(2_048),
+    Browser: z.string().min(1),
+    "Protocol-Version": z.string().min(1),
+    "User-Agent": z.string(),
+    "V8-Version": z.string(),
+    "WebKit-Version": z.string(),
+    webSocketDebuggerUrl: z.string().min(1),
 });
 const endpointTargetSchema = z.object({
-    id: z.string().min(1).max(256),
-    type: z.string().min(1).max(100),
-    title: z.string().max(16_384).default(""),
-    url: z.string().max(65_536),
+    id: z.string().min(1),
+    type: z.string().min(1),
+    title: z.string().default(""),
+    url: z.string(),
     attached: z.boolean().default(false),
-    webSocketDebuggerUrl: z.string().min(1).max(2_048).optional(),
+    webSocketDebuggerUrl: z.string().min(1).optional(),
 });
-const endpointTargetsSchema = z.array(endpointTargetSchema).max(1_000);
-/** Read bounded CDP discovery endpoints without following redirects. */
+const endpointTargetsSchema = z.array(endpointTargetSchema);
+/** Read CDP discovery endpoints without following redirects. */
 export const discoverCdpEndpoint = async (endpoint, operation, signal) => {
-    const versionInput = await readBoundedCdpJson(new URL("/json/version", endpoint), MAX_VERSION_BYTES, operation, signal);
-    const targetsInput = await readBoundedCdpJson(new URL("/json/list", endpoint), MAX_TARGET_LIST_BYTES, operation, signal);
+    const versionInput = await readCdpJson(new URL("/json/version", endpoint), operation, signal);
+    const targetsInput = await readCdpJson(new URL("/json/list", endpoint), operation, signal);
     const version = parseCdpEndpointValue(endpointVersionSchema, versionInput, operation);
     const targets = parseCdpEndpointValue(endpointTargetsSchema, targetsInput, operation);
     return {
@@ -56,7 +53,7 @@ const sanitizeTargetTitle = (value, targetUrl) => {
         return sanitizeTargetUrlAlias(value, targetUrl);
     }
     return url.protocol === "http:" || url.protocol === "https:"
-        ? sanitizeBrowserUrl(value).url.slice(0, 16_384)
+        ? sanitizeBrowserUrl(value).url
         : sanitizeTargetUrlAlias(value, targetUrl);
 };
 const sanitizeTargetUrlAlias = (value, targetUrl) => {
@@ -71,9 +68,7 @@ const sanitizeTargetUrlAlias = (value, targetUrl) => {
     if (parsed.pathname !== "/")
         markers.push(parsed.pathname);
     const candidatePattern = new RegExp(`(?:${markers.map(escapeRegExp).join("|")})[^\\s<>"']*`, "gu");
-    return value
-        .replace(candidatePattern, (candidate) => sanitizeSameOriginTitleUrl(candidate, parsed))
-        .slice(0, 16_384);
+    return value.replace(candidatePattern, (candidate) => sanitizeSameOriginTitleUrl(candidate, parsed));
 };
 const sanitizeSameOriginTitleUrl = (candidate, target) => {
     let parsed;
@@ -145,19 +140,17 @@ const safeCdpWebSocketEndpoint = (endpoint, reported, operation) => {
         : { scope: "page", targetId: path.targetId, url: parsed.href };
 };
 const cdpWebSocketPath = (pathname) => {
-    const browserId = pathIdentifier(pathname, "/devtools/browser/", 1_024);
+    const browserId = pathIdentifier(pathname, "/devtools/browser/");
     if (browserId !== undefined)
         return { scope: "browser" };
-    const targetId = pathIdentifier(pathname, "/devtools/page/", 256);
+    const targetId = pathIdentifier(pathname, "/devtools/page/");
     return targetId === undefined ? undefined : { scope: "page", targetId };
 };
-const pathIdentifier = (pathname, prefix, maximumLength) => {
+const pathIdentifier = (pathname, prefix) => {
     if (!pathname.startsWith(prefix))
         return undefined;
     const identifier = pathname.slice(prefix.length);
-    return identifier.length > 0 &&
-        identifier.length <= maximumLength &&
-        !identifier.includes("/")
+    return identifier.length > 0 && !identifier.includes("/")
         ? identifier
         : undefined;
 };
@@ -174,8 +167,8 @@ const targetWebSocket = (endpoint, target, operation) => {
         return {};
     }
 };
-/** Read one bounded loopback CDP discovery document without redirects. */
-export const readBoundedCdpJson = async (url, maximumBytes, operation, signal) => await new Promise((resolve, reject) => {
+/** Read one loopback CDP discovery document without redirects. */
+export const readCdpJson = async (url, operation, signal) => await new Promise((resolve, reject) => {
     if (signal?.aborted === true) {
         reject(new AnalysisCancelledError(operation));
         return;
@@ -187,15 +180,7 @@ export const readBoundedCdpJson = async (url, maximumBytes, operation, signal) =
             return;
         }
         const chunks = [];
-        let bytes = 0;
-        response.on("data", (chunk) => {
-            bytes += chunk.length;
-            if (bytes > maximumBytes) {
-                response.destroy(new BrowserObservationError(operation, "payload_limit"));
-                return;
-            }
-            chunks.push(chunk);
-        });
+        response.on("data", (chunk) => chunks.push(chunk));
         response.on("end", () => {
             try {
                 resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
@@ -206,7 +191,6 @@ export const readBoundedCdpJson = async (url, maximumBytes, operation, signal) =
         });
         response.on("error", (cause) => reject(endpointFailure(cause, operation, signal)));
     });
-    request_.setTimeout(HTTP_TIMEOUT_MS, () => request_.destroy(new AnalysisTimeoutError(operation, HTTP_TIMEOUT_MS)));
     request_.on("error", (cause) => reject(endpointFailure(cause, operation, signal)));
     request_.end();
 });

package/dist/browser/CdpObservationSession.js

@@ -1,17 +1,24 @@
 import { AnalysisCancelledError, BrowserObservationError, } from "../domain/errors.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { allowedSanitizedUrl, delayWithCancellation, isHttpUrl, numberValue, recordValue, stringValue, } from "./CdpCaptureValues.js";
+import { authorizedMainFrame } from "./CdpAuthorizedMainFrame.js";
+import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, stringValue, } from "./CdpCaptureValues.js";
 import { mainFrameUrl } from "./CdpCaptureDocuments.js";
 /** Observe external user actions without rejecting approved same-origin navigation. */
 export const observeCdpSession = async (context) => {
     const allowedOrigins = new Set(context.input.allowed_origins);
-    const initial = await authorizedFrame(context, allowedOrigins);
+    const initial = await authorizedMainFrame({
+        connection: context.connection,
+        sessionId: context.sessionId,
+        signal: context.signal,
+        allowedOrigins,
+        delayOperation: "observe_web_session",
+    });
     const initialUrl = mainFrameUrl(initial) ?? "";
     const mainFrameId = frameId(initial);
     if (mainFrameId === undefined)
         throw new BrowserObservationError("inspect_web_page", "protocol_error");
-    const capture = new TimelineCapture(context.input.max_timeline_events, allowedOrigins, mainFrameId, initialUrl);
+    const capture = new TimelineCapture(allowedOrigins, mainFrameId, initialUrl);
     const removeListener = context.connection.onEvent((event) => {
         if (observationEventMatches(event, context.sessionId))
             capture.ingest(event);
@@ -19,7 +26,7 @@ export const observeCdpSession = async (context) => {
     const removeDisconnectListener = context.connection.onDisconnect(() => capture.targetTerminated());
     try {
         await context.connection.send("Page.enable", {}, context.sessionId, context.signal);
-        await context.connection.send("Network.enable", { maxTotalBufferSize: 1_024 * 1_024 }, context.sessionId, context.signal);
+        await context.connection.send("Network.enable", {}, context.sessionId, context.signal);
         await context.connection.send("Page.setLifecycleEventsEnabled", { enabled: true }, context.sessionId, context.signal);
         const armedAt = new Date().toISOString();
         await context.progress?.report({
@@ -39,7 +46,6 @@ export const observeCdpSession = async (context) => {
             terminal: true,
         });
         return {
-            schema_version: 1,
             browser: context.discovery.version,
             target: {
                 target_id: context.target.id,
@@ -67,7 +73,6 @@ export const observeCdpSession = async (context) => {
     }
 };
 class TimelineCapture {
-    maximum;
     allowedOrigins;
     mainFrameId;
     timeline = [];
@@ -77,8 +82,7 @@ class TimelineCapture {
     #pendingReload = false;
     #endReason;
     #listeners = new Set();
-    constructor(maximum, allowedOrigins, mainFrameId, initialUrl) {
-        this.maximum = maximum;
+    constructor(allowedOrigins, mainFrameId, initialUrl) {
         this.allowedOrigins = allowedOrigins;
         this.mainFrameId = mainFrameId;
         this.finalUrl =
@@ -246,10 +250,6 @@ class TimelineCapture {
     #add(options) {
         const { type, params, rawUrl = null, requestId = null, detail = null, } = options;
         const destination = rawUrl == null ? null : scopedUrl(rawUrl, this.allowedOrigins);
-        if (this.timeline.length >= this.maximum) {
-            this.completeness.drop("timeline_events");
-            return;
-        }
         this.#sequence += 1;
         this.timeline.push({
             sequence: this.#sequence,
@@ -257,7 +257,7 @@ class TimelineCapture {
             timestamp: Math.max(0, numberValue(params.timestamp) ?? 0),
             frame_id: boundedId(params.frameId),
             loader_id: boundedId(params.loaderId),
-            request_id: requestId?.slice(0, 256) ?? null,
+            request_id: requestId ?? null,
             url: destination?.scope === "approved" ? destination.url : null,
             destination_scope: destination?.scope ?? null,
             detail,
@@ -296,18 +296,6 @@ const waitForWindow = async (durationMs, capture, signal) => await new Promise((
     if (signal?.aborted === true)
         onAbort();
 });
-const authorizedFrame = async (context, allowedOrigins) => {
-    for (let attempt = 0; attempt < 80; attempt += 1) {
-        const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
-        const url = mainFrameUrl(result);
-        if (allowedSanitizedUrl(url, allowedOrigins) !== undefined)
-            return result;
-        if (isHttpUrl(url))
-            throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-        await delayWithCancellation(25, "observe_web_session", context.signal);
-    }
-    throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-};
 const captureFinalUrl = async (context, capture, allowedOrigins) => {
     const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
     const url = mainFrameUrl(result);
@@ -329,7 +317,7 @@ const scopedUrl = (value, allowedOrigins) => {
         ? { url: null, scope: "outside_policy" }
         : { url: null, scope: "unsupported" };
 };
-const boundedId = (value) => stringValue(value)?.slice(0, 256) ?? null;
+const boundedId = (value) => stringValue(value) ?? null;
 const safeDetail = (value) => {
     const detail = stringValue(value)?.toLowerCase();
     return detail !== undefined && /^[a-z0-9_.:-]{1,100}$/u.test(detail)