@ssebastien/tcmd 0.1.3 → 0.1.4

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

@@ -5,17 +5,25 @@
 
 // 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 { 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, pickerRowList, rowAt, withArgValue } from "./panel.js"
+import { basename, extname, join, parent as parentPath } from "./path.js"
+import { indexOfPath } from "./selection.js"
+import { createPane, PANE_BUFFERS } from "./pane.js"
 import { hasMatch, score } from "../vendor/fzy.js"
 
 const PREVIEW_BYTES = 65536
@@ -29,30 +37,112 @@ 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 ?? ""
 	// Bookmark model (named paths). The store defaults to in-memory.
 	session.bookmarks = bookmarks ?? createBookmarks()
+	// 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)
 	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)
+
+	// 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 overlay: `bookmarkMode` is "name" while recording (an input for
 	// the new bookmark's name) or "list" while jumping (a fuzzy picker).
 	session.bookmarkOpen = cell(false)
@@ -62,29 +152,39 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 	// 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)
 	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)
+	session.panelEntries = cell(panelEntries())
+
+	// 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
+	// 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.pickerQuery = cell("")
 
-	// The command palette keeps its cursor on the first match whenever the
+	// The bookmark picker keeps its cursor on the first match whenever the
 	// query changes.
-	effect([session.paletteQuery], () => session.paletteIndex.set(0))
-	// The bookmark picker likewise.
 	effect([session.bookmarkQuery], () => session.bookmarkIndex.set(0))
 
 	// Filter editing is bound to the active pane: switching pane drops the
@@ -92,25 +192,42 @@ 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, right.cursorStat], ([entries, cursor, stat]) =>
-		entrySummary(stat ?? entries[cursor]),
+	session.rightCursorEntry = derived([right.entries, right.cursor], ([entries, cursor]) =>
+		entrySummary(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`
@@ -121,13 +238,17 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 			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).
+		const source = previewSource(entry)
+		const kind = entry.isDir ? "directory" : previewKind({ ext: source.ext })
 		if (entry.details) {
 			session.preview.set({
 				kind,
-				title: basename(entry.path),
+				title: source.title,
 				size: entry.size,
-				ext: entry.ext,
+				ext: source.ext,
 				details: entry.details,
 				text: null,
 			})
@@ -143,9 +264,9 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 		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,
 			text: head === null || hasBinaryByte(head) ? null : head,
 		})
 	})
@@ -177,37 +298,6 @@ 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.
 	session.bookmarkItems = derived(
@@ -231,59 +321,72 @@ function createSession({ fs, os, left, right, host, bookmarks } = {}) {
 	)
 
 	// 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.bookmarkMode, session.panelOpen, session.panelPicking],
+		([filtering, bookmarkOpen, bookmarkMode, panelOpen, panelPicking]) =>
+			getCommandBarItems({ filtering, bookmarkOpen, bookmarkMode, panelOpen, panelPicking }),
 	)
 
-	// 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.panelPickerMode],
+		([entries, mode]) => (mode === "dir" ? (entries ?? []).filter((entry) => entry.isDir) : entries ?? []),
+	)
+	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)),
+	)
+	// 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)),
 	)
-	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.
+	// prefixed with the entry name; a `«NAME»` marks a required argument still
+	// to fill.
 	session.panelCommand = derived(
-		[session.panelDraft, session.panelOperation],
-		([draft, op]) => {
+		[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 = op?.name ?? ""
+			const name = entry?.name ?? ""
 			return args ? `${name} ${args}` : name
 		},
 	)
 	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 +399,85 @@ 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(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)
 	})
-	// Typing a query re-anchors the operation cursor on the first match.
+	// 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 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.
+	effect([session.pickerQuery], ([query]) => {
+		session.pickerPane.setFilter(`${query ?? ""}`)
+		if (session.panelPicking.value) session.panelRowIndex.set(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.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: 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)
+}
+
 function entrySummary(entry) {
 	if (!entry) return null
 	return {
@@ -373,15 +494,22 @@ 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: 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
@@ -402,4 +530,4 @@ function hasBinaryByte(text) {
 	return false
 }
 
-export { createSession, load }
+export { createSession, load, previewSource }

package/src/js/tcmd/index.js

@@ -44,7 +44,6 @@ export {
 	prefix,
 	rankEntries,
 	runLine,
-	scriptItems,
 	sortEntries,
 	split,
 	toggleMark,