tmux-fuzzy-motion 0.0.5 → 0.0.7

package/README.ja.md

@@ -2,14 +2,16 @@
 
 [English README](./README.md)
 
-`tmux-fuzzy-motion` は、`tmux copy-mode` 内で素早くカーソル移動するための
-CLI です。現在の viewport からジャンプ対象を抽出し、fuzzy search で絞り込み、
+`tmux-fuzzy-motion` は、tmux pane 内で素早くカーソル移動するための CLI です。
+現在の viewport からジャンプ対象を抽出し、fuzzy search で絞り込み、
 大文字の hint で移動できます。英字のローマ字 query に対しては Migemo による
 日本語マッチも行います。
 
 ## 特徴
 
 - `tmux copy-mode` 内で動作
+- `start` は copy mode の外から起動しても自動で copy mode に入る
+- `start --scope all` は current window の visible pane 全体を対象にできる
 - 現在の viewport から URL、path、filename、symbol、一般的な単語を抽出
 - `fzf` による fuzzy match
 - `jsmigemo` による英字 query の Migemo マッチ
@@ -56,13 +58,32 @@ bind-key -T copy-mode-vi s run-shell 'tmux-fuzzy-motion start #{pane_id} #{clien
 bind-key -T copy-mode s run-shell 'tmux-fuzzy-motion start #{pane_id} #{client_tty}'
 ```
 
-`run-shell` を経由せずに tmux から直接 popup を開きたい場合は、次の設定も使えます。
+copy mode の外からも起動したい場合は、root table にも bind を追加します。
+
+```tmux
+bind-key s run-shell 'tmux-fuzzy-motion start #{pane_id} #{client_tty}'
+```
+
+current window の visible pane 全体から選びたい場合は、`--scope all` を付けた bind を追加します。
+
+```tmux
+bind-key S run-shell 'tmux-fuzzy-motion start --scope all #{pane_id} #{client_tty}'
+```
+
+`start` サブコマンドを経由せずに tmux から直接 popup を開きたい場合は、次の設定も使えます。
 
 ```tmux
 bind-key -T copy-mode-vi s run-shell -C "display-popup -E -B -x '##{popup_pane_left}' -y '##{popup_pane_top}' -w '#{pane_width}' -h '#{pane_height}' 'tmux-fuzzy-motion popup-live #{pane_id}'"
 bind-key -T copy-mode s run-shell -C "display-popup -E -B -x '##{popup_pane_left}' -y '##{popup_pane_top}' -w '#{pane_width}' -h '#{pane_height}' 'tmux-fuzzy-motion popup-live #{pane_id}'"
 ```
 
+> [!NOTE]
+> 後述の手順の`2.`で`'tmux-fuzzy-motion start %25 /dev/ttys000' returned 127`のようなエラーが表示される場合は以下のようにrun-shell環境のPATHに`tmux-fuzzy-motion`を含める必要があります。
+>
+> ```tmux
+> set-environment -g PATH "/path/to/node/bin:$PATH"
+> ```
+
 設定変更後は tmux を reload します。
 
 ```bash
@@ -71,13 +92,15 @@ tmux source-file ~/.tmux.conf
 
 ## 使い方
 
-1. `copy-mode` に入る
-2. `s` を押す
-3. 小文字や記号で query を入力する
-4. fuzzy match で候補を絞り込む
-5. 英字 query の場合は Migemo による日本語候補も対象になる
-6. 大文字 hint を押して即座に移動する
-7. `Esc` または `Ctrl-[` でキャンセルする
+1. `tmux-fuzzy-motion start` を bind したキーを押す
+2. `--scope current`（default）は current pane のみを対象にし、pane がまだ `copy-mode` でなければ先に `copy-mode` に入る
+3. `--scope all` は current window の visible pane 全体を popup に合成して対象にする
+4. 小文字や記号で query を入力する
+5. fuzzy match で候補を絞り込む
+6. 英字 query の場合は Migemo による日本語候補も対象になる
+7. 大文字 hint を押して即座に移動する
+8. `--scope all` で選択した場合は、該当 pane を active にして必要なら `copy-mode` に入ってから移動する
+9. `Esc` または `Ctrl-[` でキャンセルする
 
 ## 入力キー
 
