@ssebastien/tcmd 0.1.3 → 0.1.7

package/src/js/tcmd/core/session.js

@@ -5,20 +5,36 @@
 
 // Module: tcmd/core/session
 // A Session wires two panes plus cross-pane UI state (active pane, preview,
-// command palette, bookmarks) into one dispatchable model. Everything reactive
+// command panel, bookmarks) into one dispatchable model. Everything reactive
 // is a cell or derived cell; views subscribe, commands mutate.
+//
+// On top of the two (source/destination) panes the session owns two auxiliary
+// panes: `parent` mirrors the parent of the pane holding the current
+// directory, `preview` mirrors the directory the inspector is showing. They
+// are real panes — own listing, cursor, marks — so the explorer view and the
+// directory preview are clickable and keyboard-navigable like any other pane,
+// while path changes still land on the pane that owns the current directory
+// (see `currentId` / `core/commands#currentPane`).
 
 import { cell, derived, effect } from "select/state/cells"
 import { createBookmarks } from "./bookmarks.js"
-import { commandRow, createDispatch, getCommandBarItems, getPaletteCommands } from "./commands.js"
+import { createJournal } from "./journal.js"
+import { createDispatch, getCommandBarItems } from "./commands.js"
 import { createNullOs } from "./os.js"
-import { PANEL_FOCUS, bindArgs, filterPanelOperations, isTextualRow, panelCommand, panelOperations, panelRowList, panelRunnable, rowAt, withArgValue } from "./panel.js"
-import { basename, join } from "./path.js"
-import { PANE_BUFFERS } from "./pane.js"
-import { completionToken, scriptItems } from "./script.js"
+import { PANEL_FOCUS, argvFor, bindArgs, filterPanelEntries, isTextualRow, panelCommand, panelEntries, panelEntryRows, panelRowList, panelRunnable, rowAt, withArgValue } from "./panel.js"
+import { createPickerPathQueue, pickerRowList, pickerVisibleEntries } from "./picker.js"
+import { basename, parent as parentPath } from "./path.js"
+import { hasBinaryByte, PREVIEW_BYTES, previewKind, previewSource } from "./preview.js"
+import { compressedBytes, decompressHead } from "./decompress.js"
+import { indexOfPath } from "./selection.js"
+import { createPane, PANE_BUFFERS } from "./pane.js"
 import { hasMatch, score } from "../vendor/fzy.js"
 
-const PREVIEW_BYTES = 65536
+// Constant: BOOKMARK_ADD_KEY
+// Key and display label of the synthetic "add current path" row. It contains
+// spaces, which a bookmark name may not, so it can never collide with a stored
+// row.
+const BOOKMARK_ADD_KEY = "+ add current path"
 
 // Function: createSession
 // Creates the shared model for a two-pane browser.
@@ -29,62 +45,217 @@ const PREVIEW_BYTES = 65536
 // await session.load()
 // session.dispatch("pane.toggle")
 // ```
