instar 1.3.1255 → 1.3.1256

package/dist/core/ChromeCdpReloginBrowser.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { WebSocket } from 'ws';
 import { SafeFsExecutor } from './SafeFsExecutor.js';
+import { GOOGLE_ORIGIN_POLICY, PASSKEY_SESSION_CHROME_ARGS, isGoogleOrigin, isRpFamilyOrigin, mayAddCredential, mustRemoveCredentialBefore, } from './PasskeyBrowserPolicy.js';
 /** Closed structural floor for OpenAI's device confirmation; consent prose can never enter this class. */
 export function isClosedOpenAiDeviceApproval(input) {
     return input.origin === 'https://auth.openai.com'
@@ -24,6 +25,65 @@ const CHROME_EXECUTABLE_CANDIDATES = [
 export function resolveChromeExecutable() {
     return CHROME_EXECUTABLE_CANDIDATES.find((candidate) => fs.existsSync(candidate)) ?? null;
 }
+class WsTransport {
+    socket;
+    constructor(socket) {
+        this.socket = socket;
+    }
+    get open() { return this.socket.readyState === WebSocket.OPEN; }
+    send(text) { this.socket.send(text); }
+    onMessage(cb) { this.socket.on('message', (raw) => cb(raw.toString())); }
+    onClose(cb) { this.socket.on('close', cb); }
+    close() { this.socket.close(); }
+}
+/** CDP over Chrome's `--remote-debugging-pipe`: NUL-delimited JSON on fds 3 (write) / 4 (read). */
+class PipeTransport {
+    writer;
+    buffer = '';
+    closed = false;
+    messageCbs = [];
+    closeCbs = [];
+    constructor(writer, reader) {
+        this.writer = writer;
+        reader.setEncoding('utf8');
+        reader.on('data', (chunk) => {
+            this.buffer += chunk;
+            let idx;
+            while ((idx = this.buffer.indexOf('\0')) >= 0) {
+                const message = this.buffer.slice(0, idx);
+                this.buffer = this.buffer.slice(idx + 1);
+                for (const cb of this.messageCbs)
+                    cb(message);
+            }
+        });
+        const onEnd = () => { if (!this.closed) {
+            this.closed = true;
+            for (const cb of this.closeCbs)
+                cb();
+        } };
+        reader.on('end', onEnd);
+        reader.on('close', onEnd);
+        reader.on('error', onEnd);
+        writer.on('error', onEnd);
+    }
+    get open() { return !this.closed && !this.writer.destroyed; }
+    send(text) { this.writer.write(text + '\0'); }
+    onMessage(cb) { this.messageCbs.push(cb); }
+    onClose(cb) { this.closeCbs.push(cb); }
+    close() { this.closed = true; try {
+        this.writer.end();
+    }
+    catch { /* @silent-fallback-ok — pipe already gone; the process teardown below is authoritative */ } }
+}
+/**
+ * Whether a SECONDARY page target (a popup) tolerates the credential being present:
+ * every frame is either the holder origin or outside the relying-party family. A target
+ * still paused at about:blank has no RP-family frame and passes; one whose top-level
+ * frame sits on another RP-family origin fails.
+ */
+function mayAddSecondaryTarget(frames, policy) {
+    return frames.every((f) => f.origin === policy.holderOrigin || !isRpFamilyOrigin(f.origin, policy));
+}
 /**
  * Narrow Chrome DevTools implementation of ReloginBrowserPort.
  * It returns only a closed page classification; raw DOM, URLs-with-query,
@@ -35,10 +95,30 @@ export class ChromeCdpReloginBrowser {
     headless;
     launchTimeoutMs;
     operationTimeoutMs;
+    passkeyMode;
+    policy;
     child = null;
-    socket = null;
+    transport = null;
     requestId = 0;
     pending = new Map();
+    eventHandlers = new Map();
+    /** Pipe mode: every attached target by sessionId. */
+    sessions = new Map();
+    mainSessionId = null;
+    mainSessionReady = null;
+    /** The credential currently loaded into the authenticators, or null. */
+    credential = null;
+    /**
+     * Every credential id this browser has EVER loaded into an authenticator. Removal
+     * sweeps these from every authenticator regardless of the in-memory flag, so a
+     * target that received the key during a prepare/remove interleave can never keep it.
+     */
+    knownCredentialIds = new Set();
+    /** Serialises add / remove / prepare-time load so they can never interleave. */
+    credentialLock = Promise.resolve();
+    assertedCredentialIds = new Set();
+    /** True if a Google-origin document navigation was ever seen before an attach completed. */
+    navigationBeforeAttach = false;
     constructor(options) {
         this.chromePath = options.chromePath ?? resolveChromeExecutable()
             ?? '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
@@ -46,14 +126,23 @@ export class ChromeCdpReloginBrowser {
         this.headless = options.headless ?? false;
         this.launchTimeoutMs = Math.max(1_000, Math.min(30_000, options.launchTimeoutMs ?? 10_000));
         this.operationTimeoutMs = Math.max(1_000, Math.min(30_000, options.operationTimeoutMs ?? 10_000));
+        this.passkeyMode = options.passkeyMode ?? false;
+        this.policy = options.originPolicy ?? GOOGLE_ORIGIN_POLICY;
     }
+    // ── Lifecycle ────────────────────────────────────────────────────────
     async open(url) {
-        if (this.socket)
+        if (this.transport)
             throw new Error('relogin-browser-already-open');
         if (!fs.existsSync(this.chromePath))
             throw new Error('chrome-not-installed');
         fs.mkdirSync(this.userDataDir, { recursive: true, mode: 0o700 });
         fs.chmodSync(this.userDataDir, 0o700);
+        if (this.passkeyMode)
+            return this.openPipe(url);
+        return this.openTcp(url);
+    }
+    /** Legacy transport: TCP debugging port + a page-level WebSocket (non-passkey sessions). */
+    async openTcp(url) {
         const portFile = path.join(this.userDataDir, 'DevToolsActivePort');
         if (fs.existsSync(portFile)) {
             SafeFsExecutor.safeUnlinkSync(portFile, { operation: 'ChromeCdpReloginBrowser stale DevToolsActivePort cleanup' });
@@ -82,11 +171,327 @@ export class ChromeCdpReloginBrowser {
         });
         if (!target.webSocketDebuggerUrl)
             throw new Error('chrome-target-missing-websocket');
-        await this.connect(target.webSocketDebuggerUrl);
+        await this.connectWs(target.webSocketDebuggerUrl);
         await this.send('Page.enable');
         await this.send('Runtime.enable');
         await this.wait(500);
     }
+    /**
+     * Passkey transport: the debugging pipe. The initial about:blank page is
+     * auto-attached and PREPARED (authenticator, interception, service-worker
+     * bypass) before the first navigation; popups are paused until prepared.
+     */
+    async openPipe(url) {
+        const args = [
+            `--user-data-dir=${this.userDataDir}`,
+            ...PASSKEY_SESSION_CHROME_ARGS,
+            '--no-first-run',
+            '--no-default-browser-check',
+            '--disable-sync',
+            '--disable-component-update',
+            'about:blank',
+        ];
+        if (this.headless)
+            args.unshift('--headless=new');
+        const child = spawn(this.chromePath, args, { stdio: ['ignore', 'ignore', 'ignore', 'pipe', 'pipe'] });
+        this.child = child;
+        const writer = child.stdio[3];
+        const reader = child.stdio[4];
+        if (!writer || !reader)
+            throw new Error('chrome-pipe-unavailable');
+        this.attachTransport(new PipeTransport(writer, reader));
+        let resolveReady;
+        const promise = new Promise((r) => { resolveReady = r; });
+        this.mainSessionReady = { resolve: resolveReady, promise };
+        this.on('Target.attachedToTarget', (params) => this.onAttached(params));
+        this.on('Target.detachedFromTarget', (params) => { this.sessions.delete(String(params.sessionId)); });
+        this.on('Fetch.requestPaused', (params, sessionId) => this.onRequestPaused(params, sessionId));
+        this.on('WebAuthn.credentialAsserted', (params) => {
+            const cred = params.credential;
+            if (cred?.credentialId)
+                this.assertedCredentialIds.add(cred.credentialId);
+        });
+        this.on('Page.frameRequestedNavigation', (params, sessionId) => {
+            // Diagnostic only: a navigation observed on a session that was never prepared.
+            const s = sessionId ? this.sessions.get(sessionId) : undefined;
+            if (s && !s.authenticatorId && typeof params.url === 'string' && params.url !== 'about:blank')
+                this.navigationBeforeAttach = true;
+        });
+        await this.send('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
+        await Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error('chrome-launch-timeout')), this.launchTimeoutMs)),
+        ]);
+        await this.send('Page.navigate', { url }, this.mainSessionId ?? undefined);
+        await this.wait(500);
+    }
+    async onAttached(params) {
+        const sessionId = String(params.sessionId);
+        const info = (params.targetInfo ?? {});
+        const waiting = params.waitingForDebugger === true;
+        const type = info.type ?? 'other';
+        const session = { targetId: String(info.targetId ?? ''), type };
+        this.sessions.set(sessionId, session);
+        try {
+            if (type === 'page' || type === 'iframe' || type === 'webview') {
+                await this.prepareSession(sessionId, session);
+            }
+        }
+        catch { /* @silent-fallback-ok — a target we could not prepare is resumed below so the browser never wedges; the credential is only ever added to PREPARED authenticators */ }
+        if (waiting) {
+            try {
+                await this.send('Runtime.runIfWaitingForDebugger', {}, sessionId);
+            }
+            catch { /* @silent-fallback-ok — target may have gone away */ }
+        }
+        if (type === 'page' && !this.mainSessionId) {
+            this.mainSessionId = sessionId;
+            this.mainSessionReady?.resolve();
+        }
+    }
+    /** Everything a target needs BEFORE it is allowed to navigate. */
+    async prepareSession(sessionId, session) {
+        await this.send('Page.enable', {}, sessionId);
+        await this.send('Runtime.enable', {}, sessionId);
+        await this.send('Network.enable', {}, sessionId);
+        await this.send('Network.setBypassServiceWorker', { bypass: true }, sessionId);
+        await this.send('Fetch.enable', { patterns: [{ urlPattern: '*', resourceType: 'Document', requestStage: 'Request' }] }, sessionId);
+        await this.send('WebAuthn.enable', { enableUI: false }, sessionId);
+        const auth = await this.send('WebAuthn.addVirtualAuthenticator', {
+            options: {
+                protocol: 'ctap2', ctap2Version: 'ctap2_1', transport: 'internal',
+                hasResidentKey: true, hasUserVerification: true, isUserVerified: true,
+                automaticPresenceSimulation: true,
+            },
+        }, sessionId);
+        // The authenticator becomes VISIBLE to removal and receives the credential in one
+        // locked step: a concurrent removeCredential() either runs entirely before (so the
+        // credential is null here and nothing is loaded) or entirely after (so this
+        // authenticator is in its sweep). A target is still paused at about:blank here.
+        await this.withCredentialLock(async () => {
+            session.authenticatorId = String(auth.authenticatorId);
+            if (this.credential) {
+                await this.send('WebAuthn.addCredential', { authenticatorId: session.authenticatorId, credential: this.credential }, sessionId);
+            }
+        });
+        try {
+            const tree = await this.send('Page.getFrameTree', {}, sessionId);
+            session.mainFrameId = tree.frameTree?.frame?.id;
+        }
+        catch { /* @silent-fallback-ok — an OOPIF target has no page frame tree; its documents are never top-level */ }
+        // Nested auto-attach so cross-origin iframes of THIS target get the same preparation.
+        await this.send('Target.setAutoAttach', { autoAttach: true, waitForDebuggerOnStart: true, flatten: true }, sessionId);
+    }
+    async onRequestPaused(params, sessionId) {
+        const requestId = String(params.requestId);
+        const cont = () => this.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
+        if (params.resourceType !== 'Document') {
+            await cont();
+            return;
+        }
+        const session = sessionId ? this.sessions.get(sessionId) : undefined;
+        const request = (params.request ?? {});
+        const url = request.url ?? '';
+        // Unknown frame identity (no session record, or Page.getFrameTree failed) is treated
+        // as TOP-LEVEL so the stricter rule applies — over-remove, never under-remove.
+        const topLevel = session?.type === 'iframe' ? false
+            : (session?.mainFrameId === undefined || params.frameId === session.mainFrameId);
+        if ((this.credential || this.knownCredentialIds.size > 0) && mustRemoveCredentialBefore({ url, topLevel }, this.policy)) {
+            try {
+                await this.removeCredential();
+            }
+            catch {
+                // Fail CLOSED: if the credential cannot be removed, the document must not load.
+                await this.send('Fetch.failRequest', { requestId, errorReason: 'BlockedByClient' }, sessionId).catch(() => { });
+                return;
+            }
+        }
+        await cont();
+    }
+    // ── Passkey operations (spec §3.5 port additions) ─────────────────────
+    /**
+     * Add the credential to every prepared authenticator. Allowed only while the
+     * main target's frames satisfy the origin policy (top-level on the holder
+     * origin, no other RP-family frame). The value stays inside this process.
+     */
+    async addCredential(credential) {
+        if (!this.passkeyMode)
+            throw new Error('passkey-mode-required');
+        await this.withCredentialLock(async () => {
+            // EVERY page target (the main page AND every auto-attached popup) must satisfy
+            // the policy — a popup that moved to another RP-family origin earlier (and had
+            // the key removed then) must not be re-armed by an add on the main page.
+            for (const [sid, s] of this.sessions) {
+                if (s.type !== 'page' || !s.authenticatorId)
+                    continue;
+                const frames = await this.frameOrigins(sid);
+                if (sid === this.mainSessionId) {
+                    if (!mayAddCredential(frames, this.policy))
+                        throw new Error('passkey-origin-not-allowed');
+                    continue;
+                }
+                // A secondary target may be blank (still paused), on the holder origin, or on an
+                // origin OUTSIDE the relying-party family (it cannot claim the key). What it may
+                // never be is on another RP-family origin — in any of its frames.
+                if (!mayAddSecondaryTarget(frames, this.policy))
+                    throw new Error('passkey-origin-not-allowed');
+            }
+            this.credential = { ...credential };
+            this.knownCredentialIds.add(credential.credentialId);
+            for (const [sessionId, s] of this.sessions) {
+                if (!s.authenticatorId)
+                    continue;
+                await this.send('WebAuthn.addCredential', { authenticatorId: s.authenticatorId, credential: this.credential }, sessionId);
+            }
+        });
+    }
+    /**
+     * Remove every credential this browser ever loaded from EVERY authenticator, and
+     * forget the current one. Does not trust the in-memory flag: the sweep runs whenever
+     * any id is known, so no target can keep a key the flag says is gone. Idempotent.
+     */
+    async removeCredential() {
+        if (!this.credential && this.knownCredentialIds.size === 0)
+            return;
+        await this.withCredentialLock(async () => {
+            let firstError = null;
+            for (const [sessionId, s] of this.sessions) {
+                if (!s.authenticatorId)
+                    continue;
+                for (const credentialId of this.knownCredentialIds) {
+                    try {
+                        await this.send('WebAuthn.removeCredential', { authenticatorId: s.authenticatorId, credentialId }, sessionId);
+                    }
+                    catch (err) {
+                        // A target that already went away, or an authenticator that never held this
+                        // id, is fine; anything else is reported after the sweep completes.
+                        if (!(err instanceof Error && /target|session|closed|detached|not found|unknown credential/i.test(err.message)))
+                            firstError ??= err;
+                    }
+                }
+            }
+            this.credential = null;
+            if (firstError)
+                throw firstError instanceof Error ? firstError : new Error(String(firstError));
+        });
+    }
+    /** Run `fn` with exclusive access to the credential state (add / remove / prepare-time load). */
+    withCredentialLock(fn) {
+        const run = this.credentialLock.then(fn, fn);
+        this.credentialLock = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /** Whether the credential is currently loaded into the authenticators. */
+    hasCredential() { return this.credential !== null; }
+    /** True once Google (or the fixture) actually asked for and received an assertion from this credential. */
+    observedAssertion(credentialId) { return this.assertedCredentialIds.has(credentialId); }
+    /** Export every credential in the MAIN target's authenticator (used at mint). */
+    async exportCredentials() {
+        if (!this.passkeyMode || !this.mainSessionId)
+            throw new Error('passkey-mode-required');
+        const s = this.sessions.get(this.mainSessionId);
+        if (!s?.authenticatorId)
+            throw new Error('authenticator-missing');
+        const out = await this.send('WebAuthn.getCredentials', { authenticatorId: s.authenticatorId }, this.mainSessionId);
+        return (out.credentials ?? []).map((c) => ({ ...c }));
+    }
+    /** Credential COUNT per prepared target (never material) — proves every attached target's authenticator is loaded. */
+    async credentialCountsByTarget() {
+        const counts = [];
+        for (const [sid, s] of this.sessions) {
+            if (!s.authenticatorId || s.type !== 'page')
+                continue;
+            try {
+                const out = await this.send('WebAuthn.getCredentials', { authenticatorId: s.authenticatorId }, sid);
+                counts.push((out.credentials ?? []).length);
+            }
+            catch { /* @silent-fallback-ok — a target that closed holds nothing */ }
+        }
+        return counts;
+    }
+    /** Number of credentials the MAIN authenticator holds (a count, never material). */
+    async credentialCount() {
+        return (await this.exportCredentials()).length;
+    }
+    /**
+     * Compare the signed-in identity shown on the current page with the expected
+     * email INSIDE the browser; only the boolean leaves. Structural first
+     * (`data-email` / `data-identifier` / `aria-label`), then an exact-text element.
+     */
+    async readSignedInIdentityMatches(expected) {
+        return this.evaluate(`(() => {
+      const expected = ${JSON.stringify(expected)}.trim().toLowerCase();
+      if (!expected) return false;
+      const attrNodes = Array.from(document.querySelectorAll('[data-email],[data-identifier],[aria-label]'));
+      for (const n of attrNodes) {
+        for (const a of ['data-email','data-identifier','aria-label']) {
+          const v = (n.getAttribute(a) || '').trim().toLowerCase();
+          if (v === expected) return true;
+        }
+      }
+      const all = Array.from(document.querySelectorAll('div,span,p,li,td,a,button'));
+      return all.some((n) => n.children.length === 0 && (n.textContent || '').trim().toLowerCase() === expected);
+    })()`);
+    }
+    /**
+     * Whether any target was seen navigating before its authenticator was attached. A
+     * DIAGNOSTIC only: it observes from `Page.enable` onward, so it can confirm a breach
+     * it saw but not prove absence. The guarantee itself is Chrome's
+     * `waitForDebuggerOnStart` pause, which the popup test exercises.
+     */
+    sawNavigationBeforeAttach() { return this.navigationBeforeAttach; }
+    /**
+     * Run an expression in the main page. FIXTURE-ONLY: refused under the production
+     * Google policy so no caller can turn the repair browser into an arbitrary-evaluate
+     * surface on a real account page.
+     */
+    async runInPage(expression) {
+        this.assertFixturePolicy('run-in-page');
+        return this.evaluate(expression);
+    }
+    assertFixturePolicy(op) {
+        if (this.policy.holderOrigin === GOOGLE_ORIGIN_POLICY.holderOrigin || isGoogleOrigin(this.policy.holderOrigin)) {
+            throw new Error(`${op}-fixture-only`);
+        }
+    }
+    /** Origins of every frame in ONE page target (its own tree plus its out-of-process iframes). */
+    async frameOrigins(pageSessionId = this.mainSessionId) {
+        const tree = await this.send('Page.getFrameTree', {}, pageSessionId ?? undefined);
+        const out = [];
+        const walk = (node, top) => {
+            if (!node?.frame)
+                return;
+            const origin = node.frame.securityOrigin && node.frame.securityOrigin !== '://' ? node.frame.securityOrigin : (() => { try {
+                return new URL(node.frame.url ?? '').origin;
+            }
+            catch {
+                return '';
+            } })();
+            out.push({ origin, topLevel: top });
+            for (const child of (node.childFrames ?? []))
+                walk(child, false);
+        };
+        walk(tree.frameTree, true);
+        // Out-of-process iframes are separate targets: include them as subframes.
+        for (const [sid, s] of this.sessions) {
+            if (s.type !== 'iframe' || sid === this.mainSessionId)
+                continue;
+            try {
+                const t = await this.send('Page.getFrameTree', {}, sid);
+                const f = t.frameTree?.frame;
+                const origin = f?.securityOrigin && f.securityOrigin !== '://' ? f.securityOrigin : (() => { try {
+                    return new URL(f?.url ?? '').origin;
+                }
+                catch {
+                    return '';
+                } })();
+                out.push({ origin, topLevel: false });
+            }
+            catch { /* @silent-fallback-ok — a vanished OOPIF cannot hold the credential */ }
+        }
+        return out;
+    }
+    // ── ReloginBrowserPort ───────────────────────────────────────────────
     async snapshot(expectedIdentity) {
         return this.evaluate(`(() => {
       const expected = ${JSON.stringify(expectedIdentity)}.trim().toLowerCase();
@@ -136,7 +541,9 @@ export class ChromeCdpReloginBrowser {
     })()`);
     }
     async chooseExpectedAccount(expectedIdentity) {
-        await this.evaluate(`(() => {
+        // A REAL input click (spec §3.5): Google's choice-list items do not respond
+        // to a script-level element.click().
+        await this.clickReal(`(() => {
       const expected = ${JSON.stringify(expectedIdentity)}.trim().toLowerCase();
       const nodes = Array.from(document.querySelectorAll('[data-email],[data-identifier],button,[role="button"],a,[role="link"],li'));
       const identities = (node) => {
@@ -146,9 +553,9 @@ export class ChromeCdpReloginBrowser {
       };
       const matching = nodes.filter((node) => identities(node).includes(expected));
       const actionable = matching.filter((node) => !matching.some((child) => child !== node && node.contains(child)));
-      if (actionable.length !== 1 || !(actionable[0] instanceof HTMLElement)) return false;
-      actionable[0].click(); return true;
-    })()`, true);
+      if (actionable.length !== 1 || !(actionable[0] instanceof HTMLElement)) return null;
+      return actionable[0];
+    })()`);
     }
     async fillPublic(field, value) {
         const selector = field === 'email'
@@ -166,15 +573,19 @@ export class ChromeCdpReloginBrowser {
         const pattern = action === 'next' ? '^(next|continue)$'
             : action === 'google' ? '(continue|sign in|log in) with google'
                 : '^(allow|authorize|approve|continue)$';
-        await this.evaluate(`(() => {
+        await this.clickReal(`(() => {
       const re = new RegExp(${JSON.stringify(pattern)}, 'i');
       const nodes = Array.from(document.querySelectorAll('button,[role="button"],a,[role="link"],input[type="submit"]'));
       const node = nodes.find((entry) => re.test(((entry.textContent || entry.getAttribute('value') || '')).trim()));
-      if (!(node instanceof HTMLElement)) return false;
-      node.click(); return true;
-    })()`, true);
+      return node instanceof HTMLElement ? node : null;
+    })()`);
         await this.wait(500);
     }
+    /** Click a fixture/test element by CSS selector with a REAL pointer event. FIXTURE-ONLY (see runInPage). */
+    async clickSelector(selector) {
+        this.assertFixturePolicy('click-selector');
+        await this.clickReal(`(() => { const n = document.querySelector(${JSON.stringify(selector)}); return n instanceof HTMLElement ? n : null; })()`);
+    }
     async readPasteCode() {
         return this.evaluate(`(() => {
       const candidates = Array.from(document.querySelectorAll('code,pre,[data-testid*="code" i]'))
@@ -187,19 +598,22 @@ export class ChromeCdpReloginBrowser {
     }
     async close() {
         const child = this.child;
-        if (this.socket?.readyState === WebSocket.OPEN) {
+        this.credential = null;
+        if (this.transport?.open) {
             try {
                 await this.send('Browser.close');
             }
             catch { /* @silent-fallback-ok — process may already be gone; local socket/process teardown continues below */ }
         }
-        this.socket?.close();
-        this.socket = null;
+        this.transport?.close();
+        this.transport = null;
         for (const entry of this.pending.values()) {
             clearTimeout(entry.timer);
             entry.reject(new Error('relogin-browser-closed'));
         }
         this.pending.clear();
+        this.sessions.clear();
+        this.mainSessionId = null;
         if (child && child.exitCode === null && child.signalCode === null) {
             child.kill('SIGTERM');
             if (!await this.waitForChildExit(child, 5_000)) {
@@ -209,6 +623,7 @@ export class ChromeCdpReloginBrowser {
         }
         this.child = null;
     }
+    // ── Internals ────────────────────────────────────────────────────────
     async waitForChildExit(child, timeoutMs) {
         if (child.exitCode !== null || child.signalCode !== null)
             return true;
@@ -231,29 +646,63 @@ export class ChromeCdpReloginBrowser {
                 finish(true);
         });
     }
+    /**
+     * Real pointer click: resolve the element with `finderExpression` (must
+     * evaluate to an HTMLElement or null), scroll it into view, read its centre,
+     * and dispatch mouse pressed/released through the Input domain.
+     */
+    async clickReal(finderExpression) {
+        const point = await this.evaluate(`(() => {
+      const el = (${finderExpression});
+      if (!(el instanceof HTMLElement)) return null;
+      el.scrollIntoView({ block: 'center', inline: 'center' });
+      const r = el.getBoundingClientRect();
+      if (r.width === 0 || r.height === 0) return null;
+      return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
+    })()`);
+        if (!point)
+            throw new Error('browser-element-not-found');
+        const sid = this.mainSessionId ?? undefined;
+        await this.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x: point.x, y: point.y }, sid);
+        await this.send('Input.dispatchMouseEvent', { type: 'mousePressed', x: point.x, y: point.y, button: 'left', clickCount: 1 }, sid);
+        await this.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: point.x, y: point.y, button: 'left', clickCount: 1 }, sid);
+    }
     async fillAndSubmit(selector, value) {
-        const expression = `(() => {
+        const filled = await this.evaluate(`(() => {
       const node = document.querySelector(${JSON.stringify(selector)});
       if (!(node instanceof HTMLInputElement)) return false;
       const setter = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
       setter?.call(node, ${JSON.stringify(value)});
       node.dispatchEvent(new Event('input', { bubbles: true }));
       node.dispatchEvent(new Event('change', { bubbles: true }));
-      const buttons = Array.from(document.querySelectorAll('button,[role="button"],a,[role="link"],input[type="submit"]'));
-      const submit = buttons.find((entry) => /^(next|continue|sign in|verify|submit)$/i
-        .test(((entry.textContent || entry.getAttribute('value') || '')).trim()));
-      if (submit instanceof HTMLElement) { submit.click(); return true; }
-      const form = node.closest('form');
-      if (form instanceof HTMLFormElement) { form.requestSubmit(); return true; }
-      return true;
-    })()`;
-        await this.evaluate(expression, true);
+      // Read back: never submit a field whose value did not stick (measured 2026-09-21).
+      return node.value.length === ${JSON.stringify(value)}.length;
+    })()`, true);
+        if (!filled)
+            throw new Error('browser-element-not-found');
+        try {
+            await this.clickReal(`(() => {
+        const buttons = Array.from(document.querySelectorAll('button,[role="button"],a,[role="link"],input[type="submit"]'));
+        const submit = buttons.find((entry) => /^(next|continue|sign in|verify|submit)$/i
+          .test(((entry.textContent || entry.getAttribute('value') || '')).trim()));
+        return submit instanceof HTMLElement ? submit : null;
+      })()`);
+        }
+        catch {
+            // No submit button: fall back to the form's own submit.
+            await this.evaluate(`(() => {
+        const node = document.querySelector(${JSON.stringify(selector)});
+        const form = node instanceof HTMLElement ? node.closest('form') : null;
+        if (form instanceof HTMLFormElement) { form.requestSubmit(); return true; }
+        return true;
+      })()`);
+        }
         await this.wait(500);
     }
     async evaluate(expression, requireTruthy = false) {
-        const result = await this.send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true });
+        const result = await this.send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, this.mainSessionId ?? undefined);
         const remote = result.result;
-        if (!remote || remote.exceptionDetails)
+        if (!remote || result.exceptionDetails)
             throw new Error('browser-evaluation-failed');
         if (requireTruthy && !remote.value)
             throw new Error('browser-element-not-found');
@@ -274,60 +723,77 @@ export class ChromeCdpReloginBrowser {
         }
         throw new Error('chrome-launch-timeout');
     }
-    async connect(url) {
+    async connectWs(url) {
         const socket = new WebSocket(url, { origin: 'http://127.0.0.1' });
-        this.socket = socket;
-        socket.on('message', (raw) => {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error('cdp-connect-timeout')), this.operationTimeoutMs);
+            socket.once('open', () => { clearTimeout(timer); resolve(); });
+            socket.once('error', (error) => { clearTimeout(timer); reject(error); });
+        });
+        this.attachTransport(new WsTransport(socket));
+    }
+    attachTransport(transport) {
+        this.transport = transport;
+        transport.onMessage((raw) => {
             let message;
             try {
-                message = JSON.parse(raw.toString());
+                message = JSON.parse(raw);
             }
             catch {
                 return;
             }
-            if (message.id === undefined)
-                return;
-            const entry = this.pending.get(message.id);
-            if (!entry)
+            if (message.id !== undefined) {
+                const entry = this.pending.get(message.id);
+                if (!entry)
+                    return;
+                this.pending.delete(message.id);
+                clearTimeout(entry.timer);
+                if (message.error)
+                    entry.reject(new Error(message.error.message ?? 'cdp-error'));
+                else
+                    entry.resolve(message.result ?? {});
                 return;
-            this.pending.delete(message.id);
-            clearTimeout(entry.timer);
-            if (message.error)
-                entry.reject(new Error(message.error.message ?? 'cdp-error'));
-            else
-                entry.resolve(message.result ?? {});
+            }
+            if (message.method) {
+                for (const handler of this.eventHandlers.get(message.method) ?? []) {
+                    try {
+                        const out = handler(message.params ?? {}, message.sessionId);
+                        if (out && typeof out.catch === 'function')
+                            out.catch(() => { });
+                    }
+                    catch { /* @silent-fallback-ok — an event handler must never take the transport down */ }
+                }
+            }
         });
-        socket.on('close', () => {
+        transport.onClose(() => {
             for (const [id, entry] of this.pending) {
                 this.pending.delete(id);
                 clearTimeout(entry.timer);
                 entry.reject(new Error('cdp-closed'));
             }
         });
-        await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new Error('cdp-connect-timeout')), this.operationTimeoutMs);
-            socket.once('open', () => { clearTimeout(timer); resolve(); });
-            socket.once('error', (error) => { clearTimeout(timer); reject(error); });
-        });
     }
-    send(method, params = {}) {
-        const socket = this.socket;
-        if (!socket || socket.readyState !== WebSocket.OPEN)
+    on(method, handler) {
+        const list = this.eventHandlers.get(method) ?? [];
+        list.push(handler);
+        this.eventHandlers.set(method, list);
+    }
+    send(method, params = {}, sessionId) {
+        const transport = this.transport;
+        if (!transport || !transport.open)
             return Promise.reject(new Error('cdp-not-connected'));
         const id = ++this.requestId;
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`cdp-timeout:${method}`)); }, this.operationTimeoutMs);
             this.pending.set(id, { resolve, reject, timer });
-            socket.send(JSON.stringify({ id, method, params }), (error) => {
-                if (!error)
-                    return;
-                const entry = this.pending.get(id);
-                if (!entry)
-                    return;
+            try {
+                transport.send(JSON.stringify(sessionId ? { id, method, params, sessionId } : { id, method, params }));
+            }
+            catch (error) {
                 this.pending.delete(id);
-                clearTimeout(entry.timer);
-                reject(error);
-            });
+                clearTimeout(timer);
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
         });
     }
 }