@extension.dev/mcp 10.9.0 → 10.10.1

package/dist/module.js

@@ -16,9 +16,9 @@ import { fileURLToPath } from "node:url";
 import { execFile, execFileSync } from "node:child_process";
 import ws_0 from "ws";
 import node_http from "node:http";
+import { promisify } from "node:util";
 import { filterKeysForThisBrowser } from "browser-extension-manifest-fields";
 import node_net from "node:net";
-import { promisify } from "node:util";
 import { extensionInstall, extensionUninstall, getManagedBrowsersCacheRoot } from "extension-install";
 var add_feature_namespaceObject = {};
 __webpack_require__.r(add_feature_namespaceObject);
@@ -91,9 +91,12 @@ __webpack_require__.d(dom_snapshot_namespaceObject, {
 var eval_namespaceObject = {};
 __webpack_require__.r(eval_namespaceObject);
 __webpack_require__.d(eval_namespaceObject, {
+    EXTENSION_PAGE_CONTEXTS: ()=>EXTENSION_PAGE_CONTEXTS,
+    chromiumManifestVersion: ()=>chromiumManifestVersion,
     handler: ()=>eval_handler,
     resolveDefaultEvalContext: ()=>resolveDefaultEvalContext,
-    schema: ()=>eval_schema
+    schema: ()=>eval_schema,
+    wantsExtensionPageOverCdp: ()=>wantsExtensionPageOverCdp
 });
 var inspect_namespaceObject = {};
 __webpack_require__.r(inspect_namespaceObject);
@@ -126,6 +129,8 @@ __webpack_require__.d(manifest_validate_namespaceObject, {
 var open_namespaceObject = {};
 __webpack_require__.r(open_namespaceObject);
 __webpack_require__.d(open_namespaceObject, {
+    E_USER_GESTURE_REQUIRED: ()=>E_USER_GESTURE_REQUIRED,
+    OVERRIDE_SURFACES: ()=>OVERRIDE_SURFACES,
     SURFACE_MANIFEST_KEYS: ()=>SURFACE_MANIFEST_KEYS,
     clampPopupBounds: ()=>clampPopupBounds,
     declaredSurfaces: ()=>declaredSurfaces,
@@ -187,6 +192,7 @@ __webpack_require__.d(start_namespaceObject, {
 var stop_namespaceObject = {};
 __webpack_require__.r(stop_namespaceObject);
 __webpack_require__.d(stop_namespaceObject, {
+    contractProcessHints: ()=>contractProcessHints,
     handler: ()=>stop_handler,
     schema: ()=>stop_schema,
     stopOne: ()=>stopOne
@@ -222,7 +228,7 @@ __webpack_require__.d(wait_namespaceObject, {
     handler: ()=>wait_handler,
     schema: ()=>wait_schema
 });
-var package_namespaceObject = JSON.parse('{"rE":"10.9.0","El":{"OP":"4.1.2"}}');
+var package_namespaceObject = JSON.parse('{"rE":"10.10.1","El":{"OP":"4.1.30"}}');
 const ENVELOPE_SCHEMA = 1;
 const collectWarnings = (warnings)=>{
     if (!warnings) return [];
@@ -1078,9 +1084,52 @@ function parseBuildIndex(json) {
     }
     return out;
 }
+const ADDRESS_KEYS = /url|referrer/i;
+const KEEP_QUERY = /^(utm_|ref$)/;
+const SCRUB_ORIGIN = "https://www.extension.dev";
+const REPOSITORY_REF = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+@/;
+const DEPTH = 4;
+function maskRepositoryRef(value) {
+    if (!REPOSITORY_REF.test(value)) return value;
+    return `[owner]/[repo]@${value.slice(value.indexOf("@") + 1)}`;
+}
+function scrubUrlProperty(value) {
+    if ("string" != typeof value || !value) return value;
+    let parsed;
+    try {
+        parsed = new URL(value, SCRUB_ORIGIN);
+    } catch  {
+        return value;
+    }
+    let changed = false;
+    for (const key of [
+        ...parsed.searchParams.keys()
+    ])if (!KEEP_QUERY.test(key)) {
+        parsed.searchParams.delete(key);
+        changed = true;
+    }
+    if (!changed) return value;
+    return value.startsWith("/") ? `${parsed.pathname}${parsed.search}${parsed.hash}` : parsed.toString();
+}
+function maskDeep(value, remaining) {
+    if ("string" == typeof value) return maskRepositoryRef(value);
+    if (remaining <= 0 || !value || "object" != typeof value) return value;
+    if (Array.isArray(value)) return value.map((item)=>maskDeep(item, remaining - 1));
+    const masked = {};
+    for (const [key, nested] of Object.entries(value))masked[key] = maskDeep(nested, remaining - 1);
+    return masked;
+}
+function sanitizeMcpProperties(properties) {
+    const sanitized = {
+        ...properties
+    };
+    for (const [key, value] of Object.entries(sanitized))if (ADDRESS_KEYS.test(key)) sanitized[key] = scrubUrlProperty(value);
+    for (const [key, value] of Object.entries(sanitized))sanitized[key] = maskDeep(value, DEPTH);
+    return sanitized;
+}
 const DEFAULT_MEDIA_ORIGIN = "https://media.extension.land";
 const DEFAULT_CHANNEL = "latest";
-const PINNED_COMMIT = "1d04a3d62f4d82ab3f13a3388800d517d1627707";
+const PINNED_COMMIT = "8e2336852b51c0fb71fd03abeca1f5e93a44700e";
 const CHANNEL_CACHE_TTL_MS = 300000;
 function mediaOrigin() {
     return (process.env.EXTENSION_MEDIA_ORIGIN || "").trim() || DEFAULT_MEDIA_ORIGIN;
@@ -1212,7 +1261,7 @@ function creationFunnelPayload(event, properties, now = new Date()) {
         timestamp: now.toISOString(),
         properties: {
             draft_id: null,
-            ...properties,
+            ...sanitizeMcpProperties(properties),
             source: FUNNEL_SOURCE,
             entry: FUNNEL_ENTRY,
             session_id: session,
@@ -1646,6 +1695,42 @@ async function pollDeviceToken(args) {
         };
     }
 }
+const FREE_ALLOWANCE_PHRASE = "counts against your free allowance";
+function allowanceWallUrl(apiHint) {
+    return `${mcpOrigins(apiHint).www.replace(/\/+$/, "")}/pricing`;
+}
+function allowance_asRecord(value) {
+    return value && "object" == typeof value && !Array.isArray(value) ? value : null;
+}
+function asCount(value) {
+    return "number" == typeof value && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function readPlatformAllowance(body) {
+    const record = allowance_asRecord(body);
+    if (!record) return null;
+    for (const key of [
+        "allowance",
+        "quota"
+    ]){
+        const nested = allowance_asRecord(record[key]);
+        if (!nested) continue;
+        const used = asCount(nested.used);
+        const limit = asCount(nested.limit);
+        if (null !== used && null !== limit) return {
+            used,
+            limit
+        };
+    }
+    return null;
+}
+function spendNarration(options) {
+    const counted = readPlatformAllowance(options.body);
+    return {
+        spent: `${options.what} ran on extension.dev's machines and ${FREE_ALLOWANCE_PHRASE}.`,
+        remains: counted ? `The platform reports ${counted.used} of ${counted.limit} used.` : "The platform sent no remaining count on this call, and this client never invents one. When the allowance runs out, the platform refuses with its own numbers.",
+        wall: `What the free allowance covers and when the paid plan starts are published at ${allowanceWallUrl(options.api)}.`
+    };
+}
 const project_create_COMMAND = "extension_project_create";
 const FIRST_CALL_BUDGET_MS = 8000;
 const RESUME_BUDGET_MS = 22000;
@@ -1979,6 +2064,11 @@ async function finishFromPoll(poll, ctx) {
             projectId: data.projectId ?? null,
             consoleUrl,
             sourceRepo: ctx.args.repo,
+            allowance: spendNarration({
+                what: "This project creation, including its first build,",
+                body: data,
+                api: ctx.apiBase
+            }),
             nextSteps: [
                 `extension_auth (action: login, project: '${finalWorkspace}/${finalProject}')`,
                 "extension_publish"
@@ -2122,6 +2212,20 @@ async function searchTemplates(args) {
     });
 }
 const get_template_source_COMMAND = "extension_templates";
+const TEXTUAL = /\.(json|js|mjs|cjs|ts|tsx|jsx|html|htm|css|scss|sass|less|svg|txt|md|map|vue|svelte|ya?ml)$/i;
+function encodeTemplateFile(filePath, bytes) {
+    if (TEXTUAL.test(filePath)) {
+        const text = bytes.toString("utf8");
+        if (Buffer.from(text, "utf8").equals(bytes)) return {
+            content: text,
+            encoding: "utf8"
+        };
+    }
+    return {
+        content: bytes.toString("base64"),
+        encoding: "base64"
+    };
+}
 async function readTemplateSource(args) {
     const template = await getTemplateBySlug(args.slug);
     if (!template) return envelope_envelope({
@@ -2156,6 +2260,7 @@ async function readTemplateSource(args) {
         hint: "Pass specific file paths in the files parameter to read their contents."
     });
     const fileContents = {};
+    const fileEncodings = {};
     const errors = [];
     await Promise.all(args.files.map(async (filePath)=>{
         const urls = await templateFileUrls(args.slug, filePath);
@@ -2163,13 +2268,16 @@ async function readTemplateSource(args) {
         for (const url of urls)try {
             const response = await fetch(url);
             if (response.ok) {
-                fileContents[filePath] = await response.text();
+                const encoded = encodeTemplateFile(filePath, Buffer.from(await response.arrayBuffer()));
+                fileContents[filePath] = encoded.content;
+                fileEncodings[filePath] = encoded.encoding;
                 return;
             }
             lastStatus = response.status;
         } catch  {}
         errors.push(`${filePath}: ${lastStatus || "fetch failed"}`);
     }));
+    const encodedFiles = Object.keys(fileEncodings).filter((filePath)=>"base64" === fileEncodings[filePath]).sort();
     return envelope_envelope({
         ok: 0 === errors.length,
         command: get_template_source_COMMAND,
@@ -2180,8 +2288,10 @@ async function readTemplateSource(args) {
         } : null,
         value: {
             ...meta,
-            fileContents
+            fileContents,
+            fileEncodings
         },
+        hint: encodedFiles.length ? `Base64-encoded, not text: ${encodedFiles.join(", ")}. Decode before writing to disk. fileEncodings names the encoding of every file read.` : void 0,
         warnings: errors
     });
 }
@@ -3995,8 +4105,31 @@ function processCommand(pid) {
         return "";
     }
 }
-function sessionProcessPids(projectPath) {
+function contractProcessHints(projectPath, browser) {
+    try {
+        const contract = JSON.parse(node_fs.readFileSync(bridge_readyContractPath(projectPath, browser), "utf8"));
+        const pids = [
+            contract.browserPid,
+            contract.launcherPid
+        ].filter((pid)=>"number" == typeof pid && Number.isInteger(pid) && pid > 0);
+        return {
+            ..."string" == typeof contract.profilePath && contract.profilePath.trim() ? {
+                profilePath: contract.profilePath
+            } : {},
+            pids
+        };
+    } catch  {
+        return {
+            pids: []
+        };
+    }
+}
+function sessionProcessPids(projectPath, hints = {
+    pids: []
+}) {
     const pids = new Set();
+    if (hints.profilePath) for (const pid of pgrepPids(escapeRegex(hints.profilePath)))pids.add(pid);
+    for (const pid of hints.pids)if (pid !== process.pid && isAlive(pid)) pids.add(pid);
     for (const form of projectPathForms(projectPath)){
         const escaped = escapeRegex(form);
         const patterns = [
@@ -4009,8 +4142,10 @@ function sessionProcessPids(projectPath) {
         ...pids
     ].filter((pid)=>PLAUSIBLE_SESSION_BINARY.test(processCommand(pid)));
 }
-function reapSessionProcesses(projectPath) {
-    const pids = sessionProcessPids(projectPath);
+function reapSessionProcesses(projectPath, hints = {
+    pids: []
+}) {
+    const pids = sessionProcessPids(projectPath, hints);
     for (const pid of pids)try {
         process.kill(pid, "SIGKILL");
     } catch  {}
@@ -4049,8 +4184,9 @@ function pidFromReadyContract(projectPath, browser) {
 async function stopOne(projectPath, browser) {
     const session = findSessionInfo(projectPath, browser);
     const pid = session?.pid ?? pidFromReadyContract(projectPath, browser);
+    const hints = contractProcessHints(projectPath, browser);
     if (null == pid) {
-        const reaped = reapSessionProcesses(projectPath);
+        const reaped = reapSessionProcesses(projectPath, hints);
         removeSessionMarker(projectPath, browser);
         return {
             projectPath,
@@ -4072,7 +4208,7 @@ async function stopOne(projectPath, browser) {
         }
         detail = isAlive(pid) ? "Sent SIGTERM and SIGKILL but the process still reports alive; it may be exiting." : "Terminated.";
     } else detail = "Process was already gone; cleaned up session records.";
-    const reaped = reapSessionProcesses(projectPath);
+    const reaped = reapSessionProcesses(projectPath, hints);
     removeSession(projectPath, browser);
     removeSessionMarker(projectPath, browser);
     try {
@@ -4080,7 +4216,7 @@ async function stopOne(projectPath, browser) {
             force: true
         });
     } catch  {}
-    const survivors = sessionProcessPids(projectPath);
+    const survivors = sessionProcessPids(projectPath, hints);
     const stopped = !isAlive(pid) && 0 === survivors.length;
     if (survivors.length) detail += ` Warning: ${survivors.length} browser process(es) still alive after reap (pids ${survivors.join(", ")}).`;
     else if (reaped.length) detail += ` Reaped ${reaped.length} browser process(es).`;
@@ -4444,7 +4580,8 @@ async function dev_handler(args) {
     } : {
         requestedPort: args.port ?? 8080
     };
-    const portNote = null !== boundPort ? void 0 !== args.port && args.port !== boundPort ? `Requested port ${args.port} was not available; the dev server bound ${boundPort} (read from the engine's ready.json contract, the same source extension_wait reports).` : null : "The engine has not stamped its ready.json contract yet, so the bound port is not known at response time (a taken port makes the server bind the next free one). extension_wait reports the bound port from that contract once it lands; requestedPort above is only what was asked for.";
+    const autoAssigned = 0 === args.port;
+    const portNote = null !== boundPort ? void 0 !== args.port && args.port !== boundPort ? autoAssigned ? `Port 0 asked the engine for any free port and it picked ${boundPort} (read from the engine's ready.json contract, the same source extension_wait reports).` : `Requested port ${args.port} was not available; the dev server bound ${boundPort} (read from the engine's ready.json contract, the same source extension_wait reports).` : null : autoAssigned ? "Port 0 asked the engine for any free port, and it has not stamped its ready.json contract yet, so the port it picked is not known at response time. extension_wait reports it from that contract once it lands." : "The engine has not stamped its ready.json contract yet, so the bound port is not known at response time (a taken port makes the server bind the next free one). extension_wait reports the bound port from that contract once it lands; requestedPort above is only what was asked for.";
     return envelope_envelope({
         ok: true,
         command: dev_schema.name,
@@ -4634,7 +4771,7 @@ async function start_handler(args) {
     });
 }
 function toMcpSpeak(text) {
-    return text.replace(/`?extension dev(?: [^\s`]*)? --browser[= ]([\w-]+) --allow-control`?/g, 'extension_dev with { browser: "$1", allowControl: true }').replace(/--allow-control/g, "allowControl: true (extension_dev)").replace(/--allow-eval/g, "allowEval: true (extension_dev)").replace(/Use --context page --tab <id>/g, 'Use context: "page" (targets the active tab; pass url or tab to pick another)').replace(/--context[= ](background|popup|options|sidebar|devtools|newtab|history|bookmarks|content|page)\b/g, 'context: "$1"').replace(/--tab[= ](\d+|<[\w-]+>)/g, "tab: $1").replace(/--url[= ]"([^"]+)"/g, 'url: "$1"').replace(/--url[= ](<[\w-]+>|\S*(?:\/\/|\*)\S*)/g, 'url: "$1"').replace(/--browser[= ]([\w]+-based|chrome|chromium|edge|brave|opera|vivaldi|yandex|firefox|waterfox|librewolf|safari)\b/g, 'browser: "$1"').replace(/--timeout[= ](\d+)/g, "timeout: $1").replace(/`extension dev`/g, "extension_dev").replace(/\bextension dev\b/g, "extension_dev").replace(/--tab\b/g, "`tab`").replace(/--url\b/g, "`url`").replace(/--context\b/g, "`context`").replace(/--browser\b/g, "`browser`").replace(/--timeout\b/g, "`timeout`");
+    return text.replace(/`?extension dev(?: [^\s`]*)? --browser[= ]([\w-]+) --allow-control`?/g, 'extension_dev with { browser: "$1", allowControl: true }').replace(/--allow-control/g, "allowControl: true (extension_dev)").replace(/--allow-eval/g, "allowEval: true (extension_dev)").replace(/Use --context page --tab <id>/g, 'Use context: "page" (targets the active tab; pass url or tab to pick another)').replace(/--context[= ](background|popup|options|sidebar|devtools|newtab|history|bookmarks|content|page)\b/g, 'context: "$1"').replace(/--tab[= ](\d+|<[\w-]+>)/g, "tab: $1").replace(/--url[= ]"([^"]+)"/g, 'url: "$1"').replace(/--url[= ](<[\w-]+>|\S*(?:\/\/|\*)\S*)/g, 'url: "$1"').replace(/--browser[= ]([\w]+-based|chrome|chromium|edge|brave|opera|vivaldi|yandex|firefox|waterfox|librewolf|safari)\b/g, 'browser: "$1"').replace(/--timeout[= ](\d+)/g, "timeout: $1").replace(/\bextension open (popup|options|sidebar|newtab|history|bookmarks)\b/g, 'extension_open with surface: "$1"').replace(/`extension dev`/g, "extension_dev").replace(/\bextension dev\b/g, "extension_dev").replace(/--tab\b/g, "`tab`").replace(/--url\b/g, "`url`").replace(/--context\b/g, "`context`").replace(/--browser\b/g, "`browser`").replace(/--timeout\b/g, "`timeout`");
 }
 const CONTROL_CHANNEL_DOWN_CODES = new Set([
     "E_CONTROL_DENIED",
@@ -5291,6 +5428,127 @@ function isCdpEndpoint(port) {
         });
     });
 }
+function webdriver_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const WEBDRIVER_SESSION_MISSING_HINT = "A Safari page is readable only through a safaridriver session the dev session records in ready.json (webdriverPort and webdriverSessionId), and no Extension.js release opens one today: Safari grants one automation session at a time, so this server never opens its own. What Safari does give you is the dev session's log file, which extension_logs and the log-based assertions read once the extension is enabled; the rest is Web Inspector, attended.";
+function readWebDriverSession(projectPath, browser) {
+    try {
+        const contract = JSON.parse(node_fs.readFileSync(bridge_readyContractPath(projectPath, browser), "utf8"));
+        if ("number" == typeof contract.webdriverPort && Number.isFinite(contract.webdriverPort) && "string" == typeof contract.webdriverSessionId && contract.webdriverSessionId.length > 0) return {
+            port: contract.webdriverPort,
+            sessionId: contract.webdriverSessionId
+        };
+    } catch  {}
+    return null;
+}
+function readyExtensionId(projectPath, browser) {
+    try {
+        const contract = JSON.parse(node_fs.readFileSync(bridge_readyContractPath(projectPath, browser), "utf8"));
+        const id = String(contract.extensionId || "").trim();
+        return id.length > 0 ? id : null;
+    } catch  {
+        return null;
+    }
+}
+class WebDriverClient {
+    async call(method, route, body, timeoutMs = 15000) {
+        const controller = new AbortController();
+        const timer = setTimeout(()=>controller.abort(), timeoutMs);
+        try {
+            const response = await this.fetchFn(`${this.base}${route}`, {
+                method,
+                headers: {
+                    "content-type": "application/json"
+                },
+                body: "GET" === method ? void 0 : JSON.stringify(body ?? {}),
+                signal: controller.signal
+            });
+            const text = await response.text();
+            let parsed = {};
+            try {
+                parsed = text ? JSON.parse(text) : {};
+            } catch  {
+                parsed = {
+                    value: {
+                        message: text
+                    }
+                };
+            }
+            if (!response.ok) {
+                const value = parsed.value || {};
+                throw new Error(String(value.message || value.error || `${response.status} on ${route}`));
+            }
+            return parsed.value;
+        } finally{
+            clearTimeout(timer);
+        }
+    }
+    async alive() {
+        try {
+            await this.call("GET", "/url");
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async currentUrl() {
+        const value = await this.call("GET", "/url");
+        return "string" == typeof value ? value : null;
+    }
+    async navigate(url, timeoutMs = 60000) {
+        await this.call("POST", "/url", {
+            url
+        }, timeoutMs);
+    }
+    async refresh(timeoutMs = 60000) {
+        await this.call("POST", "/refresh", {}, timeoutMs);
+    }
+    async execute(script, args = [], timeoutMs = 30000) {
+        return this.call("POST", "/execute/sync", {
+            script,
+            args
+        }, timeoutMs);
+    }
+    constructor(info, fetchFn = fetch){
+        webdriver_define_property(this, "info", void 0);
+        webdriver_define_property(this, "fetchFn", void 0);
+        webdriver_define_property(this, "base", void 0);
+        this.info = info;
+        this.fetchFn = fetchFn;
+        this.base = `http://127.0.0.1:${info.port}/session/${info.sessionId}`;
+    }
+}
+const EXTENSION_ROOT_READING_SCRIPT = `
+  const nodes = Array.from(document.querySelectorAll('#extension-root,[data-extension-root]'));
+  return {
+    roots: nodes.length,
+    owners: nodes.map((n) => String(n.getAttribute('data-extjs-reinject-owner') || '')),
+    url: String(location.href),
+    title: String(document.title || '')
+  };
+`;
+async function readExtensionRoots(client) {
+    const value = await client.execute(EXTENSION_ROOT_READING_SCRIPT);
+    return {
+        roots: "number" == typeof value?.roots ? value.roots : 0,
+        owners: Array.isArray(value?.owners) ? value.owners.map((o)=>String(o)) : [],
+        url: String(value?.url || ""),
+        title: String(value?.title || "")
+    };
+}
+function sameDocument(current, wanted) {
+    if (!current) return false;
+    const strip = (u)=>u.replace(/[#?].*$/, "").replace(/\/+$/, "");
+    return strip(current) === strip(wanted);
+}
 const ENGINE_COMPANION_IDS = new Set([
     "kgdaecdpfkikjncaalnmmnjjfpofkcbl",
     CARRIER_EXTENSION_ID
@@ -5462,7 +5720,48 @@ async function pollForBridgeTab(projectPath, browser, url, budgetMs) {
         await new Promise((r)=>setTimeout(r, 250));
     }
 }
+const UNKNOWN_VERB = /unknown command/i;
 async function navigateToUrlViaBridge(projectPath, browser, url, timeout, tool = "extension_open") {
+    const viaVerb = await runActVerb([
+        "navigate",
+        url,
+        projectPath,
+        "--browser",
+        browser,
+        ...null != timeout ? [
+            "--timeout",
+            String(timeout)
+        ] : []
+    ], projectPath, timeout, tool);
+    let verbFrame;
+    try {
+        verbFrame = JSON.parse(viaVerb);
+    } catch  {
+        verbFrame = null;
+    }
+    const verbUnknown = verbFrame?.ok === false && UNKNOWN_VERB.test(String(verbFrame?.error?.message ?? ""));
+    if (verbFrame && !verbUnknown) {
+        if (false === verbFrame.ok) return actFrameJson(verbFrame.hint ? verbFrame : {
+            ...verbFrame,
+            hint: "URL navigation rides the agent bridge, so the dev session must be started with allowControl: true (extension_dev)."
+        });
+        const value = verbFrame.value && "object" == typeof verbFrame.value ? verbFrame.value : {};
+        return envelope_envelope({
+            ok: true,
+            command: tool,
+            status: "navigated",
+            value: {
+                navigated: url,
+                tabId: "number" == typeof value.tabId ? value.tabId : null,
+                created: true === value.created,
+                via: "navigate"
+            },
+            hint: "The tab now shows this page. Content scripts that match it ran on load; read them with extension_eval (context: 'content', url) or extension_assert content-script-injected."
+        });
+    }
+    return navigateToUrlViaBackgroundEval(projectPath, browser, url, timeout, tool);
+}
+async function navigateToUrlViaBackgroundEval(projectPath, browser, url, timeout, tool = "extension_open") {
     const expression = `(async () => { const api = typeof browser !== "undefined" ? browser : chrome; const tabs = await api.tabs.query({ active: true, currentWindow: true }); const active = tabs && tabs[0]; const tab = active && active.id != null ? await api.tabs.update(active.id, { url: ${JSON.stringify(url)} }) : await api.tabs.create({ url: ${JSON.stringify(url)} }); return { tabId: tab && tab.id != null ? tab.id : null }; })()`;
     const raw = await runActVerb([
         "eval",
@@ -5481,7 +5780,7 @@ async function navigateToUrlViaBridge(projectPath, browser, url, timeout, tool =
         const parsed = JSON.parse(raw);
         if (parsed?.ok === false) return actFrameJson(parsed.hint ? parsed : {
             ...parsed,
-            hint: "On this browser family URL navigation rides the agent bridge (a background eval of tabs.update), so the dev session must be started with allowEval: true (extension_dev)."
+            hint: "This engine predates the navigate verb, so URL navigation rides a background eval of tabs.update: the dev session must be started with allowEval: true (extension_dev), and an MV3 background that refuses eval by CSP (Safari, strict Chromium builds) cannot navigate this way at all; upgrade the project's Extension.js to one with `extension navigate`."
         });
     } catch  {
         return raw;
@@ -5533,6 +5832,244 @@ async function resolveBridgeBaseUrl(projectPath, browser, timeout) {
     } catch  {}
     return null;
 }
+const TARGET_ID_NOTE = "targetId is a CDP target id, NOT a chrome.tabs id: do not pass it as `tab`. Target a tab with `tabUrl` (URL substring) or `url`; if you need a numeric tab id, call extension_dom_snapshot with listTabs: true.";
+function filterPageTargets(raw) {
+    return raw.filter((t)=>"page" === t.type && !String(t.url ?? "").startsWith("devtools://")).map((t)=>({
+            targetId: String(t.id),
+            type: String(t.type),
+            url: String(t.url ?? ""),
+            title: String(t.title ?? "")
+        }));
+}
+async function listPageTargets(port) {
+    return filterPageTargets(await CDPClient.discoverTargets(port));
+}
+function matchTargetsByUrl(targets, needle) {
+    const wanted = needle.toLowerCase();
+    const byUrl = targets.filter((t)=>t.url.toLowerCase().includes(wanted));
+    if (byUrl.length > 0) return byUrl;
+    return targets.filter((t)=>t.title.toLowerCase().includes(wanted));
+}
+const RUNTIME_EVALUATE_DEFAULTS = {
+    returnByValue: true,
+    awaitPromise: true,
+    userGesture: true,
+    replMode: true
+};
+function stripHash(url) {
+    return url.replace(/#.*$/, "");
+}
+function matchExtensionPageTargets(targets, wantedUrl) {
+    const wanted = stripHash(wantedUrl);
+    return targets.filter((t)=>{
+        const url = stripHash(t.url);
+        return url === wanted || url.startsWith(wanted);
+    });
+}
+async function findExtensionPageTargets(port, wantedUrl) {
+    try {
+        return matchExtensionPageTargets(await listPageTargets(port), wantedUrl);
+    } catch  {
+        return [];
+    }
+}
+function readRemoteValue(result) {
+    if (!result) return null;
+    if ("value" in result) return result.value;
+    if ("undefined" === result.type) return null;
+    if ("string" == typeof result.unserializableValue) return result.unserializableValue;
+    return result.description ?? null;
+}
+function describeException(details) {
+    const exception = details?.exception;
+    if ("string" == typeof exception?.description && exception.description) return exception.description.split("\n")[0];
+    if (exception && "value" in exception) return String(exception.value);
+    return details?.text || "the expression threw";
+}
+async function evaluateOnExtensionPage(port, targetId, expression) {
+    const cdp = new CDPClient();
+    try {
+        await cdp.connect(await CDPClient.discoverBrowserWsUrl(port));
+        const sessionId = await cdp.attachToTarget(targetId);
+        const response = await cdp.sendCommand("Runtime.evaluate", {
+            expression,
+            ...RUNTIME_EVALUATE_DEFAULTS
+        }, sessionId);
+        if (response?.exceptionDetails) return {
+            ok: false,
+            thrown: true,
+            message: describeException(response.exceptionDetails)
+        };
+        return {
+            ok: true,
+            value: readRemoteValue(response?.result)
+        };
+    } catch (error) {
+        return {
+            ok: false,
+            thrown: false,
+            message: error instanceof Error ? error.message : String(error)
+        };
+    } finally{
+        try {
+            cdp.disconnect();
+        } catch  {}
+    }
+}
+const SIDE_PANEL_API_READY = 'typeof chrome !== "undefined" && typeof chrome.sidePanel !== "undefined" && typeof chrome.windows !== "undefined" && document.readyState !== "loading"';
+const SIDE_PANEL_STATE = "window.__extensionDevSidePanel";
+const ARM_SIDE_PANEL_SCRIPT = `(async () => {
+  const win = await chrome.windows.getCurrent();
+  const state = { phase: "armed", windowId: win.id };
+  ${SIDE_PANEL_STATE} = state;
+  const overlay = document.createElement("div");
+  overlay.setAttribute("data-extension-dev-gesture", "");
+  overlay.style.cssText = "position:fixed;inset:0;z-index:2147483647;background:transparent;cursor:default;";
+  overlay.addEventListener("click", (event) => {
+    event.stopPropagation();
+    event.preventDefault();
+    state.phase = "clicked";
+    const settle = (phase, message) => {
+      state.phase = phase;
+      if (message) state.message = message;
+      overlay.remove();
+    };
+    try {
+      Promise.resolve(chrome.sidePanel.open({ windowId: win.id }))
+        .then(() => settle("opened"))
+        .catch((error) => settle("failed", String((error && error.message) || error)));
+    } catch (error) {
+      settle("failed", String((error && error.message) || error));
+    }
+  }, { once: true });
+  document.documentElement.appendChild(overlay);
+  return win.id;
+})()`;
+const READ_SIDE_PANEL_STATE = `(() => {
+  const state = ${SIDE_PANEL_STATE};
+  return state ? { phase: state.phase, message: state.message } : null;
+})()`;
+async function pollUntil(read, budgetMs, everyMs) {
+    const deadline = Date.now() + budgetMs;
+    for(;;){
+        const value = await read();
+        if (null !== value) return value;
+        if (Date.now() >= deadline) return null;
+        await new Promise((r)=>setTimeout(r, everyMs));
+    }
+}
+async function openSidePanelWithSyntheticGesture(port, hostUrl) {
+    const cdp = new CDPClient();
+    let hostId = null;
+    const closeHost = async ()=>{
+        if (!hostId) return;
+        try {
+            await cdp.sendCommand("Target.closeTarget", {
+                targetId: hostId
+            });
+        } catch  {}
+    };
+    try {
+        await cdp.connect(await CDPClient.discoverBrowserWsUrl(port));
+        const created = await cdp.sendCommand("Target.createTarget", {
+            url: hostUrl
+        });
+        if ("string" != typeof created?.targetId) return {
+            opened: false,
+            reason: `the browser did not open a host tab for ${hostUrl}`
+        };
+        hostId = created.targetId;
+        const sessionId = await cdp.attachToTarget(hostId);
+        await cdp.sendCommand("Runtime.enable", {}, sessionId);
+        const evaluate = async (expression)=>await cdp.sendCommand("Runtime.evaluate", {
+                expression,
+                ...RUNTIME_EVALUATE_DEFAULTS
+            }, sessionId);
+        const apiReady = await pollUntil(async ()=>{
+            const response = await evaluate(SIDE_PANEL_API_READY).catch(()=>null);
+            return response?.result?.value === true ? true : null;
+        }, 5000, 200);
+        if (!apiReady) {
+            await closeHost();
+            return {
+                opened: false,
+                reason: "chrome.sidePanel is not available in the extension's own page (the manifest needs the sidePanel permission and the page must load)"
+            };
+        }
+        const armed = await evaluate(ARM_SIDE_PANEL_SCRIPT);
+        if (armed.exceptionDetails) {
+            await closeHost();
+            return {
+                opened: false,
+                reason: `arming the gesture listener threw: ${describeException(armed.exceptionDetails)}`
+            };
+        }
+        const point = {
+            x: 10,
+            y: 10
+        };
+        await cdp.sendCommand("Input.dispatchMouseEvent", {
+            type: "mouseMoved",
+            ...point
+        }, sessionId);
+        await cdp.sendCommand("Input.dispatchMouseEvent", {
+            type: "mousePressed",
+            button: "left",
+            clickCount: 1,
+            ...point
+        }, sessionId);
+        await cdp.sendCommand("Input.dispatchMouseEvent", {
+            type: "mouseReleased",
+            button: "left",
+            clickCount: 1,
+            ...point
+        }, sessionId);
+        const settled = await pollUntil(async ()=>{
+            const response = await evaluate(READ_SIDE_PANEL_STATE).catch(()=>null);
+            const state = response?.result?.value;
+            if (state?.phase === "opened" || state?.phase === "failed") return state;
+            return null;
+        }, 3000, 100);
+        await closeHost();
+        if (!settled) return {
+            opened: false,
+            reason: "the synthetic click never reached chrome.sidePanel.open (the page did not report a result within 3s)"
+        };
+        if ("failed" === settled.phase) return {
+            opened: false,
+            reason: `chrome.sidePanel.open rejected: ${settled.message ?? "no message"}`
+        };
+        const excluded = hostId;
+        const panel = await pollUntil(async ()=>{
+            const matches = (await findExtensionPageTargets(port, hostUrl)).filter((t)=>t.targetId !== excluded);
+            return matches.length ? matches[0] : null;
+        }, 3000, 250);
+        if (!panel) return {
+            opened: false,
+            reason: `chrome.sidePanel.open resolved but no page target for ${hostUrl} appeared within 3s`
+        };
+        return {
+            opened: true,
+            targetId: panel.targetId,
+            url: panel.url
+        };
+    } catch (error) {
+        await closeHost();
+        return {
+            opened: false,
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    } finally{
+        try {
+            cdp.disconnect();
+        } catch  {}
+    }
+}
+const OVERRIDE_SURFACES = [
+    "newtab",
+    "history",
+    "bookmarks"
+];
 async function pollForTarget(port, url, budgetMs, navigatedTargetId) {
     const deadline = Date.now() + budgetMs;
     const wanted = url.replace(/#.*$/, "");
@@ -5567,7 +6104,38 @@ function isDisposableTab(tabUrl, destination) {
     const origin = destination.match(/^chrome-extension:\/\/[a-p]{32}\//)?.[0];
     return Boolean(origin && tabUrl.startsWith(origin));
 }
+async function navigateToUrlViaWebDriver(projectPath, browser, url) {
+    const info = readWebDriverSession(projectPath, browser);
+    if (!info) return navigateToUrlViaBridge(projectPath, browser, url);
+    const client = new WebDriverClient(info);
+    try {
+        await client.navigate(url);
+        return envelope_envelope({
+            ok: true,
+            command: open_schema.name,
+            status: "navigated",
+            value: {
+                browser,
+                url: await client.currentUrl().catch(()=>url)
+            },
+            hint: "The Safari automation window now shows this page. Content scripts that match it ran on load; read their DOM with extension_eval or extension_assert."
+        });
+    } catch (error) {
+        return envelope_envelope({
+            ok: false,
+            command: open_schema.name,
+            status: "navigate-failed",
+            error: {
+                code: "E_NAVIGATE_FAILED",
+                name: "NavigateError",
+                message: error instanceof Error ? error.message : String(error)
+            },
+            hint: "The automation window refused the URL or is gone. extension_doctor names which."
+        });
+    }
+}
 async function navigateToUrl(projectPath, browser, url, timeout) {
+    if (WEBKIT_FAMILY.has(browser) && readWebDriverSession(projectPath, browser)) return navigateToUrlViaWebDriver(projectPath, browser, url);
     if (!isChromiumFamily(browser)) return navigateToUrlViaBridge(projectPath, browser, url, timeout);
     const resolved = await resolveCdpPort(projectPath, browser);
     if (!resolved) return envelope_envelope({
@@ -5892,7 +6460,8 @@ async function openSurfaceAsTab(projectPath, browser, surface) {
                 popupBounds = await applyPopupBounds(projectPath, browser, target.targetId);
                 if (popupBounds) renderedAsTab.popupBounds = popupBounds;
             }
-            parsed.hint = `Rendered the ${surface} document in a real tab, which is how you inspect a surface headlessly. ` + (popupBounds ? `The window was resized to the popup's content size (${popupBounds.width}x${popupBounds.height}${popupBounds.clamped ? ", clamped to Chrome's 25x25-800x600 popup bounds" : ""}), approximating real popup rendering. This resizes the WHOLE browser window for the session. It is the same page with the same extension APIs, but window.close() closes the tab. ` : "It is the same page with the same extension APIs, but it is NOT hosted in a popup window: no popup sizing, and window.close() closes the tab. ") + `Inspect it with extension_dom_snapshot context: '${surface}' (include: ['html']), or extension_inspect with this url. ` + "Do NOT pass this extension-page url to extension_dom_snapshot or extension_eval as a tab target: script injection cannot reach extension pages, only the surface context or CDP can.";
+            const reachIt = `Inspect it with extension_dom_snapshot context: '${surface}' (include: ['html']), or extension_inspect with this url. To run code in it, call extension_eval with context: '${surface}' (on Chromium this goes over CDP, which the extension page CSP does not govern); do NOT pass this extension-page url as a tab target for script injection, which cannot reach extension pages.`;
+            parsed.hint = OVERRIDE_SURFACES.includes(surface) ? `Opened the ${surface} override page in a tab, which is the only place the browser ever renders a chrome_url_overrides page, so this is the real surface and not a stand-in. ` + reachIt : `Rendered the ${surface} document in a real tab, which is how you inspect a surface headlessly. ` + (popupBounds ? `The window was resized to the popup's content size (${popupBounds.width}x${popupBounds.height}${popupBounds.clamped ? ", clamped to Chrome's 25x25-800x600 popup bounds" : ""}), approximating real popup rendering. This resizes the WHOLE browser window for the session. It is the same page with the same extension APIs, but window.close() closes the tab. ` : "It is the same page with the same extension APIs, but it is NOT hosted in a popup window: no popup sizing, and window.close() closes the tab. ") + reachIt;
             return actFrameJson(parsed);
         }
     } catch  {}
@@ -5940,7 +6509,7 @@ async function confirmSurfaceTarget(projectPath, browser, surface, raw) {
 }
 const open_schema = {
     name: "extension_open",
-    description: "Open an extension surface, or replay an event, in a running session. Pass surface:'popup', 'options' or 'sidebar' to open a UI surface, or 'newtab', 'history' or 'bookmarks' to open the matching chrome_url_overrides page in a tab. Pass surface:'action' to trigger the toolbar action, which opens its popup or replays chrome.action.onClicked when there is none. Pass surface:'command' with `name` to replay a chrome.commands.onCommand shortcut. Note that action and command replay invoke your listener without a user gesture, so the gesture-derived activeTab grant does not apply; the result reports gesture:false and warns when activeTab is declared. Start the session with allowControl:true (extension_dev).",
+    description: "Open an extension surface, or replay an event, in a running session. Pass surface:'popup', 'options' or 'sidebar' to open a UI surface, or 'newtab', 'history' or 'bookmarks' to open the matching chrome_url_overrides page in a tab (always a tab, resolved by the server, never sent to the engine). On Chromium, when Chrome refuses the sidebar for lack of a user gesture, the server opens the real panel through a synthetic click on the extension's own page and says so in warnings; if that fails too it renders the sidebar document as a tab. Pass surface:'action' to trigger the toolbar action, which opens its popup or replays chrome.action.onClicked when there is none. Pass surface:'command' with `name` to replay a chrome.commands.onCommand shortcut. Note that action and command replay invoke your listener without a user gesture, so the gesture-derived activeTab grant does not apply; the result reports gesture:false and warns when activeTab is declared. Start the session with allowControl:true (extension_dev).",
     inputSchema: {
         type: "object",
         properties: {
@@ -5992,10 +6561,9 @@ async function open_handler(args) {
         "popup",
         "options",
         "sidebar",
-        "newtab",
-        "history",
-        "bookmarks"
+        ...OVERRIDE_SURFACES
     ];
+    if (args.surface && OVERRIDE_SURFACES.includes(args.surface)) return openSurfaceAsTab(args.projectPath, browser, args.surface);
     if (args.asTab && args.surface && AS_TAB_SURFACES.includes(args.surface)) return openSurfaceAsTab(args.projectPath, browser, args.surface);
     if (!args.surface) return envelope_envelope({
         ok: false,
@@ -6062,8 +6630,135 @@ async function open_handler(args) {
             return actFrameJson(parsed);
         }
     } catch  {}
+    if (!headless && "sidebar" === args.surface && isChromiumFamily(browser)) {
+        const refusal = readGestureRefusal(raw);
+        if (refusal) return openSidebarThroughGesture(args.projectPath, browser, refusal);
+    }
+    if ("sidebar" === args.surface && isGeckoFamily(browser)) {
+        const refusal = readUnsupportedRefusal(raw);
+        if (refusal) return openGeckoSidebar(args.projectPath, browser, refusal, args.timeout);
+    }
     return AS_TAB_SURFACES.includes(args.surface) ? confirmSurfaceTarget(args.projectPath, browser, args.surface, raw) : raw;
 }
+const E_USER_GESTURE_REQUIRED = "E_USER_GESTURE_REQUIRED";
+function readGestureRefusal(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+    if (parsed?.ok !== false) return null;
+    const code = "string" == typeof parsed.error?.code ? parsed.error.code : "";
+    const message = String(parsed.error?.message ?? "");
+    return code === E_USER_GESTURE_REQUIRED || /user gesture/i.test(message) ? parsed : null;
+}
+function readUnsupportedRefusal(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+    if (parsed?.ok !== false) return null;
+    const code = "string" == typeof parsed.error?.code ? parsed.error.code : "";
+    const message = String(parsed.error?.message ?? "");
+    return "E_NOT_IMPLEMENTED" === code || /not available/i.test(message) ? parsed : null;
+}
+const GECKO_SIDEBAR_GESTURE = "Firefox opens a sidebar_action panel only from a user gesture (the toolbar button or View > Sidebar; Bugzilla 1392624), and the engine's open verb carries none, so it cannot open the panel";
+async function openGeckoSidebar(projectPath, browser, refusal, timeout) {
+    const doc = surfaceDocument(projectPath, browser, "sidebar");
+    if (!doc) return missingSurfaceError(projectPath, browser, "sidebar", "so there is no sidebar panel to open");
+    const probe = await runActVerb([
+        "inspect",
+        projectPath,
+        "--context",
+        "sidebar",
+        "--include",
+        "summary",
+        "--browser",
+        browser,
+        ...null != timeout ? [
+            "--timeout",
+            String(timeout)
+        ] : []
+    ], projectPath, timeout, open_schema.name);
+    let open = null;
+    try {
+        const parsed = JSON.parse(probe);
+        if (parsed?.ok === true) open = parsed;
+    } catch  {}
+    if (open) {
+        const url = "string" == typeof open.value?.url ? open.value.url : "string" == typeof open.value?.meta?.url ? open.value.meta.url : void 0;
+        return envelope_envelope({
+            ok: true,
+            command: open_schema.name,
+            status: "already-open",
+            value: {
+                surface: "sidebar",
+                document: doc,
+                alreadyOpen: true,
+                ...url ? {
+                    url
+                } : {}
+            },
+            hint: `The sidebar panel is open in the ${browser} window already: read it with extension_dom_snapshot context: 'sidebar' or run code in it with extension_eval context: 'sidebar'. ${GECKO_SIDEBAR_GESTURE}, and it did not need to.`
+        });
+    }
+    const fallback = await openSurfaceAsTab(projectPath, browser, "sidebar");
+    try {
+        const parsedFallback = JSON.parse(fallback);
+        if (parsedFallback?.ok) {
+            addWarning(parsedFallback, `${GECKO_SIDEBAR_GESTURE}, and the panel is not open now, so the sidebar document was rendered as a tab instead. The DOM is the same document the panel would show; the panel hosting stays unverified. A person opens the real panel from the toolbar button or View > Sidebar.`);
+            return actFrameJson(parsedFallback);
+        }
+    } catch  {}
+    refusal.error = {
+        ...refusal.error ?? {},
+        message: `${GECKO_SIDEBAR_GESTURE}. Rendering the document ${doc} as a tab failed as well.`
+    };
+    refusal.hint = "Start the session with allowEval: true so the document can be opened by url through the bridge, or open the panel from the toolbar button in the dev browser and read it with extension_dom_snapshot context: 'sidebar'.";
+    return actFrameJson(refusal);
+}
+const SIDEBAR_GESTURE_WARNING = "Chrome opens the side panel only from a user gesture and the engine's open verb carries none, so the server opened the extension's own sidebar page in a tab, dispatched a synthetic click on it over CDP and called chrome.sidePanel.open from inside that click, then closed the tab. The panel that opened is the real one; the toolbar wiring (action.onClicked or sidePanel.setPanelBehavior) was not exercised.";
+async function openSidebarThroughGesture(projectPath, browser, refusal) {
+    const doc = surfaceDocument(projectPath, browser, "sidebar");
+    const resolved = doc ? await resolveCdpPort(projectPath, browser) : null;
+    const extensionId = resolved ? await resolveExtensionId(projectPath, browser) : null;
+    let reason = "the sidebar document or the session's CDP port could not be resolved";
+    if (doc && resolved && extensionId) {
+        const hostUrl = `chrome-extension://${extensionId}/${doc}`;
+        const outcome = await openSidePanelWithSyntheticGesture(resolved.port, hostUrl);
+        if (outcome.opened) return envelope_envelope({
+            ok: true,
+            command: open_schema.name,
+            status: "opened",
+            value: {
+                surface: "sidebar",
+                gesture: "synthetic-click",
+                surfaceTarget: {
+                    targetId: outcome.targetId,
+                    url: outcome.url
+                }
+            },
+            warnings: [
+                SIDEBAR_GESTURE_WARNING
+            ],
+            hint: "Read the panel with extension_dom_snapshot context: 'sidebar' (include: ['html']) or run code in it with extension_eval context: 'sidebar'. To exercise the toolbar path itself, a person must click the toolbar icon in the dev browser."
+        });
+        reason = outcome.reason;
+    }
+    const fallback = await openSurfaceAsTab(projectPath, browser, "sidebar");
+    try {
+        const parsedFallback = JSON.parse(fallback);
+        if (parsedFallback?.ok) {
+            addWarning(parsedFallback, `Chrome opens the side panel only from a user gesture, the engine's open verb carries none, and the server's synthetic click did not open it either (${reason}), so the sidebar document was rendered as a tab instead. The DOM is the same React tree the panel would show; the panel hosting and the toolbar wiring stay unverified. Opening the real panel needs a toolbar click from a person in the dev browser.`);
+            return actFrameJson(parsedFallback);
+        }
+    } catch  {}
+    refusal.hint = `Chrome opens the side panel only from a user gesture, which the engine's open verb cannot carry, and the server's synthetic click did not open it either (${reason}). ` + (doc && extensionId ? `To read the panel page anyway, call extension_open with url: "chrome-extension://${extensionId}/${doc}" and then extension_dom_snapshot context: 'sidebar' on it. ` : "To read the panel page anyway, open its document by url with extension_open and read it with extension_dom_snapshot context: 'sidebar'. ") + "Opening the real panel needs a toolbar click from a person in the dev browser.";
+    return actFrameJson(refusal);
+}
 function resolveToken() {
     const fromEnv = String(process.env.EXTENSION_DEV_TOKEN || "").trim();
     if (fromEnv) return fromEnv;
@@ -6348,11 +7043,11 @@ const IGNORED_SEGMENTS = new Set([
     "__MACOSX"
 ]);
 const IGNORED_FILES = /^\.env(\..*)?$|\.(pem|key|p12|pfx|keystore)$/i;
-const TEXTUAL = /\.(json|js|mjs|cjs|ts|tsx|jsx|html|htm|css|svg|txt|md|map)$/i;
+const preview_upload_TEXTUAL = /\.(json|js|mjs|cjs|ts|tsx|jsx|html|htm|css|svg|txt|md|map)$/i;
 const MAX_FILES = 2000;
 const MAX_CONTENT_CHARS = 67108864;
 function encodeFile(relativePath, bytes) {
-    if (TEXTUAL.test(relativePath)) {
+    if (preview_upload_TEXTUAL.test(relativePath)) {
         const text = bytes.toString("utf8");
         if (Buffer.from(text, "utf8").equals(bytes)) return {
             content: text,
@@ -6518,6 +7213,7 @@ async function uploadPreview(options) {
     };
     return {
         ok: true,
+        body: data,
         data: {
             artifactId,
             previewUrl,
@@ -6806,6 +7502,21 @@ function localLaneRemedy(checkout) {
     const shareOut = "Pass share:true for a link that needs no local server and opens for anyone.";
     return checkout ? `Start it with '${SURFACE.devCommand}' in ${checkout}. ${shareOut}` : `${SURFACE.label} is a private app of the extension.dev monorepo and no npm install of this server can start it, so the default lane cannot resolve on this machine. ${shareOut}`;
 }
+function unrequestedShare(args) {
+    const call = {
+        projectPath: args.projectPath
+    };
+    if (args.browser) call.browser = args.browser;
+    if (false === args.build) call.build = false;
+    if (args.distPath) call.distPath = args.distPath;
+    call.share = true;
+    return {
+        requested: false,
+        localLinkNeeds: `deepLink renders only against a ${SURFACE.label} dev server running on this machine, so to anyone else it is a dead link.`,
+        shareSpends: "share:true uploads this build to extension.dev's machines and counts against your free allowance, which is why it is off by default.",
+        shareCall: `extension_preview_web ${JSON.stringify(call)}`
+    };
+}
 function previewOriginOf(previewUrl) {
     try {
         return new URL(previewUrl).origin;
@@ -6883,6 +7594,10 @@ async function buildShare(projectPath, distDir, manifest, browser, verifyInBrows
         } : {},
         serves: "uploaded-local-build",
         localBuildUploaded: true,
+        allowance: spendNarration({
+            what: "This share upload",
+            body: result.body
+        }),
         ...browserCheck ? browserCheck.held ? {
             browserLoadable: null,
             heldFromPublic: true,
@@ -6959,7 +7674,7 @@ const preview_web_schema = {
             share: {
                 type: "boolean",
                 default: false,
-                description: "Upload the built dist and return a public link (share.previewUrl) that renders those exact bytes for anyone: no install, sign-in or dev server. It also serves the build as a zip (share.zipUrl), so sharing hands over the code. Needs a token scoped to an extension.dev project (extension_auth or EXTENSION_DEV_TOKEN); without one you get a login hint and the local preview still succeeds. Live until share.expiresAt; DELETE share.revokeUrl to kill it sooner. Revocation is permanent, and re-sharing an unchanged build returns the same link unless it was revoked, so each share is also appended to the project's gitignored .extension.dev/shared-previews.json."
+                description: "Upload the built dist and return a public link (share.previewUrl) that renders those exact bytes for anyone: no install, sign-in or dev server. Uploading runs on extension.dev's machines and counts against your free allowance; left false, the result's share property says what the local deepLink needs, what share:true spends, and the exact call to get a shareable link. It also serves the build as a zip (share.zipUrl), so sharing hands over the code. Needs a token scoped to an extension.dev project (extension_auth or EXTENSION_DEV_TOKEN); without one you get a login hint and the local preview still succeeds. Live until share.expiresAt; DELETE share.revokeUrl to kill it sooner. Revocation is permanent, and re-sharing an unchanged build returns the same link unless it was revoked, so each share is also appended to the project's gitignored .extension.dev/shared-previews.json."
             }
         },
         required: [
@@ -7064,6 +7779,7 @@ async function preview_web_handler(args) {
             built: false
         }
     };
+    if (!args.share) result.share = unrequestedShare(args);
     const checkout = previewDevCheckout([
         args.projectPath,
         process.cwd()
@@ -8112,6 +8828,81 @@ function verdictSentence(verdict) {
     if (verdict.inconclusive.length > 0) parts.push(`${verdict.inconclusive.length} inconclusive, meaning this platform cannot cover the question today: not a pass, not a bug in the extension, and each one carries the evidence that would settle it in settledBy`);
     return `${parts.join(", ")}.`;
 }
+const execFileAsync = promisify(execFile);
+const SAFARI_MCP_SETTING = 'Safari > Settings > Developer > "Allow remote automation and external agents"';
+const SAFARI_MCP_ADD_COMMAND = 'claude mcp add safari-mcp -- "/usr/bin/safaridriver" --mcp';
+function parseSafariDriverHelp(helpText) {
+    const flags = new Set(Array.from(helpText.matchAll(/(?:^|\s)--([a-z][a-z-]*)/g)).map((m)=>m[1]));
+    return {
+        mcp: flags.has("mcp"),
+        bidi: flags.has("bidi")
+    };
+}
+function safariDriverCandidates(safariBinary) {
+    const candidates = [];
+    if (safariBinary) candidates.push(node_path.join(node_path.dirname(safariBinary), "safaridriver"));
+    candidates.push("/usr/bin/safaridriver");
+    return Array.from(new Set(candidates));
+}
+async function readSafariDriverHelp(driverPath) {
+    try {
+        const { stdout, stderr } = await execFileAsync(driverPath, [
+            "--help"
+        ], {
+            timeout: 5000,
+            env: {
+                ...process.env
+            }
+        });
+        return `${stdout}\n${stderr}`;
+    } catch (error) {
+        const failed = error;
+        const text = `${failed.stdout ?? ""}\n${failed.stderr ?? ""}`.trim();
+        return text.length > 0 ? text : null;
+    }
+}
+async function detectSafariAutomation(safariBinary) {
+    if ("darwin" !== process.platform) return {
+        safaridriver: null,
+        mcp: false,
+        bidi: false
+    };
+    for (const candidate of safariDriverCandidates(safariBinary)){
+        if (!node_fs.existsSync(candidate)) continue;
+        const help = await readSafariDriverHelp(candidate);
+        if (null !== help) return {
+            safaridriver: candidate,
+            ...parseSafariDriverHelp(help)
+        };
+    }
+    return {
+        safaridriver: null,
+        mcp: false,
+        bidi: false
+    };
+}
+async function readSafariVersion(safariBinary) {
+    const plist = node_path.resolve(safariBinary, "..", "..", "Info.plist");
+    if (!node_fs.existsSync(plist)) return null;
+    try {
+        const { stdout } = await execFileAsync("/usr/bin/defaults", [
+            "read",
+            plist,
+            "CFBundleShortVersionString"
+        ], {
+            timeout: 5000
+        });
+        const version = stdout.trim();
+        return /^\d+(\.\d+)*$/.test(version) ? version : null;
+    } catch  {
+        return null;
+    }
+}
+function safariAutomationHint(automation) {
+    if (automation.mcp) return `Safari ships Apple's Safari MCP server (${automation.safaridriver} --mcp). Enable ${SAFARI_MCP_SETTING}, then add it beside this server: ${SAFARI_MCP_ADD_COMMAND}. It drives an isolated automation window with page-level tools (tabs, console, network, screenshots, evaluate); it has no extension-aware tool, so use it to read a page your content script touches, not the popup or background.`;
+    if (automation.safaridriver) return `This safaridriver (${automation.safaridriver}) has no --mcp flag: Apple's Safari MCP server needs Safari 27 or Safari Technology Preview 247+. Until then a Safari session is build, open and enable only, with no console or DOM reading from this server.`;
+    return "No safaridriver found beside Safari, so no automation reading is possible for it from this machine.";
+}
 function makeFilter(args) {
     const level = String(args.level || "all").toLowerCase();
     const loggingOff = "off" === level;
@@ -8195,6 +8986,16 @@ async function environmentPreflight() {
         status: cacheExists ? "pass" : "warn",
         detail: cacheExists ? `Template catalog cached at ${cacheFile}` : "Template catalog not cached yet (extension_templates will fetch it)"
     });
+    if ("darwin" === process.platform) {
+        const safariBinary = "/Applications/Safari.app/Contents/MacOS/Safari";
+        const automation = await detectSafariAutomation(node_fs.existsSync(safariBinary) ? safariBinary : null);
+        checks.push({
+            check: "safari-agent",
+            status: automation.mcp ? "pass" : "warn",
+            detail: automation.mcp ? `Apple's Safari MCP server is available (${automation.safaridriver} --mcp)` : automation.safaridriver ? `${automation.safaridriver} has no --mcp flag, so Safari has no agent-readable window from this machine` : "No safaridriver found, so Safari has no agent-readable window from this machine",
+            remediation: automation.mcp ? `Enable ${SAFARI_MCP_SETTING}, then add it beside this server: ${SAFARI_MCP_ADD_COMMAND}. It reads pages in an isolated automation window and has no extension-aware tool.` : "Install Safari 27 (Software Update) or Safari Technology Preview 247+ for Apple's Safari MCP server. A Safari dev session still builds, opens and guides the enable step without it."
+        });
+    }
     const healthy = checks.every((c)=>"fail" !== c.status);
     return envelope_envelope({
         ok: healthy,
@@ -8247,6 +9048,25 @@ function capabilityProbeChecks(parsed) {
     return value?.checks;
 }
 const CONTROL_OFF_BY_CHOICE = /\bwas not started with --allow-control\b/i;
+function pidIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function reconcileRelaunchedBrowser(checks, contract) {
+    const exitedLeg = checks.find((leg)=>"browser" === leg.check && "fail" === leg.status && /\bexited\b/i.test(String(leg.detail ?? "")));
+    if (!exitedLeg) return false;
+    const executorAnswered = checks.some((leg)=>("executor" === leg.check || "control-channel" === leg.check) && "pass" === leg.status);
+    const browserAlive = "number" == typeof contract?.browserPid && pidIsAlive(contract.browserPid);
+    if (!executorAnswered && !browserAlive) return false;
+    exitedLeg.status = "warn";
+    exitedLeg.detail = `${exitedLeg.detail ?? "browser exited"}. ${browserAlive ? `The browser pid the launcher recorded (${contract?.browserPid}) is alive` : "The executor answered a probe after that exit"}, so the session is live and the recorded exit was an earlier process: Firefox hands a fresh profile to a relaunched process and the first one exits 0.`;
+    exitedLeg.remediation = "Nothing to do. If a later call finds the session unreachable, extension_stop and extension_dev again.";
+    return true;
+}
 function controlOffByChoiceLeg(checks) {
     return checks.find((leg)=>"control-channel" === leg.check && "fail" === leg.status && "string" == typeof leg.detail && CONTROL_OFF_BY_CHOICE.test(leg.detail)) ?? null;
 }
@@ -8283,23 +9103,15 @@ async function doctor_handler(args) {
         if (!Array.isArray(probed)) throw new Error("not a check array");
         const checks = probed;
         const readOnlyLeg = controlOffByChoiceLeg(checks);
-        for (const check of checks){
-            if ("string" == typeof check.detail) check.detail = toMcpSpeak(check.detail);
-            if ("string" == typeof check.remediation) check.remediation = toMcpSpeak(check.remediation);
-        }
-        let healthy = 0 === code;
-        const contract = readContractForDiagnosis(projectPath, browser);
-        if (contract?.status === "error") {
-            healthy = false;
-            const browserExited = "browser_exited" === contract.code || void 0 !== contract.browserExitCode;
-            const detail = browserExited ? `The ${browser} browser for this session exited unexpectedly${null != contract.browserExitCode ? ` (exit code ${contract.browserExitCode})` : ""}; the extension may have been rejected or the browser crashed. The session cannot be driven.` : contract.errors && contract.errors.length ? contract.errors.join("; ") : contract.message || "The dev session recorded status: error in ready.json.";
-            checks.push({
-                check: "runtime-errors",
-                status: "fail",
-                detail: toMcpSpeak(detail),
-                remediation: browserExited ? "Read extension_logs and the session log for the rejection cause, call extension_stop to clean up, then relaunch." : "The build or extension load failed. Fix the reported error, let the dev server recompile, then re-run doctor."
-            });
-        } else {
+        for (const check of checks){
+            if ("string" == typeof check.detail) check.detail = toMcpSpeak(check.detail);
+            if ("string" == typeof check.remediation) check.remediation = toMcpSpeak(check.remediation);
+        }
+        let healthy = 0 === code;
+        const contract = readContractForDiagnosis(projectPath, browser);
+        const relaunched = reconcileRelaunchedBrowser(checks, contract);
+        if (relaunched) healthy = !checks.some((leg)=>"fail" === leg.status);
+        if (contract?.status !== "error" || relaunched) {
             const errs = recentErrorLogs(projectPath, browser);
             if (errs.length) {
                 healthy = false;
@@ -8310,6 +9122,16 @@ async function doctor_handler(args) {
                     remediation: "The extension is throwing at runtime. Inspect with extension_logs. A chrome.* API called without its permission is a common cause: extension_manifest_validate catches a permission MISSING FROM permissions[], but it does not model host-permission scope (e.g. webRequest with no matching host_permissions) or gesture requirements (e.g. activeTab without a user gesture), so a valid:true there does not rule those out."
                 });
             }
+        } else {
+            healthy = false;
+            const browserExited = "browser_exited" === contract.code || void 0 !== contract.browserExitCode;
+            const detail = browserExited ? `The ${browser} browser for this session exited unexpectedly${null != contract.browserExitCode ? ` (exit code ${contract.browserExitCode})` : ""}; the extension may have been rejected or the browser crashed. The session cannot be driven.` : contract.errors && contract.errors.length ? contract.errors.join("; ") : contract.message || "The dev session recorded status: error in ready.json.";
+            checks.push({
+                check: "runtime-errors",
+                status: "fail",
+                detail: toMcpSpeak(detail),
+                remediation: browserExited ? "Read extension_logs and the session log for the rejection cause, call extension_stop to clean up, then relaunch." : "The build or extension load failed. Fix the reported error, let the dev server recompile, then re-run doctor."
+            });
         }
         const engineVersion = projectEngineVersion(projectPath);
         if (engineVersion) {
@@ -8324,6 +9146,19 @@ async function doctor_handler(args) {
                 } : {}
             });
         }
+        if (WEBKIT_FAMILY.has(browser)) {
+            const info = readWebDriverSession(projectPath, browser);
+            const alive = info ? await new WebDriverClient(info).alive() : false;
+            if (info && !alive) healthy = false;
+            checks.push({
+                check: "safari-window",
+                status: info ? alive ? "pass" : "fail" : "skip",
+                detail: info ? alive ? `Safari automation window recorded by the dev session (safaridriver on port ${info.port}, session ${info.sessionId})` : `ready.json records a Safari automation session on port ${info.port}, but it no longer answers: the window or the driver is gone` : "no safaridriver session recorded; page-world eval and open by url use the bridge, and everything else already does",
+                ...info && !alive ? {
+                    remediation: "Stop and restart extension_dev --browser=safari; the session that recorded the window opens it again on the first package."
+                } : {}
+            });
+        }
         const failures = checks.filter((leg)=>"fail" === leg.status);
         const readOnly = null !== readOnlyLeg && 1 === failures.length && failures[0] === readOnlyLeg;
         if (readOnly && readOnlyLeg) {
@@ -8740,6 +9575,16 @@ async function readFromStream(args, browser, limit) {
 async function logs_handler(args) {
     const { browser } = resolveSessionBrowser(args.projectPath, args.browser);
     const limit = args.limit && args.limit > 0 ? args.limit : DEFAULT_LIMIT;
+    if (WEBKIT_FAMILY.has(browser) && !node_fs.existsSync(logsPath(args.projectPath, browser))) return envelope_envelope({
+        ok: false,
+        command: TOOL,
+        status: "no-log-file",
+        error: {
+            code: "E_LOGS_MISSING",
+            message: `No logs found at ${logsPath(args.projectPath, browser)}, and ${browser} has no CDP or RDP to read instead.`
+        },
+        hint: "Safari logs arrive through the extension's bridge to the dev server, with background and content contexts, once the extension is enabled and a dev session from an Extension.js that streams Safari logs (4.1.28 or newer) is running. Start extension_dev --browser=safari, enable the extension in Safari > Settings > Extensions, then read again. The page a content script changes is also readable with extension_eval (context: 'page') or extension_assert content-script-injected."
+    });
     if (args.follow) return readFromStream(args, browser, limit);
     return readFromFile(args, browser, limit);
 }
@@ -8916,6 +9761,10 @@ function parseClauses(raw) {
 }
 const NO_SESSION_SETTLED_BY = "Start the session with extension_dev, confirm it with extension_wait, then assert again.";
 class Stage {
+    webdriver() {
+        const info = readWebDriverSession(this.projectPath, this.browser);
+        return info ? new WebDriverClient(info) : null;
+    }
     async port() {
         if (void 0 === this.cdpPort) {
             const resolved = await resolveCdpPort(this.projectPath, this.browser);
@@ -8983,6 +9832,7 @@ class Stage {
         assert_define_property(this, "browser", void 0);
         assert_define_property(this, "timeout", void 0);
         assert_define_property(this, "chromium", void 0);
+        assert_define_property(this, "webkit", void 0);
         assert_define_property(this, "cdpPort", void 0);
         assert_define_property(this, "discovered", void 0);
         assert_define_property(this, "manifestRead", void 0);
@@ -8994,6 +9844,7 @@ class Stage {
         this.discovered = null;
         this.client = null;
         this.chromium = isChromiumFamily(browser);
+        this.webkit = WEBKIT_FAMILY.has(browser);
     }
 }
 function truncate(value, max = 200) {
@@ -9125,12 +9976,77 @@ async function assertContentScriptInjected(clause, stage) {
         runId,
         coveringMatches: covering
     });
+    if (stage.webkit) return assertContentScriptInjectedOnWebKit(clause, stage, {
+        covering,
+        patterns
+    });
     return inconclusiveCheck(id, subject, covering.length > 0 ? `${covering.length} declared content_scripts match(es) cover ${clause.url} (${covering.join(", ")}), but nothing observable proves the script executed there: this platform cannot see into a content script's isolated world, and the content context logged nothing at that url in run ${runId || "(unnamed)"}.${stale ? ` ${stale}` : ""}` : `The built manifest (${read.file}) declares no content_scripts match covering ${clause.url}${patterns.length ? ` (declared: ${patterns.join(", ")})` : " and declares no content script at all"}. That is not proof of non-injection either: scripts registered at runtime with chrome.scripting.registerContentScripts are invisible to this reader.`, "Have the content script write one line, a console call or a dx.signal, and this check reads it from the log stream. To settle it now, read a marker the script sets with extension_eval (context: 'content', url: the page), which runs in the same isolated world the content script does.", {
         coveringMatches: covering,
         declaredMatches: patterns,
         runId
     });
 }
+async function assertBackgroundOnWebKit(clause, stage) {
+    const id = BACKGROUND;
+    const subject = clause.subject;
+    const runId = readLogRunId(stage.projectPath, stage.browser);
+    const stale = staleFileNote(stage.projectPath, stage.browser, runId);
+    const lines = readLogEvents(stage.projectPath, stage.browser, {
+        context: [
+            "background"
+        ]
+    });
+    if (lines.length > 0 && !stale) return passCheck(id, subject, `The background context wrote ${lines.length} log line(s) in run ${runId || "(unnamed)"} over the extension's bridge, and only a running background writes from that context.`, {
+        lines: lines.length,
+        runId
+    });
+    return inconclusiveCheck(id, subject, `${stage.browser} lists no background worker to this server, and the background context logged nothing in run ${runId || "(unnamed)"}${stale ? ` (${stale})` : ""}.`, "Have the background write one line on start (a console call), which reaches the dev session's log over the bridge once the extension is enabled; or open Web Inspector (Develop > Web Extension Background Content), attended.", {
+        runId
+    });
+}
+async function assertContentScriptInjectedOnWebKit(clause, stage, declared) {
+    const id = CONTENT_SCRIPT;
+    const subject = clause.subject;
+    const client = stage.webdriver();
+    if (!client) return inconclusiveCheck(id, subject, `The content context logged nothing at ${clause.url} in this run, and no safaridriver session is recorded for ${stage.browser}, so no page was read either.${declared.covering.length ? ` ${declared.covering.length} declared match(es) cover the url (${declared.covering.join(", ")}), which is not proof the script ran.` : ""}`, `Open ${clause.url} in Safari with the extension enabled, have the content script write one line (a console call), and assert again: the line reaches the dev session's log over the bridge. ${WEBDRIVER_SESSION_MISSING_HINT}`, {
+        coveringMatches: declared.covering,
+        declaredMatches: declared.patterns
+    });
+    let reading;
+    try {
+        const current = await client.currentUrl();
+        if (!sameDocument(current, clause.url)) {
+            await client.navigate(clause.url);
+            await new Promise((resolve)=>setTimeout(resolve, 1200));
+        }
+        reading = await readExtensionRoots(client);
+    } catch (error) {
+        return inconclusiveCheck(id, subject, `The Safari automation window could not be read: ${error instanceof Error ? error.message : String(error)}.`, "Confirm the dev session still holds its window with extension_doctor, restart extension_dev --browser=safari if it ended, then assert again.", {
+            coveringMatches: declared.covering,
+            declaredMatches: declared.patterns
+        });
+    }
+    const extensionId = readyExtensionId(stage.projectPath, stage.browser) ?? await stage.extensionId();
+    if (!extensionId) return inconclusiveCheck(id, subject, `The Safari automation window shows ${reading.roots} extension root(s) at ${reading.url}, but this session recorded no extension id, so none of them can be attributed to this extension rather than another one.`, "Restart extension_dev --browser=safari on an Extension.js that stamps extensionId into ready.json, then assert again.", {
+        roots: reading.roots,
+        owners: reading.owners,
+        url: reading.url
+    });
+    const owned = reading.owners.filter((owner)=>owner.length > 0 && owner.includes(extensionId));
+    if (owned.length > 0) return passCheck(id, subject, `${owned.length} extension root(s) mounted by this extension's content script are in the DOM at ${reading.url}, read from the Safari automation window; only an injected content script mounts them.`, {
+        roots: reading.roots,
+        owners: owned,
+        url: reading.url,
+        coveringMatches: declared.covering
+    });
+    return inconclusiveCheck(id, subject, declared.covering.length > 0 ? `${declared.covering.length} declared content_scripts match(es) cover ${clause.url} (${declared.covering.join(", ")}), and the Safari automation window shows ${reading.roots} extension root(s) at ${reading.url}${reading.roots > 0 ? " none of which names this extension as owner" : ""}. A script that mounts no root leaves nothing this reader can see, and Safari carries no console feed over WebDriver to read a line instead.` : `The built manifest declares no content_scripts match covering ${clause.url}${declared.patterns.length ? ` (declared: ${declared.patterns.join(", ")})` : " and declares no content script at all"}, and the Safari automation window shows ${reading.roots} extension root(s) there.`, "Have the content script mount an element with data-extension-root (Extension.js stamps the owner on it), or set any DOM marker and read it with extension_eval (context: 'page', url: the page). A console line would need the WebDriver BiDi log domain, which this server does not speak yet.", {
+        roots: reading.roots,
+        owners: reading.owners,
+        url: reading.url,
+        coveringMatches: declared.covering,
+        declaredMatches: declared.patterns
+    });
+}
 function readStorageValue(value, key) {
     if (null == value) return {
         shape: "absent"
@@ -9244,6 +10160,7 @@ function assertConsoleErrorsEmpty(clause, stage) {
     });
 }
 async function evaluateClause(clause, stage) {
+    if (stage.webkit && clause.assert === BACKGROUND) return assertBackgroundOnWebKit(clause, stage);
     switch(clause.assert){
         case BACKGROUND:
             return assertBackgroundWorker(clause, stage);
@@ -11170,6 +12087,32 @@ const inspect_schema_schema = {
         ]
     }
 };
+const EXTENSION_PAGE_CONTEXTS = [
+    "popup",
+    "options",
+    "sidebar",
+    "newtab",
+    "history",
+    "bookmarks"
+];
+const EXTENSION_ORIGIN = /^(moz|chrome|safari-web)-extension:\/\//;
+function isExtensionUrl(url) {
+    return "string" == typeof url && EXTENSION_ORIGIN.test(url);
+}
+function surfaceForExtensionUrl(projectPath, browser, url) {
+    const bare = url.replace(EXTENSION_ORIGIN, "").replace(/^[^/]*\//, (m)=>EXTENSION_ORIGIN.test(url) ? "" : m).replace(/^\.?\//, "").replace(/[?#].*$/, "");
+    if (!bare) return null;
+    for (const context of EXTENSION_PAGE_CONTEXTS){
+        const document = surfaceDocument(projectPath, browser, context);
+        if (document) {
+            if (bare === document || bare.endsWith(`/${document}`) || document.endsWith(`/${bare}`)) return {
+                context,
+                document
+            };
+        }
+    }
+    return null;
+}
 const inspect_gecko_TOOL = inspect_schema_schema.name;
 function buildBridgeInspectExpression(opts) {
     const parts = [
@@ -11287,7 +12230,22 @@ async function collectGeckoConsole(args, browser, urlFilter, result, notes) {
 }
 async function inspectViaBridge(args, browser, include, maxBytes) {
     const notes = [];
-    if (args.url) {
+    const surface = args.url ? surfaceForExtensionUrl(args.projectPath, browser, args.url) : null;
+    if (args.url && !surface && EXTENSION_ORIGIN.test(args.url)) {
+        const declared = declaredSurfaces(args.projectPath, browser) ?? [];
+        return envelope_envelope({
+            ok: false,
+            command: inspect_gecko_TOOL,
+            status: "no-surface",
+            error: {
+                code: "E_NO_SURFACE_DOCUMENT",
+                name: "NoSurfaceDocument",
+                message: `${args.url} is a page inside the extension, and on ${browser} a page inside the extension is read through its own surface relay, but that path matches none of the surface documents the manifest declares${declared.length ? ` (${declared.join(", ")})` : ""}. Script injection cannot reach an extension page at all.`
+            },
+            hint: declared.length ? `Pass the declared document path (extension_open surface: "${declared[0]}" opens one), or read it with extension_dom_snapshot context: "${declared[0]}".` : "Declare the page as a surface in the manifest (action.default_popup, options_ui.page, sidebar_action.default_panel or chrome_url_overrides) and rebuild."
+        });
+    }
+    if (args.url && !surface) {
         const listed = await listBridgeTabs(args.projectPath, browser, args.timeout, inspect_gecko_TOOL);
         if ("error" in listed) return listed.error;
         const already = listed.tabs.some((t)=>t.url.includes(args.url));
@@ -11314,8 +12272,8 @@ async function inspectViaBridge(args, browser, include, maxBytes) {
         expression,
         args.projectPath,
         "--context",
-        "page",
-        ...args.url ? [
+        surface ? surface.context : "page",
+        ...args.url && !surface ? [
             "--url",
             args.url
         ] : [],
@@ -11369,7 +12327,11 @@ async function inspectViaBridge(args, browser, include, maxBytes) {
     if (null === value) return raw;
     const result = {
         browser,
-        transport: "bridge"
+        transport: "bridge",
+        ...surface ? {
+            surface: surface.context,
+            document: surface.document
+        } : {}
     };
     if (value.meta) {
         result.target = {
@@ -11845,9 +12807,72 @@ async function listGeckoExtensions(projectPath, browser) {
         });
     }
 }
+const RELAY_MARK = "__extensionDevRelay";
+function cloneHelper() {
+    return `var clone = function (v) {
+    if (v === undefined) return null;
+    try {
+      if (typeof structuredClone === "function") { structuredClone(v); return v; }
+      return JSON.parse(JSON.stringify(v));
+    } catch (e) { return String(v); }
+  };`;
+}
+function relaySafeExpression(expression, token) {
+    const src = JSON.stringify(expression);
+    const key = JSON.stringify(token);
+    return `(function () {
+  ${cloneHelper()}
+  var value = (0, eval)(${src});
+  if (value && typeof value.then === "function") {
+    var store = globalThis.${RELAY_MARK} = globalThis.${RELAY_MARK} || {};
+    store[${key}] = { done: false };
+    Promise.resolve(value).then(function (settled) {
+      store[${key}] = { done: true, ok: true, value: clone(settled) };
+    }, function (error) {
+      store[${key}] = { done: true, ok: false, name: (error && error.name) || "EvalError", message: (error && error.message) || String(error) };
+    });
+    return { ${RELAY_MARK}: 1, done: false, token: ${key} };
+  }
+  return { ${RELAY_MARK}: 1, done: true, ok: true, value: clone(value) };
+})()`;
+}
+function relayPollExpression(token) {
+    const key = JSON.stringify(token);
+    return `(function () {
+  var store = globalThis.${RELAY_MARK};
+  var entry = store && store[${key}];
+  if (!entry) return { ${RELAY_MARK}: 1, done: true, ok: false, name: "RelayLost", message: "the page reloaded or navigated before the expression settled, so its result is gone" };
+  if (!entry.done) return { ${RELAY_MARK}: 1, done: false, token: ${key} };
+  delete store[${key}];
+  return { ${RELAY_MARK}: 1, done: true, ok: entry.ok, value: entry.value, name: entry.name, message: entry.message };
+})()`;
+}
+function readRelayFrame(value) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    const frame = value;
+    if (1 !== frame[RELAY_MARK] || "boolean" != typeof frame.done) return null;
+    return {
+        done: frame.done,
+        ..."boolean" == typeof frame.ok ? {
+            ok: frame.ok
+        } : {},
+        ..."value" in frame ? {
+            value: frame.value
+        } : {},
+        ..."string" == typeof frame.name ? {
+            name: frame.name
+        } : {},
+        ..."string" == typeof frame.message ? {
+            message: frame.message
+        } : {},
+        ..."string" == typeof frame.token ? {
+            token: frame.token
+        } : {}
+    };
+}
 const eval_schema = {
     name: "extension_eval",
-    description: "Evaluate an expression in a running extension context. Start the session with allowEval:true (extension_dev), which writes a 0600 session token. Context defaults to 'background', except on a Chromium MV3 session (the default template) where it defaults to 'page', the active tab, because the MV3 service worker CSP blocks eval; pass context:'background' to target the worker anyway and get that explanation back. For content and page, pass `url` to pick the tab, or omit both `url` and `tab` for the active tab; a numeric `tab` only disambiguates. Extension surfaces (popup, options, sidebar, devtools) and override pages evaluate over the in-bundle relay and need no tab id, but must already be open: open one with extension_open first, because a closed one returns an explicit error. Call extension_dom_snapshot with listTabs:true to enumerate {tabId, url, title}.",
+    description: "Evaluate an expression in a running extension context. Start the session with allowEval:true (extension_dev), which writes a 0600 session token. Context defaults to 'background', except on a Chromium MV3 session (the default template) where it defaults to 'page', the active tab, because the MV3 service worker CSP blocks eval; pass context:'background' to target the worker anyway and get that explanation back. For content and page, pass `url` to pick the tab, or omit both `url` and `tab` for the active tab; a numeric `tab` only disambiguates. Extension surfaces (popup, options, sidebar, devtools) and override pages (newtab, history, bookmarks) need no tab id but must already be open: open one with extension_open first, because a closed one returns an explicit error. On a Chromium MV3 session those pages, and context:'page' with a chrome-extension:// url, evaluate over CDP, the inspector path the extension page CSP does not govern; elsewhere they evaluate over the in-bundle relay. Call extension_dom_snapshot with listTabs:true to enumerate {tabId, url, title}.",
     inputSchema: {
         type: "object",
         properties: {
@@ -11889,15 +12914,8 @@ const eval_schema = {
         ]
     }
 };
-function resolveDefaultEvalContext(projectPath, browser) {
-    if (!isChromiumFamily(browser)) return "background";
-    const candidates = [
-        node_path.join(projectPath, "dist", browser, "manifest.json"),
-        node_path.join(projectPath, "dist", "manifest.json"),
-        node_path.join(projectPath, "src", "manifest.json"),
-        node_path.join(projectPath, "manifest.json")
-    ];
-    for (const file of candidates){
+function chromiumManifestVersion(projectPath, browser) {
+    for (const file of manifestCandidates(projectPath, browser)){
         let manifest;
         try {
             manifest = JSON.parse(node_fs.readFileSync(file, "utf8"));
@@ -11905,15 +12923,247 @@ function resolveDefaultEvalContext(projectPath, browser) {
             continue;
         }
         const version = manifest["chromium:manifest_version"] ?? manifest.manifest_version;
-        if (3 === version) return "page";
-        if (2 === version) break;
+        if (3 === version) return 3;
+        if (2 === version) return 2;
+    }
+    return null;
+}
+function resolveDefaultEvalContext(projectPath, browser) {
+    if (!isChromiumFamily(browser)) return "background";
+    return 3 === chromiumManifestVersion(projectPath, browser) ? "page" : "background";
+}
+function wantsExtensionPageOverCdp(projectPath, browser, context, url) {
+    if (!isChromiumFamily(browser) || !context) return false;
+    if ("page" === context) return "string" == typeof url && /^chrome-extension:\/\//.test(url);
+    return EXTENSION_PAGE_CONTEXTS.includes(context) && 3 === chromiumManifestVersion(projectPath, browser);
+}
+async function evaluateOnChromiumExtensionPage(args, browser, context) {
+    const resolved = await resolveCdpPort(args.projectPath, browser);
+    if (!resolved) return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: "no-session",
+        error: {
+            code: "E_NO_SESSION",
+            name: "NoSession",
+            message: `No active dev session / CDP port for ${browser}, and an extension page evaluates over CDP. Start extension_dev with allowEval: true and extension_wait for ready. ${CDP_PORT_MISSING_HINT}`
+        }
+    });
+    let wanted;
+    if ("page" === context) wanted = args.url;
+    else {
+        const doc = surfaceDocument(args.projectPath, browser, context);
+        if (!doc) {
+            const key = SURFACE_MANIFEST_KEYS[context] ?? context;
+            return envelope_envelope({
+                ok: false,
+                command: eval_schema.name,
+                status: "no-surface",
+                error: {
+                    code: "E_NO_SURFACE_DOCUMENT",
+                    name: "NoSurfaceDocument",
+                    message: `This extension declares no ${context}: nothing in its manifest sets ${key}, so there is no ${context} page to evaluate in.`
+                },
+                hint: `To add one, set ${key} in the manifest and rebuild.`
+            });
+        }
+        const extensionId = await resolveExtensionId(args.projectPath, browser);
+        if (!extensionId) return envelope_envelope({
+            ok: false,
+            command: eval_schema.name,
+            status: "no-extension-id",
+            error: {
+                code: "E_NO_EXTENSION_ID",
+                name: "NoExtensionId",
+                message: "Could not resolve the extension id from the live session's CDP targets."
+            },
+            hint: `Confirm the session is ready (extension_wait). ${CDP_PORT_MISSING_HINT}`
+        });
+        wanted = `chrome-extension://${extensionId}/${doc}`;
     }
-    return "background";
+    const targets = await findExtensionPageTargets(resolved.port, wanted);
+    if (0 === targets.length) return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: "no-target",
+        error: {
+            code: "E_NO_TARGET",
+            name: "NoTarget",
+            message: `No open page at ${wanted}, so there is nothing to evaluate in. An extension page evaluates over CDP on its own target, which exists only while the page is open.`
+        },
+        hint: "page" === context ? "Open it first with extension_open (url: this address), then retry. extension_dom_snapshot with listTargets: true lists what is open." : `Open it first with extension_open surface: "${context}", then retry. extension_dom_snapshot with listTargets: true lists what is open.`
+    });
+    const target = targets[0];
+    const outcome = await evaluateOnExtensionPage(resolved.port, target.targetId, args.expression);
+    const others = targets.slice(1);
+    const warnings = others.length ? [
+        `${targets.length} open pages match ${wanted}; evaluated in target ${target.targetId} (${target.url}). The others: ${others.map((t)=>t.targetId).join(", ")}. Close the copies you do not mean, or navigate away from them.`
+    ] : [];
+    if (!outcome.ok) return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: outcome.thrown ? "eval-failed" : "cdp-failed",
+        error: {
+            code: outcome.thrown ? "E_EVAL" : "E_CDP",
+            name: outcome.thrown ? "EvalError" : "CdpError",
+            message: outcome.message
+        },
+        warnings,
+        hint: outcome.thrown ? `The expression threw inside ${target.url}. It ran over CDP in the page's main world with extension APIs available; a promise is awaited, so an async expression can be returned directly.` : "The session's debug port refused the call or the target went away. extension_doctor names which; a session that ended needs extension_dev again."
+    });
+    return envelope_envelope({
+        ok: true,
+        command: eval_schema.name,
+        status: "evaluated",
+        value: outcome.value,
+        warnings,
+        hint: `Evaluated over CDP in ${target.url} (target ${target.targetId}), the inspector path the extension page CSP does not govern. The result is serialized by value, so return plain data rather than DOM nodes; a promise is awaited before returning.`
+    });
+}
+async function evaluateOnWebKitPage(args, browser, info) {
+    const client = new WebDriverClient(info);
+    if (args.url) {
+        const current = await client.currentUrl().catch(()=>null);
+        if (!current || !current.startsWith(args.url)) await client.navigate(args.url);
+    }
+    try {
+        const value = await client.execute(`return (${args.expression});`);
+        return envelope_envelope({
+            ok: true,
+            command: eval_schema.name,
+            status: "evaluated",
+            value: {
+                context: "page",
+                browser,
+                url: await client.currentUrl().catch(()=>null),
+                result: value
+            },
+            hint: "Evaluated in the Safari automation window's main world over the dev session's WebDriver connection."
+        });
+    } catch (error) {
+        return envelope_envelope({
+            ok: false,
+            command: eval_schema.name,
+            status: "eval-failed",
+            error: {
+                code: "E_EVAL",
+                name: "EvalError",
+                message: error instanceof Error ? error.message : String(error)
+            },
+            hint: "The expression threw, or the automation window is gone. extension_doctor names which; a session that ended needs extension_dev again."
+        });
+    }
+}
+const RELAY_POLL_MS = 300;
+const RELAY_DEFAULT_BUDGET_MS = 30000;
+function tryParseFrame(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && "object" == typeof parsed ? parsed : null;
+    } catch  {
+        return null;
+    }
+}
+async function evaluateThroughRelay(args, browser, context) {
+    const token = node_crypto.randomUUID();
+    const budgetMs = args.timeout ?? RELAY_DEFAULT_BUDGET_MS;
+    const deadline = Date.now() + budgetMs;
+    const run = (expression)=>runActVerb([
+            "eval",
+            ...commonFlags({
+                ...args,
+                context,
+                browser
+            }),
+            "--",
+            expression,
+            args.projectPath
+        ], args.projectPath, args.timeout, eval_schema.name);
+    let raw = await run(relaySafeExpression(args.expression, token));
+    let parsed = tryParseFrame(raw);
+    if (!parsed || true !== parsed.ok) return raw;
+    let frame = readRelayFrame(parsed.value);
+    if (!frame) return raw;
+    let polls = 0;
+    while(!frame.done){
+        if (Date.now() >= deadline) return envelope_envelope({
+            ok: false,
+            command: eval_schema.name,
+            status: "eval-pending",
+            error: {
+                code: "E_WAIT_TIMEOUT",
+                name: "EvalPending",
+                message: `The expression returned a promise that had not settled after ${budgetMs} ms; it is still running in the ${context} page.`
+            },
+            value: {
+                context,
+                token,
+                polls
+            },
+            hint: `Its outcome lands in globalThis.${RELAY_MARK}[${JSON.stringify(token)}] inside the ${context} page when it settles ({done, ok, value}): read it with extension_eval in the same context, or pass a larger timeout to wait here.`
+        });
+        await new Promise((r)=>setTimeout(r, RELAY_POLL_MS));
+        polls += 1;
+        raw = await run(relayPollExpression(token));
+        parsed = tryParseFrame(raw);
+        if (!parsed || true !== parsed.ok) return raw;
+        const next = readRelayFrame(parsed.value);
+        if (!next) return raw;
+        frame = next;
+    }
+    if (false === frame.ok) return envelope_envelope({
+        ok: false,
+        command: eval_schema.name,
+        status: "eval-failed",
+        error: {
+            code: "E_EVAL",
+            name: frame.name || "EvalError",
+            message: frame.message || "the expression rejected"
+        },
+        hint: `The expression threw, or the promise it returned rejected, inside the ${context} page.`
+    });
+    parsed.value = void 0 === frame.value ? null : frame.value;
+    if (polls > 0) parsed.hint = `The expression returned a promise; the ${context} page settled it and this call polled ${polls} time${1 === polls ? "" : "s"} for the result. ` + ("string" == typeof parsed.hint ? parsed.hint : "");
+    return actFrameJson(parsed);
 }
 async function eval_handler(args) {
     const { browser } = resolveSessionBrowser(args.projectPath, args.browser);
+    if (WEBKIT_FAMILY.has(browser) && "page" === args.context) {
+        const info = readWebDriverSession(args.projectPath, browser);
+        if (info) return evaluateOnWebKitPage(args, browser, info);
+    }
     const defaulted = !args.context && "page" === resolveDefaultEvalContext(args.projectPath, browser);
     const context = defaulted ? "page" : args.context;
+    if (wantsExtensionPageOverCdp(args.projectPath, browser, context, args.url)) return evaluateOnChromiumExtensionPage(args, browser, context);
+    if ("page" === context && isExtensionUrl(args.url)) {
+        const surface = surfaceForExtensionUrl(args.projectPath, browser, args.url);
+        if (surface) {
+            const raw = await evaluateThroughRelay({
+                ...args,
+                url: void 0,
+                tab: void 0
+            }, browser, surface.context);
+            const parsed = tryParseFrame(raw);
+            if (parsed) {
+                addWarning(parsed, `${args.url} is the extension's own ${surface.context} document (${surface.document}), which script injection cannot reach on any engine, so this evaluated through the ${surface.context} surface relay. Pass context: "${surface.context}" directly next time.`);
+                return actFrameJson(parsed);
+            }
+            return raw;
+        }
+        const declared = declaredSurfaces(args.projectPath, browser) ?? [];
+        return envelope_envelope({
+            ok: false,
+            command: eval_schema.name,
+            status: "no-surface",
+            error: {
+                code: "E_NO_SURFACE_DOCUMENT",
+                name: "NoSurfaceDocument",
+                message: `${args.url} is a page inside the extension, which script injection cannot reach, and it matches none of the surface documents the manifest declares${declared.length ? ` (${declared.join(", ")})` : ""}.`
+            },
+            hint: declared.length ? `Evaluate in a declared surface with context: "${declared[0]}" (open it first with extension_open), or read a web page by url.` : "Declare the page as a surface in the manifest (action.default_popup, options_ui.page, sidebar_action.default_panel or chrome_url_overrides) and rebuild."
+        });
+    }
+    if (context && EXTENSION_PAGE_CONTEXTS.includes(context)) return evaluateThroughRelay(args, browser, context);
     const raw = await runActVerb([
         "eval",
         ...commonFlags({
@@ -12075,24 +13325,6 @@ async function reload_handler(args) {
         })
     ], args.projectPath, args.timeout, reload_schema.name);
 }
-const TARGET_ID_NOTE = "targetId is a CDP target id, NOT a chrome.tabs id: do not pass it as `tab`. Target a tab with `tabUrl` (URL substring) or `url`; if you need a numeric tab id, call extension_dom_snapshot with listTabs: true.";
-function filterPageTargets(raw) {
-    return raw.filter((t)=>"page" === t.type && !String(t.url ?? "").startsWith("devtools://")).map((t)=>({
-            targetId: String(t.id),
-            type: String(t.type),
-            url: String(t.url ?? ""),
-            title: String(t.title ?? "")
-        }));
-}
-async function listPageTargets(port) {
-    return filterPageTargets(await CDPClient.discoverTargets(port));
-}
-function matchTargetsByUrl(targets, needle) {
-    const wanted = needle.toLowerCase();
-    const byUrl = targets.filter((t)=>t.url.toLowerCase().includes(wanted));
-    if (byUrl.length > 0) return byUrl;
-    return targets.filter((t)=>t.title.toLowerCase().includes(wanted));
-}
 const RDP_ACTOR_NOTE = "actor is an RDP tab descriptor actor id, NOT a chrome.tabs id: do not pass it as `tab`. Target a tab with `tabUrl` (URL substring) or `url`; if you need a numeric tab id, call extension_dom_snapshot with listTabs: true.";
 const dom_snapshot_schema = {
     name: "extension_dom_snapshot",
@@ -12542,6 +13774,11 @@ async function publish_handler(args) {
             }
         }
     }
+    data.allowance = spendNarration({
+        what: "This publish",
+        body: data,
+        api: args.api
+    });
     return envelope_envelope({
         ok: true,
         command: "extension_publish",
@@ -12726,6 +13963,11 @@ async function release_promote_handler(args) {
     const promotedRef = resolveProjectRef();
     const publicChannelUrl = userlandProjectUrl(promotedRef, UserlandProjectPage.channel(channel), args.api);
     const publicBuildUrl = userlandProjectUrl(promotedRef, UserlandProjectPage.build(buildId), args.api);
+    const allowance = spendNarration({
+        what: "This promote",
+        body: data,
+        api: args.api
+    });
     const enriched = data && "object" == typeof data && !Array.isArray(data) ? {
         ...data,
         ...publicChannelUrl ? {
@@ -12733,8 +13975,12 @@ async function release_promote_handler(args) {
         } : {},
         ...publicBuildUrl ? {
             publicBuildUrl
-        } : {}
-    } : data;
+        } : {},
+        allowance
+    } : {
+        platform: data,
+        allowance
+    };
     return envelope_envelope({
         ok: true,
         command: "extension_release_promote",
@@ -13457,7 +14703,14 @@ async function submit_handler(args) {
         if ("string" == typeof data?.message) result.platformMessage = data.message;
         message = summaryParts.join(" ");
     }
-    if (!dryRun) statusNote = "Track this submission with extension_release_status: it reads the recorded outcome, per-store credential health, and review state from the public registry.";
+    if (!dryRun) {
+        statusNote = "Track this submission with extension_release_status: it reads the recorded outcome, per-store credential health, and review state from the public registry.";
+        if (platformOk) result.allowance = spendNarration({
+            what: "This submission",
+            body: data,
+            api: args.api
+        });
+    }
     return envelope_envelope({
         ok,
         command: "extension_submit",
@@ -13599,6 +14852,12 @@ async function wait_handler(args) {
                         pid: contract.pid,
                         distPath: contract.distPath,
                         manifestPath: contract.manifestPath,
+                        ..."number" == typeof contract.browserPid ? {
+                            browserPid: contract.browserPid
+                        } : {},
+                        ..."string" == typeof contract.profilePath && contract.profilePath ? {
+                            profilePath: contract.profilePath
+                        } : {},
                         compiledAt: contract.compiledAt,
                         startedAt: contract.startedAt,
                         budgetMs,
@@ -14277,7 +15536,7 @@ async function auth_handler(args) {
     });
     return readIdentity();
 }
-const execFileAsync = promisify(execFile);
+const detect_browsers_execFileAsync = promisify(execFile);
 const ALL_BROWSERS = [
     "chrome",
     "chromium",
@@ -14455,44 +15714,58 @@ function resolveCacheRoot() {
     if (home) return node_path.join(home, ".cache", "extension.js", "browsers");
     return node_path.resolve(process.cwd(), ".cache", "extension.js", "browsers");
 }
-function findManagedBinary(browser) {
-    const browserDir = node_path.join(resolveCacheRoot(), browser);
+const MANAGED_SEARCH_DEPTH = 8;
+const MANAGED_EXEC_NAMES = {
+    chrome: [
+        "chrome",
+        "chrome.exe",
+        "Google Chrome for Testing"
+    ],
+    chromium: [
+        "chrome",
+        "chromium",
+        "chrome.exe",
+        "chromium.exe",
+        "Chromium"
+    ],
+    edge: [
+        "msedge",
+        "msedge.exe",
+        "microsoft-edge",
+        "Microsoft Edge"
+    ],
+    firefox: [
+        "firefox",
+        "firefox.exe",
+        "firefox-bin"
+    ]
+};
+function executableInsideBundle(bundle, names) {
+    const macos = node_path.join(bundle, "Contents", "MacOS");
+    try {
+        for (const entry of node_fs.readdirSync(macos, {
+            withFileTypes: true
+        }))if (entry.isFile() && names.includes(entry.name)) return node_path.join(macos, entry.name);
+    } catch  {}
+    return null;
+}
+function findManagedBinary(browser, cacheRoot = resolveCacheRoot()) {
+    const browserDir = node_path.join(cacheRoot, browser);
     if (!node_fs.existsSync(browserDir)) return null;
-    const execNames = {
-        chrome: [
-            "chrome",
-            "chrome.exe",
-            "Google Chrome for Testing"
-        ],
-        chromium: [
-            "chrome",
-            "chromium",
-            "chrome.exe",
-            "chromium.exe",
-            "Chromium.app"
-        ],
-        edge: [
-            "msedge",
-            "msedge.exe",
-            "microsoft-edge",
-            "Microsoft Edge"
-        ],
-        firefox: [
-            "firefox",
-            "firefox.exe",
-            "Firefox.app"
-        ]
-    };
-    const names = execNames[browser] ?? [];
+    const names = MANAGED_EXEC_NAMES[browser] ?? [];
     function search(dir, depth) {
-        if (depth > 4) return null;
+        if (depth > MANAGED_SEARCH_DEPTH) return null;
         try {
             for (const entry of node_fs.readdirSync(dir, {
                 withFileTypes: true
             })){
                 const full = node_path.join(dir, entry.name);
                 if (entry.isFile() && names.includes(entry.name)) return full;
-                if (entry.isDirectory() && depth < 4) {
+                if (entry.isDirectory() && entry.name.endsWith(".app")) {
+                    const inside = executableInsideBundle(full, names);
+                    if (inside) return inside;
+                }
+                if (entry.isDirectory() && depth < MANAGED_SEARCH_DEPTH) {
                     const found = search(full, depth + 1);
                     if (found) return found;
                 }
@@ -14511,7 +15784,7 @@ function findSystemBinary(browser) {
 async function getVersion(binaryPath, browser) {
     try {
         const flag = "firefox" === browser ? "--version" : "--version";
-        const { stdout } = await execFileAsync(binaryPath, [
+        const { stdout } = await detect_browsers_execFileAsync(binaryPath, [
             flag
         ], {
             timeout: 5000,
@@ -14543,12 +15816,16 @@ async function detectBrowsers(browsers) {
         const isWebkit = WEBKIT_FAMILY.has(browser);
         let binaryPath = findManagedBinary(browser);
         let source = "managed";
+        const systemBinaryPath = findSystemBinary(browser);
         if (!binaryPath) {
-            binaryPath = findSystemBinary(browser);
+            binaryPath = systemBinaryPath;
             source = binaryPath ? "system" : "not_found";
         }
         let version = null;
         if (binaryPath && !isWebkit) version = await getVersion(binaryPath, browser);
+        else if (binaryPath && isWebkit) version = await readSafariVersion(binaryPath);
+        const automation = isWebkit && binaryPath ? await detectSafariAutomation(binaryPath) : null;
+        const shadowedSystem = "managed" === source && systemBinaryPath && systemBinaryPath !== binaryPath ? systemBinaryPath : null;
         detected.push({
             browser,
             binaryPath,
@@ -14556,11 +15833,20 @@ async function detectBrowsers(browsers) {
             engine: isWebkit ? "webkit" : isGecko ? "gecko" : "chromium",
             version,
             cdpSupport: !isGecko && !isWebkit,
-            rdpSupport: isGecko
+            rdpSupport: isGecko,
+            ...automation ? {
+                automation
+            } : {},
+            ...shadowedSystem ? {
+                systemBinaryPath: shadowedSystem,
+                devLaunches: `extension_dev launches the managed binary above, not the system install at ${shadowedSystem}; pass ${isGecko ? "geckoBinary" : "chromiumBinary"} to extension_dev to use the system one.`
+            } : {}
         });
     }
     const available = detected.filter((d)=>"not_found" !== d.source);
     const missing = detected.filter((d)=>"not_found" === d.source);
+    const safari = detected.find((d)=>d.automation);
+    const safariHint = safari?.automation ? ` ${safariAutomationHint(safari.automation)}` : "";
     return envelope_envelope({
         ok: true,
         command: "extension_browsers",
@@ -14573,7 +15859,7 @@ async function detectBrowsers(browsers) {
                 missing: missing.map((d)=>d.browser)
             }
         },
-        hint: missing.length ? `Missing browser(s): ${missing.map((d)=>d.browser).join(", ")}.${missing.some((d)=>MANAGED_INSTALLABLE.has(d.browser)) ? ` Use extension_browsers with action: "install" to install ${missing.filter((d)=>MANAGED_INSTALLABLE.has(d.browser)).map((d)=>d.browser).join(", ")}.` : ""}` : "All requested browsers are available."
+        hint: missing.length ? `Missing browser(s): ${missing.map((d)=>d.browser).join(", ")}.${missing.some((d)=>MANAGED_INSTALLABLE.has(d.browser)) ? ` Use extension_browsers with action: "install" to install ${missing.filter((d)=>MANAGED_INSTALLABLE.has(d.browser)).map((d)=>d.browser).join(", ")}.` : ""}${safariHint}` : `All requested browsers are available.${safariHint}`
     });
 }
 const BROWSER_NAMES = [
@@ -14988,15 +16274,16 @@ function toolResultFrame(result) {
 }
 const toolMap = new Map();
 for (const tool of tools)toolMap.set(tool.schema.name, tool);
-async function startServer() {
-    installCarrierExitCleanup();
+const SERVER_INSTRUCTIONS = "extension-dev runs, inspects, drives, builds and publishes browser extensions (Chrome, Edge, Firefox, Safari and the other Chromium and Gecko browsers) through Extension.js and extension.dev.\nWhen the ask is to run, start, wait for, watch, inspect, drive, test, debug or build a browser extension, search this server first and use its tools: extension_dev starts the dev session (allowEval: true also turns on control), extension_wait blocks until it is ready, extension_logs streams its console, extension_open opens a surface or a url, extension_dom_snapshot and extension_inspect read a live page, extension_eval runs code in a context, extension_build makes a store-ready bundle, extension_stop ends the session.\nThese replace hand-rolled ps, curl, remote-debugging-port lookups and CDP or Playwright scripts: the server already holds the session's debug port, the extension id and the session token.\nEvery tool answers one JSON envelope {ok, status, value, error, hint, warnings}; read hint and warnings before choosing the next call, and treat ok: false as the answer, not a transport error.";
+function createServer() {
     const server = new Server({
         name: "extension-dev",
         version: package_namespaceObject.rE
     }, {
         capabilities: {
             tools: {}
-        }
+        },
+        instructions: SERVER_INSTRUCTIONS
     });
     server.setRequestHandler(ListToolsRequestSchema, async ()=>({
             tools: tools.map((t)=>({
@@ -15063,6 +16350,11 @@ async function startServer() {
             };
         }
     });
+    return server;
+}
+async function startServer() {
+    installCarrierExitCleanup();
+    const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }