@minionry/minion 0.7.36

package/electron-host/dist/roster-sync.js

@@ -0,0 +1,87 @@
+import { webContents as electronWebContents } from "electron";
+export function materialiseRosterOnSurface(deps, surface) {
+    const agent = deps.surfaces.get(deps.agentSessionId);
+    if (!agent || agent === surface)
+        return;
+    const roster = agent.viewManager.listTabs();
+    const activeId = agent.viewManager.getActiveTabId();
+    for (const tab of roster) {
+        surface.expectedUrls.set(tab.id, tab.url);
+        surface.viewManager.createTab(tab.url, {
+            tabId: tab.id,
+            makeActive: tab.id === activeId,
+        });
+    }
+}
+export function propagateHumanNavigation(deps, origin, tabId, url, inPage, canGoBack, canGoForward) {
+    const expected = origin.expectedUrls.get(tabId);
+    if (expected === url) {
+        origin.expectedUrls.delete(tabId);
+        return;
+    }
+    deps.log("nav.propagate", `from=${origin.sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} inPage=${inPage} url=${url}`);
+    for (const surface of deps.surfaces.values()) {
+        if (surface === origin)
+            continue;
+        if (!surface.viewManager.listTabs().some((t) => t.id === tabId))
+            continue;
+        if (inPage) {
+            if (surface.isAgent)
+                surface.expectedUrls.set(tabId, url);
+            continue;
+        }
+        surface.expectedUrls.set(tabId, url);
+        try {
+            surface.viewManager.navigate(tabId, url);
+        }
+        catch (err) {
+            deps.log("nav.propagate.navigateFailed", String(err));
+        }
+    }
+    deps.notifyNavigated({ tabId, url, inPage, canGoBack, canGoForward });
+}
+export function fanOutCreateTab(deps, url, tabId, origin) {
+    for (const surface of deps.surfaces.values()) {
+        if (surface === origin)
+            continue;
+        surface.expectedUrls.set(tabId, url);
+        surface.viewManager.createTab(url, { tabId });
+    }
+}
+export function fanOutNavigate(deps, tabId, url) {
+    let touched = 0;
+    for (const surface of deps.surfaces.values()) {
+        if (!surface.viewManager.listTabs().some((t) => t.id === tabId))
+            continue;
+        surface.expectedUrls.set(tabId, url);
+        surface.viewManager.navigate(tabId, url);
+        touched++;
+    }
+    if (touched === 0) {
+        deps.info("nav.noSurface", `tab=${tabId.slice(0, 8)} surfaces=${deps.surfaces.size} — navigation dropped`);
+        return;
+    }
+    deps.log("nav.fanOut", `tab=${tabId.slice(0, 8)} surfaces=${touched}/${deps.surfaces.size}`);
+}
+export function fanOutHistory(deps, tabId, label, op) {
+    let touched = 0;
+    for (const surface of deps.surfaces.values()) {
+        const targetId = tabId ?? surface.viewManager.getActiveTabId();
+        if (!targetId)
+            continue;
+        const wcId = surface.viewManager.getCaptureSourceId(targetId);
+        if (wcId === null)
+            continue;
+        const wc = electronWebContents.fromId(wcId);
+        if (wc) {
+            op(wc);
+            touched++;
+        }
+    }
+    deps.log(`view.${label}`, `tab=${tabId?.slice(0, 8) ?? "active"} surfaces=${touched}/${deps.surfaces.size}`);
+}
+export function navTabId(params) {
+    return typeof params?.tabId === "string" && params.tabId.length > 0
+        ? params.tabId
+        : null;
+}

package/electron-host/dist/rpc-context.js

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

package/electron-host/dist/rpc-tab-methods.js

