local-browser-bridge 0.1.0

package/dist/tests/fixtures/public-root-cli-stub.js

@@ -0,0 +1,143 @@
+"use strict";
+const capabilities = {
+    schemaVersion: 1,
+    kind: "local-browser-bridge",
+    product: { name: "local-browser-bridge", version: "0.1.0" }
+};
+const diagnostics = {
+    browser: "chrome",
+    checkedAt: "2026-03-30T12:00:00.000Z",
+    runtime: {
+        platform: "darwin",
+        arch: "arm64",
+        nodeVersion: "v25.8.0",
+        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: [],
+    attach: {
+        direct: {
+            mode: "direct",
+            source: "user-browser",
+            scope: "browser",
+            supported: true,
+            ready: true,
+            state: "ready",
+            blockers: []
+        },
+        relay: {
+            mode: "relay",
+            source: "extension-relay",
+            scope: "tab",
+            supported: true,
+            ready: true,
+            state: "ready",
+            blockers: []
+        }
+    }
+};
+const session = {
+    schemaVersion: 1,
+    id: "sess-cli-relay",
+    kind: "chrome-readonly",
+    browser: "chrome",
+    target: { type: "front" },
+    tab: {
+        browser: "chrome",
+        windowIndex: 1,
+        tabIndex: 1,
+        title: "Shared tab",
+        url: "https://example.com",
+        attachedAt: "2026-03-30T12:00:00.000Z",
+        identity: {
+            signature: "sig",
+            urlKey: "https://example.com",
+            titleKey: "Shared tab",
+            origin: "https://example.com",
+            pathname: "/"
+        }
+    },
+    frontTab: {
+        browser: "chrome",
+        windowIndex: 1,
+        tabIndex: 1,
+        title: "Shared tab",
+        url: "https://example.com",
+        attachedAt: "2026-03-30T12:00:00.000Z",
+        identity: {
+            signature: "sig",
+            urlKey: "https://example.com",
+            titleKey: "Shared tab",
+            origin: "https://example.com",
+            pathname: "/"
+        }
+    },
+    attach: {
+        mode: "relay",
+        source: "extension-relay",
+        scope: "tab",
+        resumable: true
+    },
+    semantics: {
+        inspect: "shared-tab-only",
+        list: "saved-session",
+        resume: "current-shared-tab",
+        tabReference: {
+            windowIndex: "synthetic-shared-tab-position",
+            tabIndex: "synthetic-shared-tab-position"
+        }
+    },
+    capabilities: {
+        resume: true,
+        activate: false,
+        navigate: false,
+        screenshot: false
+    },
+    status: {
+        state: "read-only",
+        canAct: false
+    },
+    createdAt: "2026-03-30T12:00:00.000Z"
+};
+const resumedSession = {
+    session,
+    tab: session.tab,
+    resumedAt: "2026-03-30T12:05:00.000Z",
+    resolution: {
+        strategy: "front",
+        matched: true,
+        attachMode: "relay",
+        semantics: "current-shared-tab"
+    }
+};
+function writeJson(payload) {
+    process.stdout.write(JSON.stringify(payload));
+}
+const [command, ...args] = process.argv.slice(2);
+if (command === "capabilities") {
+    writeJson({ capabilities });
+}
+else if (command === "diagnostics" && args[0] === "--browser" && args[1] === "chrome") {
+    writeJson({ diagnostics });
+}
+else if (command === "resume" && args[0] === "--id" && args[1] === "sess-cli-relay") {
+    writeJson({ resumedSession });
+}
+else {
+    process.stderr.write(`Unexpected args: ${[command, ...args].join(" ")}`);
+    process.exitCode = 1;
+}

package/dist/tests/fixtures/public-root-consumer.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectViaPublicHttpConsumer = connectViaPublicHttpConsumer;
+exports.connectViaPublicCliConsumer = connectViaPublicCliConsumer;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const { connectViaBridge, createCliBridgeAdapter, createHttpBridgeAdapter } = require("local-browser-bridge");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function normalizeRoute(value) {
+    if (value === "safari" || value === "chrome-direct" || value === "chrome-relay") {
+        return value;
+    }
+    throw new Error(`Unsupported route: ${value}`);
+}
+function toBridgeRoute(routeName, sessionId) {
+    const browser = routeName === "safari" ? "safari" : "chrome";
+    const attachMode = routeName === "chrome-relay" ? "relay" : "direct";
+    return sessionId ? { browser, attachMode, sessionId } : { browser, attachMode };
+}
+async function connectViaPublicHttpConsumer(baseUrl, routeName, sessionId) {
+    const adapter = createHttpBridgeAdapter({
+        async execute(request) {
+            const response = await fetch(`${baseUrl}${request.path}`, {
+                method: request.method,
+                headers: { "content-type": "application/json" },
+                body: request.body === undefined ? undefined : JSON.stringify(request.body)
+            });
+            const text = await response.text();
+            return {
+                status: response.status,
+                body: text.length > 0 ? JSON.parse(text) : {}
+            };
+        }
+    });
+    return connectViaBridge(adapter, toBridgeRoute(routeName, sessionId));
+}
+async function connectViaPublicCliConsumer(cliEntrypoint, routeName, sessionId) {
+    const adapter = createCliBridgeAdapter({
+        async execute(command) {
+            const result = await execFileAsync(process.execPath, [cliEntrypoint, ...command.args], {
+                cwd: process.cwd()
+            });
+            return { stdout: result.stdout };
+        }
+    });
+    return connectViaBridge(adapter, toBridgeRoute(routeName, sessionId));
+}
+async function main() {
+    const [transport, arg1, arg2, arg3] = process.argv.slice(2);
+    if (transport === "http") {
+        const connection = await connectViaPublicHttpConsumer(arg1, normalizeRoute(arg2), arg3);
+        process.stdout.write(JSON.stringify(connection));
+        return;
+    }
+    if (transport === "cli") {
+        const connection = await connectViaPublicCliConsumer(arg1, normalizeRoute(arg2), arg3);
+        process.stdout.write(JSON.stringify(connection));
+        return;
+    }
+    throw new Error("Usage: public-root-consumer.ts <http|cli> <arg1> <route> [sessionId]");
+}
+if (require.main === module) {
+    void main().catch((error) => {
+        process.stderr.write(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/tests/mcp.test.d.ts

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

package/dist/tests/mcp.test.js

@@ -0,0 +1,345 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_stream_1 = require("node:stream");
+const node_test_1 = __importDefault(require("node:test"));
+const src_1 = require("../src");
+function createSafariSession() {
+    return {
+        id: "session-safari-demo",
+        schemaVersion: 1,
+        kind: "safari-actionable",
+        browser: "safari",
+        target: { type: "front" },
+        tab: {
+            browser: "safari",
+            windowIndex: 1,
+            tabIndex: 1,
+            title: "Example",
+            url: "https://example.com",
+            attachedAt: "2026-03-31T00:00:00.000Z",
+            identity: {
+                signature: "safari-sig",
+                urlKey: "https://example.com",
+                titleKey: "Example",
+                origin: "https://example.com",
+                pathname: "/"
+            }
+        },
+        frontTab: {
+            browser: "safari",
+            windowIndex: 1,
+            tabIndex: 1,
+            title: "Example",
+            url: "https://example.com",
+            attachedAt: "2026-03-31T00:00:00.000Z",
+            identity: {
+                signature: "safari-sig",
+                urlKey: "https://example.com",
+                titleKey: "Example",
+                origin: "https://example.com",
+                pathname: "/"
+            }
+        },
+        attach: {
+            mode: "direct",
+            source: "user-browser",
+            scope: "browser"
+        },
+        semantics: {
+            inspect: "browser-tabs",
+            list: "saved-session",
+            resume: "saved-browser-target",
+            tabReference: {
+                windowIndex: "browser-position",
+                tabIndex: "browser-position"
+            }
+        },
+        capabilities: { resume: true, activate: true, navigate: true, screenshot: true },
+        status: { state: "actionable", canAct: true },
+        createdAt: "2026-03-31T00:00:00.000Z"
+    };
+}
+function createStubService() {
+    return {
+        getCapabilities() {
+            return { schemaVersion: 1, product: { name: "local-browser-bridge" } };
+        },
+        async diagnostics(browser) {
+            if (browser === "safari") {
+                return {
+                    browser,
+                    checkedAt: "2026-03-31T00:00:00.000Z",
+                    runtime: { platform: "darwin", arch: "arm64", nodeVersion: "v25.8.0" },
+                    host: {},
+                    supportedFeatures: {},
+                    constraints: [],
+                    preflight: {
+                        inspect: { ready: true, blockers: [] },
+                        automation: { ready: true, blockers: [] },
+                        screenshot: { ready: true, blockers: [] }
+                    }
+                };
+            }
+            return {
+                browser,
+                checkedAt: "2026-03-31T00:00:00.000Z",
+                runtime: { platform: "darwin", arch: "arm64", nodeVersion: "v25.8.0" },
+                host: {},
+                supportedFeatures: {},
+                constraints: [],
+                attach: {
+                    direct: { mode: "direct", ready: false, state: "unavailable", blockers: [] },
+                    relay: {
+                        mode: "relay",
+                        ready: false,
+                        state: "unavailable",
+                        blockers: [
+                            {
+                                code: "relay_share_required",
+                                message: "Share the tab first."
+                            }
+                        ]
+                    }
+                }
+            };
+        },
+        async attach(browser, request) {
+            if (browser === "safari") {
+                return createSafariSession();
+            }
+            throw new Error(`unexpected attach: ${browser}:${request?.attach?.mode}`);
+        },
+        async listTabs(browser) {
+            if (browser === "safari") {
+                return [
+                    {
+                        browser: "safari",
+                        windowIndex: 1,
+                        tabIndex: 1,
+                        title: "Example",
+                        url: "https://example.com",
+                        attachedAt: "2026-03-31T00:00:00.000Z",
+                        identity: {
+                            signature: "safari-sig",
+                            urlKey: "https://example.com",
+                            titleKey: "Example",
+                            origin: "https://example.com",
+                            pathname: "/"
+                        }
+                    }
+                ];
+            }
+            throw new Error(`unexpected listTabs: ${browser}`);
+        },
+        async resumeSession() {
+            throw new Error("resume should not run in this test");
+        }
+    };
+}
+async function createExchange() {
+    const input = new node_stream_1.PassThrough();
+    const output = new node_stream_1.PassThrough();
+    const stderr = new node_stream_1.PassThrough();
+    const lines = [];
+    let buffer = "";
+    output.setEncoding("utf8");
+    output.on("data", (chunk) => {
+        buffer += chunk;
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+            lines.push(buffer.slice(0, newlineIndex));
+            buffer = buffer.slice(newlineIndex + 1);
+            newlineIndex = buffer.indexOf("\n");
+        }
+    });
+    (0, src_1.runMcpStdioServer)({ service: createStubService(), input, output, error: stderr });
+    async function send(message) {
+        const targetCount = lines.length + 1;
+        input.write(JSON.stringify(message) + "\n");
+        await waitFor(() => lines.length >= targetCount);
+        return JSON.parse(lines[targetCount - 1]);
+    }
+    return { send, input };
+}
+async function waitFor(predicate) {
+    const deadline = Date.now() + 2000;
+    while (!predicate()) {
+        if (Date.now() > deadline) {
+            throw new Error("timed out waiting for MCP response");
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+(0, node_test_1.default)("MCP stdio server initializes and lists the minimal RC tool surface", async () => {
+    const exchange = await createExchange();
+    const initialized = await exchange.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-03-26",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" }
+        }
+    });
+    strict_1.default.equal(initialized.result.protocolVersion, "2025-03-26");
+    strict_1.default.equal(initialized.result.serverInfo.name, "local-browser-bridge");
+    exchange.input.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+    const tools = await exchange.send({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/list"
+    });
+    strict_1.default.deepEqual(tools.result.tools.map((tool) => tool.name), ["browser_doctor", "browser_tabs", "browser_connect"]);
+});
+(0, node_test_1.default)("browser_doctor returns structured Chrome relay truth without pretending relay is actionable", async () => {
+    const exchange = await createExchange();
+    await exchange.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-06-18",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" }
+        }
+    });
+    exchange.input.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+    const response = await exchange.send({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: {
+            name: "browser_doctor",
+            arguments: {
+                route: "chrome-relay"
+            }
+        }
+    });
+    strict_1.default.equal(response.result.isError, undefined);
+    strict_1.default.equal(response.result.structuredContent.tool, "browser_doctor");
+    strict_1.default.equal(response.result.structuredContent.ok, false);
+    strict_1.default.equal(response.result.structuredContent.outcome, "blocked");
+    strict_1.default.equal(response.result.structuredContent.status, "blocked");
+    strict_1.default.equal(response.result.structuredContent.category, "route-blocked");
+    strict_1.default.deepEqual(response.result.structuredContent.reason, {
+        code: "relay_share_required",
+        message: "Share the tab first."
+    });
+    strict_1.default.equal(response.result.structuredContent.truth.readOnly, true);
+    strict_1.default.equal(response.result.structuredContent.truth.sharedTabScoped, true);
+    strict_1.default.deepEqual(response.result.structuredContent.truth.unsupportedRuntimeActions, ["activate", "navigate", "screenshot"]);
+    strict_1.default.match(response.result.structuredContent.envelope.prompt, /Share the tab first/i);
+});
+(0, node_test_1.default)("browser_connect returns structured Safari session truth for actionable routes", async () => {
+    const exchange = await createExchange();
+    await exchange.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-11-25",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" }
+        }
+    });
+    exchange.input.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+    const response = await exchange.send({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: {
+            name: "browser_connect",
+            arguments: {
+                route: "safari"
+            }
+        }
+    });
+    strict_1.default.equal(response.result.isError, undefined);
+    strict_1.default.equal(response.result.structuredContent.tool, "browser_connect");
+    strict_1.default.equal(response.result.structuredContent.connected, true);
+    strict_1.default.equal(response.result.structuredContent.outcome, "success");
+    strict_1.default.equal(response.result.structuredContent.status, "connected");
+    strict_1.default.equal(response.result.structuredContent.category, "session-connected");
+    strict_1.default.equal(response.result.structuredContent.truth.actionable, true);
+    strict_1.default.deepEqual(response.result.structuredContent.truth.unsupportedRuntimeActions, []);
+    strict_1.default.equal(response.result.structuredContent.envelope.session.id, "session-safari-demo");
+    strict_1.default.equal(response.result.structuredContent.envelope.session.kind, "safari-actionable");
+});
+(0, node_test_1.default)("browser_tabs lists Safari tabs with structured success payloads", async () => {
+    const exchange = await createExchange();
+    await exchange.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-11-25",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" }
+        }
+    });
+    exchange.input.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+    const response = await exchange.send({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: {
+            name: "browser_tabs",
+            arguments: {
+                route: "safari"
+            }
+        }
+    });
+    strict_1.default.equal(response.result.isError, undefined);
+    strict_1.default.equal(response.result.structuredContent.tool, "browser_tabs");
+    strict_1.default.equal(response.result.structuredContent.ok, true);
+    strict_1.default.equal(response.result.structuredContent.blocked, false);
+    strict_1.default.equal(response.result.structuredContent.outcome, "success");
+    strict_1.default.equal(response.result.structuredContent.status, "listed");
+    strict_1.default.equal(response.result.structuredContent.category, "tab-list");
+    strict_1.default.equal(response.result.structuredContent.count, 1);
+    strict_1.default.equal(response.result.structuredContent.truth.actionable, true);
+    strict_1.default.equal(response.result.structuredContent.truth.sharedTabScoped, false);
+    strict_1.default.equal(response.result.structuredContent.tabs[0].title, "Example");
+});
+(0, node_test_1.default)("browser_tabs returns a structured blocked result for chrome-relay without marking it as an error", async () => {
+    const exchange = await createExchange();
+    await exchange.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-11-25",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0.0" }
+        }
+    });
+    exchange.input.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
+    const response = await exchange.send({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: {
+            name: "browser_tabs",
+            arguments: {
+                route: "chrome-relay"
+            }
+        }
+    });
+    strict_1.default.equal(response.result.isError, undefined);
+    strict_1.default.equal(response.result.structuredContent.tool, "browser_tabs");
+    strict_1.default.equal(response.result.structuredContent.ok, false);
+    strict_1.default.equal(response.result.structuredContent.blocked, true);
+    strict_1.default.equal(response.result.structuredContent.outcome, "unsupported");
+    strict_1.default.equal(response.result.structuredContent.status, "unsupported");
+    strict_1.default.equal(response.result.structuredContent.category, "shared-tab-scope");
+    strict_1.default.equal(response.result.structuredContent.truth.readOnly, true);
+    strict_1.default.equal(response.result.structuredContent.truth.sharedTabScoped, true);
+    strict_1.default.deepEqual(response.result.structuredContent.supportedRoutes, ["safari", "chrome-direct"]);
+    strict_1.default.equal(response.result.structuredContent.blockedReason.code, "shared_tab_scope_only");
+    strict_1.default.deepEqual(response.result.structuredContent.reason, response.result.structuredContent.blockedReason);
+});

package/dist/tests/public-consumer-helpers.test.d.ts

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

package/dist/tests/public-consumer-helpers.test.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const src_1 = require("../src");
+(0, node_test_1.default)("public consumer entrypoint re-exports the stable helper surface", () => {
+    strict_1.default.equal(typeof src_1.interpretChromeRelayFailure, "function");
+    strict_1.default.equal(typeof src_1.chromeRelayBranchPrompt, "function");
+    strict_1.default.equal(typeof src_1.chromeRelayRetryGuidance, "function");
+    strict_1.default.equal(typeof src_1.chromeRelayScopeNote, "function");
+    strict_1.default.equal(typeof src_1.interpretBrowserAttachUxFromDiagnostics, "function");
+    strict_1.default.equal(typeof src_1.interpretBrowserAttachUxFromSession, "function");
+    strict_1.default.equal(typeof src_1.interpretBrowserAttachUxFromError, "function");
+    strict_1.default.equal(typeof src_1.normalizeConnectionRouteName, "function");
+    strict_1.default.equal(typeof src_1.doctorConnectionRoute, "function");
+    strict_1.default.equal(typeof src_1.connectConnectionRoute, "function");
+    strict_1.default.equal(typeof src_1.createServiceBridgeAdapter, "function");
+    strict_1.default.equal(typeof src_1.createBridgeAdapter, "function");
+    strict_1.default.equal(typeof src_1.createHttpBridgeAdapter, "function");
+    strict_1.default.equal(typeof src_1.createCliBridgeAdapter, "function");
+    strict_1.default.equal(typeof src_1.normalizeCodexRoute, "function");
+    strict_1.default.equal(typeof src_1.connectCodexViaHttp, "function");
+    strict_1.default.equal(typeof src_1.connectCodexViaCli, "function");
+    strict_1.default.equal(typeof src_1.normalizeClaudeCodeRoute, "function");
+    strict_1.default.equal(typeof src_1.prepareClaudeCodeRoute, "function");
+    strict_1.default.equal(typeof src_1.createMcpServer, "function");
+    strict_1.default.equal(typeof src_1.runMcpStdioServer, "function");
+    strict_1.default.equal(typeof src_1.sessionFromBridgeResult, "function");
+    strict_1.default.equal(typeof src_1.connectViaBridge, "function");
+});

