tmux-ide 2.9.13 → 2.9.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmux-ide",
-  "version": "2.9.13",
+  "version": "2.9.15",
   "description": "The open-source workspace for coding agents: run Claude Code, Codex and other agents in tmux with live status",
   "type": "module",
   "bin": {

package/packages/contracts/src/index.ts

@@ -116,6 +116,7 @@ export * from "./visual-terminal-palette.ts";
 
 export * from "./window-split-layout.ts";
 export * from "./pane-editor-context.ts";
+export * from "./native-browser.ts";
 
 export * from "./tmux-agent-open.ts";
 

package/packages/contracts/src/native-browser.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+
+const text = (limit: number) =>
+  z
+    .string()
+    .max(limit)
+    // Intentionally reject control characters in display text and navigation input.
+    // eslint-disable-next-line no-control-regex
+    .refine((value) => !/[\x00-\x1f\x7f]/u.test(value));
+const identity = {
+  version: z.literal(1),
+  instance: z.uuid(),
+  pane: z
+    .string()
+    .regex(/^%[0-9]+$/u)
+    .max(32),
+  tab: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+};
+/** Display state is not authority: every command echoes the exact browser revision. */
+export const NativeBrowserStateSchemaZ = z
+  .object({
+    ...identity,
+    enabled: z.boolean(),
+    url: text(16_384),
+    title: text(512),
+    loading: z.boolean(),
+    canGoBack: z.boolean(),
+    canGoForward: z.boolean(),
+  })
+  .strict();
+export const NativeBrowserCommandSchemaZ = z.discriminatedUnion("action", [
+  z.object({ ...identity, action: z.enum(["back", "forward", "reload", "stop"]) }).strict(),
+  z
+    .object({
+      ...identity,
+      action: z.literal("navigate"),
+      text: text(16_384).refine((value) => value.trim().length > 0),
+    })
+    .strict(),
+]);
+export type NativeBrowserState = z.infer<typeof NativeBrowserStateSchemaZ>;
+export type NativeBrowserCommand = z.infer<typeof NativeBrowserCommandSchemaZ>;

package/packages/contracts/src/pane-stream.ts

@@ -249,6 +249,8 @@ export const PaneStreamKeyNameSchemaZ = SessionRuntimeTerminalKeyNameSchemaZ;
 export const PANE_STREAM_INPUT_LIFETIME_CAPABILITY_VERSION = 105;
 /** Exact hex bytes require explicit offer + ready acknowledgement; older daemons may omit it. */
 export const PANE_STREAM_INPUT_BYTES_CAPABILITY_VERSION = 106;
+/** Bundles zlib capability 102 and optional browser icon metadata; fixed 16×16 RGBA hex, empty means browser fallback. */
+export const PANE_STREAM_BROWSER_ICON_CAPABILITY_VERSION = 117;
 export const PaneStreamInputLifetimeSchemaZ = z
   .object({
     generation: z.string().min(1).max(256),
@@ -558,6 +560,11 @@ export const PaneStreamLayoutFrameSchemaZ = z
             /** Optional for compatibility with an older daemon during reconnect. */
             displayName: BoundedDisplayNameSchemaZ.nullable().optional(),
             displayNameSource: PaneDisplayNameSourceSchemaZ.nullable().optional(),
+            browserIcon: z
+              .string()
+              .regex(/^(?:[0-9a-f]{2048})?$/u)
+              .nullable()
+              .optional(),
             left: CellCoordinateSchemaZ,
             top: CellCoordinateSchemaZ,
             width: GridCellSchemaZ,

package/packages/daemon/dist/command-center/tmux-servers.js

@@ -107,6 +107,12 @@ export function mountTmuxServerRoutes(app, options) {
         owners: options.owners,
         readBody: (request) => boundedJson(request, 8 * 1024),
     });
+    app.post(`${scoped}/native-browser`, route(async (c) => {
+        const server = scope(c);
+        const input = await boundedJson(c.req.raw, 24 * 1024);
+        const state = await options.owners.withOwner(server, (owner) => owner.nativeBrowser(input, c.req.raw.signal));
+        return c.json({ version: 1, state });
+    }));
     // Structured read only: this never acquires a channel or changes tmux geometry.
     app.post(`${scoped}/split-layout/:workspaceName`, route(async (c) => {
         const server = scope(c);

package/packages/daemon/dist/lib/daemon-embed.js

@@ -6,6 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { createNativeBrowserResolver } from "./tmux-native-browser.js";
 import { createNativeSurfaceContextResolver } from "./native-surface-context.js";
 import { NativeSurfaceProviderRegistry } from "../terminal/graphics/native-surface-provider.js";
 import { TmuxServerVersionSchemaZ } from "@tmux-ide/contracts";
@@ -1397,6 +1398,20 @@ async function startEmbeddedDaemonGeneration(opts) {
                                 throw new Error("Default tmux editor context owner is unavailable");
                         },
                     }),
+                    nativeBrowser: createNativeBrowserResolver({
+                        generation: instanceId,
+                        run: fleetFactsTmuxRunner,
+                        registry: workspaceRegistry,
+                        catalog: createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner),
+                        inventory: terminalInventoryRuntime,
+                        assertOpen: () => {
+                            if (defaultEditorContextRetired ||
+                                serverOwners?.defaultRetired ||
+                                !initialNativeServerIdentity ||
+                                terminalInventoryRuntime?.lifecycleState() !== "ready")
+                                throw new Error("Default native browser owner is unavailable");
+                        },
+                    }),
                     catalog: createNativeTmuxServerCatalog(workspaceRegistry, fleetFactsTmuxRunner),
                     readWindowSplitLayout: async (workspaceName, input) => {
                         const target = WindowLinkTargetSchemaZ.parse(input);

package/packages/daemon/dist/lib/native-browser-rpc.js

@@ -0,0 +1,110 @@
+import { randomUUID } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { connect } from "node:net";
+import { NativeBrowserCommandSchemaZ, NativeBrowserStateSchemaZ, } from "@tmux-ide/contracts";
+import { z } from "zod";
+export const NativeBrowserEndpointSchema = z
+    .object({
+    version: z.literal(1),
+    pid: z.number().int().positive(),
+    instance: z.uuid(),
+    pane: z
+        .string()
+        .regex(/^%[0-9]+$/u)
+        .max(32),
+    socket: z.string().min(1).max(1024).refine(isAbsolute),
+})
+    .strict();
+export class NativeBrowserUnavailable extends Error {
+    constructor() {
+        super("Native browser controls are unavailable");
+    }
+}
+const responseSchema = z.discriminatedUnion("ok", [
+    z
+        .object({ id: z.string(), ok: z.literal(true), data: NativeBrowserStateSchemaZ.nullable() })
+        .strict(),
+    z.object({ id: z.string(), ok: z.literal(false), error: z.string().max(4096) }).strict(),
+]);
+/** One request, one bounded response. Mutations are never retried or refreshed. */
+export async function nativeBrowserRpc(endpoint, command, signal) {
+    const target = NativeBrowserEndpointSchema.parse(endpoint);
+    const payload = command ? NativeBrowserCommandSchemaZ.parse(command) : null;
+    if (payload && (payload.instance !== target.instance || payload.pane !== target.pane))
+        throw new NativeBrowserUnavailable();
+    signal.throwIfAborted();
+    const info = await lstat(target.socket);
+    if (!info.isSocket() || info.uid !== process.getuid?.() || (info.mode & 0o022) !== 0)
+        throw new NativeBrowserUnavailable();
+    try {
+        process.kill(target.pid, 0);
+    }
+    catch {
+        throw new NativeBrowserUnavailable();
+    }
+    signal.throwIfAborted();
+    const id = randomUUID();
+    const request = JSON.stringify({
+        id,
+        cmd: payload ? "native/1/command" : "native/1/state",
+        ...(payload ? { payload } : {}),
+    }) + "\n";
+    return new Promise((resolve, reject) => {
+        const socket = connect(target.socket);
+        let finished = false;
+        let size = 0;
+        const chunks = [];
+        const finish = (error, state = null) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+            socket.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve(state);
+        };
+        const abort = () => finish(new NativeBrowserUnavailable());
+        const timer = setTimeout(abort, 1500);
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        socket.once("connect", () => socket.write(request));
+        socket.on("error", abort);
+        socket.once("end", () => {
+            if (!finished)
+                abort();
+        });
+        socket.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > 128 * 1024) {
+                abort();
+                return;
+            }
+            chunks.push(chunk);
+            if (!chunk.includes(10))
+                return;
+            try {
+                const bytes = Buffer.concat(chunks);
+                const newline = bytes.indexOf(10);
+                if (newline !== bytes.length - 1)
+                    throw new NativeBrowserUnavailable();
+                const reply = responseSchema.parse(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, newline))));
+                if (reply.id !== id || !reply.ok)
+                    throw new NativeBrowserUnavailable();
+                if (reply.data &&
+                    (reply.data.instance !== target.instance || reply.data.pane !== target.pane))
+                    throw new NativeBrowserUnavailable();
+                finish(undefined, reply.data);
+            }
+            catch {
+                abort();
+            }
+        });
+    });
+}