@@ -0,0 +1,138 @@
+import { isDeviceProfileEnvelope, MAX_HOST_DIM, MIN_HOST_DIM } from "./host-wire.js";
+import { JsonRpcError, JsonRpcErrorCode } from "./ipc-server.js";
+import { isRect, requireId } from "./main-guards.js";
+import { fanOutCreateTab, fanOutHistory, fanOutNavigate, navTabId } from "./roster-sync.js";
+import { applyDeviceProfileToTab, sizeSurfaceForArmedTab } from "./surface-sizing.js";
+const SETBOUNDS_REFRESH_DEBOUNCE_MS = 150;
+export function registerTabMethods(ctx) {
+    ctx.ipcServer.register("tab.create", async (params) => {
+        if (!params || typeof params.url !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "tab.create requires { url }");
+        }
+        const agent = ctx.agentSurface();
+        const tabId = agent.viewManager.createTab(params.url);
+        fanOutCreateTab(ctx.roster, params.url, tabId, agent);
+        ctx.info("tab.create", `id=${tabId.slice(0, 8)} url=${params.url} surfaces=${ctx.surfaces.size}`);
+        return { id: tabId };
+    });
+    ctx.ipcServer.register("tab.close", async (params) => {
+        const id = requireId(params);
+        ctx.log("tab.close", `id=${id.slice(0, 8)} surfaces=${ctx.surfaces.size}`);
+        for (const surface of ctx.surfaces.values())
+            surface.viewManager.closeTab(id);
+        return null;
+    });
+    ctx.ipcServer.register("tab.switch", async (params) => {
+        const id = requireId(params);
+        let switched = 0;
+        for (const surface of ctx.surfaces.values()) {
+            if (surface.viewManager.listTabs().some((t) => t.id === id)) {
+                surface.viewManager.setActiveTab(id);
+                switched++;
+            }
+        }
+        ctx.log("tab.switch", `id=${id.slice(0, 8)} surfaces=${switched}/${ctx.surfaces.size}`);
+        return null;
+    });
+    ctx.ipcServer.register("tab.navigate", async (params) => {
+        if (!params ||
+            typeof params.id !== "string" ||
+            typeof params.url !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "tab.navigate requires { id, url }");
+        }
+        fanOutNavigate(ctx.roster, params.id, params.url);
+        return null;
+    });
+    ctx.ipcServer.register("view.navigate", async (params) => {
+        if (!params || typeof params.url !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "view.navigate requires { url }");
+        }
+        const activeId = ctx.agentSurface().viewManager.getActiveTabId();
+        if (!activeId) {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidRequest, "view.navigate: no active tab");
+        }
+        ctx.log("view.navigate", `agentActiveTab=${activeId.slice(0, 8)}`);
+        fanOutNavigate(ctx.roster, activeId, params.url);
+        return null;
+    });
+    ctx.ipcServer.register("view.setBounds", async (params) => {
+        if (!isRect(params)) {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "view.setBounds requires { x, y, width, height }");
+        }
+        const sessionId = typeof params.sessionId === "string" ? params.sessionId : null;
+        ctx.log("view.setBounds", `${params.width}x${params.height} at (${params.x},${params.y})${sessionId ? ` session=${sessionId.slice(0, 8)}` : ""}`);
+        if (!sessionId) {
+            ctx.log("view.setBounds.skip", "no sessionId (pre-attach)");
+            return null;
+        }
+        if (sessionId === ctx.agentSessionId) {
+            ctx.log("view.setBounds.skip", "agent surface is never human-resized");
+            return null;
+        }
+        const surface = ctx.getOrCreateSurface(sessionId);
+        surface.viewerSize = {
+            width: Math.max(MIN_HOST_DIM, Math.min(params.width, MAX_HOST_DIM)),
+            height: Math.max(MIN_HOST_DIM, Math.min(params.height, MAX_HOST_DIM)),
+        };
+        surface.viewerMobile = params.mobile === true;
+        sizeSurfaceForArmedTab(ctx.sizing, surface);
+        ctx.log("view.setBounds.sized", `session=${sessionId.slice(0, 8)} viewer=${surface.viewerSize.width}x${surface.viewerSize.height}`);
+        if (surface.pendingCaptureRefresh)
+            clearTimeout(surface.pendingCaptureRefresh);
+        surface.pendingCaptureRefresh = setTimeout(() => {
+            surface.pendingCaptureRefresh = undefined;
+            if (surface.armedTabId !== null && !surface.window.isDestroyed()) {
+                ctx.refreshCapture(surface, surface.armedTabId);
+            }
+        }, SETBOUNDS_REFRESH_DEBOUNCE_MS);
+        return null;
+    });
+    ctx.ipcServer.register("tab.setDeviceProfile", async (params) => {
+        if (!isDeviceProfileEnvelope(params)) {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "tab.setDeviceProfile requires { tabId, profile: { formFactor, width, height } }");
+        }
+        const { tabId, profile } = params;
+        ctx.tabProfiles.set(tabId, {
+            formFactor: profile.formFactor,
+            width: profile.width,
+            height: profile.height,
+        });
+        ctx.log("tab.setDeviceProfile", `tab=${tabId.slice(0, 8)} ${profile.formFactor} ${profile.width}x${profile.height}`);
+        for (const surface of ctx.surfaces.values()) {
+            if (surface.isAgent)
+                continue;
+            if (!surface.viewManager.listTabs().some((t) => t.id === tabId))
+                continue;
+            if (surface.armedTabId === tabId) {
+                sizeSurfaceForArmedTab(ctx.sizing, surface);
+                ctx.refreshCapture(surface, tabId);
+            }
+            else {
+                applyDeviceProfileToTab(ctx.sizing, surface, tabId);
+            }
+        }
+        return null;
+    });
+    ctx.ipcServer.register("view.back", async (params) => {
+        fanOutHistory(ctx.roster, navTabId(params), "back", (wc) => {
+            if (wc.navigationHistory?.canGoBack())
+                wc.navigationHistory.goBack();
+        });
+        return null;
+    });
+    ctx.ipcServer.register("view.forward", async (params) => {
+        fanOutHistory(ctx.roster, navTabId(params), "forward", (wc) => {
+            if (wc.navigationHistory?.canGoForward())
+                wc.navigationHistory.goForward();
+        });
+        return null;
+    });
+    ctx.ipcServer.register("view.reload", async (params) => {
+        fanOutHistory(ctx.roster, navTabId(params), "reload", (wc) => wc.reload());
+        return null;
+    });
+    ctx.ipcServer.register("view.stop", async (params) => {
+        fanOutHistory(ctx.roster, navTabId(params), "stop", (wc) => wc.stop());
+        return null;
+    });
+}

