reverseport 0.0.0-stage → 1.2.0

package/dist/browser/CdpPageCaptureScripts.js

@@ -0,0 +1,79 @@
+import { reconcileCapturedWebScript, stableWebScriptKey, } from "../domain/webInventory.js";
+import { requiredScriptSource, sourceExcluded, sourceResult, } from "./CdpCaptureValues.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
+export const captureScripts = async (options) => {
+    const { context, events, rawResources, resources, frameIds } = options;
+    const state = {
+        context,
+        events,
+        frameIds,
+        rawResources,
+        resources,
+    };
+    const drafts = [];
+    for (const script of events.scripts.values())
+        drafts.push(await buildScriptDraft(script, state));
+    if (!context.input.include_script_sources)
+        events.completeness.exclude("script_sources", "not_approved", events.scripts.size);
+    return keyAndBuildInventory(drafts, events.scripts.size);
+};
+const buildScriptDraft = async (script, state) => {
+    let source = state
+        .context.input.include_script_sources
+        ? await captureScriptSource(script, state)
+        : sourceExcluded("source capture was not selected");
+    const inventoryScript = {
+        frame_id: state.events.frameForScript(script, state.frameIds),
+        url: script.url,
+        cdp_hash: script.hash,
+        length: script.length,
+        is_module: script.isModule,
+        language: script.language,
+        source_map_url: script.sourceMapUrl,
+    };
+    return {
+        item: {
+            ...inventoryScript,
+            origin: script.origin,
+            resource_reconciliation: reconcileCapturedWebScript({ ...inventoryScript, rawUrl: script.rawUrl }, state.rawResources, state.resources),
+            source,
+        },
+        sourceMapRawUrl: script.sourceMapRawUrl,
+    };
+};
+const captureScriptSource = async (script, state) => {
+    const { context } = state;
+    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) => {
+    const keyed = drafts.map((draft) => ({
+        ...draft,
+        base: stableWebScriptKey(draft.item),
+    }));
+    keyed.sort((left, right) => compareUnicodeCodePoints(left.base, right.base) ||
+        compareUnicodeCodePoints(sourceDigest(left.item.source), sourceDigest(right.item.source)) ||
+        compareUnicodeCodePoints(left.item.frame_id ?? "", right.item.frame_id ?? ""));
+    const totals = new Map();
+    for (const { base } of keyed)
+        totals.set(base, (totals.get(base) ?? 0) + 1);
+    const seen = new Map();
+    const sourceMapRequests = [];
+    const items = keyed.map(({ base, item, sourceMapRawUrl }) => {
+        const occurrence = (seen.get(base) ?? 0) + 1;
+        seen.set(base, occurrence);
+        const scriptKey = totals.get(base) === 1 ? base : `${base}_${String(occurrence)}`;
+        if (item.source_map_url !== null && sourceMapRawUrl !== null)
+            sourceMapRequests.push({
+                scriptKey,
+                declaredUrl: item.source_map_url,
+                fetchUrl: sourceMapRawUrl,
+            });
+        return { script_key: scriptKey, ...item };
+    });
+    return {
+        inventory: { total: scriptCount, items },
+        sourceMapRequests,
+    };
+};
+const sourceDigest = (source) => (source.included ? source.artifact.sha256 : source.reason);

package/dist/browser/CdpPageCaptureWorkers.js