-function createSession({ fs, os, left, right, host, bookmarks } = {}) {
+function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explorer" } = {}) {
 	const session = {}
 	session.fs = fs
 	session.os = os ?? createNullOs()
 	session.panes = { left, right }
+	// Auxiliary panes: the explorer's parent column and the inspector's
+	// directory column. Both start on a valid path so a refresh before their
+	// first sync can never read a blank one.
+	session.panes.parent = createPane({ fs, path: parentPath(left.path.value) ?? left.path.value })
+	session.panes.preview = createPane({ fs, path: left.path.value })
+	// File picker: a private pane the command panel browses while a path
+	// argument is being picked. Kept out of `session.panes` so `load`, the
+	// pane refresh loop and pane navigation leave it alone; it is (re)read
+	// when the picker opens (see `core/commands#openPicker`).
+	session.pickerPane = createPane({ fs, path: left.path.value })
 	// Shown in the header title; empty when the environment has no hostname.
 	session.host = host ?? ""
+	// The renderer installs its quit hook at mount; the panel's Quit command
+	// calls it (core cannot exit a process or unmount a DOM app itself).
+	session.quit = null
 	// Bookmark model (named paths). The store defaults to in-memory.
 	session.bookmarks = bookmarks ?? createBookmarks()
+	// Undo/redo journal: reversible file operations (`mkdir`, `copy`, `move`,
+	// `rename`, `replace`, `trash`) record an inverse here; `^Z`/`^⇧Z` and the `u` history
+	// panel drive it. Session-only.
+	session.journal = createJournal()
+	// The shared list overlay (`u` history, `⇧T` trash): one modal list at a
+	// time. `overlay` is "history" | "trash" | null; `overlayItems` holds the
+	// rows the active overlay renders; `overlayIndex` is its cursor. A history
+	// row carries `index` (its position in the journal), a trash row carries
+	// `trashPath`.
+	session.overlay = cell(null)
+	session.overlayItems = cell([])
+	session.overlayIndex = cell(0)
+	// View mode: the three-column "explorer" (parent · current · preview) the
+	// workspace opens in, or the two-pane "commander". `view.toggleMode` (`t`)
+	// flips it; the workspace chrome in `components/Frame` reads it to decide
+	// which columns exist. Callers that need the two-pane workspace (tests, a
+	// host that prefers it) pass `viewMode: "commander"`.
+	session.viewMode = cell(viewMode)
 	session.active = cell("left")
-	// The active pane's current directory, tracked by the header title.
-	session.activePath = derived([session.active, left.path, right.path], ([active, l, r]) =>
-		active === "left" ? l : r,
+	// The source/destination pane focus last was on. The auxiliary columns
+	// are attached to it, so `currentId` survives focus moving into them.
+	session.anchor = cell("left")
+	// The pane that owns the current directory: the focused pane when focus
+	// is on a source/destination pane, the anchor otherwise. Everything that
+	// changes a *path* (open, up, back, breadcrumbs, the command panel's
+	// relative arguments) targets it; cursor-only movement targets the
+	// focused pane.
+	session.currentId = derived([session.active, session.anchor], ([active, anchor]) =>
+		active === "left" || active === "right" ? active : anchor,
+	)
+	// The current pane's directory, tracked by the header title and by the
+	// parent column's mirror.
+	session.activePath = derived([session.currentId, left.path, right.path], ([current, l, r]) =>
+		current === "left" ? l : r,
 	)
 	session.showPreview = cell(true)
-	session.paletteOpen = cell(false)
-	session.paletteMode = cell("ui")
-	session.paletteQuery = cell("")
-	session.paletteIndex = cell(0)
+	// The inspector maximized over the workspace columns (`⇧V`): the preview
+	// takes the whole pane row until toggled back, leaving the identity and
+	// command bars in place. Independent of `showPreview`, so restoring the
+	// layout returns the inline inspector to exactly what it was.
+	session.previewFull = cell(false)
+	// The fullscreen inspector overlay: a framed preview covering the whole
+	// viewport. It opens from `v` on a narrow terminal and from Enter on a file
+	// that cannot be edited (see `core/commands#pane.enter`), and closes on Esc
+	// or `v`. Core-owned so a command can request it; the renderers only show
+	// it (`components/Frame#showViewer`). Independent of `showPreview` and
+	// `previewFull`, which drive the inline and the maximized inspector.
+	session.viewerOpen = cell(false)
 	session.notice = cell(null)
 	session.confirm = cell(null)
 	// The pane whose filter input currently owns the keyboard, or null.
 	session.filtering = cell(null)
+	// Back/forward restore the focused column alongside the listing: each
+	// source/destination pane captures `active` into its history entries and
+	// restores it on Esc/⇧Esc. A column the current mode does not show falls
+	// back to the pane owning the current directory.
+	const focusContext = {
+		get: () => session.active.value,
+		set: (value) => {
+			if (value) session.active.set(visibleColumn(session, value))
+		},
+	}
+	left.setContext(focusContext)
+	right.setContext(focusContext)
 
-	// Bookmark overlay: `bookmarkMode` is "name" while recording (an input for
-	// the new bookmark's name) or "list" while jumping (a fuzzy picker).
+	// Focus remembers which source/destination pane it came from.
+	effect([session.active], ([active]) => {
+		if (active === "left" || active === "right") session.anchor.set(active)
+	})
+	// The parent column only exists in explorer mode: leaving the mode hands
+	// focus back to the pane it was following.
+	effect([session.viewMode], ([mode]) => {
+		if (mode !== "explorer" && session.active.value === "parent") {
+			session.active.set(session.currentId.value)
+		}
+	})
+	// The parent column mirrors the parent of the current directory. It never
+	// moves on its own: opening, stepping up or following a breadcrumb in it
+	// retargets the current pane instead (see `core/commands`). Its cursor
+	// follows the current directory, so the mirror always highlights the
+	// entry the current pane is showing. Mirroring never records history: the
+	// column's own back/forward stays on the paths the user navigated.
+	//
+	// `parent.entries` is a dependency so the cursor also lands when the
+	// mirror's listing arrives *after* the effect first runs — the explorer is
+	// the opening mode, so its parent column is populated by the initial
+	// `load` rather than by a later navigation.
+	effect([session.activePath, session.viewMode, session.panes.parent.entries], ([path, mode]) => {
+		if (mode !== "explorer" || !path) return
+		// The filesystem root has no parent; mirror itself rather than read a
+		// blank path.
+		const target = parentPath(path) ?? path
+		const parent = session.panes.parent
+		// Land the mirror's cursor on the current directory once its listing
+		// knows it. A sync left over from an older navigation yields: it
+		// checks the live path before writing the cursor.
+		const sync = () => {
+			if (session.activePath.value !== path) return
+			const index = indexOfPath(parent.entries.value, path)
+			if (index >= 0) parent.cursor.set(index)
+		}
+		if (parent.path.value !== target) void parent.navigate(target, { record: false }).then(sync)
+		else sync()
+	})
+
+	// Bookmark panel: one modal list. `bookmarkQuery` filters the stored
+	// bookmarks by name or path; `bookmarkIndex` is its cursor; `bookmarkTarget`
+	// is the `{ path, isDir }` the add row would record (null while closed).
 	session.bookmarkOpen = cell(false)
-	session.bookmarkMode = cell("list")
 	session.bookmarkQuery = cell("")
 	session.bookmarkIndex = cell(0)
-	// The path being recorded while in "name" mode.
 	session.bookmarkTarget = cell(null)
 
-	// Command panel (`m` / `:`): a structured Commando-style view over the
-	// operations and their argument bindings. `panelQuery` filters the
-	// operation list by typed name; `panelOpIndex` selects the operation in
-	// that filtered list; `panelRowIndex` is the cursor in the flattened
-	// argument rows (headers + items); `panelFocus` is a `PANEL_FOCUS` token
-	// ("ops": typing filters operations, "args": an argument owns the
-	// keyboard). `panelDraft` holds the transient bindings the user tweaks —
-	// it never mutates the real pane marks.
+	// Command panel (`:`): the one entry point, listing the CLI operations,
+	// with the selected operation's arguments bound from the live context.
+	// `panelQuery` filters the entry list by typed name; `panelOpIndex` selects
+	// an entry in that filtered list; `panelRowIndex` is the cursor in the
+	// flattened argument rows (headers + items); `panelFocus` is a
+	// `PANEL_FOCUS` token ("ops": typing
+	// filters entries, "args": an argument owns the keyboard). `panelDraft`
+	// holds the transient bindings the user tweaks — it never mutates the real
+	// pane marks.
 	session.panelOpen = cell(false)
 	session.panelQuery = cell("")
 	session.panelOpIndex = cell(0)
 	session.panelRowIndex = cell(0)
+	// The bit cursor inside a permission row (0=r, 1=w, 2=x): Space toggles
+	// the cell it marks, Left/Right move it.
+	session.panelPermBit = cell(0)
 	session.panelFocus = cell(PANEL_FOCUS.OPS)
 	session.panelDraft = cell([])
-	session.panelOps = cell(panelOperations())
-	// The command panel view is TUI-only; the web view disables it at startup
-	// so no dispatch path (key, palette, command bar) opens an invisible modal.
-	session.panelEnabled = cell(true)
-
-	// The command palette keeps its cursor on the first match whenever the
-	// query changes.
-	effect([session.paletteQuery], () => session.paletteIndex.set(0))
-	// The bookmark picker likewise.
+	session.panelEntries = cell(panelEntries())
+	// Errors from a panel run stay beside the action so the user can retry
+	// without losing the command draft.
+	session.panelRunError = cell(null)
+	// Amber/red operations are two-step: the first Run prints the assembled
+	// command and arms `[Confirm]`; the second executes it. Any draft or
+	// operation change disarms it.
+	session.panelArmed = cell(false)
+
+	// Picker sub-mode: while a `dest`/`path` argument is being browsed the
+	// panel's argument column shows the picker's listing instead of the
+	// argument rows. `pickerMode` ("dir"/"file"/"any") decides what the
+	// list offers and what Enter accepts; `pickerArg` is the argument the
+	// chosen path is written back to; `pickerPendingRun` reruns the operation
+	// once a pick that was holding up a run completes.
+	session.pickerOpen = cell(false)
+	session.pickerMode = cell("dir")
+	session.pickerArg = cell(-1)
+	session.pickerPendingRun = cell(false)
+	// The picker's editable path and the region that owns the keyboard: "path"
+	// (the text field) or "rows" (the entry list). `pickerQuery` is the fragment
+	// the path text resolves to and drives the pane's fuzzy filter.
+	session.pickerPathText = cell("")
+	session.pickerFocus = cell("path")
+	// The directory relative path text resolves against (set when the picker
+	// opens), so typing a relative path does not drift as the picker navigates.
+	session.pickerBasePath = cell("")
+	session.pickerQuery = cell("")
+	// Serializes path resolution and drops stale keystrokes (see
+	// `core/picker#createPickerPathQueue`).
+	session.pickerPaths = createPickerPathQueue(session)
+
+	// Auto-refresh follows the columns the view actually shows. A hidden pane
+	// stops watching — and, on adapters without a native watcher, stops
+	// polling the filesystem — until it is shown again; resuming re-reads it
+	// once so the column never comes back stale. The picker's private pane
+	// only watches while the picker is open.
+	effect(
+		[session.viewMode, session.showPreview, session.currentId, session.pickerOpen],
+		([mode, showPreview, current, pickerOpen]) => {
+			const visible = new Set()
+			if (mode === "explorer") {
+				visible.add("parent")
+				visible.add(current)
+			} else {
+				visible.add("left")
+				visible.add("right")
+			}
+			if (showPreview) visible.add("preview")
+			for (const [id, pane] of Object.entries(session.panes)) {
+				pane.setAutoRefresh?.(visible.has(id))
+			}
+			session.pickerPane?.setAutoRefresh?.(Boolean(pickerOpen))
+		},
+	)
+
+	// The bookmark panel keeps its cursor on the first match whenever the query
+	// changes.
 	effect([session.bookmarkQuery], () => session.bookmarkIndex.set(0))
 
 	// Filter editing is bound to the active pane: switching pane drops the
@@ -92,42 +263,72 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 	effect([session.active], () => session.filtering.set(null))
 
 	// The entry under the cursor of each pane, as a small plain object. The
-	// stat details (ctime, mode, uid, gid) come from the directory's lazy
-	// `cursorStat`, so the pane detail line updates as the cursor moves.
-	session.leftCursorEntry = derived([left.entries, left.cursor, left.cursorStat], ([entries, cursor, stat]) =>
-		entrySummary(stat ?? entries[cursor]),
+	// listing carries the stat details (ctime, mode, uid, gid), so the detail
+	// line updates as the cursor moves without a separate stat pass.
+	session.leftCursorEntry = derived([left.entries, left.cursor], ([entries, cursor]) =>
+		entrySummary(entries[cursor]),
+	)
+	session.rightCursorEntry = derived([right.entries, right.cursor], ([entries, cursor]) =>
+		entrySummary(entries[cursor]),
 	)
-	session.rightCursorEntry = derived([right.entries, right.cursor, right.cursorStat], ([entries, cursor, stat]) =>
-		entrySummary(stat ?? entries[cursor]),
+	// The same detail line for the explorer's parent column.
+	const parent = session.panes.parent
+	session.parentCursorEntry = derived([parent.entries, parent.cursor], ([entries, cursor]) =>
+		entrySummary(entries[cursor]),
 	)
 
-	// Preview target: a `view`/`stat` pin, or the active pane's cursor entry.
+	// Preview target: a `view`/`stat` pin, or the current pane's cursor entry.
+	// Focus on an auxiliary column does not move it: the preview keeps
+	// following the pane that owns the directory.
 	session.previewTarget = cell(null)
 	session.previewEntry = derived(
-		[session.active, session.leftCursorEntry, session.rightCursorEntry, session.previewTarget],
-		([active, l, r, target]) => target ?? (active === "left" ? l : r),
+		[session.currentId, session.leftCursorEntry, session.rightCursorEntry, session.previewTarget],
+		([current, l, r, target]) => target ?? (current === "left" ? l : r),
 	)
 
 	// Moving either cursor resumes following the cursor in the preview.
 	effect([session.leftCursorEntry, session.rightCursorEntry], () => session.previewTarget.set(null))
 
+	// The preview column mirrors the directory being previewed, so a
+	// directory reads as a pane in every view mode. It never moves on its
+	// own for the same reason as the parent column.
+	effect([session.previewEntry], ([entry]) => {
+		if (!entry?.isDir) return
+		if (session.panes.preview.path.value !== entry.path) {
+			void session.panes.preview.navigate(entry.path, { record: false })
+		}
+	})
+
 	session._previewToken = 0
 
 	// Preview payload: text head for files, metadata for the rest; `stat`
 	// targets carry `details` and render as a card even for directories.
 	session.preview = cell(null)
+	// Preview body scroll requests: a monotonic `{ delta, token }` event the
+	// renderers apply to their own body. Keeping it a signal rather than an
+	// offset lets each renderer clamp against its own measured viewport; the
+	// token makes two identical key presses distinct writes.
+	session.previewScroll = cell({ delta: 0, token: 0 })
 	session._stopPreviewWatch = effect([session.previewEntry, session.showPreview], async ([entry, show]) => {
 		if (!show || !entry) {
 			session.preview.set(null)
 			return
 		}
-		const kind = entry.isDir ? "directory" : previewKind(entry)
+		// The preview follows symlinks: its title names the traversal and its
+		// kind comes from what the link points at, not from the link's own
+		// name (a `notes -> README.md` previews as markdown). A compressed
+		// entry is classified by the name inside it and read through its
+		// decompressor (`notes.txt.gz` previews as text).
+		const source = previewSource(entry)
+		const kind = entry.isDir ? "directory" : previewKind(source.innerExt)
 		if (entry.details) {
 			session.preview.set({
 				kind,
-				title: basename(entry.path),
+				title: source.title,
 				size: entry.size,
-				ext: entry.ext,
+				ext: source.ext,
+				innerExt: source.innerExt,
+				compression: source.compression,
 				details: entry.details,
 				text: null,
 			})
@@ -138,14 +339,27 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 			return
 		}
 		const token = ++session._previewToken
-		const head =
-			kind === "text" ? await fs.readTextHead(entry.path, PREVIEW_BYTES).catch(() => null) : null
+		let head = null
+		if (kind === "text") {
+			if (source.compression) {
+				const bytes = await fs
+					.readBytes(entry.path, compressedBytes(source.compression))
+					.catch(() => null)
+				head = bytes
+					? await decompressHead(bytes, source.compression, PREVIEW_BYTES).catch(() => null)
+					: null
+			} else {
+				head = await fs.readTextHead(entry.path, PREVIEW_BYTES).catch(() => null)
+			}
+		}
 		if (token !== session._previewToken) return
 		session.preview.set({
 			kind,
-			title: basename(entry.path),
+			title: source.title,
 			size: entry.size,
-			ext: entry.ext,
+			ext: source.ext,
+			innerExt: source.innerExt,
+			compression: source.compression,
 			text: head === null || hasBinaryByte(head) ? null : head,
 		})
 	})
@@ -177,113 +391,146 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 		},
 	)
 
-	// The active pane's entries, used for script path completion.
-	session.activeEntries = derived(
-		[session.active, left.entries, right.entries],
-		([active, l, r]) => (active === "left" ? l : r),
-	)
-
-	// Script path completion: the entries of the directory being typed (a
-	// token containing "/"), or the active pane's entries otherwise.
-	session.completionEntries = cell([])
-	session._completionToken = 0
-	effect(
-		[session.paletteMode, session.paletteQuery, session.activeEntries, session.active],
-		async ([mode, query, activeEntries, active]) => {
-			if (mode !== "script") {
-				session.completionEntries.set([])
-				return
-			}
-			const token = completionToken(query)
-			if (!token) {
-				session.completionEntries.set(activeEntries ?? [])
-				return
-			}
-			const base = session.panes[active]?.path.value ?? session.fs.cwd()
-			const dir = token.dir.startsWith("/") ? token.dir : join(base, token.dir)
-			const mine = ++session._completionToken
-			const entries = await session.fs.readDir(dir).catch(() => [])
-			if (mine !== session._completionToken) return
-			session.completionEntries.set(entries)
-		},
-	)
-
-	// Bookmark picker rows: the bookmarks fuzzily matched by name or path,
-	// ranked by fzy score. Only meaningful in "list" mode.
+	// Bookmark rows: the stored bookmarks fuzzily matched by name or path,
+	// ranked by fzy score. With no query, a first row offers to record
+	// `bookmarkTarget` when that path is not bookmarked yet.
 	session.bookmarkItems = derived(
-		[session.bookmarks.entries, session.bookmarkQuery, session.bookmarkMode],
-		([entries, query, mode]) => {
-			if (mode !== "list") return []
-			const rows = Object.entries(entries ?? {}).map(([name, entry]) => ({ name, ...entry }))
+		[session.bookmarks.entries, session.bookmarkQuery, session.bookmarkTarget],
+		([entries, query, target]) => {
+			const rows = Object.entries(entries ?? {}).map(([name, entry]) => ({ key: name, name, ...entry }))
 			const q = `${query ?? ""}`.trim()
-			if (!q) return rows.sort((a, b) => a.name.localeCompare(b.name))
-			const ranked = []
-			for (const row of rows) {
-				const best = Math.max(
-					hasMatch(q, row.name) ? score(q, row.name) : -Infinity,
-					hasMatch(q, row.path) ? score(q, row.path) : -Infinity,
-				)
-				if (best > -Infinity) ranked.push({ row, score: best })
+			let items
+			if (!q) {
+				items = rows.sort((a, b) => a.name.localeCompare(b.name))
+			} else {
+				const ranked = []
+				for (const row of rows) {
+					const best = Math.max(
+						hasMatch(q, row.name) ? score(q, row.name) : -Infinity,
+						hasMatch(q, row.path) ? score(q, row.path) : -Infinity,
+					)
+					if (best > -Infinity) ranked.push({ row, score: best })
+				}
+				ranked.sort((a, b) => (a.score !== b.score ? b.score - a.score : a.row.name.localeCompare(b.row.name)))
+				items = ranked.map((match) => match.row)
+			}
+			if (!q && target && !items.some((row) => row.path === target.path)) {
+				items = [{ key: BOOKMARK_ADD_KEY, add: true, name: BOOKMARK_ADD_KEY, path: target.path, isDir: target.isDir }, ...items]
 			}
-			ranked.sort((a, b) => (a.score !== b.score ? b.score - a.score : a.row.name.localeCompare(b.row.name)))
-			return ranked.map((match) => match.row)
+			return items
 		},
 	)
 
 	// Command bar rows: context-dependent key hints (see core/commands). The
-	// TUI-only panel button is dropped when the renderer disables the panel.
+	// panel button is dropped when a host disables the panel.
 	session.commandBarItems = derived(
-		[
-			session.paletteOpen,
-			session.paletteMode,
-			session.filtering,
-			session.bookmarkOpen,
-			session.bookmarkMode,
-			session.panelOpen,
-			session.panelEnabled,
-		],
-		([open, mode, filtering, bookmarkOpen, bookmarkMode, panelOpen, panelEnabled]) => {
-			const items = getCommandBarItems(open, mode, filtering, bookmarkOpen, bookmarkMode, panelOpen)
-			if (panelEnabled) return items
-			return items.filter((item) => item.id !== "panel.toggle")
-		},
+		[session.filtering, session.bookmarkOpen, session.panelOpen, session.pickerOpen, session.panelArmed, session.overlay],
+		([filtering, bookmarkOpen, panelOpen, pickerOpen, panelArmed, overlay]) =>
+			getCommandBarItems({ filtering, bookmarkOpen, panelOpen, pickerOpen, panelArmed, overlay }),
 	)
 
-	// The operation list filtered by the typed query; `panelOpIndex` indexes
-	// into this filtered list.
+	// The entry list filtered by the typed query; `panelOpIndex` indexes into
+	// this filtered list.
 	session.panelFiltered = derived(
-		[session.panelOps, session.panelQuery],
-		([operations, query]) => filterPanelOperations(operations, query),
+		[session.panelEntries, session.panelQuery],
+		([entries, query]) => filterPanelEntries(entries, query),
 	)
-	// The operation the command panel is editing, and its bound arguments.
-	session.panelOperation = derived(
+	// The entry the command panel is editing, and its bound arguments.
+	session.panelEntry = derived(
 		[session.panelFiltered, session.panelOpIndex],
-		([operations, index]) => operations[Math.max(0, Math.min(index, operations.length - 1))] ?? null,
+		([entries, index]) => entries[Math.max(0, Math.min(index, entries.length - 1))] ?? null,
+	)
+	// The picker's visible listing for the current mode: a destination picker
+	// lists directories only, so every row is a valid choice; a file/any
+	// picker keeps the listing intact, where a directory row descends.
+	session.pickerVisible = derived(
+		[session.pickerPane.entries, session.pickerMode],
+		([entries, mode]) => pickerVisibleEntries(entries, mode),
+	)
+	session.pickerRows = derived(
+		[session.pickerVisible, session.pickerPane.path],
+		([entries, path]) => pickerRowList(entries, path),
 	)
-	session.panelRows = derived([session.panelDraft], ([draft]) => panelRowList(draft))
-	// The assembled command line the draft maps to, and whether it is runnable.
-	// The preview answers "what will this run" as the shell would see it,
-	// prefixed with the operation name; a `«NAME»` marks a required argument
-	// still to fill.
+	// The argument column: the picker's entry rows while picking; otherwise the
+	// selected operation's arguments followed by its explicit Run action.
+	session.panelRows = derived(
+		[session.panelDraft, session.panelEntry, session.pickerOpen, session.pickerRows, session.panelRunError, session.panelArmed, session.activePath],
+		([draft, entry, open, picker, runError, armed, activePath]) => {
+			if (open) return picker
+			if (!entry) return []
+			const rows = panelRowList(draft)
+			// A command with no arguments still shows the context it would act
+			// on: a read-only PATH row over the active pane's path.
+			if (!rows.length && entry.showPath) {
+				rows.push({
+					type: "arg",
+					key: "arg:path",
+					rowIndex: 0,
+					argIndex: -1,
+					itemIndex: -1,
+					name: "PATH",
+					summary: activePath ?? "",
+					kind: "path",
+					role: "active",
+					optional: false,
+					variadic: false,
+					textual: false,
+					editable: false,
+					picker: false,
+					mode: "dir",
+					multi: false,
+					readonly: true,
+					value: activePath ?? "",
+					count: 0,
+				})
+			}
+			rows.push({
+				type: "run",
+				key: "panel:run",
+				rowIndex: rows.length,
+				name: runError ? "Retry" : armed ? "Confirm" : "Run",
+				risk: entry.risk ?? null,
+				group: entry.group ?? "File",
+				error: runError,
+				armed,
+				// The command printed below `[Confirm]`.
+				command: armed ? panelCommandLine(session, entry, draft) : null,
+			})
+			return rows
+		},
+	)
+	// The right pane's argument blocks (a label line over its value/field, and
+	// a bordered item list per selection).
+	// Operation-specific preflight output (currently `replace`'s old → new
+	// mapping) is distinct from the assembled shell command.
+	session.panelPreview = derived(
+		[session.panelDraft, session.panelEntry],
+		([draft, entry]) => {
+			const preview = entry?.op?.preview?.(session, argvFor(draft), draft)
+			return typeof preview === "string" ? preview : null
+		},
+	)
+	// Preserve the existing `panelCommand` projection for consumers: operations
+	// with a custom preview return it; all others return the assembled command.
+	// The panel renders custom preflight output separately from its Run action.
 	session.panelCommand = derived(
-		[session.panelDraft, session.panelOperation],
-		([draft, op]) => {
-			const args = panelCommand(draft)
-			const name = op?.name ?? ""
-			return args ? `${name} ${args}` : name
+		[session.panelDraft, session.panelEntry, session.panelPreview],
+		([draft, entry, preview]) => {
+			if (typeof preview === "string") return preview
+			return panelCommandLine(session, entry, draft)
 		},
 	)
 	session.panelRunnable = derived([session.panelDraft], ([draft]) => panelRunnable(draft))
-	// The cursor row and whether it is a textual argument (so the panel focuses
-	// its text field).
+	// The argument row under the right pane's cursor, and whether it is a
+	// textual argument (so the panel focuses its value field).
 	session.panelCursorRow = derived(
 		[session.panelRows, session.panelRowIndex],
 		([rows, row]) => rowAt(rows, row),
 	)
 	session.panelTextual = derived([session.panelCursorRow], ([row]) => isTextualRow(row))
-	// The text the input edits. A plain cell (the input writes through it); an
-	// effect copies the focused binding's value in whenever the cursor lands on
-	// a textual argument, and another folds typing back into the transient
+	// The text the value field edits. A plain cell (the input writes through
+	// it); an effect copies the focused argument's value in whenever the cursor
+	// lands on a textual row, and another folds typing back into the transient
 	// draft so a value survives moving to another argument.
 	session.panelValue = cell("")
 	effect([session.panelCursorRow], ([row]) => {
@@ -296,67 +543,141 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 		}
 	})
 
-	// A picker-row projection for the operation list (left column), over the
-	// query-filtered operations. `summary` is the argument list the row shows
-	// — the signature with the leading operation name stripped, so the name is
-	// not repeated next to the title.
-	session.panelItems = derived([session.panelFiltered], ([operations]) =>
-		operations.map((op) => ({
-			id: `op:${op.name}`,
-			title: op.name,
-			summary: `${op.signature ?? ""}`.replace(/^\S+\s*/, ""),
-			risk: op.risk ?? null,
-		})),
-	)
+	// The command-list column's rows: the filtered operations.
+	session.panelItems = derived([session.panelFiltered], ([entries]) => panelEntryRows(entries))
 
-	// Re-bind the panel draft when the panel opens or the selected operation
+	// Re-bind the panel draft when the panel opens or the selected entry
 	// changes. The panel is modal, so the pane context does not change
-	// underneath it; an explicit toggle owns the draft while it is open.
-	effect([session.panelOpen, session.panelOperation], ([open, op]) => {
+	// underneath it; opening the panel owns the draft while it is open.
+	effect([session.panelOpen, session.panelEntry], ([open, entry]) => {
 		if (!open) return
-		session.panelDraft.set(bindArgs(session, op))
+		const draft = bindArgs(session, entry)
+		prefillPanelDraft(session, entry, draft)
+		session.panelDraft.set(draft)
 	})
-	// Selecting another operation resets the argument cursor.
-	effect([session.panelOperation], () => {
+	// Selecting another entry resets the argument cursor.
+	effect([session.panelEntry], () => {
 		session.panelRowIndex.set(0)
+		session.panelRunError.set(null)
+		session.panelArmed.set(false)
 	})
-	// Typing a query re-anchors the operation cursor on the first match.
+	// Editing the draft after an error gives the next attempt a clean action
+	// row, and disarms a pending Confirm (the command changed under it).
+	effect([session.panelDraft], () => {
+		if (session.panelRunError.value) session.panelRunError.set(null)
+		if (session.panelArmed.value) session.panelArmed.set(false)
+	})
+	// Typing a query re-anchors the entry cursor on the first match.
 	effect([session.panelQuery], () => {
 		session.panelOpIndex.set(0)
 	})
 
-	// Command palette rows: UI actions by default; in scripting mode, the
-	// operations plus the available filesets. Both are filtered by the query.
-	session.paletteCommands = cell(getPaletteCommands().map(commandRow))
-	session.paletteItems = derived(
-		[
-			session.paletteMode,
-			session.paletteQuery,
-			session.paletteCommands,
-			session.filesets,
-			session.completionEntries,
-		],
-		([mode, query, commands, filesets, entries]) =>
-			mode === "script"
-				? scriptItems(query, filesets, { entries })
-				: filterCommandRows(commands, query),
-	)
+	// The editable path resolves to a directory plus a filter fragment; the
+	// queue drops stale keystrokes and keeps fast typing from landing an older
+	// navigation after a newer one (see `core/picker#createPickerPathQueue`).
+	effect([session.pickerPathText, session.pickerOpen], ([text, open]) => {
+		if (open) session.pickerPaths.schedule(text)
+	})
+
+	// The picker's resolved fragment drives the picker pane's fuzzy filter and
+	// re-anchors the picker cursor on the first match. Only while picking, so
+	// the effect can never reset the argument cursor outside the picker.
+	effect([session.pickerQuery], ([query]) => {
+		session.pickerPane.setFilter(`${query ?? ""}`)
+		if (session.pickerOpen.value) {
+			const rows = session.pickerRows.value
+			const firstMatch = `${query ?? ""}` ? rows.findIndex((row) => row.type === "entry") : 0
+			session.panelRowIndex.set(firstMatch >= 0 ? firstMatch : 0)
+		}
+	})
+	// Closing the panel leaves the picker (it lives inside the panel).
+	effect([session.panelOpen], ([open]) => {
+		if (open) return
+		session.pickerOpen.set(false)
+		session.pickerArg.set(-1)
+		session.pickerPendingRun.set(false)
+		session.panelArmed.set(false)
+	})
 
 	session.dispatch = createDispatch(session)
 	session.load = () => load(session)
 	return session
 }
 
+// Function: visibleColumn
+// `id` when the current view mode shows that column, else the pane that owns
+// the current directory. Used to keep a restored focus on a column that
+// exists.
+function visibleColumn(session, id) {
+	const current = session.currentId.value
+	const columns =
+		session.viewMode.value === "explorer"
+			? session.showPreview.value
+				? ["parent", current, "preview"]
+				: ["parent", current]
+			: ["left", "right"]
+	return columns.includes(id) ? id : current
+}
+
 // Function: load
-// Reads the initial listing for both panes and the persisted bookmarks.
+// Reads the initial listing for every column — the two panes plus the two
+// mirrors, which start on a valid path and so may never navigate — and the
+// persisted bookmarks.
 async function load(session) {
 	await Promise.all([
-		session.panes.left.refresh(),
-		session.panes.right.refresh(),
+		...Object.values(session.panes).map((pane) => pane.refresh()),
 		session.bookmarks.load?.(),
 	])
 }
 
+// Function: prefillPanelDraft
+// Seeds a freshly bound draft: `replace` prefills FIND with a single selected
+// basename; exact `rename` prefills FROM and the containing directory from the
+// active entry (or uses the pane's current directory when there is none).
+function prefillPanelDraft(session, entry, draft) {
+	const name = entry?.op?.name
+	if (name === "replace") {
+		const find = (draft ?? []).find((binding) => binding.name === "FIND")
+		const selection = (draft ?? []).find((binding) => binding.kind === "selection")
+		const selected = (selection?.items ?? []).filter((item) => item.selected)
+		if (find && selected.length === 1) find.value = basename(selected[0].path)
+		return
+	}
+	if (name !== "rename") return
+	const active = session.active?.value
+	const auxiliaryPane =
+		(active === "parent" && session.panes.parent) ||
+		(active === "preview" &&
+			session.showPreview?.value &&
+			session.previewEntry?.value?.isDir &&
+			!session.preview?.value &&
+			session.panes.preview)
+	const pane = auxiliaryPane || session.panes[session.currentId?.value ?? active] || session.panes.left
+	const from = (draft ?? []).find((binding) => binding.name === "FROM")
+	const path = (draft ?? []).find((binding) => binding.name === "PATH")
+	const marked = [...(pane.marked?.value ?? [])]
+	const selectedPath =
+		marked.length === 1 ? marked[0] : marked.length === 0 ? pane.currentEntry?.()?.path : null
+	if (selectedPath) {
+		if (from) from.value = basename(selectedPath)
+		if (path) path.value = parentPath(selectedPath) ?? pane.path.value ?? ""
+	} else if (path) {
+		path.value = pane.path.value ?? ""
+	}
+}
+
+// Function: panelCommandLine
+// The command the panel prints below `[Confirm]`: an operation's own
+// `displayCommand` when it has one (rename spells out the two resolved paths),
+// otherwise the operation name followed by its assembled argument tokens.
+function panelCommandLine(session, entry, draft) {
+	const display = entry?.op?.displayCommand?.(session, argvFor(draft), draft)
+	if (display) return display
+	const name = entry?.name ?? ""
+	const args = panelCommand(draft)
+	return args ? `${name} ${args}` : name
+}
+
 function entrySummary(entry) {
 	if (!entry) return null
 	return {
@@ -373,33 +694,10 @@ function entrySummary(entry) {
 		gid: entry.gid,
 		owner: entry.owner,
 		ext: entry.ext,
+		// The symlink's raw target, so the preview and the header can name
+		// where the link goes.
+		target: entry.target ?? null,
 	}
 }
 
-// Function: filterCommandRows
-// Case-insensitive title filter; an empty query keeps every row.
-function filterCommandRows(rows, query) {
-	const q = `${query ?? ""}`.trim().toLowerCase()
-	if (!q) return rows
-	return rows.filter((row) => row.title.toLowerCase().includes(q))
-}
-
-// Function: previewKind
-// Preview classification for file entries; directories are not previewed.
-function previewKind(entry) {
-	const image = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "svg"]
-	const media = ["mp3", "wav", "ogg", "flac", "mp4", "webm", "mkv", "mov", "pdf"]
-	if (entry.ext && image.includes(entry.ext)) return "image"
-	if (entry.ext && media.includes(entry.ext)) return "media"
-	return "text"
-}
-
-function hasBinaryByte(text) {
-	for (let i = 0; i < 2048 && i < text.length; i++) {
-		const code = text.charCodeAt(i)
-		if (code < 9 || (code > 13 && code < 32)) return true
-	}
-	return false
-}
-
 export { createSession, load }