package/dist/tests/public-package-git-consumption.test.d.ts

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

package/dist/tests/public-package-git-consumption.test.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_test_1 = __importDefault(require("node:test"));
+(0, node_test_1.default)("package metadata exposes built JS and declarations for git consumption", () => {
+    const root = process.cwd();
+    const packageJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.resolve)(root, "package.json"), "utf8"));
+    strict_1.default.equal(packageJson.main, "./dist/src/index.js");
+    strict_1.default.equal(packageJson.types, "./dist/src/index.d.ts");
+    strict_1.default.equal(packageJson.scripts?.prepare, "npm run build");
+    strict_1.default.deepEqual(packageJson.files, ["dist/**/*", "README.md"]);
+    const rootExport = typeof packageJson.exports?.["."] === "string" ? undefined : packageJson.exports?.["."];
+    const uxHelperExport = typeof packageJson.exports?.["./browser-attach-ux-helper"] === "string"
+        ? undefined
+        : packageJson.exports?.["./browser-attach-ux-helper"];
+    const codexExport = typeof packageJson.exports?.["./codex"] === "string"
+        ? undefined
+        : packageJson.exports?.["./codex"];
+    const mcpExport = typeof packageJson.exports?.["./mcp"] === "string"
+        ? undefined
+        : packageJson.exports?.["./mcp"];
+    const relayHelperExport = typeof packageJson.exports?.["./chrome-relay-error-helper"] === "string"
+        ? undefined
+        : packageJson.exports?.["./chrome-relay-error-helper"];
+    strict_1.default.equal(rootExport?.require, "./dist/src/index.js");
+    strict_1.default.equal(rootExport?.types, "./dist/src/index.d.ts");
+    strict_1.default.equal(codexExport?.types, "./dist/src/codex.d.ts");
+    strict_1.default.equal(mcpExport?.types, "./dist/src/mcp.d.ts");
+    strict_1.default.equal(uxHelperExport?.types, "./dist/src/browser-attach-ux-helper.d.ts");
+    strict_1.default.equal(relayHelperExport?.types, "./dist/src/chrome-relay-error-helper.d.ts");
+    strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, "dist", "src", "index.js")));
+    strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, "dist", "src", "index.d.ts")));
+    strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, "dist", "src", "codex.d.ts")));
+    strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, "dist", "src", "mcp.d.ts")));
+    strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, "dist", "src", "browser-attach-ux-helper.d.ts")));
+    strict_1.default.ok((0, node_fs_1.existsSync)((0, node_path_1.resolve)(root, "dist", "src", "chrome-relay-error-helper.d.ts")));
+});
+(0, node_test_1.default)("package root resolves the stable helper surface from built output", () => {
+    const publicEntry = require(process.cwd());
+    strict_1.default.equal(typeof publicEntry.connectViaBridge, "function");
+    strict_1.default.equal(typeof publicEntry.createBridgeAdapter, "function");
+    strict_1.default.equal(typeof publicEntry.createHttpBridgeAdapter, "function");
+    strict_1.default.equal(typeof publicEntry.createCliBridgeAdapter, "function");
+    strict_1.default.equal(typeof publicEntry.normalizeCodexRoute, "function");
+    strict_1.default.equal(typeof publicEntry.connectCodexViaCli, "function");
+    strict_1.default.equal(typeof publicEntry.connectCodexViaHttp, "function");
+    strict_1.default.equal(typeof publicEntry.createMcpServer, "function");
+    strict_1.default.equal(typeof publicEntry.runMcpStdioServer, "function");
+    strict_1.default.equal(typeof publicEntry.interpretBrowserAttachUxFromSession, "function");
+    strict_1.default.equal(typeof publicEntry.interpretChromeRelayFailure, "function");
+});

package/dist/tests/public-root-consumer-smoke.test.d.ts

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