@mearl/native-host 3.0.0-beta.0 → 3.0.0-beta.10

package/dist/agent/chat-visualization.d.ts

@@ -0,0 +1,3 @@
+export declare function readChatVisualization(input: unknown, outputDirectories?: string[]): Promise<{
+    html: string;
+}>;

package/dist/agent/managed-programs.d.ts

@@ -0,0 +1,24 @@
+import { spawn } from 'node:child_process';
+import type { AgentChatStatus } from '@mearl/browser-core';
+import { type CommandRunner } from '@mearl/daemon-core';
+import type { AgentCapabilityFactory } from '../capability-hooks.js';
+import type { AgentProviderLoader } from './manager.js';
+export declare class ManagedAgentPrograms {
+    private readonly directory;
+    private readonly run;
+    private readonly spawnLogin;
+    private readonly installing;
+    private qoderLogin?;
+    constructor(directory?: string, run?: CommandRunner, spawnLogin?: typeof spawn);
+    addToExecutableSearch(env?: NodeJS.ProcessEnv): void;
+    qoderLoader(context: Parameters<AgentCapabilityFactory>[0]): (AgentProviderLoader & {
+        revision: string;
+    }) | undefined;
+    describe(status: AgentChatStatus): AgentChatStatus;
+    install(id: unknown, status: () => Promise<AgentChatStatus>): Promise<AgentChatStatus>;
+    loginQoder(onSignedIn: () => void): Promise<string | null>;
+    private startQoderLogin;
+    private installMissing;
+    private executableFiles;
+    private installPackage;
+}

package/dist/agent/manager.d.ts