@@ -0,0 +1,46 @@
+import { allowedSanitizedUrl, isHttpUrl, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { optionalCdpCommand } from "./CdpOptionalCommand.js";
+export const captureWorkers = async (input, frameIds) => {
+    const { context, allowedOrigins, limitations, events } = input;
+    const completeness = events.completeness;
+    const result = await optionalCdpCommand({ ...context, sessionId: undefined }, "Target.getTargets", {}, limitations);
+    const items = [];
+    if (result === undefined)
+        completeness.unavailable("workers");
+    for (const target of recordsValue(recordValue(result)?.targetInfos)) {
+        const type = cdpStringValue(target.type) ?? "";
+        const url = allowedSanitizedUrl(target.url, allowedOrigins);
+        const relatedToPage = cdpStringValue(target.openerId) === context.target.id ||
+            (cdpStringValue(target.parentFrameId) !== undefined &&
+                frameIds.has(cdpStringValue(target.parentFrameId) ?? ""));
+        if (!type.includes("worker"))
+            continue;
+        if (!relatedToPage) {
+            completeness.exclude("workers", "out_of_target_scope");
+            continue;
+        }
+        if (url === undefined) {
+            const rawUrl = cdpStringValue(target.url);
+            completeness.exclude("workers", rawUrl === undefined || rawUrl === ""
+                ? "unattributed_origin"
+                : isHttpUrl(rawUrl)
+                    ? "disallowed_origin"
+                    : "unsupported_url");
+            continue;
+        }
+        if (typeof target.attached !== "boolean") {
+            completeness.exclude("workers", "invalid_protocol_value");
+            continue;
+        }
+        items.push({
+            target_id: cdpStringValue(target.targetId) ?? "",
+            type,
+            url: url.url,
+            origin: url.origin,
+            attached: target.attached,
+            opener_target_id: cdpStringValue(target.openerId) ?? null,
+            parent_frame_id: cdpStringValue(target.parentFrameId) ?? null,
+        });
+    }
+    return items;
+};

package/dist/browser/CdpSafeMetadata.js

@@ -0,0 +1,284 @@
+import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
+import { numberValue, cdpStringValue, } from "./CdpCaptureValues.js";
+/** Normalize an allowlisted subset of response metadata and discard raw headers. */
+export const safeResponseMetadata = (requestId, url, response, allowedOrigins) => {
+    const headers = normalizedHeaders(response.headers);
+    const links = parseLinks(headers.get("link"), url, allowedOrigins);
+    const csp = parseCsp(headers.get("content-security-policy"), url, allowedOrigins);
+    const agentHints = [
+        ...links.flatMap((link) => link.rel.some(isAgentRel)
+            ? [agentHint("link_rel", link.rel.join(" "), link.href)]
+            : []),
+        ...agentHeaderNames.flatMap((name) => headers.has(name) ? [agentHint("response_header", name, null)] : []),
+        ...wellKnownHint(url),
+    ];
+    return {
+        response: {
+            request_id: requestId,
+            url,
+            mime_type: boundedHeader(cdpStringValue(response.mimeType)),
+            content_length: nonnegativeInteger(headers.get("content-length")),
+            content_encoding: boundedHeader(headers.get("content-encoding")),
+            csp,
+            links,
+            policies: {
+                coop: policyToken(headers.get("cross-origin-opener-policy")),
+                coep: policyToken(headers.get("cross-origin-embedder-policy")),
+                corp: policyToken(headers.get("cross-origin-resource-policy")),
+                referrer_policy: referrerPolicy(headers.get("referrer-policy")),
+                x_content_type_options: policyToken(headers.get("x-content-type-options")),
+                permissions_policy_features: permissionFeatures(headers.get("permissions-policy")),
+            },
+        },
+        agentHints,
+    };
+};
+const normalizedHeaders = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return new Map();
+    const headers = new Map();
+    for (const [name, raw] of Object.entries(value)) {
+        const normalized = name.toLowerCase();
+        const header = typeof raw === "string"
+            ? raw
+            : typeof raw === "number" && Number.isFinite(raw)
+                ? String(raw)
+                : undefined;
+        if (header !== undefined)
+            headers.set(normalized, header);
+    }
+    return headers;
+};
+const parseCsp = (value, baseUrl, allowedOrigins) => {
+    const directives = [];
+    let nonceCount = 0;
+    let hashCount = 0;
+    for (const rawDirective of (value ?? "").split(";")) {
+        const [rawName, ...tokens] = rawDirective.trim().split(/\s+/u);
+        const name = (rawName ?? "").toLowerCase();
+        if (!/^[a-z][a-z0-9\x2d]*$/u.test(name))
+            continue;
+        const sources = [];
+        for (const token of tokens) {
+            const lower = token.toLowerCase();
+            if (lower.startsWith("'nonce-")) {
+                nonceCount += 1;
+                continue;
+            }
+            if (lower.startsWith("'sha256-") ||
+                lower.startsWith("'sha384-") ||
+                lower.startsWith("'sha512-")) {
+                hashCount += 1;
+                continue;
+            }
+            sources.push(cspSource(token, baseUrl, allowedOrigins));
+        }
+        directives.push({ name, sources });
+    }
+    return { directives, nonce_count: nonceCount, hash_count: hashCount };
+};
+const cspSource = (token, baseUrl, allowedOrigins) => {
+    const lower = token.toLowerCase();
+    if (/^'[a-z0-9\x2d]+'$/u.test(lower))
+        return { kind: "keyword", value: lower };
+    if (/^[a-z][a-z0-9+.\x2d]*:$/u.test(lower))
+        return { kind: "scheme", value: lower };
+    const hostOrigin = cspHostSourceOrigin(token, baseUrl);
+    if (hostOrigin === undefined)
+        return { kind: "other", value: null };
+    return hostOrigin !== null && allowedOrigins.has(hostOrigin)
+        ? { kind: "approved_origin", value: hostOrigin }
+        : { kind: "external_origin", value: null };
+};
+/**
+ * Resolve a CSP host-source (CSP3 §2.3.1) to the single origin it names. A
+ * scheme-less source inherits the protected resource's scheme instead of being
+ * resolved as a page-relative path. Returns `null` for a recognized wildcard
+ * host or port, which denotes a set of origins rather than one origin, and
+ * `undefined` when the token is not a host-source at all.
+ */
+const cspHostSourceOrigin = (token, baseUrl) => {
+    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+.\x2d]*$/u.test(scheme))
+        return undefined;
+    if (!/^(?:\*|(?:\*\.)?[a-z0-9\x2d]+(?:\.[a-z0-9\x2d]+)*\.?)(?::(?:\*|\d+))?$/iu.test(authority))
+        return undefined;
+    if (authority.includes("*"))
+        return null;
+    try {
+        const parsed = new URL(`${scheme}://${authority}`);
+        return parsed.username === "" &&
+            parsed.password === "" &&
+            parsed.pathname === "/" &&
+            parsed.origin !== "null"
+            ? parsed.origin
+            : undefined;
+    }
+    catch (cause) {
+        // Authorities that are not a bare host[:port] are classified as other.
+        void cause;
+        return undefined;
+    }
+};
+const schemeOf = (baseUrl) => {
+    try {
+        return new URL(baseUrl).protocol.replace(/:$/u, "");
+    }
+    catch (cause) {
+        // An unparseable protected-resource URL cannot lend a scheme.
+        void cause;
+        return undefined;
+    }
+};
+const parseLinks = (value, baseUrl, allowedOrigins) => {
+    const links = [];
+    for (const entry of splitLinkHeader(value ?? "")) {
+        const match = /^\s*<([^>]*)>(.*)$/u.exec(entry);
+        if (match === null)
+            continue;
+        const parameters = linkParameters(match[2] ?? "");
+        const destination = safeDestination(match[1] ?? "", baseUrl, allowedOrigins);
+        links.push({
+            href: destination.url,
+            destination_scope: destination.scope,
+            rel: (parameters.get("rel") ?? "")
+                .toLowerCase()
+                .split(/\s+/u)
+                .filter(Boolean),
+            as: boundedHeader(parameters.get("as")),
+            type: boundedHeader(parameters.get("type")),
+            crossorigin: boundedHeader(parameters.get("crossorigin")),
+        });
+    }
+    return links;
+};
+const splitLinkHeader = (value, delimiter = ",") => {
+    const entries = [];
+    let start = 0;
+    let quoted = false;
+    let escaped = false;
+    let target = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (quoted) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === '"')
+                quoted = false;
+            continue;
+        }
+        if (character === '"' && !target)
+            quoted = true;
+        else if (delimiter === "," && character === "<")
+            target = true;
+        else if (delimiter === "," && character === ">")
+            target = false;
+        else if (character === delimiter && !target) {
+            entries.push(value.slice(start, index));
+            start = index + 1;
+        }
+    }
+    entries.push(value.slice(start));
+    return entries;
+};
+const linkParameters = (value) => {
+    const parameters = new Map();
+    for (const raw of splitLinkHeader(value, ";").slice(1)) {
+        const separator = raw.indexOf("=");
+        const name = (separator < 0 ? raw : raw.slice(0, separator))
+            .trim()
+            .toLowerCase();
+        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));
+    }
+    return parameters;
+};
+const safeDestination = (value, baseUrl, allowedOrigins) => {
+    try {
+        const parsed = new URL(value, baseUrl);
+        const sanitized = sanitizeBrowserUrl(parsed.href).url;
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+            return { url: sanitized, scope: "unsupported" };
+        if (!allowedOrigins.has(parsed.origin))
+            return { url: sanitized, scope: "outside_policy" };
+        return { url: sanitized, scope: "approved" };
+    }
+    catch (cause) {
+        // Unparseable link values keep their raw text for the analyst.
+        void cause;
+        return { url: value, scope: "unsupported" };
+    }
+};
+const permissionFeatures = (value) => [
+    ...new Set((value ?? "")
+        .split(",")
+        .map((entry) => entry.split("=", 1)[0]?.trim().toLowerCase() ?? "")
+        .filter((feature) => /^[a-z][a-z0-9\x2d]*$/u.test(feature))),
+].sort();
+const wellKnownHint = (url) => {
+    try {
+        const path = new URL(url).pathname.toLowerCase();
+        return wellKnownAgentPaths.has(path)
+            ? [agentHint("well_known_resource", path, sanitizeBrowserUrl(url).url)]
+            : [];
+    }
+    catch (cause) {
+        // Non-URL input yields no well-known hint.
+        void cause;
+        return [];
+    }
+};
+const agentHint = (mechanism, declaration, url) => ({
+    mechanism,
+    declaration,
+    url,
+    trust: "page-declared-untrusted",
+});
+const isAgentRel = (value) => ["mcp", "model-context", "ai-plugin", "service-desc"].includes(value);
+const referrerPolicies = new Set([
+    "no-referrer",
+    "no-referrer-when-downgrade",
+    "same-origin",
+    "origin",
+    "strict-origin",
+    "origin-when-cross-origin",
+    "strict-origin-when-cross-origin",
+    "unsafe-url",
+]);
+const referrerPolicy = (value) => {
+    let policy = null;
+    for (const raw of (value ?? "").split(",")) {
+        const token = raw.trim().toLowerCase();
+        if (token === "")
+            continue;
+        if (!/^[a-z\x2d]+$/u.test(token))
+            return null;
+        if (referrerPolicies.has(token))
+            policy = token;
+    }
+    return policy;
+};
+const policyToken = (value) => {
+    const token = (value ?? "").trim().toLowerCase();
+    return /^[a-z][a-z0-9_.\x2d]*$/u.test(token) ? token : null;
+};
+const nonnegativeInteger = (value) => {
+    const number = numberValue(value === undefined ? undefined : Number(value));
+    return number === undefined ? null : Math.max(0, Math.trunc(number));
+};
+const boundedHeader = (value) => value === undefined ? null : value.trim().toLowerCase();
+const unquote = (value) => value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+const agentHeaderNames = ["x-model-context", "x-webmcp", "mcp-server"];
+const wellKnownAgentPaths = new Set([
+    "/.well-known/ai-plugin.json",
+    "/.well-known/mcp",
+    "/.well-known/model-context",
+]);

