tmux-ide 2.9.13 → 2.9.15

package/packages/daemon/dist/terminal/protocol/session-descriptor-discovery.js

@@ -1,3 +1,4 @@
+import { browserIcon } from "./browser-icon.js";
 /**
  * `qa` asks tmux to escape each value as a command argument. In particular,
  * embedded tabs/newlines/backslashes become escapes, leaving our record tabs
@@ -27,6 +28,7 @@ export const SESSION_PANE_DESCRIPTOR_FORMAT = [
     "#{session_windows}",
     "#{pane_birth_id}",
     "#{qa:@tmux_ide_name_source}",
+    "#{qa:@tmux_ide_browser_icon}",
 ].join("\t");
 /** Decode the escapes emitted by tmux's `qa` format modifier. */
 export function decodeTmuxArgument(value) {
@@ -100,9 +102,9 @@ export function parseSessionPaneDescriptorReply(lines) {
             continue;
         }
         const encoded = utf8Line.split("\t");
-        if (encoded.length !== 21 && encoded.length !== 22)
+        if (encoded.length !== 21 && encoded.length !== 22 && encoded.length !== 23)
             continue;
-        const [runtimePaneId = "", semanticPaneId = "", role = "", type = "", currentCommand = "", cwd = "", windowIndexRaw = "", windowName = "", windowId = "", title = "", runtimeSessionId = "", paneIndexRaw = "", name = "", missionStamp = "", paneActiveRaw = "", windowActiveRaw = "", semanticWindowId = "", sessionName = "", windowPaneCountRaw = "", sessionWindowCountRaw = "", nativePaneBirthId = "", nameSource = "",] = encoded.map(decodeTmuxArgument);
+        const [runtimePaneId = "", semanticPaneId = "", role = "", type = "", currentCommand = "", cwd = "", windowIndexRaw = "", windowName = "", windowId = "", title = "", runtimeSessionId = "", paneIndexRaw = "", name = "", missionStamp = "", paneActiveRaw = "", windowActiveRaw = "", semanticWindowId = "", sessionName = "", windowPaneCountRaw = "", sessionWindowCountRaw = "", nativePaneBirthId = "", nameSource = "", browserIconRaw = "",] = encoded.map(decodeTmuxArgument);
         if (!/^%(?:0|[1-9][0-9]*)$/u.test(runtimePaneId) || runtimePaneId.length > 32)
             continue;
         if (!/^\$(?:0|[1-9][0-9]*)$/u.test(runtimeSessionId) || runtimeSessionId.length > 32)
@@ -139,6 +141,7 @@ export function parseSessionPaneDescriptorReply(lines) {
             continue;
         }
         descriptors.push({
+            browserIcon: browserIcon(browserIconRaw),
             sessionName,
             runtimePaneId,
             runtimeSessionId,

package/packages/daemon/src/command-center/tmux-servers.ts

@@ -150,6 +150,17 @@ export function mountTmuxServerRoutes(app: Hono, options: TmuxServerRoutesOption
     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`,

package/packages/daemon/src/lib/daemon-embed.ts

@@ -1,3 +1,4 @@
+import { createNativeBrowserResolver } from "./tmux-native-browser.ts";
 import { createNativeSurfaceContextResolver } from "./native-surface-context.ts";
 import { NativeSurfaceProviderRegistry } from "../terminal/graphics/native-surface-provider.ts";
 import { TmuxServerVersionSchemaZ } from "@tmux-ide/contracts";
@@ -1937,6 +1938,22 @@ async function startEmbeddedDaemonGeneration(
                 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/src/lib/native-browser-rpc.ts

@@ -0,0 +1,118 @@
+import { randomUUID } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { connect } from "node:net";
+import {
+  NativeBrowserCommandSchemaZ,
+  NativeBrowserStateSchemaZ,
+  type NativeBrowserCommand,
+  type NativeBrowserState,
+} 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 type NativeBrowserEndpoint = z.infer<typeof NativeBrowserEndpointSchema>;
+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: NativeBrowserEndpoint,
+  command: NativeBrowserCommand | null,
+  signal: AbortSignal,
+): Promise<NativeBrowserState | null> {
+  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: Buffer[] = [];
+    const finish = (error?: Error, state: NativeBrowserState | null = 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: Buffer) => {
+      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/src/lib/tmux-native-browser.ts

@@ -0,0 +1,100 @@
+import { PaneEditorContextTargetSchemaZ, NativeBrowserCommandSchemaZ } from "@tmux-ide/contracts";
+import { z } from "zod";
+import type { LiveSessionSummary } from "../command-center/discovery.ts";
+import type { WorkspaceTerminalInventoryRuntime } from "../terminal/attachments/native-runtime.ts";
+import type { WorkspaceRegistry } from "./workspace-registry.ts";
+import { decodeTmuxArgument } from "../terminal/protocol/session-descriptor-discovery.ts";
+import {
+  NativeBrowserEndpointSchema,
+  NativeBrowserUnavailable,
+  nativeBrowserRpc,
+} from "./native-browser-rpc.ts";
+
+export const NativeBrowserRequestSchema = z
+  .object({
+    target: PaneEditorContextTargetSchemaZ,
+    command: NativeBrowserCommandSchemaZ.nullable(),
+  })
+  .strict();
+export function createNativeBrowserResolver(options: {
+  generation: string;
+  assertOpen(): void;
+  registry: Pick<WorkspaceRegistry, "get">;
+  catalog(): Promise<LiveSessionSummary[]>;
+  inventory: Pick<WorkspaceTerminalInventoryRuntime, "discoverTerminalInventory">;
+  run(args: readonly string[], signal: AbortSignal): Promise<string>;
+}) {
+  let readers = 0;
+  return async (input: unknown, cancellation: AbortSignal) => {
+    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/src/lib/tmux-server-owner.ts

@@ -1,3 +1,4 @@
+import { createNativeBrowserResolver } from "./tmux-native-browser.ts";
 import { createNativeSurfaceContextResolver } from "./native-surface-context.ts";
 import type { LocalImageOwner } from "../terminal/graphics/local-image-owner.ts";
 import { shellEscape } from "./shell.ts";
@@ -619,6 +620,14 @@ export async function createNativeTmuxServerOwner(options: NativeTmuxServerOwner
       run: (args, signal) => generationRunAsync(args, signal),
     }),
     resolvePaneEditorContext,
+    nativeBrowser: createNativeBrowserResolver({
+      generation,
+      assertOpen,
+      registry: workspaceRegistry,
+      catalog,
+      inventory: terminalInventoryRuntime,
+      run: generationRunAsync,
+    }),
     catalog,
     readWindowSplitLayout: async (workspaceName: string, input: WindowLinkTarget) => {
       assertOpen();

package/packages/daemon/src/open-browser.ts

@@ -0,0 +1,244 @@
+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.ts";
+import { resolveRuntimeNamespace, runtimeNamespaceEnvironment } from "./lib/runtime-namespace.ts";
+import {
+  createPinnedWorkspaceTmuxRunner,
+  resolveWorkspacePaneTmuxAuthority,
+} from "./lib/workspace-pane-creation.ts";
+
+export interface OpenBrowserOptions {
+  session?: string;
+  pane?: string;
+  split?: string;
+  size?: string;
+  window?: boolean;
+}
+
+/** Resolve once before creating a pane; ignore relative PATH entries. */
+export function resolveTerminalBrowser(
+  environment: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  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: string): boolean {
+  return Array.from(value).some(
+    (character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127,
+  );
+}
+
+export function validateBrowserOpen(url: string | undefined, options: OpenBrowserOptions): void {
+  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,
+    });
+}
+
+type Run = (args: readonly string[]) => string;
+export function createBrowserPane(
+  run: Run,
+  executable: string,
+  url: string | undefined,
+  options: OpenBrowserOptions,
+  environment: NodeJS.ProcessEnv,
+  cwd: string,
+  namespace: Readonly<Record<string, string>>,
+): { pane: string; session: string; window: string; status: "created" } {
+  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: Record<string, string> = { ...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: string | undefined, options: OpenBrowserOptions = {}) {
+  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/src/terminal/mirror/events.ts

@@ -91,6 +91,7 @@ export type MirrorPaneEvent =
 
 /** One visible pane rectangle inside a layout event, in window cells. */
 export interface MirrorLayoutPane {
+  browserIcon?: string | null;
   /** Null while the pane's semantic identity join is still unverified. */
   semanticPaneId: string | null;
   /** Daemon-authored presentation; clients never infer this from terminal bytes. */

package/packages/daemon/src/terminal/mirror/session-channel.ts

@@ -749,6 +749,7 @@ export class SessionChannel {
   async start(): Promise<void> {
     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}'");
@@ -2883,6 +2884,10 @@ export class SessionChannel {
       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(
@@ -3299,6 +3304,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/src/terminal/pane-stream/pane-stream-websocket.ts

@@ -1515,8 +1515,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;
     }
@@ -1917,8 +1920,8 @@ export class PaneStreamLiveConnection {
     // 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,
+      this.#descriptor.terminalDelivery?.protocolVersions.some(
+        (version) => version === TERMINAL_GRAPHICS_ZLIB_CAPABILITY_VERSION || version === 117,
       ) === true;
     channel.graphicsZlib = zlib;
     channel.graphicsLocal =
@@ -2414,6 +2417,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/src/terminal/protocol/browser-icon.ts

@@ -0,0 +1,14 @@
+/** Browser-provided 16×16 RGBA pixels, never a URL or filesystem path. */
+export function browserIcon(value: string, alive = processAlive): string | null {
+  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: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}