package/electron-host/dist/rpc-webrtc-methods.js

@@ -0,0 +1,121 @@
+import { JsonRpcError, JsonRpcErrorCode } from "./ipc-server.js";
+import { isIceCandidateInit } from "./main-guards.js";
+import { sizeSurfaceForArmedTab } from "./surface-sizing.js";
+import { CH_CLOSE_VIEWER, CH_REMOTE_ANSWER, CH_REMOTE_ICE, CH_SET_ICE_CONFIG, CH_START_SESSION, CH_SWITCH_VIEWER_TAB, } from "./webrtc-channels.js";
+export function registerWebrtcMethods(ctx) {
+    ctx.ipcServer.register("input.forward", async (params) => {
+        if (!params || typeof params !== "object") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "input.forward requires an envelope");
+        }
+        const rawSession = params.sessionId;
+        const sessionId = typeof rawSession === "string" && rawSession.length > 0 ? rawSession : null;
+        ctx.withInputTarget(sessionId, () => ctx.inputRouter.forwardEvent(params));
+        return null;
+    });
+    ctx.ipcServer.register("webrtc.offer", async (params) => {
+        if (!params || typeof params.sessionId !== "string" || typeof params.tabId !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "webrtc.offer requires { sessionId, tabId }");
+        }
+        const sessionId = params.sessionId;
+        const tabId = params.tabId;
+        const surface = ctx.getOrCreateSurface(sessionId);
+        surface.armedTabId = tabId;
+        if (ctx.viewers.has(sessionId)) {
+            ctx.info("webrtc.offer.rearm", `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)}`);
+        }
+        else {
+            ctx.info("webrtc.offer.arm", `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} viewers=${ctx.viewers.size + 1} controllerReady=${ctx.controllerChannel.isReady}`);
+        }
+        ctx.viewers.set(sessionId, tabId);
+        if (surface.viewManager.listTabs().some((t) => t.id === tabId)) {
+            surface.viewManager.setActiveTab(tabId);
+        }
+        else {
+            ctx.info("webrtc.offer.tabNotOnSurface", `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} surfaceTabs=${surface.viewManager.listTabs().length}`);
+        }
+        sizeSurfaceForArmedTab(ctx.sizing, surface);
+        ctx.attachFocusReporter(surface, tabId);
+        ctx.controllerChannel.send(CH_START_SESSION, { sessionId, tabId });
+        return null;
+    });
+    ctx.ipcServer.register("webrtc.switchTab", async (params) => {
+        if (!params ||
+            typeof params.sessionId !== "string" ||
+            typeof params.tabId !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "webrtc.switchTab requires { sessionId, tabId }");
+        }
+        const { sessionId, tabId } = params;
+        const surface = ctx.surfaces.get(sessionId);
+        if (!surface || !ctx.viewers.has(sessionId)) {
+            ctx.log("webrtc.switchTab.unknownSession", `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} — dropping`);
+            return null;
+        }
+        ctx.log("webrtc.switchTab", `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)}`);
+        ctx.viewers.set(sessionId, tabId);
+        surface.armedTabId = tabId;
+        if (surface.viewManager.listTabs().some((t) => t.id === tabId)) {
+            surface.viewManager.setActiveTab(tabId);
+        }
+        sizeSurfaceForArmedTab(ctx.sizing, surface);
+        ctx.controllerChannel.send(CH_SWITCH_VIEWER_TAB, {
+            sessionId,
+            tabId,
+        });
+        return null;
+    });
+    ctx.ipcServer.register("webrtc.closeOne", async (params) => {
+        if (!params || typeof params.sessionId !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "webrtc.closeOne requires { sessionId }");
+        }
+        ctx.info("webrtc.closeOne", `session=${params.sessionId.slice(0, 8)} viewers=${ctx.viewers.size - (ctx.viewers.has(params.sessionId) ? 1 : 0)}`);
+        ctx.controllerChannel.send(CH_CLOSE_VIEWER, { sessionId: params.sessionId });
+        ctx.viewers.delete(params.sessionId);
+        ctx.teardownSurface(params.sessionId);
+        return null;
+    });
+    ctx.ipcServer.register("webrtc.answer", async (params) => {
+        if (!params || typeof params.sessionId !== "string" || typeof params.sdp !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "webrtc.answer requires { sessionId, sdp }");
+        }
+        ctx.log("webrtc.answer", `session=${params.sessionId.slice(0, 8)} sdpLen=${params.sdp.length} known=${ctx.viewers.has(params.sessionId)}`);
+        ctx.controllerChannel.send(CH_REMOTE_ANSWER, params);
+        return null;
+    });
+    ctx.ipcServer.register("webrtc.ice", async (params) => {
+        if (!params || typeof params.sessionId !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "webrtc.ice requires { sessionId, candidate }");
+        }
+        if (params.candidate !== null && !isIceCandidateInit(params.candidate)) {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "webrtc.ice candidate must be RTCIceCandidateInit or null");
+        }
+        ctx.log("webrtc.ice", `session=${params.sessionId.slice(0, 8)} eoc=${params.candidate === null} known=${ctx.viewers.has(params.sessionId)}`);
+        ctx.controllerChannel.send(CH_REMOTE_ICE, params);
+        return null;
+    });
+    ctx.ipcServer.register("webrtc.setConfig", async (params) => {
+        if (!params || !Array.isArray(params.iceServers)) {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "webrtc.setConfig requires { iceServers: RTCIceServer[] }");
+        }
+        ctx.log("webrtc.setConfig", `servers=${params.iceServers.length} controllerReady=${ctx.controllerChannel.isReady}`);
+        ctx.controllerChannel.send(CH_SET_ICE_CONFIG, params);
+        return null;
+    });
+    ctx.ipcServer.register("sdk.deliver", async (params) => {
+        if (!params ||
+            typeof params.pageId !== "number" ||
+            typeof params.frame !== "string") {
+            throw new JsonRpcError(JsonRpcErrorCode.InvalidParams, "sdk.deliver requires { pageId, frame }");
+        }
+        const injector = ctx.sdkInjectors.get(params.pageId);
+        if (!injector) {
+            ctx.log("sdk.deliver.pageGone", `page=${params.pageId}`);
+            return null;
+        }
+        await injector.deliver(params.frame);
+        return null;
+    });
+    ctx.ipcServer.register("host.shutdown", async () => {
+        queueMicrotask(() => ctx.requestShutdown());
+        return null;
+    });
+}