package/dist/browser/CdpScreenshot.js

@@ -0,0 +1,110 @@
+import { createWebScreenshotArtifact } from "../domain/webScreenshot.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { isMainFrameNavigation } from "./CdpCaptureEventHelpers.js";
+import { allowedSanitizedUrl, recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
+import { mainFrameUrl } from "./CdpCaptureDocuments.js";
+import { captureFrames } from "./CdpCaptureDocuments.js";
+import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
+import { decodeCanonicalBase64 } from "../domain/webScreenshot.js";
+/** Capture the current viewport without navigation, evaluation, or page mutation. */
+export const captureCdpScreenshot = async (context) => {
+    const origins = new Set(context.input.allowed_origins);
+    await context.progress?.report({
+        phase: "browser_observation",
+        completed: 1,
+        total: 2,
+        message: "Authorizing current screenshot frame",
+    });
+    await context.connection.send("Page.enable", {}, context.sessionId, context.signal);
+    const before = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
+    const beforeUrl = mainFrameUrl(before);
+    const authorized = allowedSanitizedUrl(beforeUrl, origins);
+    const mainFrame = captureFrames(before, origins, 1).items[0];
+    if (authorized === undefined || mainFrame === undefined)
+        throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
+    const initialFrame = recordValue(recordValue(recordValue(before)?.frameTree)?.frame);
+    const navigation = {
+        changed: false,
+        leftScope: false,
+        url: beforeUrl,
+        loaderId: cdpStringValue(initialFrame?.loaderId),
+    };
+    const removeListener = context.connection.onEvent((event) => {
+        if (event.sessionId !== context.sessionId)
+            return;
+        observeScreenshotNavigation(event, mainFrame.frame_id, origins, navigation);
+    });
+    let result;
+    let after;
+    try {
+        result = recordValue(await context.connection.send("Page.captureScreenshot", { format: "png", fromSurface: true, captureBeyondViewport: false }, context.sessionId, context.signal));
+        after = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
+    }
+    finally {
+        removeListener();
+    }
+    const encoded = cdpStringValue(result?.data);
+    const bytes = encoded === undefined ? undefined : decodeCanonicalBase64(encoded);
+    if (bytes === undefined)
+        throw new BrowserObservationError("inspect_web_page", "payload_limit");
+    const dimensions = pngDimensions(bytes);
+    if (navigation.leftScope)
+        throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
+    const afterUrl = mainFrameUrl(after);
+    if (navigation.changed ||
+        afterUrl !== beforeUrl ||
+        allowedSanitizedUrl(afterUrl, origins) === undefined)
+        throw new BrowserObservationError("inspect_web_page", "target_changed");
+    await context.progress?.report({
+        phase: "browser_observation",
+        completed: 2,
+        total: 2,
+        message: "Screenshot capture complete",
+        terminal: true,
+    });
+    return {
+        browser: context.discovery.version,
+        target: {
+            target_id: context.target.id,
+            url: authorized.url,
+            origin: authorized.origin ?? "",
+        },
+        captured_at: new Date().toISOString(),
+        viewport: dimensions,
+        artifact: createWebScreenshotArtifact(bytes),
+        completeness: new CdpCaptureCompleteness().snapshot(),
+        limitations: [
+            "The screenshot contains the visible viewport, including on-screen content.",
+            "REA does not scroll, evaluate JavaScript, or capture beyond the current viewport.",
+        ],
+    };
+};
+const observeScreenshotNavigation = (event, mainFrameId, origins, state) => {
+    if (!isMainFrameNavigation(event, mainFrameId))
+        return;
+    const params = recordValue(event.params);
+    if (params === undefined)
+        return;
+    const frame = event.method === "Page.frameNavigated" ? recordValue(params.frame) : params;
+    if (event.method === "Page.frameNavigated" &&
+        state.loaderId !== undefined &&
+        state.loaderId !== "" &&
+        cdpStringValue(frame?.loaderId) === state.loaderId &&
+        cdpStringValue(frame?.url) === state.url)
+        return;
+    state.changed = true;
+    if (allowedSanitizedUrl(frame?.url, origins) === undefined)
+        state.leftScope = true;
+};
+const pngDimensions = (bytes) => {
+    if (bytes.byteLength < 24 ||
+        !bytes.subarray(0, 8).equals(PNG_SIGNATURE) ||
+        bytes.subarray(12, 16).toString("ascii") !== "IHDR")
+        throw new BrowserObservationError("inspect_web_page", "protocol_error");
+    const width = bytes.readUInt32BE(16);
+    const height = bytes.readUInt32BE(20);
+    if (width === 0 || height === 0)
+        throw new BrowserObservationError("inspect_web_page", "protocol_error");
+    return { width, height };
+};
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);

