opendevbrowser 0.0.15 → 0.0.16

package/dist/tools/workflow-runtime.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderExecutor } from "../providers";
+import type { ToolDeps } from "./deps";
+export declare const resolveProviderRuntime: (deps: ToolDeps) => ProviderExecutor;
+//# sourceMappingURL=workflow-runtime.d.ts.map

package/dist/tools/workflow-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-runtime.d.ts","sourceRoot":"","sources":["../../src/tools/workflow-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC,eAAO,MAAM,sBAAsB,GAAI,MAAM,QAAQ,KAAG,gBAUvD,CAAC"}

package/dist/utils/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function generateSecureToken(): string;
+//# sourceMappingURL=crypto.d.ts.map

package/dist/utils/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/utils/crypto.ts"],"names":[],"mappings":"AAEA,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}

package/dist/utils/endpoint-validation.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureLocalEndpoint(endpoint: string, allowNonLocal: boolean): void;
+//# sourceMappingURL=endpoint-validation.d.ts.map

package/dist/utils/endpoint-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-validation.d.ts","sourceRoot":"","sources":["../../src/utils/endpoint-validation.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI,CAqBlF"}

package/dist/utils/fs.d.ts

@@ -0,0 +1,5 @@
+export declare function writeFileAtomic(filePath: string, content: string, options?: {
+    encoding?: BufferEncoding;
+    mode?: number;
+}): void;
+//# sourceMappingURL=fs.d.ts.map

package/dist/utils/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../src/utils/fs.ts"],"names":[],"mappings":"AAIA,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,cAAc,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACzD,IAAI,CA2BN"}

package/dist/utils/hub-enabled.d.ts

@@ -0,0 +1,3 @@
+import type { OpenDevBrowserConfig } from "../config";
+export declare const isHubEnabled: (config: OpenDevBrowserConfig) => boolean;
+//# sourceMappingURL=hub-enabled.d.ts.map

package/dist/utils/hub-enabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-enabled.d.ts","sourceRoot":"","sources":["../../src/utils/hub-enabled.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD,eAAO,MAAM,YAAY,GAAI,QAAQ,oBAAoB,KAAG,OAE3D,CAAC"}

package/extension/dist/background.js

@@ -31,6 +31,8 @@ const ANNOTATION_MAX_PAYLOAD_BYTES = 10 * 1024 * 1024;
 const ANNOTATION_REQUEST_TIMEOUT_MS = 120_000;
 const LAST_ANNOTATION_META_KEY = "annotationLastMeta";
 const LAST_ANNOTATION_PAYLOAD_KEY = "annotationLastPayloadSansScreenshots";