package/electron-host/dist/screen-capture-cache.js

@@ -0,0 +1,147 @@
+function captureKey(sessionId, tabId) {
+    return `${sessionId}::${tabId}`;
+}
+export const AUDIO_RETRY_BACKOFF_MS = 30_000;
+export function captureConstraints(withAudio) {
+    return {
+        video: { frameRate: { ideal: 30, max: 60 } },
+        audio: withAudio,
+    };
+}
+export function isAudioSourceFailure(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const message = err.message;
+    return typeof message === 'string' && /audio source/i.test(message);
+}
+export class ScreenCaptureCache {
+    wrappers = new Map();
+    deps;
+    acquireChain = Promise.resolve();
+    audioRetryAt = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get audioEnabled() {
+        return Date.now() >= this.audioRetryAt;
+    }
+    async acquire(sessionId, tabId) {
+        const cached = this.wrappers.get(captureKey(sessionId, tabId));
+        if (cached) {
+            const tracks = cached.getTracks();
+            if (tracks.length > 0 && tracks.every((t) => t.readyState === 'live')) {
+                return cached;
+            }
+        }
+        return this.acquireFreshTracks(sessionId, tabId);
+    }
+    async refresh(sessionId, tabId) {
+        return this.acquireFreshTracks(sessionId, tabId);
+    }
+    async acquireFreshTracks(sessionId, tabId) {
+        const next = this.acquireChain.then(() => this.runAcquireFreshTracks(sessionId, tabId));
+        this.acquireChain = next.catch(() => undefined);
+        return next;
+    }
+    async arm(sessionId, tabId) {
+        try {
+            await this.deps.armDisplayMedia(sessionId, tabId);
+            this.deps.log?.('arm-display-media.ack', `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)}`);
+        }
+        catch (err) {
+            throw new Error(`arm-display-media failed: ${err.message ?? err}`);
+        }
+    }
+    async acquireDisplayMedia(sessionId, tabId) {
+        const plans = this.audioEnabled ? [true, false] : [false];
+        let lastError = new Error('getDisplayMedia: no acquisition plan');
+        for (const withAudio of plans) {
+            await this.arm(sessionId, tabId);
+            try {
+                return await this.deps.getDisplayMedia(captureConstraints(withAudio));
+            }
+            catch (err) {
+                lastError = err;
+                if (!withAudio || !isAudioSourceFailure(err))
+                    throw err;
+                this.audioRetryAt = Date.now() + AUDIO_RETRY_BACKOFF_MS;
+                this.deps.log?.('capture.audioUnavailable', `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} ${err.message} — retrying video-only, audio paused ${AUDIO_RETRY_BACKOFF_MS}ms`);
+            }
+        }
+        throw lastError;
+    }
+    async runAcquireFreshTracks(sessionId, tabId) {
+        const fresh = await this.acquireDisplayMedia(sessionId, tabId);
+        const videoTrack = fresh.getVideoTracks()[0];
+        if (videoTrack)
+            videoTrack.contentHint = 'detail';
+        const key = captureKey(sessionId, tabId);
+        let wrapper = this.wrappers.get(key);
+        if (!wrapper) {
+            wrapper = new MediaStream();
+            this.wrappers.set(key, wrapper);
+        }
+        else {
+            for (const old of wrapper.getTracks()) {
+                try {
+                    old.stop();
+                }
+                catch {   }
+                wrapper.removeTrack(old);
+            }
+        }
+        for (const track of fresh.getTracks()) {
+            wrapper.addTrack(track);
+        }
+        const activeWrapper = wrapper;
+        for (const track of fresh.getTracks()) {
+            track.addEventListener('ended', () => {
+                const wrapperLive = this.wrappers.get(key) === activeWrapper;
+                const trackCurrent = activeWrapper.getTracks().includes(track);
+                this.deps.log?.('capture.trackEnded', `session=${sessionId.slice(0, 8)} tab=${tabId.slice(0, 8)} kind=${track.kind} wrapperLive=${wrapperLive} trackCurrent=${trackCurrent}`);
+                if (wrapperLive && trackCurrent) {
+                    this.deps.onTrackEnded(sessionId, tabId);
+                }
+            });
+        }
+        return wrapper;
+    }
+    evict(sessionId, tabId) {
+        const key = captureKey(sessionId, tabId);
+        const wrapper = this.wrappers.get(key);
+        if (!wrapper)
+            return;
+        for (const track of wrapper.getTracks()) {
+            try {
+                track.stop();
+            }
+            catch {   }
+        }
+        this.wrappers.delete(key);
+    }
+    evictSession(sessionId) {
+        const prefix = `${sessionId}::`;
+        for (const [key, wrapper] of [...this.wrappers]) {
+            if (!key.startsWith(prefix))
+                continue;
+            for (const track of wrapper.getTracks()) {
+                try {
+                    track.stop();
+                }
+                catch {   }
+            }
+            this.wrappers.delete(key);
+        }
+    }
+    clear() {
+        for (const wrapper of this.wrappers.values()) {
+            for (const track of wrapper.getTracks()) {
+                try {
+                    track.stop();
+                }
+                catch {   }
+            }
+        }
+        this.wrappers.clear();
+    }
+}