package/dist/browser/CdpTargetEvents.js

@@ -0,0 +1,8 @@
+import { cdpStringValue, recordValue } from "./CdpCaptureValues.js";
+/** Match ordinary session envelopes and root detachment's parameter-scoped session identity. */
+export const cdpTargetEventMatches = (event, sessionId) => {
+    if (event.method !== "Target.detachedFromTarget")
+        return event.sessionId === sessionId;
+    return (sessionId !== undefined &&
+        cdpStringValue(recordValue(event.params)?.sessionId) === sessionId);
+};

package/dist/browser/CdpTargetSession.js

@@ -0,0 +1,65 @@
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { CdpConnection } from "./CdpConnection.js";
+import { cdpTargetWebSocket, } from "./CdpEndpoint.js";
+/** Open one authorized target through its supported browser or page transport. */
+export const openCdpTargetSession = async (discovery, target, operation, signal, limits) => {
+    const webSocket = cdpTargetWebSocket(discovery, target, operation);
+    const connection = await CdpConnection.connect(webSocket.url, operation, signal, limits);
+    if (webSocket.scope === "page")
+        return { connection, sessionId: undefined };
+    try {
+        const attached = await connection.send("Target.attachToTarget", { targetId: target.id, flatten: true }, undefined, signal);
+        return { connection, sessionId: attachedSessionId(attached, operation) };
+    }
+    catch (cause) {
+        await connection.close();
+        throw cause;
+    }
+};
+/** Disable enabled domains, detach browser sessions, and close REA's socket. */
+export const closeCdpTargetSession = async (targetSession, enabledDomains, signal) => {
+    const { connection, sessionId } = targetSession;
+    const cleanup = new AbortController();
+    const domainSignal = signal === undefined
+        ? cleanup.signal
+        : AbortSignal.any([cleanup.signal, signal]);
+    const timeout = setTimeout(() => cleanup.abort(), 1_000);
+    timeout.unref();
+    try {
+        if (signal?.aborted !== true) {
+            for (const domain of enabledDomains) {
+                if (domainSignal.aborted)
+                    break;
+                try {
+                    await connection.send(`${domain}.disable`, {}, sessionId, domainSignal);
+                }
+                catch {
+                    // Best-effort domain cleanup; transport close is the definitive boundary.
+                }
+            }
+        }
+        // Cancellation skips optional domain shutdown but still releases the
+        // attached session using its independent, bounded cleanup signal.
+        if (!cleanup.signal.aborted && sessionId !== undefined)
+            try {
+                await connection.send("Target.detachFromTarget", { sessionId }, undefined, cleanup.signal);
+            }
+            catch {
+                // Best-effort detach; transport close is the definitive boundary.
+            }
+    }
+    finally {
+        clearTimeout(timeout);
+        cleanup.abort();
+        await connection.close();
+    }
+};
+const attachedSessionId = (value, operation) => {
+    if (typeof value !== "object" ||
+        value === null ||
+        !("sessionId" in value) ||
+        typeof value.sessionId !== "string" ||
+        value.sessionId.length === 0)
+        throw new BrowserObservationError(operation, "protocol_error");
+    return value.sessionId;
+};