package/packages/daemon/dist/lib/tmux-native-browser.js

@@ -0,0 +1,80 @@
+import { PaneEditorContextTargetSchemaZ, NativeBrowserCommandSchemaZ } from "@tmux-ide/contracts";
+import { z } from "zod";
+import { decodeTmuxArgument } from "../terminal/protocol/session-descriptor-discovery.js";
+import { NativeBrowserEndpointSchema, NativeBrowserUnavailable, nativeBrowserRpc, } from "./native-browser-rpc.js";
+export const NativeBrowserRequestSchema = z
+    .object({
+    target: PaneEditorContextTargetSchemaZ,
+    command: NativeBrowserCommandSchemaZ.nullable(),
+})
+    .strict();
+export function createNativeBrowserResolver(options) {
+    let readers = 0;
+    return async (input, cancellation) => {
+        const { target, command } = NativeBrowserRequestSchema.parse(input);
+        const signal = AbortSignal.any([cancellation, AbortSignal.timeout(2500)]);
+        const workspace = options.registry.get(target.workspaceName);
+        const assertCurrent = () => {
+            options.assertOpen();
+            signal.throwIfAborted();
+            if (target.generation !== options.generation ||
+                !workspace ||
+                options.registry.get(target.workspaceName) !== workspace)
+                throw new NativeBrowserUnavailable();
+        };
+        assertCurrent();
+        if (readers >= 8)
+            throw new NativeBrowserUnavailable();
+        readers++;
+        try {
+            const sessions = await options.catalog();
+            assertCurrent();
+            const matching = sessions.filter((s) => s.liveSessionId === target.liveSessionId);
+            if (matching.length !== 1 || matching[0].sessionName !== workspace.sessionName)
+                throw new NativeBrowserUnavailable();
+            const snapshot = await options.inventory.discoverTerminalInventory(signal);
+            assertCurrent();
+            if (snapshot.catalog.invalidRuntimeProof ||
+                snapshot.catalog.duplicateSemanticStamp ||
+                snapshot.catalog.duplicateRuntimePaneBinding)
+                throw new NativeBrowserUnavailable();
+            const matches = snapshot.panes.filter((p) => p.workspaceName === target.workspaceName &&
+                p.semanticPaneId === target.semanticPaneId &&
+                p.sessionName === workspace.sessionName);
+            if (matches.length !== 1)
+                throw new NativeBrowserUnavailable();
+            const pane = { ...matches[0] };
+            if (!pane.nativePaneBirthId || !/^%[0-9]+$/u.test(pane.runtimePaneId))
+                throw new NativeBrowserUnavailable();
+            const observe = async () => {
+                const raw = await options.run([
+                    "display-message",
+                    "-p",
+                    "-t",
+                    pane.runtimePaneId,
+                    "#{qa:@tmux_ide_pane_id}\t#{qa:pane_birth_id}\t#{qa:@tmux_ide_browser_control}",
+                ], signal);
+                assertCurrent();
+                if (raw.length > 8192)
+                    throw new NativeBrowserUnavailable();
+                const [semantic, birth, endpoint] = raw.trimEnd().split("\t").map(decodeTmuxArgument);
+                if (semantic !== target.semanticPaneId || birth !== pane.nativePaneBirthId)
+                    throw new NativeBrowserUnavailable();
+                const parsed = NativeBrowserEndpointSchema.parse(JSON.parse(endpoint ?? "null"));
+                if (parsed.pane !== pane.runtimePaneId)
+                    throw new NativeBrowserUnavailable();
+                return parsed;
+            };
+            const endpoint = await observe();
+            const result = await nativeBrowserRpc(endpoint, command, signal);
+            assertCurrent();
+            const current = await observe();
+            if (JSON.stringify(current) !== JSON.stringify(endpoint))
+                throw new NativeBrowserUnavailable();
+            return result;
+        }
+        finally {
+            readers--;
+        }
+    };
+}

