@ssebastien/tcmd 0.1.4 → 0.1.7

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

@@ -18,15 +18,23 @@
 
 import { cell, derived, effect } from "select/state/cells"
 import { createBookmarks } from "./bookmarks.js"
+import { createJournal } from "./journal.js"
 import { createDispatch, getCommandBarItems } from "./commands.js"
 import { createNullOs } from "./os.js"
-import { PANEL_FOCUS, argvFor, bindArgs, filterPanelEntries, isTextualRow, panelCommand, panelEntries, panelEntryRows, panelRowList, panelRunnable, pickerRowList, rowAt, withArgValue } from "./panel.js"
-import { basename, extname, join, parent as parentPath } from "./path.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.
@@ -54,8 +62,23 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 	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
@@ -85,11 +108,17 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 	// 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
@@ -143,13 +172,12 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 		else sync()
 	})
 
-	// Bookmark overlay: `bookmarkMode` is "name" while recording (an input for
-	// the new bookmark's name) or "list" while jumping (a fuzzy picker).
+	// 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 (`:`): the one entry point, listing the CLI operations,
@@ -165,26 +193,69 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 	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.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. `panelPickerMode` ("dir"/"file"/"any") decides what the
-	// list offers and what Enter accepts; `panelPickerArg` is the argument the
-	// chosen path is written back to; `panelPendingRun` reruns the operation
+	// 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.panelPicking = cell(false)
-	session.panelPickerMode = cell("dir")
-	session.panelPickerArg = cell(-1)
-	session.panelPendingRun = cell(false)
-	// The picker's fuzzy filter, written by the picker input and routed to the
-	// picker pane's own filter (see the effect below).
+	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 picker keeps its cursor on the first match whenever the
-	// query changes.
+	// 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
@@ -233,6 +304,11 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 	// 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)
@@ -240,15 +316,19 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 		}
 		// 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).
+		// 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({ ext: source.ext })
+		const kind = entry.isDir ? "directory" : previewKind(source.innerExt)
 		if (entry.details) {
 			session.preview.set({
 				kind,
 				title: source.title,
 				size: entry.size,
 				ext: source.ext,
+				innerExt: source.innerExt,
+				compression: source.compression,
 				details: entry.details,
 				text: null,
 			})
@@ -259,14 +339,27 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 			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: source.title,
 			size: entry.size,
 			ext: source.ext,
+			innerExt: source.innerExt,
+			compression: source.compression,
 			text: head === null || hasBinaryByte(head) ? null : head,
 		})
 	})
@@ -298,34 +391,42 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 		},
 	)
 
-	// 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)
 			}
-			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)
+			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]
+			}
+			return items
 		},
 	)
 
 	// Command bar rows: context-dependent key hints (see core/commands). The
 	// panel button is dropped when a host disables the panel.
 	session.commandBarItems = derived(
-		[session.filtering, session.bookmarkOpen, session.bookmarkMode, session.panelOpen, session.panelPicking],
-		([filtering, bookmarkOpen, bookmarkMode, panelOpen, panelPicking]) =>
-			getCommandBarItems({ filtering, bookmarkOpen, bookmarkMode, panelOpen, panelPicking }),
+		[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 entry list filtered by the typed query; `panelOpIndex` indexes into
@@ -343,37 +444,80 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 	// 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.panelPickerMode],
-		([entries, mode]) => (mode === "dir" ? (entries ?? []).filter((entry) => entry.isDir) : entries ?? []),
+		[session.pickerPane.entries, session.pickerMode],
+		([entries, mode]) => pickerVisibleEntries(entries, mode),
 	)
-	session.pickerRows = derived([session.pickerVisible], ([entries]) => pickerRowList(entries))
-	// The argument column: the picker's entry rows while picking, the draft's
-	// argument rows otherwise. Focus is read from `panelRowIndex` by the row
-	// builder, so it works for both row shapes.
-	session.panelRows = derived(
-		[session.panelDraft, session.panelPicking, session.pickerRows],
-		([draft, picking, picker]) => (picking ? picker : panelRowList(draft)),
+	session.pickerRows = derived(
+		[session.pickerVisible, session.pickerPane.path],
+		([entries, path]) => pickerRowList(entries, path),
 	)
-	// The right pane's argument blocks (label + value/field, and a bordered
-	// item list per selection), and the label column width that aligns them.
-	session.panelLabelWidth = derived([session.panelDraft], ([draft]) =>
-		Math.max(4, ...(draft ?? []).map((binding) => `${binding.name ?? ""}`.length)),
+	// 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 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 entry name; a `«NAME»` marks a required argument still
-	// to fill.
-	session.panelCommand = derived(
+	// 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]) => {
-			// An operation may preview its own mapping instead of the command
-			// line (`rename` shows `old → new` per path). Anything else falls
-			// back to the assembled command line.
-			const custom = entry?.op?.preview?.(session, argvFor(draft), draft)
-			if (typeof custom === "string") return custom
-			const args = panelCommand(draft)
-			const name = entry?.name ?? ""
-			return args ? `${name} ${args}` : name
+			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.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))
@@ -408,31 +552,51 @@ function createSession({ fs, os, left, right, host, bookmarks, viewMode = "explo
 	effect([session.panelOpen, session.panelEntry], ([open, entry]) => {
 		if (!open) return
 		const draft = bindArgs(session, entry)
-		prefillPanelDraft(entry, draft)
+		prefillPanelDraft(session, entry, draft)
 		session.panelDraft.set(draft)
 	})
 	// Selecting another entry resets the argument cursor.
 	effect([session.panelEntry], () => {
 		session.panelRowIndex.set(0)
+		session.panelRunError.set(null)
+		session.panelArmed.set(false)
+	})
+	// 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)
 	})
 
-	// The picker's query 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.
+	// 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.panelPicking.value) session.panelRowIndex.set(0)
+		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.panelPicking.set(false)
-		session.panelPickerArg.set(-1)
-		session.panelPendingRun.set(false)
+		session.pickerOpen.set(false)
+		session.pickerArg.set(-1)
+		session.pickerPendingRun.set(false)
+		session.panelArmed.set(false)
 	})
 
 	session.dispatch = createDispatch(session)
@@ -467,15 +631,51 @@ async function load(session) {
 }
 
 // Function: prefillPanelDraft
-// Seeds a freshly bound draft: a single-path `rename` prefills FIND with the
-// whole name, so typing REPLACE renames it in one step; a multi-path rename
-// keeps FIND empty for a shared substring.
-function prefillPanelDraft(entry, draft) {
-	if (entry?.op?.name !== "rename") return
-	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)
+// 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) {
@@ -500,34 +700,4 @@ function entrySummary(entry) {
 	}
 }
 
-// Function: previewSource
-// What the preview renders *through* a symlink: `title` names the traversal
-// (`notes -> ../real/notes`) so it is visible in the header, and `ext` is the
-// target's extension, so a link previews with the kind of what it points at
-// rather than the kind of its own name. Plain entries pass through unchanged.
-function previewSource(entry) {
-	const target = entry?.isSymlink && entry.target ? `${entry.target}` : null
-	if (!target || !entry?.path) return { title: basename(entry?.path ?? ""), ext: entry?.ext ?? null }
-	const ext = extname(target) ?? entry.ext ?? null
-	return { title: `${basename(entry.path)} -> ${target}`, ext }
-}
-
-// 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, previewSource }
+export { createSession, load }