@@ -2,9 +2,12 @@ import type { AgentChatEvent, AgentChatEventsOptions, AgentChatEventsResult, Age
 import { type ToolboxAgentRuntime } from '../toolbox-service.js';
 import type { AgentProvider, AgentProviderSessionOptions, AgentProviderTurnOptions } from '@mearl/agent-runtime';
 export interface AgentChatManagerDependencies {
+    installedProviders?: () => Array<AgentProviderLoader & {
+        revision: unknown;
+    }>;
     resolveToolboxAgent?: (toolId: string) => ToolboxAgentRuntime;
 }
-interface AgentProviderLoader {
+export interface AgentProviderLoader {
     id: string;
     load(): Promise<AgentProvider>;
 }
@@ -14,6 +17,9 @@ export declare class AgentChatManager {
     private readonly providers;
     private readonly providerLoaders;
     private readonly providerLoads;
+    private readonly providerOperations;
+    private readonly installedSources;
+    private readonly unavailableProviders;
     private disposed;
     private readonly sessions;
     private readonly sessionByProviderThread;
@@ -25,6 +31,8 @@ export declare class AgentChatManager {
     private readonly truncatedEventSessions;
     private readonly unsubscribe;
     private readonly taskListeners;
+    private qoderNeedsReconnect;
+    private readonly qoderSessionsToResume;
     constructor(providers: Array<AgentProvider | AgentProviderLoader>, emit: (event: AgentChatEvent) => void, dependencies?: AgentChatManagerDependencies);
     getStatus(): Promise<AgentChatStatus>;
     prepare(options: AgentChatPrepareOptions): Promise<void>;
@@ -49,11 +57,16 @@ export declare class AgentChatManager {
     private recordEvent;
     private trimReplayBuffer;
     private getProvider;
+    qoderCredentialsChanged(): void;
+    private reconnectQoderIfIdle;
     private registerProvider;
+    private withProvider;
+    private withAcceptedProvider;
+    private releaseProviderOperation;
+    private refreshInstalledProviders;
     private loadProvider;
     private getSession;
     private providerThreadKey;
     private providerRequestKey;
     private sessionTurnKey;
 }
-export {};

package/dist/agent/skill-manager.d.ts

@@ -14,6 +14,7 @@ export interface AgentSkillBackend {
     install(data: AgentSkillInstallOptions): ReturnType<SkillCliRunner>;
     installBatch?(data: SkillBackendBatchOptions): ReturnType<SkillCliRunner>;
     normalizeSource?(source: string, sourceType?: string): string;
+    readSources?: typeof readTrackedSkillSources;
     update(data: AgentSkillMutationOptions): ReturnType<SkillCliRunner>;
     uninstall(data: AgentSkillMutationOptions): ReturnType<SkillCliRunner>;
     checkUpdates(data: AgentSkillCheckUpdatesOptions): Promise<AgentSkillCheckUpdatesResult>;
@@ -35,14 +36,20 @@ export declare class AgentSkillManager {
     private backend;
     /** A preset batch keeps one accepted manager for all of its operations. */
     capture(): AgentSkillManager;
-    inspectGlobal(source: string, name: string, version?: string): SkillInstallationStatus;
+    inspectGlobal(source: string, name: string, version?: string, migrateFrom?: readonly string[]): SkillInstallationStatus;
+    hasGlobalRegistrationConflict(name: string, aliases: readonly string[]): boolean;
     repairGlobalRegistration(name: string, options?: {
         registrationManagedBy?: string;
+        replaceExisting?: boolean;
+        expectedPluginNames?: readonly string[];
     }): Promise<void>;
     install(data: AgentSkillInstallOptions): Promise<AgentSkillMutationResult>;
     installGlobal(source: string, name: string): Promise<AgentSkillMutationResult>;
     installGlobals(source: string, names: string[], options?: {
         registrationManagedBy?: string;
+        migrateFrom?: Readonly<Record<string, readonly string[]>>;
+        replaceSkills?: readonly string[];
+        expectedPluginNames?: Readonly<Record<string, readonly string[]>>;
     }): Promise<AgentSkillMutationResult>;
     private installAccepted;
     checkUpdates(data: AgentSkillCheckUpdatesOptions): Promise<AgentSkillCheckUpdatesResult>;

package/dist/app-authorization.d.ts

@@ -0,0 +1,8 @@
+export type AppAuthorizationProgress = 'installing' | 'connected' | 'authorizing';
+export declare function startAppAuthorization(hook: string, value: unknown, progress?: (phase: AppAuthorizationProgress) => void): Promise<{
+    browserId: string;
+    qrSvg: string;
+}>;
+export declare function waitAppAuthorization(browserId: string, value: unknown, progress?: (phase: AppAuthorizationProgress) => void): Promise<Record<string, unknown>>;
+export declare function closeAppAuthorization(browserId: string): Promise<void>;
+export declare function closeAppAuthorizations(): Promise<void>;

package/dist/app-profile-catalog.d.ts

@@ -1,7 +1,9 @@
 import { type ResolveAppProfileOptions } from '@mearl/app-profiles';
 import { type AppProfileCatalogEntry } from '@mearl/browser-core';
 export declare function findCapabilityAppProfile(id: string): AppProfileCatalogEntry | undefined;
-export declare function listInstalledAppProfiles(): Promise<{
+export declare function listInstalledAppProfiles(options?: {
+    refresh?: boolean;
+}): Promise<{
     profiles: AppProfileCatalogEntry[];
     errors: Array<{
         plugin: string;

package/dist/browser-enhancement-gateway.d.ts

@@ -0,0 +1,24 @@
+import { type BrowserEnhancementRequest, type BrowserEnhancementResponse, type ProviderEnhancementTarget } from '@mearl/browser-core';
+import type { ProviderControlHostRecord } from '@mearl/provider/host';
+import { type BrowserRecord } from './browser-registry.js';
+interface Dependencies {
+    browsers(): BrowserRecord[];
+    controlHost(): ProviderControlHostRecord | null;
+    available(): boolean;
+    run<T>(action: string, data: {
+        tabId: number;
+        [key: string]: unknown;
+    }, work: () => Promise<T>): Promise<T>;
+    tabs(deadline?: number): Promise<number[]>;
+    verifySource(provider: BrowserRecord, tabId: number, deadline?: number): Promise<ProviderEnhancementTarget>;
+    invoke(request: BrowserEnhancementRequest, deadline?: number): Promise<BrowserEnhancementResponse>;
+}
+/** Accept only the live control host's scoped RPC, never caller-supplied trust/owner flags. */
+export declare class BrowserEnhancementGateway {
+    private readonly dependencies;
+    private readonly bindings;
+    private pendingBindings;
+    constructor(dependencies: Dependencies);
+    invoke(source: unknown, proof: unknown, request: BrowserEnhancementRequest, deadline?: number, sourceIdentity?: unknown, sourceTabId?: unknown): Promise<BrowserEnhancementResponse>;
+}
+export {};

package/dist/browser-identity.d.ts

@@ -0,0 +1,11 @@
+interface BrowserIdentityProbe {
+    platform: NodeJS.Platform;
+    parentPid: number;
+    executable(pid: number): string;
+    bundleIdentifier(plist: string): string;
+}
+/** Inspect only the Native Messaging host's direct parent, never all running browsers. */
+export declare function detectNativeBrowserName(probe?: BrowserIdentityProbe): string | undefined;
+/** Cache the bounded probe across extension reconnects; keep the reported name as fallback. */
+export declare function createExtensionBrowserNameResolver(detect?: typeof detectNativeBrowserName): (reportedName: string) => string;
+export {};

package/dist/browser-registry.d.ts

@@ -51,6 +51,7 @@ export interface BrowserRecord extends DaemonRecord {
     /** Epoch ms of the last record write; latest-wins tiebreak. */
     updatedAt: number;
 }
+export declare function browserConnectionIdentity(browser: Pick<BrowserRecord, 'pid' | 'startedAt' | 'socketPath'>): string;
 export declare function initBrowserRegistry(deps: {
     log: (...args: any[]) => void;
 }): void;

package/dist/browser-socket-request.d.ts

@@ -2,4 +2,8 @@ import { type ProviderHostContextData } from '@mearl/provider';
 export declare function requestBrowserSocket(socketPath: string, action: string, data: Record<string, any>, version: string, timeoutMs?: number, browserId?: string, host?: ProviderHostContextData, routing?: {
     providerTarget?: string;
     controlSource?: string;
+    providerControlToken?: string;
+    providerSourceIdentity?: string;
+    providerPageId?: number;
+    deadline?: number;
 }): Promise<any>;

package/dist/capability-contracts.d.ts

@@ -1,66 +1,29 @@
-import type { MtopRequest, ParsedSseEvent, RumEvent, SendMtopRequestParams } from '@mearl/browser-core';
-export interface ResolvedMtopRequest {
-    api: string;
+import type { RequestCookie, RequestMetadata, ParsedSseEvent, RumEvent } from '@mearl/browser-core';
+/** Protocol-specific fields remain opaque to the HTTP host. */
+export interface ResolvedProtocolRequest {
     requestData: unknown;
-    dataStr: string;
-    version: string;
     normalizedMethod: 'GET' | 'POST';
-    appKey: string;
+    timeout: number;
     gatewayUrl: URL;
     customHeaders: Record<string, string>;
-    ttid?: string;
-    timeout: number;
-    isMopen: boolean;
+    metadata?: RequestMetadata;
+    [key: string]: unknown;
 }
-export interface PreparedSignedMtopRequest extends ResolvedMtopRequest {
+export interface PreparedProtocolRequest extends ResolvedProtocolRequest {
     targetUrl: URL;
     requestHeaders: Record<string, string>;
     cookieHeader: string;
     body?: string;
 }
-export interface MtopStreamCapture {
-    request: MtopRequest;
-    startTimeMs: number;
-    lastMessageTimeMs?: number;
-}
-export interface MtopStreamCaptureStart {
-    id: number;
-    api: string;
+export type { RequestStreamCapture as ProtocolStreamCapture, RequestStreamCaptureResponse as ProtocolStreamCaptureResponse } from '@mearl/browser-core';
+export type ProtocolStreamCaptureStart = Omit<import('@mearl/browser-core').RequestStreamCaptureStart, 'url'> & {
     url?: string;
-    method: string;
-    requestHeaders?: Array<{
-        name: string;
-        value: string;
-    }>;
-    requestData?: unknown;
-    timestampMs?: number;
-    tabId?: number;
-    captureSequence: number;
-}
-export interface MtopStreamCaptureResponse {
-    status: number;
-    statusText: string;
-    responseHeaders: Array<{
-        name: string;
-        value: string;
-    }>;
-}
-export interface MtopCapability {
-    resolveRequest(data: SendMtopRequestParams): ResolvedMtopRequest;
-    prepareRequest(resolved: ResolvedMtopRequest, cookies: Map<string, string>, stream?: boolean): PreparedSignedMtopRequest;
+};
+export interface RequestProtocolCapability {
+    resolveRequest(data: Record<string, unknown>): ResolvedProtocolRequest;
+    prepareRequest(resolved: ResolvedProtocolRequest, cookies: readonly RequestCookie[], stream?: boolean): PreparedProtocolRequest;
     parseResponse(text: string): unknown;
     consumeResponse(response: Response, onReceive: (event: ParsedSseEvent) => void | Promise<void>): Promise<unknown>;
-    createCapture(data: MtopStreamCaptureStart): MtopStreamCapture;
-    updateCapture(capture: MtopStreamCapture, response: MtopStreamCaptureResponse): void;
-    appendCapture(capture: MtopStreamCapture, data: unknown, timestampMs?: number): boolean;
-    finishCapture(capture: MtopStreamCapture, options?: {
-        timestampMs?: number;
-        error?: string;
-    }): void;
-    gateways: Array<{
-        prod: string;
-        pre: string;
-    }>;
 }
 export interface TrackingCapability {
     matches(url: string): boolean;
@@ -69,5 +32,5 @@ export interface TrackingCapability {
         now?: number;
     }): RumEvent[];
 }
-export declare function getMtopCapability(): MtopCapability;
-export declare function getTrackingCapability(): TrackingCapability | undefined;
+export declare function getRequestProtocolCapability(): RequestProtocolCapability;
+export declare function getTrackingCapability(): TrackingCapability;

package/dist/capability-hooks.d.ts

@@ -0,0 +1,42 @@
+import type { RequestCookie, AppProfileDefinition } from '@mearl/browser-core';
+import type { AgentProvider } from '@mearl/agent-runtime';
+import type { BrowserSegmentedControl, PageRuntimeBinding } from '@mearl/preset/bundles';
+import type { RequestProtocolCapability, TrackingCapability } from './capability-contracts.js';
+import type { AgentSkillBackend } from './agent/skill-manager.js';
+import type { SandboxBrowserAccessCapability, ResolvedSandboxBrowserAccess } from './sandbox-browser-access.js';
+import type { CookieCopyPlan } from './cdp-backend/cookie-transfer.js';
+import type { BuiltinBrowserLaunchOptions } from './builtin-provider-options.js';
+export interface AppCapabilityCatalog {
+    namespace: string;
+    profiles: AppProfileDefinition[];
+    bindings: Record<string, string>;
+    order?: string[];
+}
+export type AgentCapabilityFactory = (options: {
+    log(message: string): void;
+    version: string;
+}) => AgentProvider | Promise<AgentProvider>;
+/** Host-owned contracts are defined once; providers implement these contracts. */
+export interface NativeCapabilityHooks {
+    'request.protocol': () => RequestProtocolCapability;
+    'tracking.request': () => TrackingCapability;
+    'request.inspect': (input: {
+        url: string;
+        body?: string;
+    }) => unknown;
+    'app.profileCatalog': () => AppCapabilityCatalog;
+    'app.pageRuntime': (binding: PageRuntimeBinding) => string | undefined;
+    'app.defaultPageRuntime': () => PageRuntimeBinding;
+    'app.userInfo': (url: string, cookies: RequestCookie[]) => {
+        userId?: string;
+        userName?: string;
+    };
+    'browser.control': () => BrowserSegmentedControl;
+    'browser.access.capability': () => SandboxBrowserAccessCapability | null;
+    'browser.access.resolve': () => Promise<ResolvedSandboxBrowserAccess>;
+    'cookie.copyPlan': (input: BuiltinBrowserLaunchOptions['copyCookieDomains']) => CookieCopyPlan;
+    'plugins.catalog': () => unknown;
+    'skills.manager': () => AgentSkillBackend | undefined;
+    'analytics.endpoint': () => string;
+    [hook: `agent.provider.${string}`]: AgentCapabilityFactory;
+}

package/dist/cdp-backend/buffers.d.ts

@@ -1,14 +1,14 @@
-import { type MtopStreamCapture, type MtopStreamCaptureResponse, type MtopStreamCaptureStart } from '../capability-contracts.js';
+import { type ProtocolStreamCapture, type ProtocolStreamCaptureResponse, type ProtocolStreamCaptureStart } from '../capability-contracts.js';
 /**
  * In-memory circular buffers for CDP network requests, console logs, and
  * RUM/tracking events. A single CdpSession subscribes to CDP events and
  * fills these buffers; callers read from them without CDP interaction.
  */
 import { TextDecoder } from 'node:util';
-import type { MtopRequest, RumEvent, ConsoleLog, RequestBufferAccounting } from '@mearl/browser-core';
+import type { CapturedRequest, RumEvent, ConsoleLog, RequestBufferAccounting } from '@mearl/browser-core';
 import { type CaptureSequenceState, type SseEventParser } from '@mearl/browser-core';
 import type { CdpClient, CdpChildSession } from './client.js';
-interface PartialRequest extends MtopRequest {
+interface PartialRequest extends CapturedRequest {
     id: number;
     requestId: string;
     timestamp: string;
@@ -43,11 +43,11 @@ interface CdpSseStream {
     mode: 'eventsource' | 'resource' | 'fallback';
     lastMessageTimeMs?: number;
 }
-export type CdpMtopStreamCapture = MtopStreamCapture;
-export type CdpMtopStreamStart = Omit<MtopStreamCaptureStart, 'id' | 'tabId' | 'captureSequence'>;
-export type CdpMtopStreamResponse = MtopStreamCaptureResponse;
+export type CdpProtocolStreamCapture = ProtocolStreamCapture;
+export type CdpProtocolStreamStart = Omit<ProtocolStreamCaptureStart, 'id' | 'tabId' | 'captureSequence'>;
+export type CdpProtocolStreamResponse = ProtocolStreamCaptureResponse;
 export interface CdpBuffers {
-    requests: MtopRequest[];
+    requests: CapturedRequest[];
     logs: ConsoleLog[];
     events: RumEvent[];
     pending: Map<string, PartialRequest>;
@@ -61,10 +61,10 @@ export interface CdpBuffers {
     };
 }
 export declare function createBuffers(tabId?: number): CdpBuffers;
-export declare function recordCdpMtopStreamStart(buffers: CdpBuffers, data: CdpMtopStreamStart): CdpMtopStreamCapture;
-export declare function recordCdpMtopStreamResponse(buffers: CdpBuffers, capture: CdpMtopStreamCapture, response: CdpMtopStreamResponse): void;
-export declare function recordCdpMtopStreamChunk(buffers: CdpBuffers, capture: CdpMtopStreamCapture, data: unknown, timestampMs?: number): void;
-export declare function recordCdpMtopStreamEnd(buffers: CdpBuffers, capture: CdpMtopStreamCapture, options?: {
+export declare function recordCdpProtocolStreamStart(buffers: CdpBuffers, data: CdpProtocolStreamStart): CdpProtocolStreamCapture;
+export declare function recordCdpProtocolStreamResponse(buffers: CdpBuffers, capture: CdpProtocolStreamCapture, response: CdpProtocolStreamResponse): void;
+export declare function recordCdpProtocolStreamChunk(buffers: CdpBuffers, capture: CdpProtocolStreamCapture, data: unknown, timestampMs?: number): void;
+export declare function recordCdpProtocolStreamEnd(buffers: CdpBuffers, capture: CdpProtocolStreamCapture, options?: {
     timestampMs?: number;
     error?: string;
 }): void;

package/dist/cdp-backend/capability-handlers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cdp-backend/cdp-session.d.ts

@@ -50,6 +50,7 @@ export declare class CdpSession {
     private pageSessions;
     private pageSessionPromises;
     private pageSessionInitializers;
+    private pageInitialization;
     /** Virtual tabId counter → CDP targetId */
     private tabIdMap;
     private nextTabId;
@@ -74,6 +75,7 @@ export declare class CdpSession {
     attachOpenPageTargets(): Promise<void>;
     private connectBrowserClient;
     private createPageSession;
+    private preparePageSession;
     private getOrCreatePageSession;
     private findTargetById;
     private findDefaultPageTarget;

package/dist/cdp-backend/cdp-utils.d.ts

@@ -1,10 +1,4 @@
-/**
- * Shared utilities for CDP backend handlers.
- *
- * Contains: HTTP helper (nodeFetch), cookie utilities, page-load waiters,
- * viewport helpers, and serialized function sources for page injection.
- */
-import { type PageClickPointerType, type PageDragPoint, type PageDragPointerType } from '@mearl/browser-core';
+import { type CookieCandidate, type PageClickPointerType, type PageDragPoint, type PageDragPointerType } from '@mearl/browser-core';
 import type { PageSession } from './cdp-session.js';
 export declare const TYPE_INTO_ELEMENT_SRC: string;
 export declare const CLICK_ELEMENT_VIA_JS_SRC: string;
@@ -21,8 +15,9 @@ export declare function nodeFetch(urlStr: string, options?: {
     headers: Record<string, string>;
     body: string;
     bodyBuffer: Buffer;
+    setCookies: string[];
 }>;
-export declare function getCookiesForUrl(session: PageSession, targetUrl: string): Promise<Map<string, string>>;
+export declare function getCookiesForUrl(session: PageSession, targetUrl: string): Promise<CookieCandidate[]>;
 export declare function buildMultipartFormBody(fields: Record<string, string>): {
     contentType: string;
     body: string;

package/dist/cdp-backend/handlers.d.ts

@@ -8,6 +8,7 @@ import './request-handlers.js';
 import './mock-handlers.js';
 import './http-handlers.js';
 import './browser-handlers.js';
+import './capability-handlers.js';
 import './rule-handlers.js';
 import './tab-handlers.js';
 import './interaction-handlers.js';
@@ -19,7 +20,7 @@ import './composite-handlers.js';
 export { dispatchCdpAction, getRegisteredActionNames } from './action-registry.js';
 export { cdpGetRequests, cdpGetLogs, cdpGetEvents } from './request-handlers.js';
 export { cdpSetMock, cdpGetMocks } from './mock-handlers.js';
-export { cdpSendRequest, cdpSendMtopRequest } from './http-handlers.js';
+export { cdpSendRequest, cdpSendProtocolRequest } from './http-handlers.js';
 export { cdpPageScreenshot } from './browser-handlers.js';
 export { cdpTabOpen, cdpTabClose, cdpTabList } from './tab-handlers.js';
 export { cdpPageClick, cdpPageType, cdpPageScroll, cdpPageInspect, cdpPageEval, cdpPagePress, cdpPageWait, cdpPageNavigate, cdpPageUpload, cdpSetDeviceEmulation, } from './interaction-handlers.js';

package/dist/cdp-backend/http-handlers.d.ts

@@ -1,17 +1,19 @@
+import { type ResponseCookieSync } from './response-cookies.js';
 /**
- * CDP HTTP proxy / MTOP request / API schema handlers.
+ * CDP HTTP proxy / PROTOCOL request / API schema handlers.
  */
-import type { SendMtopRequestParams, SendRequestParams } from '@mearl/browser-core';
+import { type RequestMetadata, SendRequestParams } from '@mearl/browser-core';
 import type { PageSession } from './cdp-session.js';
-export interface CdpMtopStreamRequestMetadata {
+export interface CdpProtocolStreamRequestMetadata {
     method: 'GET' | 'POST';
     url: string;
     requestHeaders: Array<{
         name: string;
         value: string;
     }>;
+    metadata?: RequestMetadata;
 }
-export interface CdpMtopStreamResponseMetadata {
+export interface CdpProtocolStreamResponseMetadata {
     status: number;
     statusText: string;
     responseHeaders: Array<{
@@ -19,15 +21,16 @@ export interface CdpMtopStreamResponseMetadata {
         value: string;
     }>;
 }
-export interface CdpMtopStreamCallbacks {
-    onRequestPrepared?: (metadata: CdpMtopStreamRequestMetadata) => void | Promise<void>;
-    onResponse?: (metadata: CdpMtopStreamResponseMetadata) => void | Promise<void>;
+export interface CdpProtocolStreamCallbacks {
+    onRequestPrepared?: (metadata: CdpProtocolStreamRequestMetadata) => void | Promise<void>;
+    onResponse?: (metadata: CdpProtocolStreamResponseMetadata) => void | Promise<void>;
     onReceive: (data: unknown) => void | Promise<void>;
 }
 export declare function cdpSendRequest(session: PageSession, data: SendRequestParams): Promise<any>;
-export declare function cdpSendMtopRequest(session: PageSession, data: SendMtopRequestParams): Promise<any>;
-export declare function cdpSendMtopStreamRequest(session: PageSession, data: SendMtopRequestParams, callbacks: CdpMtopStreamCallbacks): Promise<{
+export declare function cdpSendProtocolRequest(session: PageSession, data: Record<string, unknown>): Promise<any>;
+export declare function cdpSendProtocolStreamRequest(session: PageSession, data: Record<string, unknown>, callbacks: CdpProtocolStreamCallbacks): Promise<{
     success: true;
     response: unknown;
     requestData: unknown;
+    cookieSync?: ResponseCookieSync;
 }>;

package/dist/cdp-backend/network-control.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkControlSelection } from '@mearl/browser-core';
+import type { PageSession } from './cdp-session.js';
+export declare function setCdpNetworkControl(session: PageSession, selection: NetworkControlSelection | null): Promise<void>;
+export declare function getCdpNetworkControl(session: PageSession): NetworkControlSelection | undefined;
+export declare function clearCdpNetworkControlState(sessions?: Iterable<PageSession>): void;

package/dist/cdp-backend/page-dialogs.d.ts

@@ -0,0 +1,14 @@
+import { PageDialogState } from '@mearl/browser-core';
+import type { PageSession } from './cdp-session.js';
+import type { CdpClient, CdpChildSession } from './client.js';
+type Client = CdpClient | CdpChildSession;
+export declare function getCdpPageDialogs(session: PageSession): PageDialogState;
+/** A temporary frame connection that owns a modal must survive until its handling ack. */
+export declare function deferCdpDialogCleanup(session: PageSession, cleanup: () => void): void;
+/** Subscribe before Page.enable, including on temporary frame sessions. */
+export declare function monitorCdpPageDialogs(session: PageSession, client?: CdpChildSession | CdpClient): () => void;
+/** Only page execution goes through this gate; lifecycle and Fetch cleanup remain independent. */
+export declare function sendCdpPageCommand(session: PageSession, client: Pick<Client, 'sendCommand'>, method: string, params?: Record<string, any>, timeoutMs?: number, onDispatch?: () => void): Promise<any>;
+export declare function snapshotCdpPageDialog(session: PageSession, data: any): any;
+export declare function pressCdpPageDialog(session: PageSession, data: any): Promise<any>;
+export {};

package/dist/cdp-backend/request-cookies.d.ts

@@ -0,0 +1,8 @@
+import { type CookieCandidate } from '@mearl/browser-core';
+/** Background proxy requests use the target URL's first-party, schemeful site. */
+export declare function getRequestCookiePartition(url: string): {
+    topLevelSite: string;
+    hasCrossSiteAncestor: false;
+};
+/** Keep ordinary cookies and only the target site's first-party partition. */
+export declare function selectRequestCookies<T extends CookieCandidate>(cookies: readonly T[], url: string): T[];

package/dist/cdp-backend/response-cookies.d.ts

@@ -0,0 +1,8 @@
+import type { PageSession } from './cdp-session.js';
+export interface ResponseCookieSync {
+    updatedCount: number;
+    rejectedCount: number;
+    failedCount: number;
+}
+/** Apply response cookies to the same browser context that supplied the request's credentials. */
+export declare function syncResponseCookies(session: PageSession, url: string, headers: readonly string[]): Promise<ResponseCookieSync | undefined>;

package/dist/cdp-backend/send-request.d.ts

@@ -1,2 +1,3 @@
-import { type SendRequestParams } from '@mearl/browser-core';
-export declare function executeNodeSendRequest(data: SendRequestParams, cookieMap?: Map<string, string>): Promise<any>;
+import { type RequestCookie, type SendRequestParams } from '@mearl/browser-core';
+import type { ResponseCookieSync } from './response-cookies.js';
+export declare function executeNodeSendRequest(data: SendRequestParams, cookies?: readonly RequestCookie[], onResponseCookies?: (url: string, headers: readonly string[]) => Promise<ResponseCookieSync | undefined>): Promise<any>;

package/dist/control-session-manager.d.ts

@@ -6,7 +6,7 @@ interface Dependencies {
     transport: () => ControlSessionInfo['transport'];
     invoke: (action: string, data: any, transport: ControlSessionInfo['transport']) => Promise<any>;
     deactivate?: (tabs: number[], transport: ControlSessionInfo['transport']) => Promise<void>;
-    cleanup: (tabs: number[], transport: ControlSessionInfo['transport'], preserveEnvironment: boolean) => Promise<void>;
+    cleanup: (tabs: number[], transport: ControlSessionInfo['transport'], preserveEnvironment: boolean, returningToAgent?: boolean) => Promise<void>;
     download: (data: PageDownloadParams, transport: ControlSessionInfo['transport'], origin: string) => Promise<{
         filename: string;
         filePath: string;