tmux-ide 2.9.0-beta.20 → 2.9.0-beta.21

package/packages/daemon/src/tui/mirror/runtime/application-terminal-workspace.tsx

@@ -9,6 +9,7 @@ import {
   For,
   Show,
   createMemo,
+  createEffect,
   createRenderEffect,
   createSignal,
   onCleanup,
@@ -175,6 +176,7 @@ export interface ApplicationTerminalWorkspaceProps {
   ) => void;
   readonly onResizePreview?: (preview: ApplicationPaneResizePreview) => void;
   readonly onResizePane?: (preview: ApplicationPaneResizePreview) => void;
+  readonly onCancelResize?: () => void;
   readonly onResizePointerIngress?: (input: {
     readonly action: "down" | "drag" | "up";
     readonly x: number;
@@ -510,11 +512,38 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
   } | null = null;
   let drag: {
     readonly separator: ApplicationPaneSeparator;
+    readonly rendererEpoch: number;
+    readonly adapter: ApplicationTerminalWorkspaceProps["adapter"];
+    readonly windowId: string | null | undefined;
     readonly origin: number;
     preview: ApplicationPaneResizePreview;
     readonly gestureId: string | null;
   } | null = null;
 
+  const cancelResize = () => {
+    if (!drag) return;
+    drag = null;
+    setResizePreview(null);
+    setHoveredSeparator(null);
+    props.onCancelResize?.();
+  };
+  createEffect(() => {
+    const current = layout().current;
+    const epoch = props.rendererEpoch;
+    const adapter = props.adapter;
+    const interactive = props.interactive;
+    if (
+      drag &&
+      (interactive === false ||
+        epoch !== drag.rendererEpoch ||
+        adapter !== drag.adapter ||
+        (current?.semanticWindowId ?? current?.windowName) !== drag.windowId ||
+        !current?.panes.some((pane) => pane.pane === drag?.preview.semanticPaneId))
+    )
+      cancelResize();
+  });
+  onCleanup(cancelResize);
+
   const terminalPoint = (event: WorkspaceMouseEvent): { x: number; y: number } => ({
     x: event.x - (props.originX ?? 0),
     y: event.y - (props.originY ?? 0) - topOffset(),
@@ -1059,8 +1088,16 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
     return true;
   };
   props.onSelectionKeyOwner?.(
-    handlePaneMenuKey,
-    () => props.interactive !== false && (paneMenu.ownsInput() || keyboardCopy() !== null),
+    (name, event) => {
+      if (drag && name === "escape") {
+        cancelResize();
+        return true;
+      }
+      return handlePaneMenuKey(name, event);
+    },
+    () =>
+      props.interactive !== false &&
+      (drag !== null || paneMenu.ownsInput() || keyboardCopy() !== null),
     () => {
       // Called only after global shortcuts, copy, and local navigation decline
       // the event, immediately before terminal key or paste delivery.
@@ -1075,6 +1112,8 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
     props.onSelectionCopyOwner?.(null);
     props.onSelectionKeyOwner?.(null);
   });
+  // Register this router only as onMouse. OpenTUI invokes both the general
+  // listener and the typed listener on a target, even after stopPropagation.
   const routePointer = (event: WorkspaceMouseEvent): void => {
     if (event.type === "down") wheelGesture.reset();
     if (paneMenu.ownsInput()) {
@@ -1153,19 +1192,17 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
         }
         if (isRelease) {
           const completed = drag.preview;
-          const changed = completed.cells !== drag.separator.initialCells;
           drag = null;
           setResizePreview(null);
           setHoveredSeparator(null);
-          if (changed)
-            props.onResizePane?.(
-              globalPreview(
-                Object.freeze({
-                  ...completed,
-                  ...(ingress ? { pointerIngress: ingress } : {}),
-                }),
-              ),
-            );
+          props.onResizePane?.(
+            globalPreview(
+              Object.freeze({
+                ...completed,
+                ...(ingress ? { pointerIngress: ingress } : {}),
+              }),
+            ),
+          );
         }
       }
       return;
@@ -1334,7 +1371,16 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
         const ingress = resizeIngress();
         const origin = separator.axis === "x" ? point.x : point.y;
         const preview = terminalPaneResizePreview(separator, origin, origin);
-        drag = { separator, origin, preview, gestureId: ingress?.gestureId ?? null };
+        drag = {
+          separator,
+          origin,
+          preview,
+          gestureId: ingress?.gestureId ?? null,
+          rendererEpoch: props.rendererEpoch,
+          adapter: props.adapter,
+          windowId: layout().current?.semanticWindowId ?? layout().current?.windowName,
+        };
+        props.onResizePreview?.(globalPreview(preview));
         setHoveredSeparator(null);
         setResizePreview(preview);
         return;
@@ -1582,8 +1628,6 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
         width={props.width}
         height={props.height}
         onMouse={routePointer}
-        onMouseDown={routePointer}
-        onMouseUp={routePointer}
       />
       <box
         position="absolute"
@@ -1754,8 +1798,6 @@ export function ApplicationTerminalWorkspace(props: ApplicationTerminalWorkspace
             height={separator.axis === "x" ? Math.max(1, separator.end - separator.start) : 1}
             backgroundColor={props.theme.colors.accentMuted}
             onMouse={routePointer}
-            onMouseDown={routePointer}
-            onMouseUp={routePointer}
           >
             <Show when={separator.axis === "y"}>
               <text fg={props.theme.roles.text.primary}>↕</text>

package/packages/daemon/src/tui/mirror/runtime/semantic-shell-viewport-resize.ts

@@ -3,6 +3,8 @@ import type { ApplicationShellProjectionV1 } from "@tmux-ide/contracts";
 import type { OpenTuiGenerationHostSnapshot } from "./open-tui-generation-host.ts";
 import { applicationShellViewport } from "./application-shell-viewport.ts";
 
+import type { OpenTuiWorkspaceLayout } from "../open-tui-workspace-runtime-port.ts";
+
 type Dimensions = Readonly<{ width: number; height: number }>;
 
 /**
@@ -11,7 +13,11 @@ type Dimensions = Readonly<{ width: number; height: number }>;
  */
 export function createSemanticShellViewportResizeOwner(
   getLayout: () => {
-    readonly current: { readonly paneBorderStatus: "off" | "top" | "bottom" } | null;
+    readonly windows?: readonly Pick<
+      OpenTuiWorkspaceLayout,
+      "semanticWindowId" | "paneBorderStatus"
+    >[];
+    readonly current: Pick<OpenTuiWorkspaceLayout, "paneBorderStatus"> | null;
   } = () => ({ current: { paneBorderStatus: "top" } }),
 ): Readonly<{
   adopt(
@@ -32,6 +38,60 @@ export function createSemanticShellViewportResizeOwner(
   }>;
   let applied: ResizeIdentity | null = null;
   let pending: ResizeIdentity | null = null;
+  type ScopedTarget = Readonly<{ cols: number; rows: number; semanticWindowId?: string }>;
+  let desired: Readonly<{ identity: ResizeIdentity; targets: readonly ScopedTarget[] }> | null =
+    null;
+  let scopedFlight = false;
+  let scopedEpoch = 0;
+  let authorityClient: OpenTuiGenerationHostSnapshot["authorityClient"] = null;
+  let stopAuthority: (() => void) | null = null;
+  let geometryOwner: string | null = null;
+  let authoritySuspended = false;
+  let retry: (() => void) | null = null;
+  const scopedApplied = new Map<string, string>();
+  const targetKey = (target: ScopedTarget) => target.semanticWindowId ?? "";
+  const targetSize = (target: ScopedTarget) => `${target.cols}x${target.rows}`;
+  const drain = async (): Promise<void> => {
+    if (scopedFlight || disposed || authoritySuspended) return;
+    scopedFlight = true;
+    try {
+      while (desired && !disposed && !authoritySuspended) {
+        const owner = desired;
+        const epoch = scopedEpoch;
+        const target = owner.targets.find(
+          (entry) => scopedApplied.get(targetKey(entry)) !== targetSize(entry),
+        );
+        if (!target) break;
+        // A global fit clears this control client's window overrides. Forget
+        // them before dispatch, including a reversal while the receipt waits.
+        if (target.semanticWindowId === undefined) scopedApplied.clear();
+        else scopedApplied.delete(targetKey(target));
+        const outcome = await owner.identity.lane.lane
+          .resize(target)
+          .catch(() => ({ status: "failed" as const }));
+        if (disposed || !desired) break;
+        if (epoch !== scopedEpoch) continue;
+        const stillDesired = desired.targets.some(
+          (entry) =>
+            targetKey(entry) === targetKey(target) && targetSize(entry) === targetSize(target),
+        );
+        if (outcome.status !== "applied") {
+          if (!stillDesired) continue;
+          break;
+        }
+        // Preserve the actual accepted size even after a reversal so the next
+        // pass compares current truth with the latest complete desired set.
+        if (desired.targets.some((entry) => targetKey(entry) === targetKey(target)))
+          scopedApplied.set(targetKey(target), targetSize(target));
+      }
+    } finally {
+      scopedFlight = false;
+    }
+  };
+  const sameAuthority = (left: ResizeIdentity, right: ResizeIdentity): boolean =>
+    left.lane === right.lane &&
+    left.daemonGeneration === right.daemonGeneration &&
+    left.rendererEpoch === right.rendererEpoch;
   const same = (left: ResizeIdentity | null, right: ResizeIdentity): boolean =>
     left?.lane === right.lane &&
     left.daemonGeneration === right.daemonGeneration &&
@@ -40,23 +100,59 @@ export function createSemanticShellViewportResizeOwner(
     left.rows === right.rows;
 
   return Object.freeze({
-    adopt(
+    adopt: function adopt(
       dimensions,
       semantic,
       generation,
       paneBorderStatus = getLayout().current?.paneBorderStatus ?? "off",
     ) {
       if (disposed) return;
+      retry = () => adopt(dimensions, semantic, generation, paneBorderStatus);
       if (
         semantic === null ||
         generation?.status !== "live" ||
         generation.daemonGeneration === null ||
         generation.fastLane === null
       ) {
+        stopAuthority?.();
+        stopAuthority = null;
+        authorityClient = null;
+        authoritySuspended = false;
         applied = null;
         pending = null;
+        desired = null;
+        scopedEpoch += 1;
+        scopedApplied.clear();
         return;
       }
+      if (authorityClient !== generation.authorityClient) {
+        stopAuthority?.();
+        authorityClient = generation.authorityClient;
+        const observed = authorityClient;
+        geometryOwner = observed?.getAuthoritySnapshot()?.owners.geometry ?? null;
+        authoritySuspended =
+          geometryOwner !== null && geometryOwner !== observed?.authorityIdentity.clientId;
+        stopAuthority =
+          observed?.onAuthority((snapshot) => {
+            if (
+              disposed ||
+              authorityClient !== observed ||
+              snapshot.generation !== generation.daemonGeneration
+            )
+              return;
+            const next = snapshot.owners.geometry;
+            if (next === geometryOwner) return;
+            geometryOwner = next;
+            authoritySuspended = next !== null && next !== observed.authorityIdentity.clientId;
+            // The daemon clears scoped fits on handoff even when the host/runtime
+            // identity survives. Reacquisition must rebuild them from current truth.
+            applied = null;
+            pending = null;
+            scopedApplied.clear();
+            scopedEpoch += 1;
+            if (!authoritySuspended) retry?.();
+          }) ?? null;
+      }
       const viewport = applicationShellViewport(dimensions, true);
       const lane = generation.fastLane;
       const target = Object.freeze({
@@ -66,7 +162,53 @@ export function createSemanticShellViewportResizeOwner(
         cols: viewport.width,
         rows: Math.max(2, viewport.height - (paneBorderStatus === "off" ? 1 : 0)),
       });
-      if (same(applied, target) || same(pending, target)) return;
+      const windows = getLayout().windows;
+      if (
+        windows &&
+        windows.every(
+          (window) =>
+            typeof window.semanticWindowId === "string" && window.semanticWindowId.length > 0,
+        )
+      ) {
+        applied = null;
+        pending = null;
+        if (!desired || !sameAuthority(desired.identity, target)) {
+          scopedEpoch += 1;
+          scopedApplied.clear();
+        }
+        const retainedWindows = new Set(["", ...windows.map((window) => window.semanticWindowId!)]);
+        for (const key of scopedApplied.keys())
+          if (!retainedWindows.has(key)) scopedApplied.delete(key);
+        desired = {
+          identity: target,
+          targets: [
+            // Unscoped/new windows inherit a stable size, independent of the
+            // selected window's border policy. Known windows then fit their own
+            // header reservation without resizing their neighbours on switch.
+            { cols: viewport.width, rows: Math.max(2, viewport.height - 1) },
+            ...windows.map((window) => ({
+              semanticWindowId: window.semanticWindowId!,
+              cols: viewport.width,
+              rows: Math.max(2, viewport.height - (window.paneBorderStatus === "off" ? 1 : 0)),
+            })),
+          ],
+        };
+        void drain();
+        return;
+      }
+      if (desired) {
+        desired = null;
+        scopedEpoch += 1;
+        scopedApplied.clear();
+        applied = null;
+        pending = null;
+      }
+      if (authoritySuspended || same(applied, target) || same(pending, target)) return;
+      // The accepted size stops being a dedupe target as soon as another
+      // resize can mutate tmux. Otherwise A -> B -> A drops the final A while
+      // B is still awaiting its receipt. The fast lane owns first/latest
+      // coalescing; it must see the reversal to retain the actual final size.
+      applied = null;
       pending = target;
       void lane.lane.resize({ cols: target.cols, rows: target.rows }).then(
         (outcome) => {
@@ -81,6 +223,12 @@ export function createSemanticShellViewportResizeOwner(
     },
     dispose() {
       disposed = true;
+      retry = null;
+      stopAuthority?.();
+      stopAuthority = null;
+      authorityClient = null;
+      desired = null;
+      scopedApplied.clear();
       applied = null;
       pending = null;
     },

package/packages/daemon/src/tui/mirror/runtime/workspace-terminal-fast-lane.ts

@@ -103,7 +103,9 @@ export function createOpenTuiWorkspaceTerminalFastLane(
         if (client.getSnapshot().target?.daemon.instanceId !== address.generation) {
           return Promise.resolve("authority-lost");
         }
-        return client.fitViewport(viewport.cols, viewport.rows);
+        return viewport.semanticWindowId === undefined
+          ? client.fitViewport(viewport.cols, viewport.rows)
+          : client.fitViewport(viewport.cols, viewport.rows, viewport.semanticWindowId);
       },
     },
     ...(performanceSink?.terminalTraceStage

package/packages/daemon/src/tui/mirror/semantic-pane-render-source.ts

@@ -758,7 +758,8 @@ export function blitSemanticRow(
     let background = resolveColor(cell.background, false, palette);
     let attributes = cell.attributes;
     if ((attributes & 32) !== 0) {
-      [foreground, background] = [background, foreground];
+      // Resolve each side before reversing: a default retains its original role.
+      [foreground, background] = [background ?? defaultBg, foreground ?? defaultFg];
       attributes &= ~32;
     }
     // Native tmux clears a partial wide glyph, retaining its background.

package/packages/daemon/src/tui/mirror/theme.ts

@@ -37,6 +37,7 @@ import {
   type LegacyThemeOverrideProvenance,
 } from "../../lib/legacy-theme-compat.ts";
 import type { ResolvedThemeMode, ThemeModeSetting } from "../../lib/theme-mode.ts";
+import { parseTerminalHostColor, terminalHostMode } from "../../lib/terminal-host-color.ts";
 import { XTERM_PALETTE } from "./ansi-palette.ts";
 
 /** Stable categorical host accents; palette authority stays with the theme. */
@@ -379,35 +380,6 @@ function rendererNeutralFromPacked(color: number): RendererNeutralColor {
   return rendererNeutral((color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
 }
 
-function perceivedLuminance(color: RendererNeutralColor): number {
-  return 0.299 * color.red + 0.587 * color.green + 0.114 * color.blue;
-}
-
-function parseTerminalHostColor(value: string | null | undefined): RendererNeutralColor | null {
-  if (!value) return null;
-  const normalized = value.trim().toLowerCase();
-  const hex = /^#([\da-f]{3}|[\da-f]{6})$/u.exec(normalized)?.[1];
-  if (hex) {
-    const expanded =
-      hex.length === 3 ? `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}` : hex;
-    return rendererNeutral(
-      Number.parseInt(expanded.slice(0, 2), 16),
-      Number.parseInt(expanded.slice(2, 4), 16),
-      Number.parseInt(expanded.slice(4, 6), 16),
-    );
-  }
-  // OSC palette replies may use X11's rgb:RR/GG/BB form with one to four
-  // hexadecimal digits per channel. Scale each channel to a byte rather than
-  // truncating high-fidelity replies.
-  const x11 = /^rgb:([\da-f]{1,4})\/([\da-f]{1,4})\/([\da-f]{1,4})$/u.exec(normalized);
-  if (!x11) return null;
-  const channel = (part: string): number => {
-    const maximum = 16 ** part.length - 1;
-    return Math.round((Number.parseInt(part, 16) / maximum) * 255);
-  };
-  return rendererNeutral(channel(x11[1]!), channel(x11[2]!), channel(x11[3]!));
-}
-
 function mostReadable(
   background: RendererNeutralColor,
   candidates: readonly RendererNeutralColor[],
@@ -458,10 +430,8 @@ export function deriveSystemVisualHostDefaults(
   const reportedPalette = Array.from({ length: 16 }, (_, index) =>
     parseTerminalHostColor(input.palette[index]),
   );
-  const measuredBackground =
-    parseTerminalHostColor(input.defaultBackground) ?? reportedPalette[0] ?? null;
-  const measuredForeground =
-    parseTerminalHostColor(input.defaultForeground) ?? reportedPalette[7] ?? null;
+  const measuredBackground = parseTerminalHostColor(input.defaultBackground);
+  const measuredForeground = parseTerminalHostColor(input.defaultForeground);
   if (!measuredBackground && !measuredForeground && reportedPalette.every((value) => !value))
     return null;
 
@@ -469,12 +439,7 @@ export function deriveSystemVisualHostDefaults(
   const background = measuredBackground ?? BUILTIN_VISUAL_THEMES[fallbackMode].surfaces.canvas;
   const black = rendererNeutral(0, 0, 0);
   const white = rendererNeutral(255, 255, 255);
-  const appearance =
-    measuredBackground === null
-      ? fallbackMode
-      : perceivedLuminance(background) > 127.5
-        ? "light"
-        : "dark";
+  const appearance = terminalHostMode(input.defaultBackground) ?? fallbackMode;
   const builtIn = BUILTIN_VISUAL_THEMES[appearance];
   const structuralTarget = appearance === "dark" ? white : black;
   const panel = mixSrgbColors(background, structuralTarget, appearance === "dark" ? 0.055 : 0.04);

package/packages/daemon/src/tui/mirror/workspace/terminal-pane-header.tsx

@@ -2,7 +2,7 @@
 import { paneInteractionPresence, type PaneInteractionProjection } from "@tmux-ide/core";
 import { Badge } from "../ui/badge.tsx";
 import type { AgentActivity } from "@tmux-ide/contracts";
-import { createSignal, Show } from "solid-js";
+import { createMemo, createSignal, Show } from "solid-js";
 
 import type { SemanticThemeSnapshot } from "../theme.ts";
 import { clipTerminal, terminalDisplayWidth } from "../terminal-text.ts";
@@ -104,13 +104,6 @@ export function PaneTitleBar(props: PaneTitleBarProps) {
     if (!presence() || available < presence()!.badge.length + 2) return 0;
     return Math.min(available, terminalDisplayWidth(activityLabel()) + 2);
   };
-  // Capture one non-null presence for each badge lifetime. A retiring child's
-  // queued style effect must not dereference the parent's now-expired receipt.
-  const activityBadge = () => {
-    const current = presence();
-    const width = activityWidth();
-    return current && width > 0 ? { presence: current, width, label: activityLabel() } : null;
-  };
   // Keep the state glyph out of the first two inline cells. OpenTUI can repaint
   // those cells from the clipped parent during nested workspace composition.
   const markerGutterWidth = () => Math.min(2, safeWidth());
@@ -187,6 +180,26 @@ export function PaneTitleBar(props: PaneTitleBarProps) {
     else props.onSelectIntent();
   };
 
+  // Capture one non-null presence for each badge lifetime. A retiring child's
+  // queued style effect must not dereference the parent's now-expired receipt.
+  const activityBadge = createMemo(
+    () => {
+      const current = presence();
+      const width = activityWidth();
+      return current && width > 0 ? { presence: current, width, label: activityLabel() } : null;
+    },
+    undefined,
+    {
+      equals: (previous, next) =>
+        previous === next ||
+        (previous !== null &&
+          next !== null &&
+          previous.width === next.width &&
+          previous.label === next.label &&
+          previous.presence.tone === next.presence.tone),
+    },
+  );
+
   return (
     <box
       id={`pane-title-bar:${props.paneId}`}

package/packages/daemon-client/src/terminal-fast-lane.test.ts

@@ -648,6 +648,24 @@ describe("terminal fast lane", () => {
     });
   });
 
+  it("keeps equal-sized scoped targets distinct across an in-flight resize", async () => {
+    const { lane, control } = rig();
+    control.owned.add("geometry");
+    const gate = deferred<void>();
+    control.resizeGates.push(gate.promise, Promise.resolve());
+    const first = lane.resize({ semanticWindowId: "window.a", cols: 80, rows: 24 });
+    const second = lane.resize({ semanticWindowId: "window.b", cols: 80, rows: 24 });
+    gate.resolve();
+    await settle();
+    expect(await first).toEqual({ status: "applied" });
+    expect(await second).toEqual({ status: "applied" });
+    expect(control.resizes.map(({ viewport }) => viewport.semanticWindowId)).toEqual([
+      "window.a",
+      "window.b",
+    ]);
+    lane.dispose();
+  });
+
   it("preserves an exact geometry authority conflict without treating it as applied", async () => {
     const { lane, control } = rig();
     control.owned.add("geometry");

package/packages/daemon-client/src/terminal-fast-lane.ts

@@ -73,6 +73,7 @@ export interface TerminalFastLaneControlPort {
 }
 
 export interface TerminalFastLaneViewport {
+  readonly semanticWindowId?: string;
   readonly cols: number;
   readonly rows: number;
 }
@@ -225,7 +226,11 @@ function validViewport(viewport: TerminalFastLaneViewport): boolean {
     Number.isInteger(viewport.cols) &&
     Number.isInteger(viewport.rows) &&
     viewport.cols > 0 &&
-    viewport.rows > 0
+    viewport.rows > 0 &&
+    (viewport.semanticWindowId === undefined ||
+      (typeof viewport.semanticWindowId === "string" &&
+        viewport.semanticWindowId.length > 0 &&
+        viewport.semanticWindowId.length <= 256))
   );
 }
 
@@ -744,7 +749,7 @@ export function createTerminalFastLane(options: TerminalFastLaneOptions): Termin
         return Promise.resolve({ status: "failed", error: new TypeError("invalid viewport") });
       }
       const retained = Object.freeze({ ...viewport });
-      const key = `${retained.cols}x${retained.rows}`;
+      const key = JSON.stringify([retained.semanticWindowId ?? null, retained.cols, retained.rows]);
       const epoch = generationEpoch;
       mutableCounters.resizeAccepted += 1;
       return new Promise((resolve) => {