+const BADGE_CONNECTED_DOT_COLOR = "#16a34a";
+const BADGE_DISCONNECTED_DOT_COLOR = "#dc2626";
 const annotationSessions = new Map();
 let lastAnnotationFull = null;
 connection.onAnnotationCommand((command) => {
@@ -53,10 +55,14 @@ const RESTRICTED_PROTOCOLS = new Set([
 ]);
 const updateBadge = (status) => {
     const isConnected = status === "connected";
-    chrome.action.setBadgeText({ text: isConnected ? "ON" : "OFF" });
-    chrome.action.setBadgeBackgroundColor({
-        color: isConnected ? "#20d5c6" : "#5b667a"
-    });
+    const dotColor = isConnected ? BADGE_CONNECTED_DOT_COLOR : BADGE_DISCONNECTED_DOT_COLOR;
+    chrome.action.setBadgeText({ text: "●" });
+    if (typeof chrome.action.setBadgeTextColor === "function") {
+        chrome.action.setBadgeTextColor({ color: dotColor });
+        chrome.action.setBadgeBackgroundColor({ color: [0, 0, 0, 0] });
+        return;
+    }
+    chrome.action.setBadgeBackgroundColor({ color: dotColor });
 };
 const getEffectiveStatus = () => {
     if (connection.getStatus() === "connected") {

package/extension/dist/ops/ops-runtime.js

@@ -5,12 +5,40 @@ import { logError } from "../logging.js";
 import { DomBridge } from "./dom-bridge.js";
 import { buildSnapshot } from "./snapshot-builder.js";
 import { OpsSessionStore } from "./ops-session-store.js";
+import { DEFAULT_OPS_PARALLELISM_POLICY, evaluateOpsGovernor } from "./parallelism-governor.js";
 import { redactConsoleText, redactUrl } from "./redaction.js";
 const MAX_CONSOLE_EVENTS = 200;
 const MAX_NETWORK_EVENTS = 300;
 const SESSION_TTL_MS = 20_000;
 const SCREENSHOT_TIMEOUT_MS = 8000;
 const TAB_CLOSE_TIMEOUT_MS = 5000;
+const TARGET_SCOPED_COMMANDS = new Set([
+    "storage.setCookies",
+    "storage.getCookies",
+    "nav.goto",
+    "nav.wait",
+    "nav.snapshot",
+    "interact.click",
+    "interact.hover",
+    "interact.press",
+    "interact.check",
+    "interact.uncheck",
+    "interact.type",
+    "interact.select",
+    "interact.scroll",
+    "interact.scrollIntoView",
+    "dom.getHtml",
+    "dom.getText",
+    "dom.getAttr",
+    "dom.getValue",
+    "dom.isVisible",
+    "dom.isEnabled",
+    "dom.isChecked",
+    "export.clonePage",
+    "export.cloneComponent",
+    "devtools.perf",
+    "page.screenshot"
+]);
 export class OpsRuntime {
     sendEnvelope;
     cdp;
@@ -19,10 +47,12 @@ export class OpsRuntime {
     sessions = new OpsSessionStore();
     encoder = new TextEncoder();
     closingTimers = new Map();
+    parallelWaiters = new Map();
     constructor(options) {
         this.sendEnvelope = options.send;
         this.cdp = options.cdp;
         chrome.tabs.onRemoved.addListener(this.handleTabRemoved);
+        chrome.tabs.onUpdated.addListener(this.handleTabUpdated);
         chrome.debugger.onEvent.addListener(this.handleDebuggerEvent);
         chrome.debugger.onDetach.addListener(this.handleDebuggerDetach);
     }
@@ -95,6 +125,19 @@ export class OpsRuntime {
     handleTabRemoved = (tabId) => {
         this.handleClosedTarget(tabId, "ops_tab_closed");
     };
+    handleTabUpdated = (tabId, changeInfo, tab) => {
+        const session = this.sessions.getByTabId(tabId);
+        if (!session)
+            return;
+        if (changeInfo.discarded === true || tab.discarded === true) {
+            session.discardedSignals += 1;
+        }
+        const frozenChange = changeInfo.frozen === true;
+        const frozenTab = tab.frozen === true;
+        if (frozenChange || frozenTab) {
+            session.frozenSignals += 1;
+        }
+    };
     handleDebuggerDetach = (source) => {
         if (typeof source.tabId !== "number")
             return;
@@ -197,6 +240,12 @@ export class OpsRuntime {
             case "session.status":
                 await this.handleSessionStatus(message, clientId);
                 return;
+            case "storage.setCookies":
+                await this.withSession(message, clientId, (session) => this.handleStorageSetCookies(message, session));
+                return;
+            case "storage.getCookies":
+                await this.withSession(message, clientId, (session) => this.handleStorageGetCookies(message, session));
+                return;
             case "targets.list":
                 await this.withSession(message, clientId, (session) => this.handleTargetsList(message, session));
                 return;
@@ -299,6 +348,7 @@ export class OpsRuntime {
     }
     async handleSessionLaunch(message, clientId) {
         const payload = isRecord(message.payload) ? message.payload : {};
+        const parallelismPolicy = parseParallelismPolicy(payload.parallelismPolicy);
         const startUrl = typeof payload.startUrl === "string" ? payload.startUrl : undefined;
         if (startUrl) {
             try {
@@ -342,6 +392,8 @@ export class OpsRuntime {
         const session = this.sessions.createSession(clientId, activeTab.id, leaseId, {
             url: activeTab.url ?? undefined,
             title: activeTab.title ?? undefined
+        }, {
+            parallelismPolicy
         });
         await this.enableSessionDomains(session);
         this.sendEvent({
@@ -925,6 +977,90 @@ export class OpsRuntime {
         const nextSeq = lastEvent ? lastEvent.seq : sinceSeq;
         this.sendResponse(message, { events, nextSeq });
     }
+    async handleStorageSetCookies(message, session) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const cookies = Array.isArray(payload.cookies) ? payload.cookies : null;
+        if (!cookies) {
+            this.sendError(message, buildError("invalid_request", "Missing cookies", false));
+            return;
+        }
+        const strict = payload.strict !== false;
+        const requestId = typeof payload.requestId === "string" && payload.requestId.trim().length > 0
+            ? payload.requestId
+            : createId();
+        const normalized = [];
+        const rejected = [];
+        cookies.forEach((entry, index) => {
+            if (!isRecord(entry)) {
+                rejected.push({ index, reason: "Invalid cookie entry: expected object." });
+                return;
+            }
+            const validation = validateCookieRecord(entry);
+            if (!validation.valid) {
+                rejected.push({ index, reason: validation.reason });
+                return;
+            }
+            normalized.push(validation.cookie);
+        });
+        if (strict && rejected.length > 0) {
+            this.sendError(message, buildError("invalid_request", `Cookie import rejected ${rejected.length} entries.`, false));
+            return;
+        }
+        if (normalized.length > 0) {
+            const target = this.requireActiveTarget(session, message);
+            if (!target)
+                return;
+            try {
+                await this.cdp.sendCommand({ tabId: target.tabId }, "Network.setCookies", { cookies: normalized });
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : "Cookie import failed";
+                this.sendError(message, buildError("execution_failed", detail, false));
+                return;
+            }
+        }
+        this.sendResponse(message, {
+            requestId,
+            imported: normalized.length,
+            rejected
+        });
+    }
+    async handleStorageGetCookies(message, session) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const requestId = typeof payload.requestId === "string" && payload.requestId.trim().length > 0
+            ? payload.requestId
+            : createId();
+        let urls;
+        try {
+            urls = parseCookieFilterUrls(payload.urls);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : "Invalid cookie url filter.";
+            this.sendError(message, buildError("invalid_request", detail, false));
+            return;
+        }
+        const target = this.requireActiveTarget(session, message);
+        if (!target)
+            return;
+        let rawCookies = [];
+        try {
+            const response = await this.cdp.sendCommand({ tabId: target.tabId }, "Network.getCookies", urls ? { urls } : {});
+            rawCookies = Array.isArray(response.cookies) ? response.cookies : [];
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : "Cookie list failed";
+            this.sendError(message, buildError("execution_failed", detail, false));
+            return;
+        }
+        const cookies = rawCookies
+            .map((entry) => toCookieListRecord(entry))
+            .filter((entry) => entry !== null);
+        this.sendResponse(message, {
+            requestId,
+            cookies,
+            count: cookies.length
+        });
+    }
     async enableSessionDomains(session) {
         try {
             await this.cdp.sendCommand({ tabId: session.tabId }, "Runtime.enable", {});
@@ -939,8 +1075,175 @@ export class OpsRuntime {
         const session = this.getSessionForMessage(message, clientId);
         if (!session)
             return;
-        session.queue = session.queue.then(() => handler(session), () => handler(session));
-        await session.queue;
+        if (!TARGET_SCOPED_COMMANDS.has(message.command)) {
+            session.queue = session.queue.then(() => handler(session), () => handler(session));
+            await session.queue;
+            return;
+        }
+        try {
+            await this.withTargetQueue(message, session, handler);
+        }
+        catch (error) {
+            if (isParallelismBackpressureError(error)) {
+                this.sendError(message, buildError("parallelism_backpressure", error.message, true, error.details));
+                return;
+            }
+            throw error;
+        }
+    }
+    resolveTargetIdForQueue(session, message) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        const requested = typeof payload.targetId === "string" ? payload.targetId.trim() : "";
+        return requested || session.activeTargetId || session.targetId;
+    }
+    sessionQueueAgeMs(session) {
+        let oldest = null;
+        for (const value of session.targetQueueOldestAt.values()) {
+            if (oldest === null || value < oldest) {
+                oldest = value;
+            }
+        }
+        return oldest === null ? 0 : Math.max(0, Date.now() - oldest);
+    }
+    sampleParallelism(session) {
+        const now = Date.now();
+        const policy = session.parallelismPolicy;
+        if (session.parallelismState.lastSampleAt > 0
+            && now - session.parallelismState.lastSampleAt < policy.sampleIntervalMs) {
+            return {
+                state: session.parallelismState,
+                pressure: session.parallelismState.lastPressure,
+                targetCap: session.parallelismState.effectiveCap,
+                waitQueueDepth: session.pendingParallel,
+                waitQueueAgeMs: this.sessionQueueAgeMs(session)
+            };
+        }
+        const snapshot = evaluateOpsGovernor(policy, session.parallelismState, {
+            hostFreeMemPct: 100,
+            rssUsagePct: 0,
+            queueAgeMs: this.sessionQueueAgeMs(session),
+            queueDepth: session.pendingParallel,
+            discardedSignals: session.discardedSignals,
+            frozenSignals: session.frozenSignals
+        }, now);
+        session.parallelismState = snapshot.state;
+        session.discardedSignals = 0;
+        session.frozenSignals = 0;
+        return snapshot;
+    }
+    wakeParallelWaiters(session) {
+        const waiters = this.parallelWaiters.get(session.id);
+        if (!waiters || waiters.length === 0) {
+            return;
+        }
+        this.sampleParallelism(session);
+        while (waiters.length > 0 && session.parallelInFlight < session.parallelismState.effectiveCap) {
+            const waiter = waiters.shift();
+            if (!waiter)
+                break;
+            if (waiter.timer !== null) {
+                clearTimeout(waiter.timer);
+                waiter.timer = null;
+            }
+            session.parallelInFlight += 1;
+            waiter.resolve();
+        }
+        if (waiters.length === 0) {
+            this.parallelWaiters.delete(session.id);
+        }
+    }
+    createParallelismBackpressureError(session, targetId, timeoutMs) {
+        const snapshot = this.sampleParallelism(session);
+        const details = {
+            sessionId: session.id,
+            targetId,
+            effectiveParallelCap: session.parallelismState.effectiveCap,
+            inFlight: session.parallelInFlight,
+            waitQueueDepth: snapshot.waitQueueDepth,
+            waitQueueAgeMs: snapshot.waitQueueAgeMs,
+            pressure: snapshot.pressure,
+            timeoutMs
+        };
+        const error = new Error(`Parallelism cap reached for target ${targetId}; retry later.`);
+        error.code = "parallelism_backpressure";
+        error.details = details;
+        return error;
+    }
+    async acquireParallelSlot(session, targetId, timeoutMs) {
+        const waiters = this.parallelWaiters.get(session.id) ?? [];
+        this.parallelWaiters.set(session.id, waiters);
+        this.sampleParallelism(session);
+        if (session.parallelInFlight < session.parallelismState.effectiveCap && waiters.length === 0) {
+            session.parallelInFlight += 1;
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            const waiter = {
+                targetId,
+                enqueuedAt: Date.now(),
+                timeoutMs,
+                resolve,
+                reject,
+                timer: null
+            };
+            waiter.timer = setTimeout(() => {
+                const index = waiters.indexOf(waiter);
+                if (index >= 0) {
+                    waiters.splice(index, 1);
+                }
+                if (waiters.length === 0) {
+                    this.parallelWaiters.delete(session.id);
+                }
+                reject(this.createParallelismBackpressureError(session, targetId, timeoutMs));
+            }, timeoutMs);
+            waiters.push(waiter);
+            this.wakeParallelWaiters(session);
+        });
+    }
+    releaseParallelSlot(session) {
+        session.parallelInFlight = Math.max(0, session.parallelInFlight - 1);
+        this.wakeParallelWaiters(session);
+    }
+    async withTargetQueue(message, session, handler) {
+        const targetId = this.resolveTargetIdForQueue(session, message);
+        const enqueuedAt = Date.now();
+        const previous = session.targetQueues.get(targetId) ?? Promise.resolve();
+        let releaseQueue = () => { };
+        const gate = new Promise((resolve) => {
+            releaseQueue = resolve;
+        });
+        const tail = previous.then(() => gate, () => gate);
+        session.targetQueues.set(targetId, tail);
+        session.pendingParallel += 1;
+        session.targetQueueDepth.set(targetId, (session.targetQueueDepth.get(targetId) ?? 0) + 1);
+        if (!session.targetQueueOldestAt.has(targetId)) {
+            session.targetQueueOldestAt.set(targetId, enqueuedAt);
+        }
+        await previous;
+        let acquired = false;
+        try {
+            await this.acquireParallelSlot(session, targetId, session.parallelismPolicy.backpressureTimeoutMs);
+            acquired = true;
+            await handler(session);
+        }
+        finally {
+            if (acquired) {
+                this.releaseParallelSlot(session);
+            }
+            releaseQueue();
+            const depth = (session.targetQueueDepth.get(targetId) ?? 1) - 1;
+            if (depth <= 0) {
+                session.targetQueueDepth.delete(targetId);
+                session.targetQueueOldestAt.delete(targetId);
+            }
+            else {
+                session.targetQueueDepth.set(targetId, depth);
+            }
+            session.pendingParallel = Math.max(0, session.pendingParallel - 1);
+            if (session.targetQueues.get(targetId) === tail) {
+                session.targetQueues.delete(targetId);
+            }
+        }
     }
     getSessionForMessage(message, clientId) {
         const opsSessionId = message.opsSessionId;
@@ -974,8 +1277,15 @@ export class OpsRuntime {
         session.lastUsedAt = Date.now();
         return session;
     }
+    requestedTargetId(session, message) {
+        const payload = isRecord(message.payload) ? message.payload : {};
+        if (typeof payload.targetId === "string" && payload.targetId.trim().length > 0) {
+            return payload.targetId.trim();
+        }
+        return session.activeTargetId || null;
+    }
     requireActiveTarget(session, message) {
-        const targetId = session.activeTargetId;
+        const targetId = this.requestedTargetId(session, message);
         if (!targetId) {
             this.sendError(message, buildError("invalid_request", "No active target", false));
             return null;
@@ -1002,7 +1312,12 @@ export class OpsRuntime {
             this.sendError(message, buildError("invalid_request", "Missing ref", false));
             return null;
         }
-        const entry = session.refStore.resolve(session.activeTargetId, ref);
+        const targetId = this.requestedTargetId(session, message);
+        if (!targetId) {
+            this.sendError(message, buildError("invalid_request", "No active target", false));
+            return null;
+        }
+        const entry = session.refStore.resolve(targetId, ref);
         if (!entry) {
             this.sendError(message, buildError("invalid_request", `Unknown ref: ${ref}`, false));
             return null;
@@ -1025,6 +1340,17 @@ export class OpsRuntime {
     }
     cleanupSession(session, event) {
         this.clearClosingTimer(session.id);
+        const waiters = this.parallelWaiters.get(session.id);
+        if (waiters) {
+            for (const waiter of waiters) {
+                if (waiter.timer !== null) {
+                    clearTimeout(waiter.timer);
+                    waiter.timer = null;
+                }
+                waiter.reject(new Error("Ops session closed while waiting for parallelism slot."));
+            }
+            this.parallelWaiters.delete(session.id);
+        }
         this.sessions.delete(session.id);
         for (const target of session.targets.values()) {
             void this.cdp.detachTab(target.tabId).catch(() => undefined);
@@ -1185,12 +1511,188 @@ export class OpsRuntime {
         });
     }
 }
+const numberInRange = (value, fallback, min, max) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, value));
+};
+const parseParallelismPolicy = (value) => {
+    if (!isRecord(value)) {
+        return DEFAULT_OPS_PARALLELISM_POLICY;
+    }
+    const modeCapsInput = isRecord(value.modeCaps) ? value.modeCaps : {};
+    return {
+        floor: numberInRange(value.floor, DEFAULT_OPS_PARALLELISM_POLICY.floor, 1, 32),
+        backpressureTimeoutMs: numberInRange(value.backpressureTimeoutMs, DEFAULT_OPS_PARALLELISM_POLICY.backpressureTimeoutMs, 100, 120000),
+        sampleIntervalMs: numberInRange(value.sampleIntervalMs, DEFAULT_OPS_PARALLELISM_POLICY.sampleIntervalMs, 250, 60000),
+        recoveryStableWindows: numberInRange(value.recoveryStableWindows, DEFAULT_OPS_PARALLELISM_POLICY.recoveryStableWindows, 1, 20),
+        hostFreeMemMediumPct: numberInRange(value.hostFreeMemMediumPct, DEFAULT_OPS_PARALLELISM_POLICY.hostFreeMemMediumPct, 1, 99),
+        hostFreeMemHighPct: numberInRange(value.hostFreeMemHighPct, DEFAULT_OPS_PARALLELISM_POLICY.hostFreeMemHighPct, 1, 99),
+        hostFreeMemCriticalPct: numberInRange(value.hostFreeMemCriticalPct, DEFAULT_OPS_PARALLELISM_POLICY.hostFreeMemCriticalPct, 1, 99),
+        rssBudgetMb: numberInRange(value.rssBudgetMb, DEFAULT_OPS_PARALLELISM_POLICY.rssBudgetMb, 64, 65536),
+        rssSoftPct: numberInRange(value.rssSoftPct, DEFAULT_OPS_PARALLELISM_POLICY.rssSoftPct, 1, 99),
+        rssHighPct: numberInRange(value.rssHighPct, DEFAULT_OPS_PARALLELISM_POLICY.rssHighPct, 1, 99),
+        rssCriticalPct: numberInRange(value.rssCriticalPct, DEFAULT_OPS_PARALLELISM_POLICY.rssCriticalPct, 1, 99),
+        queueAgeHighMs: numberInRange(value.queueAgeHighMs, DEFAULT_OPS_PARALLELISM_POLICY.queueAgeHighMs, 100, 120000),
+        queueAgeCriticalMs: numberInRange(value.queueAgeCriticalMs, DEFAULT_OPS_PARALLELISM_POLICY.queueAgeCriticalMs, 100, 120000),
+        modeCaps: {
+            managedHeaded: numberInRange(modeCapsInput.managedHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.managedHeaded, 1, 64),
+            managedHeadless: numberInRange(modeCapsInput.managedHeadless, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.managedHeadless, 1, 64),
+            cdpConnectHeaded: numberInRange(modeCapsInput.cdpConnectHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.cdpConnectHeaded, 1, 64),
+            cdpConnectHeadless: numberInRange(modeCapsInput.cdpConnectHeadless, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.cdpConnectHeadless, 1, 64),
+            extensionOpsHeaded: numberInRange(modeCapsInput.extensionOpsHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.extensionOpsHeaded, 1, 64),
+            extensionLegacyCdpHeaded: numberInRange(modeCapsInput.extensionLegacyCdpHeaded, DEFAULT_OPS_PARALLELISM_POLICY.modeCaps.extensionLegacyCdpHeaded, 1, 64)
+        }
+    };
+};
+const isParallelismBackpressureError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const typed = error;
+    return typed.code === "parallelism_backpressure" && typeof typed.details === "object" && typed.details !== null;
+};
 const buildError = (code, message, retryable, details) => ({
     code,
     message,
     retryable,
     details
 });
+const validateCookieRecord = (cookie) => {
+    const name = cookie.name?.trim();
+    if (!name) {
+        return { valid: false, reason: "Cookie name is required.", cookie };
+    }
+    if (!/^[^\s;=]+$/.test(name)) {
+        return { valid: false, reason: `Invalid cookie name: ${cookie.name}.`, cookie };
+    }
+    if (typeof cookie.value !== "string" || /\r|\n|;/.test(cookie.value)) {
+        return { valid: false, reason: `Invalid cookie value for ${name}.`, cookie };
+    }
+    const hasUrl = typeof cookie.url === "string" && cookie.url.trim().length > 0;
+    const hasDomain = typeof cookie.domain === "string" && cookie.domain.trim().length > 0;
+    if (!hasUrl && !hasDomain) {
+        return { valid: false, reason: `Cookie ${name} requires url or domain.`, cookie };
+    }
+    let normalizedUrl;
+    if (hasUrl) {
+        try {
+            const parsedUrl = new URL(cookie.url);
+            if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+                return { valid: false, reason: `Cookie ${name} url must be http(s).`, cookie };
+            }
+            normalizedUrl = parsedUrl.toString();
+        }
+        catch {
+            return { valid: false, reason: `Cookie ${name} has invalid url.`, cookie };
+        }
+    }
+    let normalizedDomain;
+    if (hasDomain) {
+        normalizedDomain = String(cookie.domain).trim().toLowerCase();
+        if (!/^\.?[a-z0-9.-]+$/.test(normalizedDomain) || normalizedDomain.includes("..")) {
+            return { valid: false, reason: `Cookie ${name} has invalid domain.`, cookie };
+        }
+    }
+    const normalizedPath = typeof cookie.path === "string" ? cookie.path.trim() : undefined;
+    if (typeof normalizedPath === "string" && !normalizedPath.startsWith("/")) {
+        return { valid: false, reason: `Cookie ${name} path must start with '/'.`, cookie };
+    }
+    if (typeof cookie.expires !== "undefined") {
+        if (!Number.isFinite(cookie.expires) || cookie.expires < -1) {
+            return { valid: false, reason: `Cookie ${name} has invalid expires.`, cookie };
+        }
+    }
+    if (cookie.sameSite === "None" && cookie.secure !== true) {
+        return { valid: false, reason: `Cookie ${name} with SameSite=None must set secure=true.`, cookie };
+    }
+    const normalizedCookie = {
+        name,
+        value: cookie.value,
+        ...(typeof cookie.expires === "number" ? { expires: cookie.expires } : {}),
+        ...(typeof cookie.httpOnly === "boolean" ? { httpOnly: cookie.httpOnly } : {}),
+        ...(typeof cookie.secure === "boolean" ? { secure: cookie.secure } : {}),
+        ...(cookie.sameSite ? { sameSite: cookie.sameSite } : {})
+    };
+    if (normalizedDomain) {
+        normalizedCookie.domain = normalizedDomain;
+        normalizedCookie.path = normalizedPath ?? "/";
+    }
+    else if (normalizedUrl) {
+        normalizedCookie.url = normalizedUrl;
+    }
+    return {
+        valid: true,
+        reason: "",
+        cookie: normalizedCookie
+    };
+};
+const parseCookieFilterUrls = (value) => {
+    if (typeof value === "undefined") {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("Cookie url filters must be an array of strings.");
+    }
+    const normalized = [];
+    const seen = new Set();
+    for (const entry of value) {
+        if (typeof entry !== "string") {
+            throw new Error("Cookie url filters must be an array of strings.");
+        }
+        const trimmed = entry.trim();
+        if (!trimmed) {
+            throw new Error("Cookie url filters must be non-empty strings.");
+        }
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(trimmed);
+        }
+        catch {
+            throw new Error(`Cookie url filter is invalid: ${trimmed}`);
+        }
+        if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+            throw new Error(`Cookie url filter must be http(s): ${trimmed}`);
+        }
+        const normalizedUrl = parsedUrl.toString();
+        if (seen.has(normalizedUrl)) {
+            continue;
+        }
+        seen.add(normalizedUrl);
+        normalized.push(normalizedUrl);
+    }
+    return normalized.length > 0 ? normalized : undefined;
+};
+const toCookieListRecord = (entry) => {
+    if (!isRecord(entry)) {
+        return null;
+    }
+    const name = typeof entry.name === "string" ? entry.name : "";
+    const value = typeof entry.value === "string" ? entry.value : "";
+    const domain = typeof entry.domain === "string" ? entry.domain : "";
+    const path = typeof entry.path === "string" ? entry.path : "";
+    const expires = typeof entry.expires === "number" && Number.isFinite(entry.expires) ? entry.expires : -1;
+    const httpOnly = entry.httpOnly === true;
+    const secure = entry.secure === true;
+    if (!name || !domain || !path) {
+        return null;
+    }
+    const sameSiteRaw = entry.sameSite;
+    const sameSite = sameSiteRaw === "Strict" || sameSiteRaw === "Lax" || sameSiteRaw === "None"
+        ? sameSiteRaw
+        : undefined;
+    return {
+        name,
+        value,
+        domain,
+        path,
+        expires,
+        httpOnly,
+        secure,
+        ...(sameSite ? { sameSite } : {})
+    };
+};
 const isRecord = (value) => {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 };