package/packages/daemon/dist/lib/tmux-server-owner.js

@@ -1,3 +1,4 @@
+import { createNativeBrowserResolver } from "./tmux-native-browser.js";
 import { createNativeSurfaceContextResolver } from "./native-surface-context.js";
 import { shellEscape } from "./shell.js";
 import { createNativeSplitCapabilityProbe, createNativeSplitReadiness, } from "./native-split-capability.js";
@@ -505,6 +506,14 @@ export async function createNativeTmuxServerOwner(options) {
             run: (args, signal) => generationRunAsync(args, signal),
         }),
         resolvePaneEditorContext,
+        nativeBrowser: createNativeBrowserResolver({
+            generation,
+            assertOpen,
+            registry: workspaceRegistry,
+            catalog,
+            inventory: terminalInventoryRuntime,
+            run: generationRunAsync,
+        }),
         catalog,
         readWindowSplitLayout: async (workspaceName, input) => {
             assertOpen();

package/packages/daemon/dist/native/TmuxIdeNotifier.app/Contents/Info.plist

@@ -21,9 +21,9 @@
   <key>CFBundlePackageType</key>
   <string>APPL</string>
   <key>CFBundleShortVersionString</key>
-  <string>2.9.13</string>
+  <string>2.9.15</string>
   <key>CFBundleVersion</key>
-  <string>2.9.13</string>
+  <string>2.9.15</string>
   <key>LSMinimumSystemVersion</key>
   <string>11.0</string>
   <key>LSUIElement</key>

package/packages/daemon/dist/native/TmuxIdeNotifier.app/Contents/_CodeSignature/CodeResources

@@ -10,7 +10,7 @@
 		</data>
 		<key>Resources/Assets.car</key>
 		<data>
-		6Tstp1dls1WRUQD+/DDuIhts8/g=
+		g6ppKlYeW830G3DwzRm9o0xINW8=
 		</data>
 	</dict>
 	<key>files2</key>
@@ -26,7 +26,7 @@
 		<dict>
 			<key>hash2</key>
 			<data>
-			5CnAgYS5jeHfuf40WhEyRn9BbniU54houDrGdNEkNyI=
+			lo9t3TSww0mSpC4nN+YoeeUgaXGcFCrv53qBXtKpzEY=
 			</data>
 		</dict>
 	</dict>

package/packages/daemon/dist/open-browser.js

@@ -0,0 +1,186 @@
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { IdeError } from "./lib/errors.js";
+import { resolveRuntimeNamespace, runtimeNamespaceEnvironment } from "./lib/runtime-namespace.js";
+import { createPinnedWorkspaceTmuxRunner, resolveWorkspacePaneTmuxAuthority, } from "./lib/workspace-pane-creation.js";
+/** Resolve once before creating a pane; ignore relative PATH entries. */
+export function resolveTerminalBrowser(environment = process.env, platform = process.platform) {
+    const configured = environment.TMUX_IDE_TERMINAL_BROWSER_BIN;
+    const home = environment.HOME ?? homedir();
+    // Resolve the managed alias on every invocation so an app update selects its
+    // matching browser. Native assets remain outside the universal npm package.
+    const bundled = platform === "darwin" && isAbsolute(home)
+        ? [
+            join(home, "Library", "Application Support", "tmux-ide", "native-alpha", "TmuxIDE.app", "Contents", "Resources", "browser", "terminal-browser"),
+        ]
+        : [];
+    const candidates = configured
+        ? [configured]
+        : [
+            ...bundled,
+            ...(environment.PATH ?? "")
+                .split(delimiter)
+                .filter(isAbsolute)
+                .map((dir) => join(dir, "terminal-browser")),
+        ];
+    for (const candidate of candidates) {
+        try {
+            if (!isAbsolute(candidate))
+                continue;
+            accessSync(candidate, constants.X_OK);
+            const path = realpathSync(candidate);
+            if (statSync(path).isFile())
+                return path;
+        }
+        catch {
+            /* Try the next executable. */
+        }
+    }
+    throw new IdeError(configured
+        ? "TMUX_IDE_TERMINAL_BROWSER_BIN must name an absolute executable browser launcher."
+        : "terminal-browser is not installed or is not on PATH. Install terminal-browser, or set TMUX_IDE_TERMINAL_BROWSER_BIN to its absolute launcher path.", { code: "BROWSER_UNAVAILABLE" });
+}
+function hasControlCharacter(value) {
+    return Array.from(value).some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+}
+export function validateBrowserOpen(url, options) {
+    if (url !== undefined &&
+        (!url || url.length > 16_384 || hasControlCharacter(url) || url.startsWith("-")))
+        throw new IdeError("Provide one URL, localhost address, or HTML file path.", {
+            code: "USAGE",
+            exitCode: 2,
+        });
+    if (options.split !== undefined && !["right", "down"].includes(options.split))
+        throw new IdeError("--split must be right or down.", { code: "USAGE", exitCode: 2 });
+    if (options.size !== undefined &&
+        (!/^\d+$/u.test(options.size) || Number(options.size) < 10 || Number(options.size) > 90))
+        throw new IdeError("--size must be a percentage from 10 to 90.", {
+            code: "USAGE",
+            exitCode: 2,
+        });
+    if (options.window && (options.split !== undefined || options.size !== undefined))
+        throw new IdeError("--window cannot be combined with --split or --size.", {
+            code: "USAGE",
+            exitCode: 2,
+        });
+    if (options.pane !== undefined && !/^%\d+$/u.test(options.pane))
+        throw new IdeError("--pane must be an exact tmux pane ID, such as %3.", {
+            code: "USAGE",
+            exitCode: 2,
+        });
+    if (options.session !== undefined &&
+        (!options.session || hasControlCharacter(options.session) || options.session.includes(":")))
+        throw new IdeError("--session must be an exact tmux session name.", {
+            code: "USAGE",
+            exitCode: 2,
+        });
+}
+export function createBrowserPane(run, executable, url, options, environment, cwd, namespace) {
+    validateBrowserOpen(url, options);
+    const inheritedPane = /^%\d+$/u.test(environment.TMUX_PANE ?? "")
+        ? environment.TMUX_PANE
+        : undefined;
+    const inheritedServer = /^(.*),(\d+),(\d+)$/u.exec(environment.TMUX ?? "");
+    const implicit = !options.pane && !options.session;
+    const target = options.pane ??
+        (options.session
+            ? `=${options.session}:`
+            : inheritedPane && inheritedServer
+                ? `$${inheritedServer[3]}:.${inheritedPane}`
+                : undefined);
+    if (!target)
+        throw new IdeError("Run tmux-ide open inside a tmux pane, or select a session with --session NAME.", { code: "BROWSER_TARGET_REQUIRED", exitCode: 2 });
+    // Resolve IDs before mutation. No implicit last-used session or window target.
+    const identity = run([
+        "display-message",
+        "-p",
+        "-t",
+        target,
+        "#{session_id}\t#{window_id}\t#{pane_id}\t#{pid}",
+    ])
+        .trim()
+        .split("\t");
+    const [session, window, sourcePane, serverPid] = identity;
+    if (identity.length !== 4 ||
+        !/^\$\d+$/u.test(session ?? "") ||
+        !/^@\d+$/u.test(window ?? "") ||
+        !/^%\d+$/u.test(sourcePane ?? ""))
+        throw new IdeError("The browser target is no longer available.", {
+            code: "BROWSER_TARGET_UNAVAILABLE",
+        });
+    if (implicit && serverPid !== inheritedServer?.[2])
+        throw new IdeError("The current pane belongs to a different tmux server. Select a session explicitly.", { code: "BROWSER_TARGET_MISMATCH", exitCode: 2 });
+    if (options.session && options.pane) {
+        const selected = run([
+            "display-message",
+            "-p",
+            "-t",
+            `=${options.session}:`,
+            "#{session_id}",
+        ]).trim();
+        if (selected !== session)
+            throw new IdeError("The pane does not belong to the requested session.", {
+                code: "BROWSER_TARGET_MISMATCH",
+                exitCode: 2,
+            });
+    }
+    const args = options.window
+        ? ["new-window", "-t", `${session}:`, "-n", "Browser"]
+        : [
+            "split-window",
+            options.split === "down" ? "-v" : "-h",
+            "-t",
+            `${session}:${window}.${sourcePane}`,
+            "-l",
+            `${options.size ?? "50"}%`,
+        ];
+    args.push("-c", resolve(cwd), "-P", "-F", "#{session_id}\t#{window_id}\t#{pane_id}");
+    // tmux supplies the new pane's TMUX and TMUX_PANE. Never copy the caller's
+    // native-surface route, which belongs to a different pane.
+    const childEnvironment = { ...namespace };
+    for (const key of [
+        "PATH",
+        "HOME",
+        "XDG_CONFIG_HOME",
+        "XDG_DATA_HOME",
+        "XDG_STATE_HOME",
+        "XDG_CACHE_HOME",
+        "XDG_RUNTIME_DIR",
+    ])
+        if (environment[key] !== undefined)
+            childEnvironment[key] = environment[key];
+    for (const [key, value] of Object.entries(childEnvironment))
+        args.push("-e", `${key}=${value}`);
+    // Multiple command arguments use tmux's direct exec path, not shell parsing.
+    args.push(executable, "open", ...(url === undefined ? [] : [url]), "--no-merge");
+    const [createdSession, createdWindow, pane] = run(args).trim().split("\t");
+    if (!/^%\d+$/u.test(pane ?? "") ||
+        createdSession !== session ||
+        !/^@\d+$/u.test(createdWindow ?? ""))
+        throw new IdeError("tmux did not return the created browser pane ID.", {
+            code: "BROWSER_CREATE_FAILED",
+        });
+    return { pane: pane, session: createdSession, window: createdWindow, status: "created" };
+}
+export function openBrowser(url, options = {}) {
+    validateBrowserOpen(url, options);
+    const executable = resolveTerminalBrowser();
+    try {
+        const namespace = { ...runtimeNamespaceEnvironment(resolveRuntimeNamespace()) };
+        const authority = resolveWorkspacePaneTmuxAuthority();
+        namespace.TMUX_IDE_BROWSER_TMUX = authority.executablePath;
+        const run = createPinnedWorkspaceTmuxRunner(authority, {
+            timeoutMs: 10_000,
+        });
+        return createBrowserPane(run, executable, url, options, process.env, process.cwd(), namespace);
+    }
+    catch (error) {
+        if (error instanceof IdeError)
+            throw error;
+        throw new IdeError("Could not create the browser pane. Check that the target tmux session is running.", {
+            code: "BROWSER_CREATE_FAILED",
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+}

package/packages/daemon/dist/terminal/mirror/session-channel.js

@@ -363,6 +363,7 @@ export class SessionChannel {
     async start() {
         await this.io.start();
         await this.captureAttachedSessionIdentity();
+        this.io.send("refresh-client -B 'tmux-ide-browser-icon:%*:#{@tmux_ide_browser_icon}'");
         // Changing border placement can resize PTYs without changing the layout
         // string, so tmux emits no layout-change. Subscribe to this window option.
         this.io.send("refresh-client -B 'tmux-ide-pane-borders:@*:#{pane-border-status}'");
@@ -2249,6 +2250,10 @@ export class SessionChannel {
             name === "session-renamed" ||
             name === "sessions-changed")
             this.opts.onWindowTopologyChanged?.();
+        if (name === "subscription-changed" && rest.startsWith("tmux-ide-browser-icon ")) {
+            this.scheduleSync();
+            return;
+        }
         if (name === "subscription-changed") {
             const policy = /^tmux-ide-scroll-on-clear\s+\$[0-9]+\s+@[0-9]+\s+[0-9]+\s+(%[0-9]+)\s+:\s+([01])\s*$/u.exec(rest);
             if (policy) {
@@ -2650,6 +2655,7 @@ export class SessionChannel {
                     semanticPaneId: pane?.semanticId ?? null,
                     displayName: display?.name ?? null,
                     displayNameSource: display?.source ?? null,
+                    browserIcon: pane?.descriptor?.browserIcon ?? null,
                     left: leaf.left,
                     top: leaf.top,
                     width: leaf.width,

package/packages/daemon/dist/terminal/pane-stream/pane-stream-websocket.js

@@ -955,8 +955,11 @@ export class PaneStreamLiveConnection {
             this.close(1011, "stream-unavailable");
             return;
         }
-        const expectedPaneIds = [...this.#descriptor.panes].sort();
-        if (expectedPaneIds.some((pane) => !known.has(pane))) {
+        // Layout authority covers the whole session, while content leases may select
+        // only one pane (for example a native browser observing its own canvas).
+        // Keep the full inventory fence without subscribing to unleased content.
+        const expectedPaneIds = [...known].sort();
+        if (this.#descriptor.panes.some((pane) => !known.has(pane))) {
             this.#failTopologyChanged();
             return;
         }
@@ -1317,7 +1320,7 @@ export class PaneStreamLiveConnection {
         this.#observeSurfaceDemand([channel.semanticPaneId]);
         // Renderers that cannot inflate see raw formats; their bytes are inflated
         // when served.
-        const zlib = this.#descriptor.terminalDelivery?.protocolVersions.includes(TERMINAL_GRAPHICS_ZLIB_CAPABILITY_VERSION) === true;
+        const zlib = this.#descriptor.terminalDelivery?.protocolVersions.some((version) => version === TERMINAL_GRAPHICS_ZLIB_CAPABILITY_VERSION || version === 117) === true;
         channel.graphicsZlib = zlib;
         channel.graphicsLocal =
             !!this.#localImages &&
@@ -1793,6 +1796,9 @@ export class PaneStreamLiveConnection {
                 pane: pane.semanticPaneId,
                 displayName: pane.displayName,
                 displayNameSource: pane.displayNameSource,
+                ...(this.#descriptor.terminalDelivery?.protocolVersions.includes(117)
+                    ? { browserIcon: pane.browserIcon ?? null }
+                    : {}),
                 left: pane.left,
                 top: pane.top,
                 width: pane.width,

package/packages/daemon/dist/terminal/protocol/browser-icon.js

@@ -0,0 +1,16 @@
+/** Browser-provided 16×16 RGBA pixels, never a URL or filesystem path. */
+export function browserIcon(value, alive = processAlive) {
+    const match = /^([1-9][0-9]{0,9}):([0-9a-f]{2048}|)$/u.exec(value);
+    if (!match || !alive(Number(match[1])))
+        return null;
+    return match[2];
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}