@@ -91,7 +114,7 @@ tmux source-file ~/.tmux.conf
 ## コマンド
 
 ```text
-tmux-fuzzy-motion start <pane-id> <client-tty>
+tmux-fuzzy-motion start [--scope current|all] <pane-id> <client-tty>
 tmux-fuzzy-motion popup-live <pane-id>
 tmux-fuzzy-motion doctor
 ```
@@ -99,6 +122,11 @@ tmux-fuzzy-motion doctor
 `popup` と `daemon` は内部サブコマンドです。`popup-live` は `display-popup`
 から直接起動する設定向けです。
 
+`--scope`:
+
+- `current`: current pane のみを対象にする。default
+- `all`: current window の visible pane 全体を対象にする
+
 ## Doctor
 
 ローカル環境の確認には `doctor` を使います。
@@ -141,17 +169,12 @@ pnpm run dev
 pnpm check
 ```
 
-warm な daemon を前提に popup 起動時間を測る場合:
-
-```bash
-pnpm bench:startup dist/cli.js
-```
-
 ## 制約
 
-- 対象は現在の viewport のみ
-- `copy-mode` 専用
+- 対象は各 pane の現在の viewport のみ
+- `--scope all` の対象は current window の visible pane のみ
+- zoom 中の `--scope all` は見えている pane のみを対象にする
 - query 入力は ASCII 寄り
 - combining character の完全な扱いは未保証
 - `display-popup` が必要なため、tmux 3.2 以上が必須
-- query は pane 内の最下行右端に描画する
+- query は popup の最下行右端に描画する

package/README.md

@@ -2,7 +2,7 @@
 
 [日本語版はこちら](./README.ja.md)
 
-`tmux-fuzzy-motion` is a CLI for quick cursor jumps inside `tmux copy-mode`.
+`tmux-fuzzy-motion` is a CLI for quick cursor jumps in tmux panes.
 It scans the current viewport, extracts jump targets, filters them with fuzzy
 search, and lets you jump with uppercase hints. Roman queries can also match
 Japanese text through Migemo.
@@ -10,6 +10,8 @@ Japanese text through Migemo.
 ## Features
 
 - Works inside `tmux copy-mode`
+- `start` can also be launched outside copy-mode and enters copy-mode automatically
+- `start --scope all` can target every visible pane in the current window
 - Extracts URLs, paths, filenames, symbols, and general words from the current viewport
 - Supports fuzzy matching with `fzf`
 - Supports Migemo matching for alphabetic queries via `jsmigemo`
@@ -56,14 +58,35 @@ bind-key -T copy-mode-vi s run-shell 'tmux-fuzzy-motion start #{pane_id} #{clien
 bind-key -T copy-mode s run-shell 'tmux-fuzzy-motion start #{pane_id} #{client_tty}'
 ```
 
-If you want tmux to open the popup directly and avoid the extra `run-shell`
-hop, use this instead:
+If you also want to launch it outside copy-mode, add a binding in the root
+table as well:
+
+```tmux
+bind-key s run-shell 'tmux-fuzzy-motion start #{pane_id} #{client_tty}'
+```
+
+If you want to search across every visible pane in the current window, add a
+binding with `--scope all`.
+
+```tmux
+bind-key S run-shell 'tmux-fuzzy-motion start --scope all #{pane_id} #{client_tty}'
+```
+
+If you want tmux to open the popup directly without going through the `start`
+subcommand, use this instead:
 
 ```tmux
 bind-key -T copy-mode-vi s run-shell -C "display-popup -E -B -x '##{popup_pane_left}' -y '##{popup_pane_top}' -w '#{pane_width}' -h '#{pane_height}' 'tmux-fuzzy-motion popup-live #{pane_id}'"
 bind-key -T copy-mode s run-shell -C "display-popup -E -B -x '##{popup_pane_left}' -y '##{popup_pane_top}' -w '#{pane_width}' -h '#{pane_height}' 'tmux-fuzzy-motion popup-live #{pane_id}'"
 ```
 
