@ssebastien/tcmd 0.1.3 → 0.1.4

package/src/js/tcmd/core/directory.js

@@ -9,29 +9,18 @@
 // figures, the selection buffer and the navigation history (back/forward).
 // A pane owns exactly one directory — the
 // former multi-tab model is gone — and the pane's cells proxy it directly.
+//
+// Reads commit atomically: the displayed directory (path, listing, filter,
+// marks, cursor) is replaced in one reactive batch once its replacement is
+// ready, and only the latest read may publish (see `read`). Listings carry
+// their stat details, so the cursor entry needs no separate enrichment pass.
 
-import { cell, derived, effect } from "select/state/cells"
+import { batch, cell, derived } from "select/state/cells"
 import { viewEntries } from "./entries.js"
-import { clampCursor, currentEntry, toggleMark } from "./selection.js"
+import { createHistory } from "./history.js"
+import { clampCursor, currentEntry, indexOfPath, toggleMark } from "./selection.js"
 import { SEP, parent as parentPath, split, prefix } from "./path.js"
 
-// Function: enrichEntry
-// Merges `stat` details (ctime, mode, uid, gid) the listing may not carry.
-async function enrichEntry(fs, entry) {
-	if (!entry) return null
-	const stats = await fs.stat(entry.path).catch(() => null)
-	if (!stats) return entry
-	return {
-		...entry,
-		size: entry.isDir ? 0 : (stats.size ?? entry.size),
-		mtimeMs: stats.mtimeMs ?? entry.mtimeMs,
-		ctimeMs: stats.ctimeMs ?? entry.ctimeMs,
-		mode: stats.mode ?? entry.mode,
-		uid: stats.uid ?? entry.uid,
-		gid: stats.gid ?? entry.gid,
-	}
-}
-
 // Function: createDirectory
 // Creates the directory state for one pane, bound to a filesystem adapter.
 //