package/electron-host/dist/sdk-injector.js

@@ -0,0 +1,166 @@
+import { hostLog } from "./host-log.js";
+const CDP_PROTOCOL_VERSION = "1.3";
+export const SDK_BINDING_NAME = "__minionryBinding";
+export const SDK_MESSAGE_EVENT = "minionry#message";
+const slog = hostLog("sdk");
+export class SdkInjector {
+    dbg;
+    stubSource;
+    onRequest;
+    started = false;
+    disposed = false;
+    contexts = new Map();
+    mainFrameId = null;
+    onMessage;
+    constructor(options) {
+        this.dbg = options.debugger;
+        this.stubSource = options.stubSource;
+        this.onRequest = options.onRequest;
+        this.onMessage = (_event, method, params) => this.handleCdpMessage(method, params);
+    }
+    start() {
+        if (this.started || this.disposed)
+            return;
+        this.started = true;
+        try {
+            if (!this.dbg.isAttached()) {
+                this.dbg.attach(CDP_PROTOCOL_VERSION);
+            }
+        }
+        catch (err) {
+            slog("attach_race", errMessage(err));
+        }
+        this.dbg.on("message", this.onMessage);
+        void this.send("Runtime.enable");
+        void this.send("Page.enable");
+        void this.send("Runtime.addBinding", { name: SDK_BINDING_NAME });
+        void this.send("Page.addScriptToEvaluateOnNewDocument", {
+            source: this.stubSource,
+        });
+        void this.send("Page.getFrameTree").then((tree) => {
+            const id = tree?.frameTree?.frame?.id;
+            if (this.mainFrameId === null && typeof id === "string") {
+                this.mainFrameId = id;
+            }
+        });
+        void this.send("Runtime.evaluate", {
+            expression: this.stubSource,
+            includeCommandLineAPI: false,
+        });
+        slog("start", `binding=${SDK_BINDING_NAME}`);
+    }
+    async deliver(frameJson) {
+        if (this.disposed)
+            return;
+        const expression = `(() => { try { window.dispatchEvent(new CustomEvent(${JSON.stringify(SDK_MESSAGE_EVENT)}, { detail: ${JSON.stringify(frameJson)} })); } catch (_e) {} })();`;
+        await this.send("Runtime.evaluate", {
+            expression,
+            includeCommandLineAPI: false,
+            silent: true,
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        try {
+            this.dbg.off("message", this.onMessage);
+        }
+        catch (err) {
+            slog("dispose.offFailed", errMessage(err));
+        }
+        this.contexts.clear();
+    }
+    send(method, params) {
+        try {
+            const p = this.dbg.sendCommand(method, params);
+            if (p && typeof p.then === "function") {
+                return p.catch((err) => {
+                    slog("cdp.error", `method=${method} err=${errMessage(err)}`);
+                    return undefined;
+                });
+            }
+            return Promise.resolve(p);
+        }
+        catch (err) {
+            slog("cdp.throw", `method=${method} err=${errMessage(err)}`);
+            return Promise.resolve(undefined);
+        }
+    }
+    handleCdpMessage(method, params) {
+        if (this.disposed)
+            return;
+        switch (method) {
+            case "Runtime.executionContextCreated": {
+                const context = params.context;
+                if (!context || typeof context.id !== "number")
+                    return;
+                this.contexts.set(context.id, {
+                    origin: typeof context.origin === "string" ? context.origin : "",
+                    frameId: typeof context.auxData?.frameId === "string"
+                        ? context.auxData.frameId
+                        : null,
+                    isDefault: context.auxData?.isDefault === true,
+                });
+                return;
+            }
+            case "Runtime.executionContextDestroyed": {
+                const id = params.executionContextId;
+                if (typeof id === "number")
+                    this.contexts.delete(id);
+                return;
+            }
+            case "Runtime.executionContextsCleared": {
+                this.contexts.clear();
+                return;
+            }
+            case "Page.frameNavigated": {
+                const frame = params.frame;
+                if (frame && typeof frame.id === "string" && frame.parentId === undefined) {
+                    this.mainFrameId = frame.id;
+                }
+                return;
+            }
+            case "Runtime.bindingCalled": {
+                this.handleBindingCalled(params);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    handleBindingCalled(params) {
+        if (params.name !== SDK_BINDING_NAME)
+            return;
+        const payload = params.payload;
+        if (typeof payload !== "string")
+            return;
+        const contextId = params.executionContextId;
+        const context = typeof contextId === "number" ? this.contexts.get(contextId) : undefined;
+        if (!context) {
+            slog("drop.unknownContext", `contextId=${String(contextId)}`);
+            return;
+        }
+        if (!context.isDefault) {
+            slog("drop.nonDefaultContext", `contextId=${String(contextId)}`);
+            return;
+        }
+        if (this.mainFrameId === null || context.frameId !== this.mainFrameId) {
+            slog("drop.subframe", `frame=${String(context.frameId)} main=${String(this.mainFrameId)}`);
+            return;
+        }
+        if (context.origin === "") {
+            slog("drop.noOrigin", `contextId=${String(contextId)}`);
+            return;
+        }
+        try {
+            this.onRequest({ origin: context.origin, payload });
+        }
+        catch (err) {
+            slog("onRequest.threw", errMessage(err));
+        }
+    }
+}
+function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}