+> [!NOTE]
+> If you see an error like `'tmux-fuzzy-motion start %25 /dev/ttys000' returned 127` at step 2 below, you need to add `tmux-fuzzy-motion` to the PATH in the run-shell environment:
+>
+> ```tmux
+> set-environment -g PATH "/path/to/node/bin:$PATH"
+> ```
+
 Reload tmux after editing the config:
 
 ```bash
@@ -72,13 +95,18 @@ tmux source-file ~/.tmux.conf
 
 ## Usage
 
-1. Enter `copy-mode`.
-2. Press `s`.
-3. Type a query in lowercase or symbols.
-4. Narrow the candidates with fuzzy matching.
-5. For alphabetic queries, Migemo also expands roman input to Japanese matches.
-6. Press an uppercase hint to jump immediately.
-7. Press `Esc` or `Ctrl-[` to cancel.
+1. Press the key bound to `tmux-fuzzy-motion start`.
+2. `--scope current` (the default) targets only the current pane and enters
+   copy-mode first if needed.
+3. `--scope all` targets every visible pane in the current window by composing
+   them into a single popup.
+4. Type a query in lowercase or symbols.
+5. Narrow the candidates with fuzzy matching.
+6. For alphabetic queries, Migemo also expands roman input to Japanese matches.
+7. Press an uppercase hint to jump immediately.
+8. In `--scope all`, the selected pane becomes active and enters copy-mode if
+   needed before the cursor moves.
+9. Press `Esc` or `Ctrl-[` to cancel.
 
 ## Input Keys
 
@@ -92,7 +120,7 @@ tmux source-file ~/.tmux.conf
 ## Commands
 
 ```text
-tmux-fuzzy-motion start <pane-id> <client-tty>
+tmux-fuzzy-motion start [--scope current|all] <pane-id> <client-tty>
 tmux-fuzzy-motion popup-live <pane-id>
 tmux-fuzzy-motion doctor
 ```
@@ -100,6 +128,11 @@ tmux-fuzzy-motion doctor
 `popup` and `daemon` are internal subcommands. `popup-live` is intended for
 direct `display-popup` bindings.
 
+`--scope`:
+
+- `current`: target only the current pane. This is the default.
+- `all`: target every visible pane in the current window.
+
 ## Doctor
 
 Use `doctor` to verify the local environment:
@@ -142,17 +175,12 @@ Run the full local check:
 pnpm check
 ```
 
-Measure popup startup against a warm daemon:
-
-```bash
-pnpm bench:startup dist/cli.js
-```
-
 ## Limitations
 
-- Targets are limited to the current viewport
-- Designed for `copy-mode` only
+- Targets are limited to the current viewport of each pane
+- `--scope all` targets only visible panes in the current window
+- Zoomed windows with `--scope all` only target the pane that is visible
 - Query input is ASCII-oriented
 - Exact behavior for combining characters is not fully guaranteed
 - Requires `display-popup`, so tmux 3.2 or later is mandatory
-- The query is drawn on the bottom row inside the pane, aligned to the right edge
+- The query is drawn on the popup's bottom row, aligned to the right edge

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { execFile, spawn } from "node:child_process";
-import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { access, appendFile, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { createConnection, createServer } from "node:net";
 import { tmpdir } from "node:os";
@@ -52,6 +52,17 @@ const focusClientPane = async (tmux, paneId, clientTty) => {
 		throw new Error("tmux-fuzzy-motion: client not found", { cause: error });
 	}
 };
+const enterCopyMode = async (tmux, paneId) => {
+	try {
+		await tmux.run([
+			"copy-mode",
+			"-t",
+			paneId
+		]);
+	} catch (error) {
+		throw new Error("tmux-fuzzy-motion: failed to enter copy-mode", { cause: error });
+	}
+};
 const getPaneStartContext = async (tmux, paneId) => {
 	let output = "";
 	try {
@@ -67,10 +78,9 @@ const getPaneStartContext = async (tmux, paneId) => {
 	}
 	const [resolvedPaneId, paneInMode, width, height, currentPath] = output.split("	");
 	if (!resolvedPaneId || !paneInMode || !currentPath || [width, height].map((value) => Number(value)).some((value) => !Number.isFinite(value))) throw new Error("tmux-fuzzy-motion: failed to resolve pane context");
-	if (paneInMode !== "1") throw new Error("tmux-fuzzy-motion: pane is not in copy-mode");
 	return {
 		paneId: resolvedPaneId,
-		inCopyMode: true,
+		inCopyMode: paneInMode === "1",
 		width: Number(width),
 		height: Number(height),
 		currentPath
@@ -88,9 +98,9 @@ const displayPopup = async (tmux, options) => {
 		"-d",
 		options.currentPath,
 		"-x",
-		"#{popup_pane_left}",
+		String(options.x ?? "#{popup_pane_left}"),
 		"-y",
-		"#{popup_pane_top}",
+		String(options.y ?? "#{popup_pane_top}"),
 		"-w",
 		String(options.width),
 		"-h",
@@ -98,6 +108,64 @@ const displayPopup = async (tmux, options) => {
 		...options.command
 	]);
 };
+const listWindowPanes = async (tmux, paneId) => {
+	let output = "";
+	try {
+		output = (await tmux.capture([
+			"list-panes",
+			"-t",
+			paneId,
+			"-F",
+			"#{pane_id}	#{pane_in_mode}	#{pane_width}	#{pane_height}	#{pane_current_path}	#{pane_left}	#{pane_top}	#{?pane_active,1,0}	#{window_zoomed_flag}"
+		])).trim();
+	} catch (error) {
+		throw new Error("tmux-fuzzy-motion: pane not found", { cause: error });
+	}
+	const panes = output.split("\n").filter((line) => line.length > 0).map((line) => {
+		const [resolvedPaneId, paneInMode, width, height, currentPath, left, top, active, zoomed] = line.split("	");
+		const numeric = [
+			width,
+			height,
+			left,
+			top
+		].map((value) => Number(value));
+		if (!resolvedPaneId || !paneInMode || !currentPath || [active, zoomed].some((value) => value === void 0) || numeric.some((value) => !Number.isFinite(value))) throw new Error("tmux-fuzzy-motion: failed to resolve window panes");
+		return {
+			paneId: resolvedPaneId,
+			inCopyMode: paneInMode === "1",
+			width: Number(width),
+			height: Number(height),
+			currentPath,
+			left: Number(left),
+			top: Number(top),
+			active: active === "1",
+			zoomed: zoomed === "1"
+		};
+	});
+	if (panes.length === 0) throw new Error("tmux-fuzzy-motion: pane not found");
+	const zoomed = panes.some((pane) => pane.zoomed);
+	return panes.filter((pane) => !zoomed || pane.active).map((pane) => {
+		const { zoomed: paneZoomed, ...rest } = pane;
+		return rest;
+	});
+};
+const getPaneBorderLines = async (tmux, paneId) => {
+	let output = "";
+	try {
+		output = (await tmux.capture([
+			"show-options",
+			"-A",
+			"-wv",
+			"-t",
+			paneId,
+			"pane-border-lines"
+		])).trim();
+	} catch (error) {
+		throw new Error("tmux-fuzzy-motion: failed to resolve pane border lines", { cause: error });
+	}
+	if (output === "single" || output === "double" || output === "heavy" || output === "simple" || output === "number" || output === "spaces") return output;
+	throw new Error("tmux-fuzzy-motion: failed to resolve pane border lines");
+};
 const getTmuxVersion = async () => {
 	return (await runProcess("tmux", ["-V"])).stdout.trim();
 };
@@ -4789,7 +4857,7 @@ const extractCandidates = (lines) => {
 //#region src/core/hint.ts
 const HINT_CHARS$1 = "ASDFGHJKLQWERTYUIOPZXCVBNM";
 const MAX_TARGETS = 200;
-const createTargetKey = (target) => `${target.line}:${target.col}:${target.text}`;
+const createTargetKey = (target) => `${target.paneId ?? ""}:${target.line}:${target.col}:${target.text}`;
 const generateHints = (characters, maxHintLength) => {
 	const single = [...characters];
 	if (maxHintLength === 1) return single;
@@ -5602,6 +5670,7 @@ var Fzf = class {
 //#endregion
 //#region src/core/matcher.ts
 const candidateKey = (candidate) => [
+	candidate.paneId ?? "",
 	candidate.kind,
 	candidate.text,
 	String(candidate.line),
@@ -5773,14 +5842,16 @@ const measureCellWidth = (cells, start) => {
 const createOverlayRenderer = (lines) => {
 	const baseCellsByLine = lines.map((line) => createStyledDisplayCells(line));
 	const baseLines = baseCellsByLine.map((cells) => cells.join(""));
+	const targetLine = (target) => (target.screenLine ?? target.line) - 1;
+	const targetCol = (target) => target.screenCol ?? target.col;
 	return (targets) => {
 		const rendered = [...baseLines];
 		const mutableCells = /* @__PURE__ */ new Map();
 		const occupiedByLine = /* @__PURE__ */ new Map();
 		const enterTarget = targets[0];
-		const sorted = [...targets].sort((left, right) => left.line - right.line || left.col + left.primary - (right.col + right.primary));
+		const sorted = [...targets].sort((left, right) => targetLine(left) - targetLine(right) || targetCol(left) + left.primary - (targetCol(right) + right.primary));
 		for (const target of sorted) {
-			const lineIndex = target.line - 1;
+			const lineIndex = targetLine(target);
 			const baseCells = baseCellsByLine[lineIndex];
 			if (!baseCells) continue;
 			let cells = mutableCells.get(lineIndex);
@@ -5793,14 +5864,14 @@ const createOverlayRenderer = (lines) => {
 				lineOccupied = Array.from({ length: baseCells.length }, () => false);
 				occupiedByLine.set(lineIndex, lineOccupied);
 			}
-			const matchCol = target.col + target.primary;
+			const matchCol = targetCol(target) + target.primary;
 			const hintCol = findOverlayStart(cells, matchCol);
 			const baseWidth = measureCellWidth(cells, hintCol);
 			const paddedHint = hintCol < matchCol ? target.hint.padEnd(baseWidth, " ") : target.hint;
 			const hintWidth = displayWidth(paddedHint);
 			const shouldHighlightPrimary = hintCol < matchCol;
-			const highlightCols = target.positions.filter((position) => position !== target.primary || shouldHighlightPrimary).map((position) => target.col + position);
-			const isEnterTarget = enterTarget?.line === target.line && enterTarget.col === target.col && enterTarget.text === target.text;
+			const highlightCols = target.positions.filter((position) => position !== target.primary || shouldHighlightPrimary).map((position) => targetCol(target) + position);
+			const isEnterTarget = enterTarget !== void 0 && enterTarget.paneId === target.paneId && targetLine(enterTarget) === lineIndex && targetCol(enterTarget) === targetCol(target) && enterTarget.text === target.text;
 			const hintStyle = isEnterTarget ? PRIMARY_HINT_STYLE : SECONDARY_HINT_STYLE;
 			const highlightStyle = isEnterTarget ? PRIMARY_HIGHLIGHT_STYLE : SECONDARY_HIGHLIGHT_STYLE;
 			const overlapsHint = Array.from({ length: hintWidth }, (_, offset) => lineOccupied[hintCol + offset]).some(Boolean);
@@ -6006,8 +6077,13 @@ const computeMatches = (query, previousHints, matcher) => assignHints(matcher(qu
 	maxHintLength: 1,
 	maxTargets: 26
 });
-const createPreparedMatcher = async (lines, migemoPromise) => {
-	const candidates = extractCandidates(lines);
+const createPreparedMatcher = async (state, migemoPromise) => {
+	const candidates = state.scope === "all" ? state.panes.flatMap((pane) => extractCandidates(pane.plainLines).map((candidate) => ({
+		...candidate,
+		paneId: pane.paneId,
+		screenLine: pane.top + candidate.line,
+		screenCol: pane.left + candidate.col
+	}))) : extractCandidates(state.plainLines);
 	const migemo = await migemoPromise;
 	return {
 		candidateCount: candidates.length,
@@ -6193,8 +6269,10 @@ const runPopupLive = async (args) => {
 	const socketPath = createDaemonSocketPath();
 	try {
 		const pane = await getPaneStartContext(tmux, paneId);
+		if (!pane.inCopyMode) throw new Error("tmux-fuzzy-motion: pane is not in copy-mode");
 		const capture = fitCaptureToHeight(await capturePane(tmux, paneId), pane.height);
 		const state = {
+			scope: "current",
 			paneId,
 			clientTty: "",
 			displayLines: capture.displayLines,
@@ -6279,7 +6357,7 @@ const runDaemon = async (args) => {
 			}
 			if (request.type === "prepare") {
 				activeSocket = socket;
-				const prepared = await createPreparedMatcher(JSON.parse(await readFile(request.stateFile, "utf8")).plainLines, migemoPromise);
+				const prepared = await createPreparedMatcher(JSON.parse(await readFile(request.stateFile, "utf8")), migemoPromise);
 				activeMatcher = prepared.matcher;
 				await writeMessage({
 					type: "prepared",
@@ -6337,6 +6415,21 @@ const runDaemon = async (args) => {
 };
 //#endregion
 //#region src/commands/start.ts
+const writeDebugLog = async (payload) => {
+	const debugLogPath = process.env.TMUX_FUZZY_MOTION_DEBUG_LOG;
+	if (!debugLogPath) return;
+	const line = JSON.stringify({
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...payload
+	});
+	try {
+		await appendFile(debugLogPath, `${line}\n`, "utf8");
+	} catch {}
+};
+const buildPopupRelativePosition = (axis, targetOrigin) => {
+	if (axis === "x") return `#{e|+|:#{popup_pane_left},#{e|-|:${targetOrigin},#{pane_left}}}`;
+	return `#{e|+|:#{popup_height},${`#{e|+|:#{e|-|:${targetOrigin},#{window_offset_y}},#{?#{==:#{status-position},top},#{e|-|:#{client_height},#{window_height}},0}}`}}`;
+};
 const buildPopupCommand = (stateFile, resultFile, socketPath) => [
 	process.execPath,
 	resolveCliEntrypoint(),
@@ -6355,8 +6448,194 @@ const readResult = async (resultFile) => {
 		throw new Error("tmux-fuzzy-motion: popup did not produce result", { cause: error });
 	}
 };
+const parseStartArgs = (args) => {
+	let scope = "current";
+	const positional = [];
+	for (let index = 0; index < args.length; index += 1) {
+		const value = args[index];
+		if (value === "--scope") {
+			const nextScope = args[index + 1];
+			if (nextScope === "current" || nextScope === "all") scope = nextScope;
+			index += 1;
+			continue;
+		}
+		positional.push(value ?? "");
+	}
+	return {
+		scope,
+		paneId: positional[0] ?? "",
+		clientTty: positional[1] ?? ""
+	};
+};
+const createBlankRow = (width) => Array.from({ length: width }, () => " ");
+const BORDER_SETS = {
+	single: {
+		vertical: "│",
+		horizontal: "─",
+		intersection: "┼"
+	},
+	double: {
+		vertical: "║",
+		horizontal: "═",
+		intersection: "╬"
+	},
+	heavy: {
+		vertical: "┃",
+		horizontal: "━",
+		intersection: "╋"
+	},
+	simple: {
+		vertical: "|",
+		horizontal: "-",
+		intersection: "+"
+	},
+	spaces: {
+		vertical: " ",
+		horizontal: " ",
+		intersection: " "
+	}
+};
+const createOccupancyGrid = (panes, width, height) => {
+	const occupied = Array.from({ length: height }, () => Array.from({ length: width }, () => false));
+	for (const pane of panes) for (let row = pane.top; row < pane.top + pane.height; row += 1) {
+		const line = occupied[row];
+		if (!line) continue;
+		for (let column = pane.left; column < pane.left + pane.width; column += 1) if (column >= 0 && column < line.length) line[column] = true;
+	}
+	return occupied;
+};
+const resolveBorderSet = (borderLines) => borderLines === "number" ? BORDER_SETS.simple : BORDER_SETS[borderLines];
+const drawPaneBorders = (rows, occupied, borderLines) => {
+	const borderSet = resolveBorderSet(borderLines);
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+		const row = rows[rowIndex];
+		const occupiedRow = occupied[rowIndex];
+		if (!row || !occupiedRow) continue;
+		for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
+			if (occupiedRow[columnIndex]) continue;
+			const left = occupiedRow[columnIndex - 1] ?? false;
+			const right = occupiedRow[columnIndex + 1] ?? false;
+			const top = occupied[rowIndex - 1]?.[columnIndex] ?? false;
+			const bottom = occupied[rowIndex + 1]?.[columnIndex] ?? false;
+			const hasVertical = left || right;
+			const hasHorizontal = top || bottom;
+			if (hasVertical && hasHorizontal) row[columnIndex] = borderSet.intersection;
+			else if (hasVertical) row[columnIndex] = borderSet.vertical;
+			else if (hasHorizontal) row[columnIndex] = borderSet.horizontal;
+		}
+	}
+};
+const composeDisplayLines = (panes, width, height, borderLines) => {
+	const rows = Array.from({ length: height }, () => createBlankRow(width));
+	const occupied = createOccupancyGrid(panes, width, height);
+	for (const pane of panes) pane.displayLines.forEach((line, lineIndex) => {
+		const row = rows[pane.top + lineIndex];
+		if (!row) return;
+		createStyledDisplayCells(line).forEach((cell, cellIndex) => {
+			const column = pane.left + cellIndex;
+			if (column < 0 || column >= row.length) return;
+			row[column] = cell;
+		});
+	});
+	drawPaneBorders(rows, occupied, borderLines);
+	return rows.map((row) => row.join(""));
+};
+const buildCurrentState = async (tmux, pane, paneId, clientTty) => {
+	if (!pane.inCopyMode) await enterCopyMode(tmux, paneId);
+	const capture = fitCaptureToHeight(await capturePane(tmux, paneId), pane.height);
+	return {
+		currentPath: pane.currentPath,
+		state: {
+			scope: "current",
+			paneId,
+			clientTty,
+			displayLines: capture.displayLines,
+			plainLines: capture.lines,
+			width: pane.width,
+			height: pane.height
+		}
+	};
+};
+const buildAllPaneState = async (tmux, pane, paneId, clientTty) => {
+	const panes = await listWindowPanes(tmux, paneId);
+	const borderLines = await getPaneBorderLines(tmux, paneId);
+	const bounds = panes.reduce((accumulator, item) => ({
+		left: Math.min(accumulator.left, item.left),
+		top: Math.min(accumulator.top, item.top),
+		right: Math.max(accumulator.right, item.left + item.width),
+		bottom: Math.max(accumulator.bottom, item.top + item.height)
+	}), {
+		left: Number.POSITIVE_INFINITY,
+		top: Number.POSITIVE_INFINITY,
+		right: Number.NEGATIVE_INFINITY,
+		bottom: Number.NEGATIVE_INFINITY
+	});
+	const snapshots = [];
+	for (const item of panes) {
+		const capture = fitCaptureToHeight(await capturePane(tmux, item.paneId), item.height);
+		snapshots.push({
+			paneId: item.paneId,
+			inCopyMode: item.inCopyMode,
+			width: item.width,
+			height: item.height,
+			left: item.left - bounds.left,
+			top: item.top - bounds.top,
+			plainLines: capture.lines,
+			displayLines: capture.displayLines
+		});
+	}
+	const width = Math.max(0, bounds.right - bounds.left);
+	const height = Math.max(0, bounds.bottom - bounds.top);
+	const x = buildPopupRelativePosition("x", bounds.left);
+	const y = buildPopupRelativePosition("y", bounds.top);
+	await writeDebugLog({
+		event: "start.build-all-pane-state",
+		paneId,
+		clientTty,
+		targetPane: {
+			paneId: pane.paneId,
+			width: pane.width,
+			height: pane.height,
+			inCopyMode: pane.inCopyMode,
+			currentPath: pane.currentPath
+		},
+		bounds,
+		size: {
+			width,
+			height
+		},
+		popupPosition: {
+			x,
+			y
+		},
+		panes: panes.map((item) => ({
+			paneId: item.paneId,
+			left: item.left,
+			top: item.top,
+			width: item.width,
+			height: item.height,
+			active: item.active,
+			inCopyMode: item.inCopyMode,
+			currentPath: item.currentPath
+		}))
+	});
+	return {
+		currentPath: pane.currentPath,
+		x,
+		y,
+		state: {
+			scope: "all",
+			paneId,
+			clientTty,
+			displayLines: composeDisplayLines(snapshots, width, height, borderLines),
+			panes: snapshots,
+			width,
+			height
+		}
+	};
+};
 const runStart = async (args) => {
-	const [paneId, clientTty] = args;
+	const { scope, paneId, clientTty } = parseStartArgs(args);
 	if (!process.env.TMUX) {
 		console.error("tmux-fuzzy-motion: must be run inside tmux");
 		return 2;
@@ -6377,33 +6656,46 @@ const runStart = async (args) => {
 	try {
 		const pane = await getPaneStartContext(tmux, paneId);
 		await focusClientPane(tmux, paneId, clientTty);
-		const capture = fitCaptureToHeight(await capturePane(tmux, paneId), pane.height);
-		const state = {
-			paneId,
-			clientTty,
-			displayLines: capture.displayLines,
-			plainLines: capture.lines,
-			width: pane.width,
-			height: pane.height
-		};
+		const popupState = scope === "all" ? await buildAllPaneState(tmux, pane, paneId, clientTty) : await buildCurrentState(tmux, pane, paneId, clientTty);
+		const state = popupState.state;
 		await writeFile(stateFile, JSON.stringify(state), "utf8");
 		await ensureDaemon(socketPath);
-		await displayPopup(tmux, {
+		const popupOptions = {
 			command: buildPopupCommand(stateFile, resultFile, socketPath),
-			currentPath: pane.currentPath,
-			height: pane.height,
+			currentPath: popupState.currentPath,
+			height: state.height,
 			targetClient: clientTty,
 			targetPane: paneId,
-			width: pane.width
+			width: state.width
+		};
+		if (popupState.x !== void 0) popupOptions.x = popupState.x;
+		if (popupState.y !== void 0) popupOptions.y = popupState.y;
+		await writeDebugLog({
+			event: "start.display-popup",
+			scope,
+			paneId,
+			clientTty,
+			popupOptions: {
+				targetPane: popupOptions.targetPane,
+				targetClient: popupOptions.targetClient,
+				currentPath: popupOptions.currentPath,
+				width: popupOptions.width,
+				height: popupOptions.height,
+				x: popupOptions.x ?? "#{popup_pane_left}",
+				y: popupOptions.y ?? "#{popup_pane_top}"
+			}
 		});
+		await displayPopup(tmux, popupOptions);
 		const result = await readResult(resultFile);
 		if (result.status === "selected") {
+			const targetPaneId = result.target.paneId ?? paneId;
 			await tmux.runQuiet([
 				"select-pane",
 				"-t",
-				paneId
+				targetPaneId
 			]);
-			await moveCopyCursor(tmux, paneId, result.target);
+			if (state.scope === "all" && !state.panes.some((targetPane) => targetPane.paneId === targetPaneId && targetPane.inCopyMode)) await enterCopyMode(tmux, targetPaneId);
+			await moveCopyCursor(tmux, targetPaneId, result.target);
 		}
 		return 0;
 	} catch (error) {
@@ -6422,7 +6714,7 @@ const runStart = async (args) => {
 const usage = `tmux-fuzzy-motion
 
 Usage:
-  tmux-fuzzy-motion start <pane-id> <client-tty>
+  tmux-fuzzy-motion start [--scope current|all] <pane-id> <client-tty>
   tmux-fuzzy-motion popup --state-file <path> --result-file <path> --socket <path>
   tmux-fuzzy-motion popup-live <pane-id>
   tmux-fuzzy-motion daemon --socket <path>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmux-fuzzy-motion",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Fuzzy hint motion for tmux copy-mode",
   "type": "module",
   "files": [