@@ -41,7 +30,7 @@ async function enrichEntry(fs, entry) {
 // await dir.refresh()
 // dir.entries.value // sorted, filtered FileEntry[]
 // ```
-function createDirectory({ fs, path: initialPath }) {
+function createDirectory({ fs, path: initialPath, context: initialContext }) {
 	const dir = { fs }
 	dir.path = cell(initialPath)
 	dir.rawEntries = cell([])
@@ -54,105 +43,167 @@ function createDirectory({ fs, path: initialPath }) {
 	)
 	dir.cursor = cell(0)
 	dir.disk = cell(null)
-	// Stat details (ctime, mode, uid, gid) for the entry under the cursor,
-	// fetched lazily: listings only carry size/mtime, so the pane detail line
-	// re-stats the selected path when the cursor moves (cached by path).
-	dir.cursorStat = cell(null)
-	let cursorStatPath = null
 	// Selection buffer for this directory (the pane's marked paths).
 	dir.marked = cell(new Set())
-	// Navigation history: visited paths with the current one at
-	// `history.index`, so back/forward walk the stack like a browser.
-	dir.history = { stack: [initialPath], index: 0 }
-
-	// A changing filter re-ranks the listing: snap the cursor back to the top
-	// match. Disposed with the directory (see `dispose`).
-	const stopFilterWatch = effect([dir.filter], () => dir.cursor.set(0))
-
-	// Re-stat the cursor entry on movement; cache by path so a re-render that
-	// does not move the cursor does not hit the filesystem again.
-	const stopCursorWatch = effect([dir.entries, dir.cursor], () => {
-		const entry = currentEntry(dir.entries.value, dir.cursor.value)
-		if (!entry || entry.path === cursorStatPath) return
-		cursorStatPath = entry.path
-		dir.cursorStat.set(entry)
-		void enrichEntry(fs, entry).then((enriched) => {
-			if (cursorStatPath === entry.path) dir.cursorStat.set(enriched)
-		})
+	// An opaque per-entry value the owner captures into the history and gets
+	// back on restore. The session uses it to restore the focused column; the
+	// directory itself never inspects it.
+	let context = initialContext
+	const contextGet = () => context?.get?.()
+	const contextSet = (value) => context?.set?.(value)
+	// Function: snapshot
+	// The directory's restorable view state: path, filter, cursor, marks and
+	// the owner's context.
+	const snapshot = () => ({
+		path: dir.path.value,
+		filter: dir.filter.value,
+		cursor: dir.cursor.value,
+		marks: new Set(dir.marked.value),
+		context: contextGet(),
 	})
+	// Navigation history: full view snapshots with the current one at
+	// `history.index`, so back/forward restore position, selection and filter
+	// like a browser.
+	dir.history = createHistory(snapshot())
+	// Cursor memory: the last cursor position per path, so re-entering a
+	// directory (a fresh `open`, not a history step) lands on the entry that
+	// was last selected there.
+	const cursorMemory = new Map()
+	let readToken = 0
+
+	// Function: setContext
+	// Replaces the owner context captured into history entries.
+	dir.setContext = (next) => {
+		context = next
+	}
 
-	// Function: refresh
-	// Re-reads the directory at `dir.path`, updating `rawEntries` and clamping
-	// the cursor. Sets `loading` while in flight; failures land in `error`.
-	dir.refresh = async () => {
-		dir.loading.set(true)
-		dir.error.set(null)
+	// Function: read
+	// Reads `path` and, unless a newer read supersedes it, commits the listing
+	// as one atomic update: the displayed directory stays intact until its
+	// replacement is ready, and disk figures never delay the listing.
+	//
+	// Options:
+	// - `move`: move to `path` (reset filter and marks, remember the cursor
+	//   for re-entry). Without it, `read` re-reads the displayed directory in
+	//   place, preserving filter, marks and cursor (`refresh`).
+	// - `record`: also record the move in the history (a navigation). Mirror
+	//   columns move without recording.
+	// - `cursorPath`: land the cursor on that entry when the listing has it.
+	// - `restore`: a history snapshot to restore instead of a fresh move.
+	const read = async (
+		path,
+		{ move = false, record = false, cursorPath = null, restore = null } = {},
+	) => {
+		const token = ++readToken
+		batch(() => {
+			dir.loading.set(true)
+			dir.error.set(null)
+		})
 		try {
-			dir.rawEntries.set(await fs.readDir(dir.path.value))
-			dir.cursor.set(clampCursor(dir.cursor.value, dir.entries.value.length))
-			dir.disk.set(await fs.disk(dir.path.value))
+			const raw = await fs.readDir(path)
+			if (token !== readToken) return
+			const isMove = move || Boolean(restore)
+			const filter = restore ? restore.filter : isMove ? "" : dir.filter.value
+			const entries = viewEntries(raw, filter, dir.sort.value)
+			let cursor
+			if (restore) {
+				cursor = clampCursor(restore.cursor, entries.length)
+			} else {
+				const remembered = isMove && path !== dir.path.value
+					? (cursorMemory.get(path) ?? 0)
+					: dir.cursor.value
+				const selected = cursorPath ? indexOfPath(entries, cursorPath) : -1
+				cursor = clampCursor(selected >= 0 ? selected : remembered, entries.length)
+			}
+			// A move that rewrites the filter sets the cursor it computed; no
+			// watcher intervenes (the filter cell is written directly, not
+			// through `setFilter`).
+			batch(() => {
+				if (restore) {
+					dir.path.set(path)
+					dir.filter.set(restore.filter)
+					dir.marked.set(new Set(restore.marks))
+					dir.disk.set(null)
+					contextSet(restore.context)
+				} else if (isMove) {
+					cursorMemory.set(dir.path.value, dir.cursor.value)
+					// Capture the view being left before overwriting it, but
+					// only for recorded moves: mirror columns keep no history.
+					if (record) dir.history.replace(snapshot())
+					dir.path.set(path)
+					dir.filter.set("")
+					dir.marked.set(new Set())
+					dir.disk.set(null)
+				}
+				dir.rawEntries.set(raw)
+				dir.cursor.set(cursor)
+				dir.loading.set(false)
+			})
+			if (record) {
+				const entry = { path, filter: "", cursor, marks: new Set(), context: contextGet() }
+				// Re-navigating to the current path updates the entry instead of
+				// duplicating it.
+				if (dir.history.current()?.path === path) dir.history.replace(entry)
+				else dir.history.push(entry)
+			}
+			const disk = await fs.disk(path)
+			if (token === readToken) dir.disk.set(disk)
 		} catch (error) {
-			dir.error.set(`${error?.message ?? error}`)
+			if (token === readToken) dir.error.set(`${error?.message ?? error}`)
 		} finally {
-			dir.loading.set(false)
+			if (token === readToken) dir.loading.set(false)
 		}
 	}
 
-	// Function: apply
-	// The actual move to `path`: sets the path, resets filter, marks and
-	// cursor, then refreshes. History-neutral — navigate/back/forward record
-	// their own steps around it.
-	const apply = async (path) => {
-		dir.path.set(path)
-		dir.filter.set("")
-		dir.marked.set(new Set())
-		dir.cursor.set(0)
-		await dir.refresh()
-	}
+	// Function: refresh
+	// Re-reads the displayed directory, preserving filter, marks and cursor.
+	dir.refresh = () => read(dir.path.value)
 
 	// Function: navigate
-	// Moves the directory to `path` (resetting filter, marks and cursor),
-	// records the step in the history and refreshes. Re-navigating to the
-	// current path does not duplicate the entry.
-	dir.navigate = async (path) => {
-		const history = dir.history
-		if (history.stack[history.index] !== path) {
-			// A new navigation truncates the forward branch, like a browser.
-			history.stack.length = history.index + 1
-			history.stack.push(path)
-			history.index = history.stack.length - 1
-		}
-		await apply(path)
-	}
+	// Moves the directory to `path` (resetting filter and marks, restoring the
+	// cursor remembered for `path`), records the step in the history and reads
+	// the listing. Re-navigating to the current path does not duplicate the
+	// entry. `record: false` mirrors without touching the history (the
+	// explorer's parent and inspector columns).
+	dir.navigate = (path, { cursorPath = null, record = true } = {}) =>
+		read(path, { move: true, record, cursorPath })
 
 	// Function: back
-	// Steps one entry back in the navigation history; no-op at its start.
+	// Restores the previous history entry — path, filter, cursor and marks —
+	// and reads it; no-op at the start of the history.
 	dir.back = async () => {
-		const history = dir.history
-		if (history.index <= 0) return
-		history.index -= 1
-		await apply(history.stack[history.index])
+		const entry = dir.history.back()
+		if (entry) await read(entry.path, { restore: entry })
 	}
 
 	// Function: forward
-	// Steps one entry forward in the navigation history; no-op at its end.
+	// Restores the next history entry; no-op at the end of the history.
 	dir.forward = async () => {
-		const history = dir.history
-		if (history.index >= history.stack.length - 1) return
-		history.index += 1
-		await apply(history.stack[history.index])
+		const entry = dir.history.forward()
+		if (entry) await read(entry.path, { restore: entry })
 	}
 
 	// Function: up
-	// Navigates to the parent directory; no-op at the filesystem root.
+	// Navigates to the parent directory, landing the cursor on the entry we
+	// came from — stepping up always returns to the previously selected
+	// element. No-op at the filesystem root.
 	dir.up = async () => {
-		const target = parentPath(dir.path.value)
-		if (target) await dir.navigate(target)
+		const cameFrom = dir.path.value
+		const target = parentPath(cameFrom)
+		if (!target) return
+		await dir.navigate(target, { cursorPath: cameFrom })
+	}
+
+	// Function: setFilter
+	// Sets the fuzzy filter and re-anchors the cursor on the first match.
+	dir.setFilter = (query) => {
+		dir.filter.set(query)
+		dir.cursor.set(0)
 	}
 
 	// Function: clearFilter
 	// Removes the directory's filter, restoring the full listing.
-	dir.clearFilter = () => dir.filter.set("")
+	dir.clearFilter = () => dir.setFilter("")
 
 	// Function: open
 	// Opens the entry under the cursor: descends into directories.
@@ -182,10 +233,9 @@ function createDirectory({ fs, path: initialPath }) {
 	})
 
 	// Function: dispose
-	// Releases the directory's reactive watchers.
+	// Cancels any in-flight read so a late listing can no longer publish.
 	dir.dispose = () => {
-		stopFilterWatch()
-		stopCursorWatch()
+		readToken += 1
 	}
 
 	return dir

package/src/js/tcmd/core/fs.js

@@ -19,6 +19,12 @@
 // - `trash(paths)`, `erase(paths)`: Promise<void> - delete, with/without trash
 // - `touch(path)`: Promise<void> - create or bump mtime
 // - `home()`, `cwd()`: string - well-known directories
+//
+// A listing entry additionally reports symlinks as what they point at:
+// `isSymlink` keeps the entry's own identity, `target` is the raw `readlink`
+// text (relative as written, null otherwise), and `isDir`/`size` follow the
+// link — so a link to a directory sorts, opens and previews as a directory,
+// and a link to a file carries the target's size.
 
 import fs from "node:fs/promises"
 import nodeFs from "node:fs"
@@ -70,6 +76,9 @@ function toEntry(name, dirPath, isDir, stats) {
 		path: pathJoin(dirPath, name),
 		isDir,
 		isSymlink: Boolean(stat.isSymlink),
+		// The raw `readlink` text — relative when the link was written that
+		// way — so the listing and the preview can show where it points.
+		target: stat.target ?? null,
 		isDevice: Boolean(stat.isDevice),
 		size: isDir ? 0 : stat.size ?? 0,
 		mtimeMs: stat.mtimeMs ?? 0,
@@ -100,8 +109,15 @@ function createNodeFs() {
 				const d = dirents[i]
 				const full = pathJoin(path, d.name)
 				const stats = await statSafe(full)
-				entries[i] = toEntry(d.name, path, d.isDirectory(), {
-					isSymlink: d.isSymbolicLink(),
+				const isLink = d.isSymbolicLink()
+				// The dirent type describes the link itself, not what it
+				// points at: resolve through the followed stat so a link to a
+				// directory is listed (sorted, opened, previewed) as one. A
+				// broken link has no stats and stays a plain entry.
+				const isDir = d.isDirectory() || (isLink && Boolean(stats?.isDir))
+				entries[i] = toEntry(d.name, path, isDir, {
+					isSymlink: isLink,
+					target: isLink ? await readLinkSafe(full) : null,
 					isDevice: isDeviceNode(d),
 					size: stats?.size ?? 0,
 					mtimeMs: stats?.mtimeMs ?? 0,
@@ -237,6 +253,17 @@ async function statSafe(path) {
 	}
 }
 
+// Function: readLinkSafe
+// The raw `readlink` text of `path`, or null when it is not a link (or the
+// link cannot be read). Relative targets stay relative, as written.
+async function readLinkSafe(path) {
+	try {
+		return await fs.readlink(path)
+	} catch (error) {
+		return null
+	}
+}
+
 // Function: duSafe
 // Recursive disk usage; unreadable entries contribute 0 and never throw.
 async function duSafe(path) {

package/src/js/tcmd/core/history.js

@@ -0,0 +1,58 @@
+// Project: TinyCommand
+// Author:  Sebastien Pierre
+// License: BSD
+// Created: 2026-10-14
+
+// Module: tcmd/core/history
+// A browser-like history over snapshots: a stack with a cursor (`index`) into
+// it. `push` truncates the forward branch, `back`/`forward` move the cursor and
+// return the snapshot to restore, and `replace` updates the current entry in
+// place. Pure bookkeeping — callers own what a snapshot contains and how to
+// apply it.
+
+// Function: createHistory
+// Creates a history seeded with `initial` and the cursor on it.
+function createHistory(initial) {
+	const stack = [initial]
+	let index = 0
+	return {
+		stack,
+		get index() {
+			return index
+		},
+		// Function: current
+		// The snapshot the cursor is on.
+		current: () => stack[index],
+		// Function: push
+		// Records `snapshot` after the cursor, dropping the forward branch.
+		push(snapshot) {
+			stack.length = index + 1
+			stack.push(snapshot)
+			index = stack.length - 1
+		},
+		// Function: replace
+		// Updates the current entry in place, so a later return restores the
+		// state as it was left (moved cursor, marks, filter).
+		replace(snapshot) {
+			stack[index] = snapshot
+		},
+		// Function: back
+		// Moves one entry back and returns its snapshot, or null at the start.
+		back() {
+			if (index <= 0) return null
+			index -= 1
+			return stack[index]
+		},
+		// Function: forward
+		// Moves one entry forward and returns its snapshot, or null at the end.
+		forward() {
+			if (index >= stack.length - 1) return null
+			index += 1
+			return stack[index]
+		},
+	}
+}
+
+export { createHistory }
+
+// EOF

package/src/js/tcmd/core/index.js

@@ -14,6 +14,7 @@ export { createNodeFs } from "./fs.js"
 export { createNullOs, createNodeOs } from "./os.js"
 export { filterEntries, rankEntries, sortEntries, viewEntries } from "./entries.js"
 export { clampCursor, currentEntry, moveCursor, toggleMark } from "./selection.js"
+export { createHistory } from "./history.js"
 export { PANE_BUFFERS, PANE_LABELS, createPane } from "./pane.js"
 export { createDirectory } from "./directory.js"
 export {
@@ -26,14 +27,7 @@ export {
 export { DEFAULT_KEYMAP, matchKeymap } from "./keymap.js"
 export { createDispatch, getCommand, getCommands } from "./commands.js"
 export { expandAll, expandArg, decodePathToken, getOperation, getOperations, pathToken, runOperation } from "./operations.js"
-export {
-	PANEL_FOCUS,
-	argvFor,
-	bindArgs,
-	panelOperations,
-	panelRowList,
-	paneSelectionPaths,
-} from "./panel.js"
-export { parseLine, runLine, scriptItems, tokenize } from "./script.js"
+export { PANEL_FOCUS, argvFor, bindArgs, panelEntries, panelRowList, paneSelectionPaths } from "./panel.js"
+export { parseLine, runLine, tokenize } from "./script.js"
 export { createSession, load } from "./session.js"
 export { SEP, basename, extname, join, normalize, parent, prefix, split } from "./path.js"

package/src/js/tcmd/core/keymap.js

@@ -28,15 +28,15 @@ const DEFAULT_KEYMAP = [
 	{ key: "space", command: "list.mark" },
 	{ key: "b", command: "bookmark.record" },
 	{ key: "g", command: "bookmark.jump" },
-	{ key: "m", command: "panel.toggle" },
 	{ key: ":", command: "panel.open" },
-	{ key: "!", command: "palette.run" },
+	{ key: "!", command: "panel.shell" },
 	{ key: "/", command: "filter.start" },
 	{ key: "r", ctrl: true, command: "pane.reload" },
 	{ key: "v", command: "view.togglePreview" },
+	{ key: "v", shift: true, command: "view.maximize" },
+	{ key: "t", command: "view.toggleMode" },
 	{ key: "o", shift: true, command: "file.open" },
 	{ key: "e", shift: true, command: "file.edit" },
-	{ key: "p", ctrl: true, command: "palette.toggle" },
 	{ key: "q", command: "app.quit" },
 ]
 

package/src/js/tcmd/core/operations.js

@@ -4,13 +4,13 @@
 // Created: 2026-09-27
 
 // Module: tcmd/core/operations
-// The scripting operations: the file-management verbs the command palette's
-// scripting mode completes and runs. An operation receives the session and
-// its raw argument tokens; path arguments resolve filesets ($A … $FILE), `~`
-// and paths relative to the active pane. Operations own their side effects and
-// return a one-line message (shown in the command bar) or undefined.
+// The CLI operations: the file-management verbs the command panel runs. An
+// operation receives the session and its raw argument tokens; path arguments
+// resolve filesets ($A … $FILE), `~` and paths relative to the active pane.
+// Operations own their side effects and return a one-line message (shown in
+// the command bar) or undefined.
 //
-// Registry entries carry the presentation metadata the palette renders:
+// Registry entries carry the presentation metadata the panel renders:
 // `signature`, `description`, `aliases` and an optional `confirmText`. An
 // optional `risk` ("caution" for a move, "destructive" for delete/erase) lets
 // the command panel tint the operation by how dangerous it is.
@@ -26,8 +26,8 @@
 // - "literal": free text (a name), edited in the panel's text field.
 // - "raw": the rest of the line, unparsed (a shell command).
 
-import { basename, extname, join, normalize } from "./path.js"
-import { PANE_BUFFERS } from "./pane.js"
+import { basename, extname, join, normalize, parent as parentOf } from "./path.js"
+import { currentPane, currentPaneId, PANE_BUFFERS } from "./pane.js"
 
 // Constant: PATHS_PREFIX
 // The prefix of a self-contained path-list token the command panel encodes
@@ -62,7 +62,7 @@ const operations = [
 		description: "Copy files and directories",
 		arity: { min: 2, max: 2 },
 		args: [
-			{ name: "FROM", kind: "selection", role: "source" },
+			{ name: "FROM", kind: "selection", role: "source", variadic: true },
 			{ name: "TO", kind: "dest" },
 		],
 		async run(session, args) {
@@ -89,7 +89,7 @@ const operations = [
 		risk: "caution",
 		arity: { min: 2, max: 2 },
 		args: [
-			{ name: "FROM", kind: "selection", role: "source" },
+			{ name: "FROM", kind: "selection", role: "source", variadic: true },
 			{ name: "TO", kind: "dest" },
 		],
 		async run(session, args) {
@@ -109,6 +109,67 @@ const operations = [
 			return `moved ${sources.length} path${sources.length === 1 ? "" : "s"} to ${target}`
 		},
 	},
+	{
+		name: "rename",
+		signature: "rename FIND REPLACE PATH...",
+		description: "Rename paths with a literal find-and-replace",
+		risk: "caution",
+		arity: { min: 3 },
+		args: [
+			{ name: "FIND", kind: "literal" },
+			{ name: "REPLACE", kind: "literal" },
+			{ name: "PATH", kind: "selection", role: "active", variadic: true },
+		],
+		// The live mapping the panel previews instead of the command line: one
+		// `old → new` line per path, an unchanged path marked as such, and an
+		// invalid name or a duplicate target flagged before anything runs.
+		preview(session, argv) {
+			const [find, replace] = argv
+			if (!find || !replace) return null
+			let paths
+			try {
+				paths = expandAll(session, argv.slice(2))
+			} catch (error) {
+				return null
+			}
+			if (!paths.length) return null
+			const plan = renamePlan(find, replace, paths)
+			const lines = plan.map((row) => {
+				if (row.error) return `${row.name} → ⚠ ${row.error}`
+				if (!row.changed) return `${row.name}  (unchanged)`
+				return `${row.name} → ${row.newName}`
+			})
+			for (const name of duplicateTargets(plan)) lines.push(`⚠ duplicate target: ${name}`)
+			return lines.join("\n")
+		},
+		async run(session, args) {
+			const find = `${args[0] ?? ""}`
+			const replace = `${args[1] ?? ""}`
+			if (!find) throw new Error("rename needs FIND")
+			if (!replace) throw new Error("rename needs REPLACE")
+			const paths = expandAll(session, args.slice(2))
+			if (!paths.length) throw new Error("rename needs at least one path")
+			const plan = renamePlan(find, replace, paths)
+			const bad = plan.find((row) => row.error)
+			if (bad) throw new Error(`rename ${basename(bad.path)}: ${bad.error}`)
+			const duplicates = duplicateTargets(plan)
+			if (duplicates.length) throw new Error(`rename: duplicate target ${duplicates[0]}`)
+			for (const row of plan) {
+				if (!row.changed) continue
+				const target = join(parentOf(row.path), row.newName)
+				if (await session.fs.stat(target)) throw new Error(`rename: ${row.newName} already exists`)
+			}
+			let count = 0
+			for (const row of plan) {
+				if (!row.changed) continue
+				await session.fs.move(row.path, join(parentOf(row.path), row.newName))
+				count += 1
+			}
+			await refreshPanes(session)
+			if (!count) return "rename: nothing changed"
+			return `renamed ${count} path${count === 1 ? "" : "s"}`
+		},
+	},
 	{
 		name: "delete",
 		signature: "delete PATH...",
@@ -191,7 +252,7 @@ const operations = [
 			if (!tokens.length) throw new Error("sel needs at least one path")
 			const paths = expandAll(session, tokens)
 			const target = findBuffer(session, buffer)
-			const label = buffer ? `${buffer}`.toUpperCase() : PANE_BUFFERS[session.active.value] ?? PANE_BUFFERS.left
+			const label = buffer ? `${buffer}`.toUpperCase() : PANE_BUFFERS[currentPaneId(session)] ?? PANE_BUFFERS.left
 			const marks = new Set(target.marked.value)
 			for (const path of paths) {
 				if (sign === "-") marks.delete(path)
@@ -286,7 +347,7 @@ const operations = [
 		async run(session, args) {
 			const command = `${args[0] ?? ""}`.trim()
 			if (!command) throw new Error("run needs a command")
-			const cwd = session.panes[session.active.value]?.path.value
+			const cwd = currentPane(session).path.value
 			await session.os.run(command, { cwd })
 			await refreshPanes(session)
 			return `ran ${command}`
@@ -360,7 +421,7 @@ function expandArg(session, token) {
 		return [rest ? join(session.fs.home(), rest) : session.fs.home()]
 	}
 	if (text.startsWith("/")) return [normalize(text)]
-	const base = session.panes[session.active.value]?.path.value ?? session.fs.cwd()
+	const base = currentPane(session).path.value ?? session.fs.cwd()
 	return [join(base, text)]
 }
 
@@ -378,7 +439,9 @@ async function isDir(session, path) {
 }
 
 async function refreshPanes(session) {
-	await Promise.all([session.panes.left.refresh(), session.panes.right.refresh()])
+	// Every rendered column: the two panes, plus the explorer's parent mirror
+	// and the directory the inspector is showing.
+	await Promise.all(Object.values(session.panes).map((pane) => pane.refresh()))
 }
 
 async function previewTarget(session, path, details) {
@@ -414,7 +477,7 @@ function parseSelection(args) {
 // default, or the pane whose buffer label matches `name` (`A` = source/left,
 // `B` = destination/right).
 function findBuffer(session, name) {
-	const active = session.panes[session.active.value] ?? session.panes.left
+	const active = currentPane(session)
 	if (!name) return active
 	const target = `${name}`.toUpperCase()
 	for (const paneId of Object.keys(session.panes)) {
@@ -423,6 +486,35 @@ function findBuffer(session, name) {
 	throw new Error(`unknown selection buffer: ${name}`)
 }
 
+// Function: renamePlan
+// The literal find-and-replace mapping a `rename` runs: one row per path with
+// its source basename, its new basename (every occurrence of FIND replaced by
+// REPLACE), whether it changed, and an error when the result is empty or
+// contains a path separator. Pure, so the panel preview and the run agree.
+function renamePlan(find, replace, paths) {
+	return (paths ?? []).map((path) => {
+		const name = basename(path)
+		const newName = name.split(find).join(replace)
+		let error = null
+		if (!newName) error = "empty name"
+		else if (newName.includes("/")) error = "name has a slash"
+		return { path, name, newName, changed: error === null && newName !== name, error }
+	})
+}
+
+// Function: duplicateTargets
+// The new names two or more different paths would collide on.
+function duplicateTargets(plan) {
+	const seen = new Set()
+	const duplicates = new Set()
+	for (const row of plan ?? []) {
+		if (!row.changed) continue
+		if (seen.has(row.newName)) duplicates.add(row.newName)
+		seen.add(row.newName)
+	}
+	return [...duplicates]
+}
+
 // Function: humanSize
 // Compact byte size for stat output (core-local: components own presentation
 // formatting).
@@ -447,6 +539,7 @@ export {
 	getOperations,
 	humanSize,
 	pathToken,
+	renamePlan,
 	runOperation,
 }