local-browser-bridge 0.1.0

package/dist/tests/attach-service.test.js

@@ -0,0 +1,1367 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_http_1 = require("node:http");
+const node_path_1 = require("node:path");
+const browser_1 = require("../src/browser");
+const safari_1 = require("../src/browser/safari");
+const http_1 = require("../src/http");
+const attach_service_1 = require("../src/service/attach-service");
+const session_store_1 = require("../src/store/session-store");
+const cli_1 = require("../src/cli");
+const errors_1 = require("../src/errors");
+class FakeAdapter {
+    browser = "safari";
+    mode = "stable";
+    setMode(mode) {
+        this.mode = mode;
+    }
+    async listTabs() {
+        if (this.mode === "moved") {
+            return [
+                this.makeTab(1, 1, "Front", "https://front.example.com", true, true, "front-signature"),
+                this.makeTab(5, 9, "Example", "https://example.com", false, false, "example-signature")
+            ];
+        }
+        return [
+            this.makeTab(1, 1, "Front", "https://front.example.com", true, true, "front-signature"),
+            this.makeTab(2, 3, "Example", "https://example.com", false, false, "example-signature")
+        ];
+    }
+    async resolveTab(target) {
+        const tabs = await this.listTabs();
+        if (target.type === "front") {
+            return tabs[0];
+        }
+        if (target.type === "signature") {
+            const bySignature = tabs.find((tab) => tab.identity.signature === target.signature);
+            if (bySignature) {
+                return bySignature;
+            }
+        }
+        const matched = tabs.find((tab) => tab.windowIndex === target.windowIndex && tab.tabIndex === target.tabIndex);
+        strict_1.default.ok(matched);
+        return matched;
+    }
+    async performSessionAction(action) {
+        const tab = await this.resolveTab(action.target);
+        if (action.action === "activate") {
+            return {
+                action: "activate",
+                browser: this.browser,
+                tab,
+                activatedAt: "2026-01-02T00:00:00.000Z",
+                implementation: {
+                    browserNative: false,
+                    engine: "fake-adapter",
+                    selectedTarget: true,
+                    broughtAppToFront: true,
+                    reorderedWindowToFront: true
+                }
+            };
+        }
+        if (action.action === "navigate") {
+            const requestedUrl = String(action.options.url);
+            return {
+                action: "navigate",
+                browser: this.browser,
+                requestedUrl,
+                previousTab: tab,
+                tab: this.makeTab(tab.windowIndex, tab.tabIndex, "Navigated", requestedUrl, tab.isFrontWindow, tab.isActiveInWindow),
+                navigatedAt: "2026-01-02T00:00:00.000Z",
+                implementation: {
+                    browserNative: false,
+                    engine: "fake-adapter",
+                    selectedTarget: true,
+                    broughtAppToFront: true,
+                    reusedExistingTab: true
+                }
+            };
+        }
+        strict_1.default.equal(action.action, "screenshot");
+        const outputPath = action.options && typeof action.options === "object" && "outputPath" in action.options
+            ? String(action.options.outputPath)
+            : "";
+        strict_1.default.ok(outputPath);
+        await (0, promises_1.writeFile)(outputPath, "fake-png", "utf8");
+        return {
+            action: "screenshot",
+            browser: this.browser,
+            tab,
+            outputPath,
+            format: "png",
+            capturedAt: "2026-01-02T00:00:00.000Z",
+            implementation: {
+                browserNative: false,
+                engine: "fake-adapter",
+                scope: "window",
+                activatedTarget: true,
+                includesBrowserChrome: true
+            }
+        };
+    }
+    async getDiagnostics() {
+        return {
+            browser: this.browser,
+            checkedAt: "2026-01-02T00:00:00.000Z",
+            runtime: {
+                platform: process.platform,
+                arch: process.arch,
+                nodeVersion: process.version,
+                safariRunning: true
+            },
+            host: {
+                osascriptAvailable: true,
+                screencaptureAvailable: true,
+                safariApplicationAvailable: true
+            },
+            supportedFeatures: {
+                inspectTabs: true,
+                attach: true,
+                activate: true,
+                navigate: true,
+                screenshot: true,
+                savedSessions: true,
+                cli: true,
+                httpApi: true
+            },
+            constraints: ["Fake adapter constraint"],
+            preflight: {
+                inspect: {
+                    ready: true,
+                    checks: ["inspect"],
+                    blockers: []
+                },
+                automation: {
+                    ready: true,
+                    checks: ["automation"],
+                    blockers: []
+                },
+                screenshot: {
+                    ready: true,
+                    checks: ["screenshot"],
+                    blockers: []
+                }
+            }
+        };
+    }
+    makeTab(windowIndex, tabIndex, title, url, isFrontWindow = false, isActiveInWindow = false, signature) {
+        return {
+            browser: "safari",
+            windowIndex,
+            tabIndex,
+            title,
+            url,
+            attachedAt: "2026-01-01T00:00:00.000Z",
+            identity: {
+                signature: signature ?? `${title.toLowerCase()}-${tabIndex}`,
+                urlKey: `${url}/`.replace(/\/\/$/, "/"),
+                titleKey: title.toLowerCase(),
+                origin: new URL(url).origin,
+                pathname: new URL(url).pathname
+            },
+            isFrontWindow,
+            isActiveInWindow
+        };
+    }
+}
+function createTestService(baseDir, adapter = new FakeAdapter()) {
+    const store = new session_store_1.SessionStore({ filePath: (0, node_path_1.resolve)(baseDir, "sessions.json") });
+    const service = new attach_service_1.AttachService({
+        store,
+        adapterFactory: (_browser) => adapter
+    });
+    return { service, adapter };
+}
+async function withCapturedStreams(run) {
+    let stdout = "";
+    let stderr = "";
+    const stdoutWrite = process.stdout.write.bind(process.stdout);
+    const stderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = ((chunk) => {
+        stdout += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    });
+    process.stderr.write = ((chunk) => {
+        stderr += typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        return true;
+    });
+    try {
+        await run();
+        return { stdout, stderr };
+    }
+    finally {
+        process.stdout.write = stdoutWrite;
+        process.stderr.write = stderrWrite;
+    }
+}
+(0, node_test_1.default)("attach persists stronger signature targets and list returns newest-first sessions", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "service");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const { service } = createTestService(baseDir);
+    const first = await service.attach("safari");
+    const second = await service.attach("safari", { type: "indexed", windowIndex: 2, tabIndex: 3 });
+    const sessions = await service.listSessions();
+    strict_1.default.equal(sessions.length, 2);
+    strict_1.default.equal(sessions[0].id, second.id);
+    strict_1.default.equal(sessions[1].id, first.id);
+    strict_1.default.equal(sessions[0].tab.url, "https://example.com");
+    strict_1.default.equal(sessions[0].target.type, "signature");
+    strict_1.default.equal((sessions[0].target.type === "signature" && sessions[0].target.signature) || "", "example-signature");
+    strict_1.default.equal(sessions[0].schemaVersion, 1);
+    strict_1.default.equal(sessions[0].kind, "safari-actionable");
+    strict_1.default.equal(sessions[0].status.state, "actionable");
+    strict_1.default.equal(sessions[0].status.canAct, true);
+    strict_1.default.equal(sessions[0].capabilities.resume, true);
+    strict_1.default.equal(sessions[0].capabilities.activate, true);
+    strict_1.default.equal(sessions[0].capabilities.navigate, true);
+    strict_1.default.equal(sessions[0].capabilities.screenshot, true);
+    const persisted = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(baseDir, "sessions.json"), "utf8"));
+    strict_1.default.equal(persisted[0].schemaVersion, 1);
+    strict_1.default.equal(persisted[0].kind, "safari-actionable");
+    strict_1.default.equal(persisted[0].status.state, "actionable");
+    strict_1.default.equal(persisted[0].capabilities.activate, true);
+});
+(0, node_test_1.default)("resume falls back to stronger identity when tabs moved", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "resume");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const { service, adapter } = createTestService(baseDir);
+    const session = await service.attach("safari", { type: "indexed", windowIndex: 2, tabIndex: 3 });
+    adapter.setMode("moved");
+    const resumed = await service.resumeSession(session.id);
+    strict_1.default.equal(resumed.session.id, session.id);
+    strict_1.default.equal(resumed.tab.windowIndex, 5);
+    strict_1.default.equal(resumed.resolution.strategy, "signature");
+});
+(0, node_test_1.default)("store hydrates additive session metadata for older saved payloads", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "session-hydration");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const sessionPath = (0, node_path_1.resolve)(baseDir, "sessions.json");
+    await (0, promises_1.writeFile)(sessionPath, JSON.stringify([
+        {
+            id: "legacy-session",
+            browser: "chrome",
+            target: {
+                type: "signature",
+                signature: "example-two",
+                url: "https://example.com/two",
+                title: "Example Two"
+            },
+            tab: {
+                browser: "chrome",
+                windowIndex: 1,
+                tabIndex: 2,
+                title: "Example Two",
+                url: "https://example.com/two",
+                attachedAt: "2026-01-01T00:00:00.000Z",
+                identity: {
+                    signature: "example-two",
+                    urlKey: "https://example.com/two",
+                    titleKey: "example two",
+                    origin: "https://example.com",
+                    pathname: "/two"
+                }
+            },
+            frontTab: {
+                browser: "chrome",
+                windowIndex: 1,
+                tabIndex: 2,
+                title: "Example Two",
+                url: "https://example.com/two",
+                attachedAt: "2026-01-01T00:00:00.000Z",
+                identity: {
+                    signature: "example-two",
+                    urlKey: "https://example.com/two",
+                    titleKey: "example two",
+                    origin: "https://example.com",
+                    pathname: "/two"
+                }
+            },
+            createdAt: "2026-01-01T00:00:00.000Z"
+        }
+    ], null, 2) + "\n", "utf8");
+    const store = new session_store_1.SessionStore({ filePath: sessionPath });
+    const [session] = await store.list();
+    strict_1.default.equal(session.schemaVersion, 1);
+    strict_1.default.equal(session.kind, "chrome-readonly");
+    strict_1.default.equal(session.attach.mode, "direct");
+    strict_1.default.equal(session.attach.source, "user-browser");
+    strict_1.default.equal(session.attach.scope, "browser");
+    strict_1.default.equal(session.status.state, "read-only");
+    strict_1.default.equal(session.status.canAct, false);
+    strict_1.default.equal(session.capabilities.resume, true);
+    strict_1.default.equal(session.capabilities.activate, false);
+    strict_1.default.equal(session.capabilities.navigate, false);
+    strict_1.default.equal(session.capabilities.screenshot, false);
+});
+(0, node_test_1.default)("activate, navigate, diagnostics, and session navigation work through the service", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "actions");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const { service, adapter } = createTestService(baseDir);
+    const activation = await service.activate("safari", { type: "indexed", windowIndex: 2, tabIndex: 3 });
+    strict_1.default.equal(activation.tab.url, "https://example.com");
+    const navigation = await service.navigate("safari", { type: "indexed", windowIndex: 2, tabIndex: 3 }, { url: "https://example.com/next" });
+    strict_1.default.equal(navigation.previousTab.url, "https://example.com");
+    strict_1.default.equal(navigation.tab.url, "https://example.com/next");
+    const diagnostics = await service.diagnostics("safari");
+    strict_1.default.equal(diagnostics.supportedFeatures.navigate, true);
+    strict_1.default.equal(diagnostics.preflight?.automation.ready, true);
+    const session = await service.attach("safari", { type: "indexed", windowIndex: 2, tabIndex: 3 });
+    adapter.setMode("moved");
+    const sessionNavigation = await service.navigateSession(session.id, { url: "https://example.com/renamed" });
+    strict_1.default.equal(sessionNavigation.navigation.previousTab.windowIndex, 5);
+    strict_1.default.equal(sessionNavigation.navigation.tab.url, "https://example.com/renamed");
+    strict_1.default.equal(sessionNavigation.session.target.type, "signature");
+    strict_1.default.equal(sessionNavigation.session.tab.url, "https://example.com/renamed");
+});
+(0, node_test_1.default)("screenshot writes a file for a target and session screenshot resolves from saved session", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "screenshot");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const { service, adapter } = createTestService(baseDir);
+    const screenshotPath = (0, node_path_1.resolve)(baseDir, "target.png");
+    const targetScreenshot = await service.screenshot("safari", { type: "indexed", windowIndex: 2, tabIndex: 3 }, { outputPath: screenshotPath });
+    strict_1.default.equal(targetScreenshot.outputPath, screenshotPath);
+    strict_1.default.equal(await (0, promises_1.readFile)(screenshotPath, "utf8"), "fake-png");
+    const session = await service.attach("safari", { type: "indexed", windowIndex: 2, tabIndex: 3 });
+    adapter.setMode("moved");
+    const sessionScreenshotPath = (0, node_path_1.resolve)(baseDir, "session.png");
+    const sessionScreenshot = await service.screenshotSession(session.id, { outputPath: sessionScreenshotPath });
+    strict_1.default.equal(sessionScreenshot.screenshot.tab.windowIndex, 5);
+    strict_1.default.equal(await (0, promises_1.readFile)(sessionScreenshotPath, "utf8"), "fake-png");
+});
+(0, node_test_1.default)("http server exposes diagnostics, navigation, session navigation, and structured errors", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "http");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const { service, adapter } = createTestService(baseDir);
+    const server = (0, http_1.createApiServer)(service);
+    await new Promise((resolvePromise) => server.listen(0, "127.0.0.1", resolvePromise));
+    const address = server.address();
+    strict_1.default.ok(address && typeof address === "object");
+    const baseUrl = `http://127.0.0.1:${address.port}`;
+    const diagnostics = await fetch(`${baseUrl}/v1/diagnostics?browser=safari`);
+    strict_1.default.equal(diagnostics.status, 200);
+    const diagnosticsPayload = (await diagnostics.json());
+    strict_1.default.equal(diagnosticsPayload.diagnostics.supportedFeatures.navigate, true);
+    strict_1.default.equal(diagnosticsPayload.diagnostics.preflight?.automation.ready, true);
+    const capabilities = await fetch(`${baseUrl}/v1/capabilities?browser=safari`);
+    strict_1.default.equal(capabilities.status, 200);
+    const capabilitiesPayload = (await capabilities.json());
+    strict_1.default.equal(capabilitiesPayload.capabilities.schemaVersion, 1);
+    strict_1.default.equal(capabilitiesPayload.capabilities.schema.path, "schema/capabilities.schema.json");
+    strict_1.default.equal(capabilitiesPayload.capabilities.schema.version, "1.0.0");
+    strict_1.default.equal(capabilitiesPayload.capabilities.product.manifestoPath, "docs/product-direction.md");
+    strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].kind, "safari-actionable");
+    strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].browser, "safari");
+    strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].operations.screenshot, true);
+    const attach = await fetch(`${baseUrl}/v1/attach`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ browser: "safari", target: { windowIndex: 2, tabIndex: 3 } })
+    });
+    const attachPayload = (await attach.json());
+    strict_1.default.equal(attachPayload.session.schemaVersion, 1);
+    strict_1.default.equal(attachPayload.session.kind, "safari-actionable");
+    strict_1.default.equal(attachPayload.session.status.state, "actionable");
+    strict_1.default.equal(attachPayload.session.capabilities.navigate, true);
+    strict_1.default.equal(attachPayload.session.capabilities.screenshot, true);
+    const navigate = await fetch(`${baseUrl}/v1/navigate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            browser: "safari",
+            target: { signature: "example-signature", url: "https://example.com", title: "Example" },
+            url: "https://example.com/next"
+        })
+    });
+    strict_1.default.equal(navigate.status, 201);
+    const navigatePayload = (await navigate.json());
+    strict_1.default.equal(navigatePayload.navigation.requestedUrl, "https://example.com/next");
+    strict_1.default.equal(navigatePayload.navigation.tab.url, "https://example.com/next");
+    adapter.setMode("moved");
+    const sessionNavigate = await fetch(`${baseUrl}/v1/sessions/${attachPayload.session.id}/navigate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ url: "https://example.com/from-session" })
+    });
+    strict_1.default.equal(sessionNavigate.status, 201);
+    const sessionNavigatePayload = (await sessionNavigate.json());
+    strict_1.default.equal(sessionNavigatePayload.sessionNavigation.navigation.previousTab.windowIndex, 5);
+    strict_1.default.equal(sessionNavigatePayload.sessionNavigation.navigation.tab.url, "https://example.com/from-session");
+    strict_1.default.equal(sessionNavigatePayload.sessionNavigation.session.tab.url, "https://example.com/from-session");
+    strict_1.default.equal(sessionNavigatePayload.sessionNavigation.session.status.state, "actionable");
+    const missingUrl = await fetch(`${baseUrl}/v1/navigate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ browser: "safari", target: { windowIndex: 2, tabIndex: 3 } })
+    });
+    strict_1.default.equal(missingUrl.status, 400);
+    strict_1.default.deepEqual(await missingUrl.json(), {
+        error: {
+            code: "missing_url",
+            message: "url is required.",
+            statusCode: 400
+        }
+    });
+    await new Promise((resolvePromise, reject) => server.close((error) => (error ? reject(error) : resolvePromise())));
+});
+(0, node_test_1.default)("cli prints diagnostics JSON and machine-readable errors", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "cli");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const { service } = createTestService(baseDir);
+    const diagnosticsResult = await withCapturedStreams(async () => {
+        await (0, cli_1.runCli)(["diagnostics", "--browser", "safari"], service);
+    });
+    const diagnosticsPayload = JSON.parse(diagnosticsResult.stdout);
+    strict_1.default.equal(diagnosticsPayload.diagnostics.browser, "safari");
+    strict_1.default.equal(diagnosticsPayload.diagnostics.preflight?.inspect.ready, true);
+    const capabilitiesResult = await withCapturedStreams(async () => {
+        await (0, cli_1.runCli)(["capabilities", "--browser", "safari"], service);
+    });
+    const capabilitiesPayload = JSON.parse(capabilitiesResult.stdout);
+    strict_1.default.equal(capabilitiesPayload.capabilities.schemaVersion, 1);
+    strict_1.default.equal(capabilitiesPayload.capabilities.product.name, "local-browser-bridge");
+    strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].kind, "safari-actionable");
+    strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].browser, "safari");
+    strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].operations.attach, true);
+    const doctorResult = await withCapturedStreams(async () => {
+        await (0, cli_1.runCli)(["doctor", "--route", "safari"], service);
+    });
+    const doctorPayload = JSON.parse(doctorResult.stdout);
+    strict_1.default.equal(doctorPayload.ok, true);
+    strict_1.default.equal(doctorPayload.blocked, false);
+    strict_1.default.equal(doctorPayload.route.name, "safari");
+    strict_1.default.equal(doctorPayload.route.browser, "safari");
+    strict_1.default.equal(doctorPayload.route.attachMode, "direct");
+    strict_1.default.equal(doctorPayload.routeUx.label, "Safari (actionable)");
+    strict_1.default.equal(doctorPayload.routeUx.readOnly, false);
+    strict_1.default.equal(doctorPayload.nextStep.action, "connect");
+    strict_1.default.equal(doctorPayload.nextStep.command, "local-browser-bridge connect --route safari");
+    strict_1.default.match(doctorPayload.summary, /Safari \(actionable\) is ready/i);
+    const attachResult = await withCapturedStreams(async () => {
+        await (0, cli_1.runCli)(["attach", "--browser", "safari", "--window-index", "2", "--tab-index", "3"], service);
+    });
+    const attachPayload = JSON.parse(attachResult.stdout);
+    strict_1.default.equal(attachPayload.session.schemaVersion, 1);
+    strict_1.default.equal(attachPayload.session.kind, "safari-actionable");
+    strict_1.default.equal(attachPayload.session.status.state, "actionable");
+    strict_1.default.equal(attachPayload.session.capabilities.navigate, true);
+    strict_1.default.equal(attachPayload.session.capabilities.screenshot, true);
+    const connectResult = await withCapturedStreams(async () => {
+        await (0, cli_1.runCli)(["connect", "--route", "safari"], service);
+    });
+    const connectPayload = JSON.parse(connectResult.stdout);
+    strict_1.default.equal(connectPayload.ok, true);
+    strict_1.default.equal(connectPayload.connected, true);
+    strict_1.default.equal(connectPayload.routeUx.label, "Safari (actionable)");
+    strict_1.default.equal(connectPayload.sessionUx.label, "Safari (actionable)");
+    strict_1.default.equal(connectPayload.sessionUx.readOnly, false);
+    strict_1.default.equal(connectPayload.session.kind, "safari-actionable");
+    strict_1.default.equal(connectPayload.session.status.state, "actionable");
+    strict_1.default.equal(connectPayload.nextStep.action, "session-ready");
+    strict_1.default.match(connectPayload.nextStep.prompt, /activate, navigate, or screenshot/i);
+    strict_1.default.match(connectPayload.summary, /Connected Safari \(actionable\) session/i);
+    const errorResult = await withCapturedStreams(async () => {
+        try {
+            await (0, cli_1.runCli)(["navigate", "--browser", "safari"], service);
+        }
+        catch (error) {
+            const { payload } = (0, errors_1.toErrorPayload)(error);
+            process.stderr.write(JSON.stringify(payload, null, 2) + "\n");
+        }
+    });
+    const errorPayload = JSON.parse(errorResult.stderr);
+    strict_1.default.equal(errorPayload.error.code, "missing_url");
+    strict_1.default.equal(errorPayload.error.statusCode, 400);
+});
+async function withChromeDevtoolsFixture(run) {
+    let scenario = "stable";
+    const server = (0, node_http_1.createServer)((request, response) => {
+        if (request.url === "/json/version") {
+            response.writeHead(200, { "content-type": "application/json" });
+            response.end(JSON.stringify({ Browser: "Chrome/123.0.0.0", ProtocolVersion: "1.3" }));
+            return;
+        }
+        if (request.url === "/json/list") {
+            const payload = scenario === "moved"
+                ? [
+                    {
+                        id: "page-1",
+                        type: "page",
+                        title: "Example One",
+                        url: "https://example.com/one"
+                    },
+                    {
+                        id: "page-2",
+                        type: "page",
+                        title: "Retitled Two",
+                        url: "https://example.com/two-renamed",
+                        attached: true,
+                        openerId: "page-1",
+                        browserContextId: "context-1"
+                    }
+                ]
+                : [
+                    { id: "page-1", type: "page", title: "Example One", url: "https://example.com/one" },
+                    {
+                        id: "page-2",
+                        type: "page",
+                        title: "Example Two",
+                        url: "https://example.com/two",
+                        attached: false,
+                        openerId: "page-1",
+                        browserContextId: "context-1"
+                    },
+                    { id: "worker-1", type: "service_worker", title: "Worker", url: "https://example.com/sw.js" }
+                ];
+            response.writeHead(200, { "content-type": "application/json" });
+            response.end(JSON.stringify(payload));
+            return;
+        }
+        response.writeHead(404, { "content-type": "application/json" });
+        response.end(JSON.stringify({ error: "not found" }));
+    });
+    await new Promise((resolvePromise) => server.listen(0, "127.0.0.1", resolvePromise));
+    const address = server.address();
+    strict_1.default.ok(address && typeof address === "object");
+    const baseUrl = `http://127.0.0.1:${address.port}`;
+    const previous = process.env.LOCAL_BROWSER_BRIDGE_CHROME_DEBUG_URL;
+    process.env.LOCAL_BROWSER_BRIDGE_CHROME_DEBUG_URL = baseUrl;
+    try {
+        return await run(baseUrl, (nextScenario) => {
+            scenario = nextScenario;
+        });
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env.LOCAL_BROWSER_BRIDGE_CHROME_DEBUG_URL;
+        }
+        else {
+            process.env.LOCAL_BROWSER_BRIDGE_CHROME_DEBUG_URL = previous;
+        }
+        await new Promise((resolvePromise, reject) => server.close((error) => (error ? reject(error) : resolvePromise())));
+    }
+}
+async function withChromeRelayStateFixture(state, run) {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "chrome-relay");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    const statePath = (0, node_path_1.resolve)(baseDir, "chrome-relay-state.json");
+    await (0, promises_1.writeFile)(statePath, JSON.stringify(state, null, 2), "utf8");
+    const previous = process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH;
+    process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH = statePath;
+    try {
+        return await run(statePath);
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH;
+        }
+        else {
+            process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH = previous;
+        }
+    }
+}
+async function withChromeRelayStatePathOverride(value, run) {
+    const previous = process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH;
+    if (value === undefined) {
+        delete process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH;
+    }
+    else {
+        process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH = value;
+    }
+    try {
+        return await run();
+    }
+    finally {
+        if (previous === undefined) {
+            delete process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH;
+        }
+        else {
+            process.env.LOCAL_BROWSER_BRIDGE_CHROME_RELAY_STATE_PATH = previous;
+        }
+    }
+}
+(0, node_test_1.default)("safari runtime errors classify permission, availability, and target-loss states truthfully", async () => {
+    const automationDenied = (0, safari_1.classifySafariRuntimeError)("activate", new Error("execution error: Not authorized to send Apple events to Safari. (-1743)"));
+    strict_1.default.equal(automationDenied.code, "automation_permission_denied");
+    strict_1.default.equal(automationDenied.statusCode, 403);
+    strict_1.default.match(automationDenied.message, /automation\/apple events permission/i);
+    const screenshotDenied = (0, safari_1.classifySafariRuntimeError)("screenshot", new Error("screencapture: not permitted to capture screen"));
+    strict_1.default.equal(screenshotDenied.code, "screen_recording_permission_denied");
+    strict_1.default.equal(screenshotDenied.statusCode, 403);
+    strict_1.default.match(screenshotDenied.message, /screen recording permission/i);
+    const preflightDenied = (0, safari_1.classifySafariRuntimeError)("screenshot", new Error("CGPreflightScreenCaptureAccess returned false. Screen recording permission is required before Safari screenshots can be captured."));
+    strict_1.default.equal(preflightDenied.code, "screen_recording_permission_denied");
+    strict_1.default.equal(preflightDenied.statusCode, 403);
+    strict_1.default.match(preflightDenied.message, /screen recording permission/i);
+    const notRunning = (0, safari_1.classifySafariRuntimeError)("inspect", new Error("Safari is not running."));
+    strict_1.default.equal(notRunning.code, "browser_not_running");
+    strict_1.default.equal(notRunning.statusCode, 503);
+    strict_1.default.match(notRunning.message, /not running/i);
+    const noWindows = (0, safari_1.classifySafariRuntimeError)("inspect", new Error("Safari has no open windows."));
+    strict_1.default.equal(noWindows.code, "browser_unavailable");
+    strict_1.default.equal(noWindows.statusCode, 503);
+    strict_1.default.match(noWindows.message, /no open windows/i);
+    const missingTarget = (0, safari_1.classifySafariRuntimeError)("navigate", new Error("Safari target tab is no longer available."));
+    strict_1.default.equal(missingTarget.code, "tab_not_found");
+    strict_1.default.equal(missingTarget.statusCode, 404);
+    strict_1.default.match(missingTarget.message, /attach or resume/i);
+    const invalidBounds = (0, safari_1.classifySafariRuntimeError)("screenshot", new Error("Safari target window bounds are unavailable or invalid for screenshot capture."));
+    strict_1.default.equal(invalidBounds.code, "window_bounds_unavailable");
+    strict_1.default.equal(invalidBounds.statusCode, 503);
+    strict_1.default.match(invalidBounds.message, /aborted before calling screencapture/i);
+    const rejectedRect = (0, safari_1.classifySafariRuntimeError)("screenshot", new Error("Command failed: screencapture -x -R 0,31,1440,869 out.png\ncould not create image from rect\n"));
+    strict_1.default.equal(rejectedRect.code, "screenshot_capture_failed");
+    strict_1.default.equal(rejectedRect.statusCode, 503);
+    strict_1.default.match(rejectedRect.message, /rejected the safari window region/i);
+});
+(0, node_test_1.default)("safari window bounds validator accepts only finite positive screenshot regions", () => {
+    strict_1.default.equal((0, safari_1.isValidSafariWindowBounds)({ x: 10, y: 20, width: 1200, height: 800, reorderedWindowToFront: true }), true);
+    strict_1.default.equal((0, safari_1.isValidSafariWindowBounds)({ x: 10, y: 20, width: 0, height: 800, reorderedWindowToFront: true }), false);
+    strict_1.default.equal((0, safari_1.isValidSafariWindowBounds)({ x: 10, y: 20, width: Number.NaN, height: 800, reorderedWindowToFront: true }), false);
+    strict_1.default.equal((0, safari_1.isValidSafariWindowBounds)(null), false);
+});
+(0, node_test_1.default)("safari tab resolution errors distinguish no windows, no inspectable tabs, and missing targets", () => {
+    const noWindows = (0, safari_1.classifySafariTabResolutionError)({ type: "front" }, {
+        tabs: [],
+        windowCount: 0,
+        inspectableWindowCount: 0,
+        tabCount: 0
+    });
+    strict_1.default.equal(noWindows.code, "browser_no_windows");
+    strict_1.default.equal(noWindows.statusCode, 503);
+    strict_1.default.match(noWindows.message, /no open windows/i);
+    const noInspectableTabs = (0, safari_1.classifySafariTabResolutionError)({ type: "front" }, {
+        tabs: [],
+        windowCount: 2,
+        inspectableWindowCount: 0,
+        tabCount: 0
+    });
+    strict_1.default.equal(noInspectableTabs.code, "browser_no_tabs");
+    strict_1.default.equal(noInspectableTabs.statusCode, 503);
+    strict_1.default.match(noInspectableTabs.message, /no inspectable tabs/i);
+    const indexedNoInspectableTabs = (0, safari_1.classifySafariTabResolutionError)({ type: "indexed", windowIndex: 1, tabIndex: 1 }, {
+        tabs: [],
+        windowCount: 1,
+        inspectableWindowCount: 0,
+        tabCount: 0
+    });
+    strict_1.default.equal(indexedNoInspectableTabs.code, "browser_no_tabs");
+    strict_1.default.equal(indexedNoInspectableTabs.statusCode, 503);
+    strict_1.default.match(indexedNoInspectableTabs.message, /resolve/i);
+    const missingIndexed = (0, safari_1.classifySafariTabResolutionError)({ type: "indexed", windowIndex: 9, tabIndex: 4 }, {
+        tabs: [
+            {
+                browser: "safari",
+                windowIndex: 1,
+                tabIndex: 1,
+                title: "Front",
+                url: "https://example.com",
+                isFrontWindow: true,
+                isActiveInWindow: true
+            }
+        ],
+        windowCount: 1,
+        inspectableWindowCount: 1,
+        tabCount: 1
+    });
+    strict_1.default.equal(missingIndexed.code, "tab_not_found");
+    strict_1.default.equal(missingIndexed.statusCode, 404);
+    strict_1.default.match(missingIndexed.message, /window 9, tab 4/i);
+});
+(0, node_test_1.default)("safari inspection snapshot parsing preserves inspectable tabs and skips broken windows", () => {
+    const snapshot = (0, safari_1.parseSafariInspectionSnapshot)(JSON.stringify({
+        tabs: [
+            {
+                browser: "safari",
+                windowIndex: 2,
+                tabIndex: 1,
+                title: "Inspectable",
+                url: "https://example.com",
+                isFrontWindow: false,
+                isActiveInWindow: true
+            }
+        ],
+        windowCount: 3,
+        inspectableWindowCount: 1,
+        tabCount: 1
+    }));
+    strict_1.default.equal(snapshot.windowCount, 3);
+    strict_1.default.equal(snapshot.inspectableWindowCount, 1);
+    strict_1.default.equal(snapshot.tabCount, 1);
+    strict_1.default.equal(snapshot.tabs.length, 1);
+    strict_1.default.equal(snapshot.tabs[0]?.windowIndex, 2);
+    strict_1.default.equal(snapshot.tabs[0]?.title, "Inspectable");
+});
+(0, node_test_1.default)("safari diagnostics preflight exposes machine-readable readiness and blockers", async () => {
+    const ready = (0, safari_1.buildSafariPreflight)({
+        osascriptAvailable: true,
+        screencaptureAvailable: true,
+        applicationAvailable: true,
+        safariRunning: true,
+        windowCount: 2,
+        inspectableWindowCount: 2,
+        tabCount: 4
+    });
+    strict_1.default.equal(ready.inspect.ready, true);
+    strict_1.default.equal(ready.automation.ready, true);
+    strict_1.default.equal(ready.screenshot.ready, true);
+    strict_1.default.equal(ready.inspect.blockers.length, 0);
+    const noWindows = (0, safari_1.buildSafariPreflight)({
+        osascriptAvailable: true,
+        screencaptureAvailable: true,
+        applicationAvailable: true,
+        safariRunning: true,
+        windowCount: 0,
+        inspectableWindowCount: 0,
+        tabCount: 0
+    });
+    strict_1.default.equal(noWindows.inspect.ready, false);
+    strict_1.default.equal(noWindows.automation.ready, false);
+    strict_1.default.equal(noWindows.screenshot.ready, false);
+    strict_1.default.equal(noWindows.inspect.blockers[0]?.code, "browser_no_windows");
+    const noInspectableTabs = (0, safari_1.buildSafariPreflight)({
+        osascriptAvailable: true,
+        screencaptureAvailable: true,
+        applicationAvailable: true,
+        safariRunning: true,
+        windowCount: 2,
+        inspectableWindowCount: 0,
+        tabCount: 0
+    });
+    strict_1.default.equal(noInspectableTabs.inspect.ready, false);
+    strict_1.default.equal(noInspectableTabs.automation.ready, false);
+    strict_1.default.equal(noInspectableTabs.screenshot.ready, false);
+    strict_1.default.equal(noInspectableTabs.inspect.blockers[0]?.code, "browser_no_tabs");
+    strict_1.default.match(noInspectableTabs.inspect.blockers[0]?.message ?? "", /special or transient windows/i);
+    const permissionDenied = (0, safari_1.buildSafariPreflight)({
+        osascriptAvailable: true,
+        screencaptureAvailable: true,
+        applicationAvailable: true,
+        safariRunning: true,
+        probeError: new Error("execution error: Not authorized to send Apple events to Safari. (-1743)")
+    });
+    strict_1.default.equal(permissionDenied.inspect.ready, false);
+    strict_1.default.equal(permissionDenied.automation.blockers[0]?.code, "automation_permission_denied");
+    strict_1.default.equal(permissionDenied.screenshot.blockers[0]?.code, "automation_permission_denied");
+    const screenshotHostBlocked = (0, safari_1.buildSafariPreflight)({
+        osascriptAvailable: true,
+        screencaptureAvailable: false,
+        applicationAvailable: true,
+        safariRunning: true,
+        windowCount: 1,
+        inspectableWindowCount: 1,
+        tabCount: 1
+    });
+    strict_1.default.equal(screenshotHostBlocked.inspect.ready, true);
+    strict_1.default.equal(screenshotHostBlocked.automation.ready, true);
+    strict_1.default.equal(screenshotHostBlocked.screenshot.ready, false);
+    strict_1.default.equal(screenshotHostBlocked.screenshot.blockers[0]?.code, "host_tool_missing");
+    const screenRecordingDenied = (0, safari_1.buildSafariPreflight)({
+        osascriptAvailable: true,
+        screencaptureAvailable: true,
+        applicationAvailable: true,
+        safariRunning: true,
+        screenRecordingPermissionGranted: false,
+        windowCount: 1,
+        inspectableWindowCount: 1,
+        tabCount: 1
+    });
+    strict_1.default.equal(screenRecordingDenied.inspect.ready, true);
+    strict_1.default.equal(screenRecordingDenied.automation.ready, true);
+    strict_1.default.equal(screenRecordingDenied.screenshot.ready, false);
+    strict_1.default.equal(screenRecordingDenied.screenshot.blockers[0]?.code, "screen_recording_permission_denied");
+    strict_1.default.match(screenRecordingDenied.screenshot.blockers[0]?.message ?? "", /screen recording/i);
+});
+(0, node_test_1.default)("chrome capabilities expose read-only inspection and chromium normalizes to chrome", async () => {
+    strict_1.default.equal((0, browser_1.normalizeBrowser)("chromium"), "chrome");
+    const service = new attach_service_1.AttachService();
+    const capabilities = service.getCapabilities();
+    const chrome = capabilities.browsers.find((browser) => browser.browser === "chrome");
+    strict_1.default.ok(chrome);
+    strict_1.default.equal(chrome.kind, "chrome-readonly");
+    strict_1.default.equal(chrome.maturity, "experimental-readonly");
+    strict_1.default.equal(chrome.attachModes?.[0]?.mode, "direct");
+    strict_1.default.equal(chrome.attachModes?.[0]?.source, "user-browser");
+    strict_1.default.equal(chrome.attachModes?.[1]?.mode, "relay");
+    strict_1.default.equal(chrome.attachModes?.[1]?.scope, "tab");
+    strict_1.default.equal(chrome.operations.capabilities, true);
+    strict_1.default.equal(chrome.operations.diagnostics, true);
+    strict_1.default.equal(chrome.operations.inspectFrontTab, true);
+    strict_1.default.equal(chrome.operations.inspectTab, true);
+    strict_1.default.equal(chrome.operations.listTabs, true);
+    strict_1.default.equal(chrome.operations.attach, true);
+    strict_1.default.equal(chrome.operations.resumeSession, true);
+    strict_1.default.equal(chrome.operations.navigate, false);
+    strict_1.default.equal(chrome.operations.screenshot, false);
+});
+(0, node_test_1.default)("chrome diagnostics expose discovery candidates and selected endpoint", async () => {
+    await withChromeRelayStatePathOverride((0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "missing-relay-state.json"), async () => {
+        await withChromeDevtoolsFixture(async (baseUrl) => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.browser, "chrome");
+            strict_1.default.equal(diagnostics.supportedFeatures.inspectTabs, true);
+            strict_1.default.equal(diagnostics.supportedFeatures.attach, true);
+            strict_1.default.equal(diagnostics.supportedFeatures.navigate, false);
+            strict_1.default.equal(diagnostics.supportedFeatures.savedSessions, true);
+            strict_1.default.equal(diagnostics.adapter?.mode, "chrome-devtools-readonly");
+            strict_1.default.equal(diagnostics.attach?.direct.mode, "direct");
+            strict_1.default.equal(diagnostics.attach?.direct.scope, "browser");
+            strict_1.default.equal(diagnostics.attach?.direct.ready, true);
+            strict_1.default.match(String(diagnostics.attach?.direct.state), /ready|degraded/);
+            strict_1.default.equal(diagnostics.attach?.relay.mode, "relay");
+            strict_1.default.equal(diagnostics.attach?.relay.ready, false);
+            strict_1.default.equal(diagnostics.attach?.relay.state, "unavailable");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers[0]?.code, "relay_probe_not_configured");
+            strict_1.default.equal(diagnostics.adapter?.discovery?.selectedBaseUrl, baseUrl);
+            strict_1.default.match(diagnostics.constraints.join(" "), /read-only/i);
+            strict_1.default.ok((diagnostics.adapter?.discovery?.candidates.length ?? 0) >= 1);
+        });
+    });
+});
+(0, node_test_1.default)("chrome relay diagnostics differentiate local probe states and report relay readiness truthfully", async () => {
+    await withChromeDevtoolsFixture(async () => {
+        await withChromeRelayStateFixture({
+            version: "1.0.0",
+            updatedAt: "2026-03-28T10:00:00.000Z",
+            extensionInstalled: false
+        }, async (statePath) => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.attach?.relay.ready, false);
+            strict_1.default.equal(diagnostics.attach?.relay.state, "unavailable");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers[0]?.code, "relay_extension_not_installed");
+            strict_1.default.match(diagnostics.attach?.relay.notes?.join(" ") ?? "", new RegExp(statePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+        });
+        await withChromeRelayStateFixture({
+            extensionInstalled: true,
+            connected: false
+        }, async () => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.attach?.relay.state, "unavailable");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers[0]?.code, "relay_extension_disconnected");
+        });
+        await withChromeRelayStateFixture({
+            extensionInstalled: true,
+            connected: true,
+            shareRequired: true,
+            sharedTab: {
+                id: "tab-contradiction"
+            }
+        }, async () => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.attach?.relay.state, "unavailable");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers[0]?.code, "relay_probe_invalid");
+        });
+        await withChromeRelayStateFixture({
+            extensionInstalled: true,
+            connected: true,
+            userGestureRequired: true
+        }, async () => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.attach?.relay.state, "attention-required");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers[0]?.code, "relay_toolbar_not_clicked");
+        });
+        await withChromeRelayStateFixture({
+            extensionInstalled: true,
+            connected: true,
+            shareRequired: true
+        }, async () => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.attach?.relay.state, "attention-required");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers[0]?.code, "relay_share_required");
+        });
+        await withChromeRelayStateFixture({
+            extensionInstalled: true,
+            connected: true,
+            sharedTab: null
+        }, async () => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.attach?.relay.state, "unavailable");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers[0]?.code, "relay_no_shared_tab");
+        });
+        await withChromeRelayStateFixture({
+            version: "1.1.0",
+            updatedAt: "2026-03-28T11:00:00.000Z",
+            extensionInstalled: true,
+            connected: true,
+            sharedTab: {
+                id: "tab-123",
+                title: "Relay Example",
+                url: "https://example.com/shared"
+            }
+        }, async () => {
+            const service = new attach_service_1.AttachService();
+            const diagnostics = await service.diagnostics("chrome");
+            strict_1.default.equal(diagnostics.attach?.relay.ready, true);
+            strict_1.default.equal(diagnostics.attach?.relay.state, "ready");
+            strict_1.default.equal(diagnostics.attach?.relay.blockers.length, 0);
+            strict_1.default.match(diagnostics.attach?.relay.notes?.join(" ") ?? "", /shared tab detected/i);
+        });
+    });
+});
+(0, node_test_1.default)("chrome relay attach creates a read-only tab-scoped session and resumes when relay state still matches", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "chrome-relay-attach-session");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    await withChromeRelayStateFixture({
+        version: "1.1.0",
+        updatedAt: "2026-03-28T11:00:00.000Z",
+        extensionInstalled: true,
+        connected: true,
+        resumable: true,
+        expiresAt: "2099-03-28T12:00:00.000Z",
+        sharedTab: {
+            id: "tab-123",
+            title: "Relay Example",
+            url: "https://example.com/shared"
+        }
+    }, async (statePath) => {
+        const service = new attach_service_1.AttachService({
+            store: new session_store_1.SessionStore({ filePath: (0, node_path_1.resolve)(baseDir, "sessions.json") })
+        });
+        const session = await service.attach("chrome", {
+            target: { type: "front" },
+            attach: { mode: "relay" }
+        });
+        strict_1.default.equal(session.kind, "chrome-readonly");
+        strict_1.default.equal(session.attach.mode, "relay");
+        strict_1.default.equal(session.attach.source, "extension-relay");
+        strict_1.default.equal(session.attach.scope, "tab");
+        strict_1.default.equal(session.attach.resumable, true);
+        strict_1.default.equal(session.attach.expiresAt, "2099-03-28T12:00:00.000Z");
+        strict_1.default.equal(session.semantics.inspect, "shared-tab-only");
+        strict_1.default.equal(session.semantics.resume, "current-shared-tab");
+        strict_1.default.equal(session.semantics.tabReference.windowIndex, "synthetic-shared-tab-position");
+        strict_1.default.equal(session.status.state, "read-only");
+        strict_1.default.equal(session.capabilities.navigate, false);
+        strict_1.default.equal(session.tab.url, "https://example.com/shared");
+        strict_1.default.equal(session.target.type, "signature");
+        await (0, promises_1.writeFile)(statePath, JSON.stringify({
+            version: "1.1.0",
+            updatedAt: "2026-03-28T11:30:00.000Z",
+            extensionInstalled: true,
+            connected: true,
+            resumable: false,
+            resumeRequiresUserGesture: false,
+            expiresAt: "2099-03-28T13:00:00.000Z",
+            sharedTab: {
+                id: "tab-123",
+                title: "Relay Example",
+                url: "https://example.com/shared"
+            }
+        }, null, 2), "utf8");
+        const resumed = await service.resumeSession(session.id);
+        strict_1.default.equal(resumed.resolution.strategy, "signature");
+        strict_1.default.equal(resumed.resolution.attachMode, "relay");
+        strict_1.default.equal(resumed.resolution.semantics, "current-shared-tab");
+        strict_1.default.equal(resumed.tab.url, "https://example.com/shared");
+        strict_1.default.equal(resumed.session.kind, "chrome-readonly");
+        strict_1.default.equal(resumed.session.attach.mode, "relay");
+        strict_1.default.equal(resumed.session.attach.source, "extension-relay");
+        strict_1.default.equal(resumed.session.attach.scope, "tab");
+        strict_1.default.equal(resumed.session.attach.trustedAt, "2026-03-28T11:30:00.000Z");
+        strict_1.default.equal(resumed.session.attach.resumable, false);
+        strict_1.default.equal(resumed.session.attach.resumeRequiresUserGesture, false);
+        strict_1.default.equal(resumed.session.attach.expiresAt, "2099-03-28T13:00:00.000Z");
+        strict_1.default.equal(resumed.session.semantics.inspect, "shared-tab-only");
+        strict_1.default.equal(resumed.session.semantics.resume, "current-shared-tab");
+        strict_1.default.equal(resumed.session.tab.title, "Relay Example");
+        strict_1.default.equal(resumed.session.frontTab.url, "https://example.com/shared");
+        strict_1.default.equal(resumed.session.target.type, "signature");
+        strict_1.default.equal(resumed.session.target.url, "https://example.com/shared");
+        const refreshed = await service.getSession(session.id);
+        strict_1.default.equal(refreshed.attach.trustedAt, "2026-03-28T11:30:00.000Z");
+        strict_1.default.equal(refreshed.attach.expiresAt, "2099-03-28T13:00:00.000Z");
+        strict_1.default.equal(refreshed.tab.title, "Relay Example");
+    });
+});
+(0, node_test_1.default)("chrome relay resume failures expose structured relay details for consumer branching", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "chrome-relay-resume-errors");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    await withChromeRelayStateFixture({
+        version: "1.1.0",
+        updatedAt: "2026-03-28T11:00:00.000Z",
+        extensionInstalled: true,
+        connected: true,
+        resumable: false,
+        resumeRequiresUserGesture: true,
+        expiresAt: "2099-03-28T12:00:00.000Z",
+        sharedTab: {
+            id: "tab-123",
+            title: "Relay Example",
+            url: "https://example.com/shared"
+        }
+    }, async () => {
+        const service = new attach_service_1.AttachService({
+            store: new session_store_1.SessionStore({ filePath: (0, node_path_1.resolve)(baseDir, "sessions.json") })
+        });
+        const session = await service.attach("chrome", {
+            target: { type: "front" },
+            attach: { mode: "relay" }
+        });
+        await strict_1.default.rejects(() => service.resumeSession(session.id), (error) => {
+            strict_1.default.ok(error instanceof errors_1.AppError);
+            strict_1.default.equal(error.code, "relay_share_required");
+            strict_1.default.equal(error.statusCode, 409);
+            strict_1.default.deepEqual(error.details?.context, {
+                browser: "chrome",
+                attachMode: "relay",
+                operation: "resumeSession"
+            });
+            strict_1.default.equal(error.details?.relay?.branch, "share-original-tab-again");
+            strict_1.default.equal(error.details?.relay?.retryable, true);
+            strict_1.default.equal(error.details?.relay?.userActionRequired, true);
+            strict_1.default.equal(error.details?.relay?.phase, "session-precondition");
+            strict_1.default.equal(error.details?.relay?.sharedTabScope, "current-shared-tab");
+            strict_1.default.equal(error.details?.relay?.resumable, false);
+            strict_1.default.equal(error.details?.relay?.resumeRequiresUserGesture, true);
+            strict_1.default.equal(error.details?.relay?.sessionId, session.id);
+            return true;
+        });
+    });
+});
+(0, node_test_1.default)("chrome relay attach fails with relay-aware errors for unshared or out-of-scope requests", async () => {
+    await withChromeRelayStateFixture({
+        extensionInstalled: true,
+        connected: true,
+        shareRequired: true
+    }, async () => {
+        const service = new attach_service_1.AttachService();
+        await strict_1.default.rejects(() => service.attach("chrome", { target: { type: "front" }, attach: { mode: "relay" } }), (error) => {
+            strict_1.default.ok(error instanceof errors_1.AppError);
+            strict_1.default.equal(error.code, "relay_share_required");
+            strict_1.default.equal(error.statusCode, 503);
+            strict_1.default.deepEqual(error.details?.context, {
+                browser: "chrome",
+                attachMode: "relay",
+                operation: "attach"
+            });
+            strict_1.default.equal(error.details?.relay?.branch, "share-tab");
+            strict_1.default.equal(error.details?.relay?.retryable, true);
+            strict_1.default.equal(error.details?.relay?.userActionRequired, true);
+            strict_1.default.equal(error.details?.relay?.phase, "diagnostics");
+            strict_1.default.equal(error.details?.relay?.sharedTabScope, "current-shared-tab");
+            return true;
+        });
+    });
+    await withChromeRelayStateFixture({
+        extensionInstalled: true,
+        connected: true,
+        sharedTab: {
+            id: "tab-123",
+            title: "Relay Example",
+            url: "https://example.com/shared"
+        }
+    }, async () => {
+        const service = new attach_service_1.AttachService();
+        await strict_1.default.rejects(() => service.attach("chrome", {
+            target: { type: "indexed", windowIndex: 1, tabIndex: 2 },
+            attach: { mode: "relay" }
+        }), (error) => {
+            strict_1.default.ok(error instanceof errors_1.AppError);
+            strict_1.default.equal(error.code, "relay_attach_target_out_of_scope");
+            strict_1.default.equal(error.statusCode, 409);
+            strict_1.default.deepEqual(error.details?.context, {
+                browser: "chrome",
+                attachMode: "relay",
+                operation: "attach"
+            });
+            strict_1.default.equal(error.details?.relay?.branch, "use-current-shared-tab");
+            strict_1.default.equal(error.details?.relay?.retryable, true);
+            strict_1.default.equal(error.details?.relay?.userActionRequired, true);
+            strict_1.default.equal(error.details?.relay?.phase, "target-selection");
+            strict_1.default.equal(error.details?.relay?.sharedTabScope, "current-shared-tab");
+            strict_1.default.equal(error.details?.relay?.currentSharedTabMatches, false);
+            return true;
+        });
+    });
+});
+(0, node_test_1.default)("chrome read-only inspection works while session actions still fail clearly", async () => {
+    await withChromeDevtoolsFixture(async () => {
+        const service = new attach_service_1.AttachService();
+        const tabs = await service.listTabs("chrome");
+        strict_1.default.equal(tabs.length, 2);
+        strict_1.default.equal(tabs[0].title, "Example One");
+        strict_1.default.equal(tabs[1].url, "https://example.com/two");
+        strict_1.default.equal(tabs[1].identity.native?.kind, "chrome-devtools-target");
+        strict_1.default.equal(tabs[1].identity.native?.targetId, "page-2");
+        const front = await service.inspectFrontTab("chrome");
+        strict_1.default.equal(front.url, "https://example.com/one");
+        const resolved = await service.inspectTab("chrome", {
+            type: "signature",
+            signature: tabs[1].identity.signature,
+            url: tabs[1].url,
+            title: tabs[1].title
+        });
+        strict_1.default.equal(resolved.title, "Example Two");
+        await strict_1.default.rejects(() => service.activate("chrome"), (error) => {
+            strict_1.default.ok(error instanceof errors_1.AppError);
+            strict_1.default.equal(error.code, "activation_unavailable");
+            strict_1.default.equal(error.statusCode, 501);
+            strict_1.default.match(error.message, /not implemented/i);
+            return true;
+        });
+        await strict_1.default.rejects(() => service.navigate("chrome", { type: "front" }, { url: "https://example.com" }), (error) => {
+            strict_1.default.ok(error instanceof errors_1.AppError);
+            strict_1.default.equal(error.code, "navigation_unavailable");
+            strict_1.default.equal(error.statusCode, 501);
+            return true;
+        });
+    });
+});
+(0, node_test_1.default)("chrome sessions persist native target identity and resume read-only when metadata changes", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "chrome-resume");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    await withChromeDevtoolsFixture(async (_baseUrl, setScenario) => {
+        const service = new attach_service_1.AttachService({
+            store: new session_store_1.SessionStore({ filePath: (0, node_path_1.resolve)(baseDir, "sessions.json") })
+        });
+        const session = await service.attach("chrome", { type: "indexed", windowIndex: 1, tabIndex: 2 });
+        strict_1.default.equal(session.target.type, "signature");
+        strict_1.default.equal(session.target.type === "signature" ? session.target.native?.targetId : "", "page-2");
+        strict_1.default.equal(session.schemaVersion, 1);
+        strict_1.default.equal(session.kind, "chrome-readonly");
+        strict_1.default.equal(session.attach.mode, "direct");
+        strict_1.default.equal(session.attach.source, "user-browser");
+        strict_1.default.equal(session.attach.scope, "browser");
+        strict_1.default.equal(session.semantics.inspect, "browser-tabs");
+        strict_1.default.equal(session.semantics.resume, "saved-browser-target");
+        strict_1.default.equal(session.semantics.tabReference.tabIndex, "browser-position");
+        strict_1.default.equal(session.status.state, "read-only");
+        strict_1.default.equal(session.status.canAct, false);
+        strict_1.default.equal(session.capabilities.resume, true);
+        strict_1.default.equal(session.capabilities.activate, false);
+        strict_1.default.equal(session.capabilities.navigate, false);
+        strict_1.default.equal(session.capabilities.screenshot, false);
+        setScenario("moved");
+        const resumed = await service.resumeSession(session.id);
+        strict_1.default.equal(resumed.resolution.strategy, "native_identity");
+        strict_1.default.equal(resumed.resolution.attachMode, "direct");
+        strict_1.default.equal(resumed.resolution.semantics, "saved-browser-target");
+        strict_1.default.equal(resumed.tab.url, "https://example.com/two-renamed");
+        strict_1.default.equal(resumed.tab.title, "Retitled Two");
+        strict_1.default.equal(resumed.tab.identity.native?.targetId, "page-2");
+    });
+});
+(0, node_test_1.default)("http and cli surfaces expose chrome read-only details", async () => {
+    const baseDir = (0, node_path_1.resolve)(process.cwd(), ".tmp-tests", "chrome-surfaces");
+    await (0, promises_1.rm)(baseDir, { recursive: true, force: true });
+    await (0, promises_1.mkdir)(baseDir, { recursive: true });
+    await withChromeDevtoolsFixture(async (debugBaseUrl) => {
+        await withChromeRelayStateFixture({
+            version: "1.1.0",
+            updatedAt: "2026-03-28T11:00:00.000Z",
+            extensionInstalled: true,
+            connected: true,
+            resumable: false,
+            resumeRequiresUserGesture: true,
+            expiresAt: "2099-03-28T12:00:00.000Z",
+            sharedTab: {
+                id: "tab-123",
+                title: "Relay Example",
+                url: "https://example.com/shared"
+            }
+        }, async () => {
+            const service = new attach_service_1.AttachService({
+                store: new session_store_1.SessionStore({ filePath: (0, node_path_1.resolve)(baseDir, "sessions.json") })
+            });
+            const server = (0, http_1.createApiServer)(service);
+            await new Promise((resolvePromise) => server.listen(0, "127.0.0.1", resolvePromise));
+            const address = server.address();
+            strict_1.default.ok(address && typeof address === "object");
+            const baseUrl = `http://127.0.0.1:${address.port}`;
+            const capabilities = await fetch(`${baseUrl}/v1/capabilities?browser=chrome`);
+            strict_1.default.equal(capabilities.status, 200);
+            const capabilitiesPayload = (await capabilities.json());
+            strict_1.default.equal(capabilitiesPayload.capabilities.schemaVersion, 1);
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].kind, "chrome-readonly");
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].browser, "chrome");
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].maturity, "experimental-readonly");
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].attachModes?.[0]?.mode, "direct");
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].attachModes?.[1]?.mode, "relay");
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].operations.inspectTab, true);
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].operations.diagnostics, true);
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].operations.attach, true);
+            strict_1.default.equal(capabilitiesPayload.capabilities.browsers[0].operations.resumeSession, true);
+            const frontTab = await fetch(`${baseUrl}/v1/front-tab?browser=chrome`);
+            strict_1.default.equal(frontTab.status, 200);
+            const frontTabPayload = (await frontTab.json());
+            strict_1.default.equal(frontTabPayload.frontTab.url, "https://example.com/one");
+            const diagnostics = await fetch(`${baseUrl}/v1/diagnostics?browser=chrome`);
+            strict_1.default.equal(diagnostics.status, 200);
+            const diagnosticsPayload = (await diagnostics.json());
+            strict_1.default.equal(diagnosticsPayload.diagnostics.adapter?.discovery?.selectedBaseUrl, debugBaseUrl);
+            strict_1.default.equal(diagnosticsPayload.diagnostics.attach?.direct?.mode, "direct");
+            strict_1.default.equal(diagnosticsPayload.diagnostics.attach?.direct?.ready, true);
+            strict_1.default.equal(diagnosticsPayload.diagnostics.attach?.relay?.mode, "relay");
+            strict_1.default.equal(diagnosticsPayload.diagnostics.attach?.relay?.state, "ready");
+            strict_1.default.equal(diagnosticsPayload.diagnostics.attach?.relay?.ready, true);
+            strict_1.default.equal(diagnosticsPayload.diagnostics.supportedFeatures.attach, true);
+            strict_1.default.equal(diagnosticsPayload.diagnostics.supportedFeatures.savedSessions, true);
+            const attach = await fetch(`${baseUrl}/v1/attach`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ browser: "chrome", target: { windowIndex: 1, tabIndex: 2 } })
+            });
+            strict_1.default.equal(attach.status, 201);
+            const attachPayload = (await attach.json());
+            strict_1.default.equal(attachPayload.session.schemaVersion, 1);
+            strict_1.default.equal(attachPayload.session.kind, "chrome-readonly");
+            strict_1.default.equal(attachPayload.session.attach.mode, "direct");
+            strict_1.default.equal(attachPayload.session.attach.scope, "browser");
+            strict_1.default.equal(attachPayload.session.status.state, "read-only");
+            strict_1.default.equal(attachPayload.session.status.canAct, false);
+            strict_1.default.equal(attachPayload.session.capabilities.activate, false);
+            strict_1.default.equal(attachPayload.session.capabilities.navigate, false);
+            strict_1.default.equal(attachPayload.session.capabilities.screenshot, false);
+            const relayAttach = await fetch(`${baseUrl}/v1/attach`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ browser: "chrome", attach: { mode: "relay" } })
+            });
+            strict_1.default.equal(relayAttach.status, 201);
+            const relayAttachPayload = (await relayAttach.json());
+            strict_1.default.equal(relayAttachPayload.session.attach.mode, "relay");
+            strict_1.default.equal(relayAttachPayload.session.attach.source, "extension-relay");
+            strict_1.default.equal(relayAttachPayload.session.attach.scope, "tab");
+            strict_1.default.equal(relayAttachPayload.session.attach.resumable, false);
+            strict_1.default.equal(relayAttachPayload.session.attach.resumeRequiresUserGesture, true);
+            strict_1.default.equal(relayAttachPayload.session.attach.expiresAt, "2099-03-28T12:00:00.000Z");
+            strict_1.default.equal(relayAttachPayload.session.semantics.inspect, "shared-tab-only");
+            strict_1.default.equal(relayAttachPayload.session.semantics.resume, "current-shared-tab");
+            strict_1.default.equal(relayAttachPayload.session.semantics.tabReference.windowIndex, "synthetic-shared-tab-position");
+            strict_1.default.equal(relayAttachPayload.session.tab.url, "https://example.com/shared");
+            await new Promise((resolvePromise, reject) => server.close((error) => (error ? reject(error) : resolvePromise())));
+            const cliCapabilities = await withCapturedStreams(async () => {
+                await (0, cli_1.runCli)(["capabilities", "--browser", "chromium"], service);
+            });
+            const cliCapabilitiesPayload = JSON.parse(cliCapabilities.stdout);
+            strict_1.default.equal(cliCapabilitiesPayload.capabilities.schemaVersion, 1);
+            strict_1.default.equal(cliCapabilitiesPayload.capabilities.browsers[0].kind, "chrome-readonly");
+            strict_1.default.equal(cliCapabilitiesPayload.capabilities.browsers[0].browser, "chrome");
+            strict_1.default.equal(cliCapabilitiesPayload.capabilities.browsers[0].maturity, "experimental-readonly");
+            strict_1.default.equal(cliCapabilitiesPayload.capabilities.browsers[0].attachModes?.[0]?.mode, "direct");
+            const cliRelayAttach = await withCapturedStreams(async () => {
+                await (0, cli_1.runCli)(["attach", "--browser", "chrome", "--attach-mode", "relay"], service);
+            });
+            const cliRelayAttachPayload = JSON.parse(cliRelayAttach.stdout);
+            strict_1.default.equal(cliRelayAttachPayload.session.attach.mode, "relay");
+            strict_1.default.equal(cliRelayAttachPayload.session.attach.scope, "tab");
+            strict_1.default.equal(cliRelayAttachPayload.session.semantics.inspect, "shared-tab-only");
+            strict_1.default.equal(cliRelayAttachPayload.session.semantics.resume, "current-shared-tab");
+            strict_1.default.equal(cliRelayAttachPayload.session.tab.url, "https://example.com/shared");
+            const cliSessions = await withCapturedStreams(async () => {
+                await (0, cli_1.runCli)(["sessions"], service);
+            });
+            const cliSessionsPayload = JSON.parse(cliSessions.stdout);
+            strict_1.default.equal(cliSessionsPayload.sessions[0].schemaVersion, 1);
+            strict_1.default.equal(cliSessionsPayload.sessions[0].kind, "chrome-readonly");
+            strict_1.default.equal(cliSessionsPayload.sessions[0].attach.mode, "relay");
+            strict_1.default.equal(cliSessionsPayload.sessions[0].semantics.inspect, "shared-tab-only");
+            strict_1.default.equal(cliSessionsPayload.sessions[0].semantics.resume, "current-shared-tab");
+            strict_1.default.equal(cliSessionsPayload.sessions[0].semantics.tabReference.tabIndex, "synthetic-shared-tab-position");
+            strict_1.default.equal(cliSessionsPayload.sessions[0].status.state, "read-only");
+            strict_1.default.equal(cliSessionsPayload.sessions[0].capabilities.activate, false);
+            strict_1.default.equal(cliSessionsPayload.sessions[0].capabilities.navigate, false);
+            strict_1.default.equal(cliSessionsPayload.sessions[0].capabilities.screenshot, false);
+        });
+    });
+});
+(0, node_test_1.default)("chrome relay CLI and HTTP errors expose the same structured failure details", async () => {
+    await withChromeRelayStateFixture({
+        extensionInstalled: true,
+        connected: true,
+        shareRequired: true
+    }, async () => {
+        const service = new attach_service_1.AttachService();
+        const server = (0, http_1.createApiServer)(service);
+        await new Promise((resolvePromise, reject) => server.listen(0, "127.0.0.1", (error) => (error ? reject(error) : resolvePromise())));
+        const address = server.address();
+        strict_1.default.ok(address && typeof address === "object");
+        const baseUrl = `http://127.0.0.1:${address.port}`;
+        try {
+            const httpResponse = await fetch(`${baseUrl}/v1/attach`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ browser: "chrome", attach: { mode: "relay" } })
+            });
+            strict_1.default.equal(httpResponse.status, 503);
+            const httpPayload = (await httpResponse.json());
+            strict_1.default.equal(httpPayload.error.code, "relay_share_required");
+            strict_1.default.equal(httpPayload.error.details?.context?.operation, "attach");
+            strict_1.default.equal(httpPayload.error.details?.relay?.branch, "share-tab");
+            strict_1.default.equal(httpPayload.error.details?.relay?.phase, "diagnostics");
+            strict_1.default.equal(httpPayload.error.details?.relay?.sharedTabScope, "current-shared-tab");
+            const cliResult = await withCapturedStreams(async () => {
+                try {
+                    await (0, cli_1.runCli)(["attach", "--browser", "chrome", "--attach-mode", "relay"], service);
+                }
+                catch (error) {
+                    const { payload } = (0, errors_1.toErrorPayload)(error);
+                    process.stderr.write(JSON.stringify(payload, null, 2) + "\n");
+                }
+            });
+            const cliPayload = JSON.parse(cliResult.stderr);
+            strict_1.default.equal(cliPayload.error.code, httpPayload.error.code);
+            strict_1.default.deepEqual(cliPayload.error.details, httpPayload.error.details);
+            const cliDoctor = await withCapturedStreams(async () => {
+                await (0, cli_1.runCli)(["doctor", "--route", "chrome-relay"], service);
+            });
+            const cliDoctorPayload = JSON.parse(cliDoctor.stdout);
+            strict_1.default.equal(cliDoctorPayload.ok, false);
+            strict_1.default.equal(cliDoctorPayload.blocked, true);
+            strict_1.default.equal(cliDoctorPayload.outcome, "blocked");
+            strict_1.default.equal(cliDoctorPayload.status, "blocked");
+            strict_1.default.equal(cliDoctorPayload.category, "route-blocked");
+            strict_1.default.equal(cliDoctorPayload.reason?.code, "relay_share_required");
+            strict_1.default.equal(cliDoctorPayload.routeUx.label, "Chrome (shared tab, read-only)");
+            strict_1.default.equal(cliDoctorPayload.routeUx.readOnly, true);
+            strict_1.default.equal(cliDoctorPayload.routeUx.sharedTabScoped, true);
+            strict_1.default.match(cliDoctorPayload.routeUx.prompt ?? "", /Share the tab first/i);
+            strict_1.default.equal(cliDoctorPayload.nextStep.action, "fix-blocker");
+            strict_1.default.match(cliDoctorPayload.summary, /currently shared tab/i);
+            const cliConnect = await withCapturedStreams(async () => {
+                await (0, cli_1.runCli)(["connect", "--route", "chrome-relay"], service);
+            });
+            const cliConnectPayload = JSON.parse(cliConnect.stdout);
+            strict_1.default.equal(cliConnectPayload.ok, false);
+            strict_1.default.equal(cliConnectPayload.blocked, true);
+            strict_1.default.equal(cliConnectPayload.connected, false);
+            strict_1.default.equal(cliConnectPayload.outcome, "blocked");
+            strict_1.default.equal(cliConnectPayload.status, "blocked");
+            strict_1.default.equal(cliConnectPayload.category, "connection-blocked");
+            strict_1.default.equal(cliConnectPayload.reason?.code, "relay_share_required");
+            strict_1.default.equal(cliConnectPayload.error, undefined);
+            strict_1.default.equal(cliConnectPayload.routeUx?.state, "blocked");
+            strict_1.default.equal(cliConnectPayload.routeUx?.sharedTabScoped, true);
+            strict_1.default.equal(cliConnectPayload.routeUx?.readOnly, true);
+            strict_1.default.match(cliConnectPayload.routeUx?.prompt ?? "", /Share the tab first/i);
+            strict_1.default.equal(cliConnectPayload.nextStep.action, "fix-blocker");
+            strict_1.default.match(cliConnectPayload.summary, /currently shared tab/i);
+        }
+        finally {
+            await new Promise((resolvePromise, reject) => server.close((error) => (error ? reject(error) : resolvePromise())));
+        }
+    });
+});