@ssebastien/tcmd 0.1.2 → 0.1.4

package/src/js/tcmd/core/pane.js

@@ -6,8 +6,11 @@
 // Module: tcmd/core/pane
 // A Pane is one column with a single directory: it owns that directory and
 // proxies its cells (path, entries, cursor, marks, disk, …) as pane-level
-// cells, so views and commands address the pane directly. Navigation is async
-// and updates the directory's `rawEntries` in place.
+// cells, so views and commands address the pane directly. Navigation reads the
+// target first and commits atomically (see `core/directory#read`), so the pane
+// keeps showing its current listing until the replacement is ready. The pane
+// also owns its navigation history (back/forward snapshots of the view), which
+// the session drives to restore position, selection and focus.
 
 import { cell } from "select/state/cells"
 import { createDirectory } from "./directory.js"
@@ -22,6 +25,23 @@ const PANE_BUFFERS = { left: "A", right: "B" }
 // destination (DST).
 const PANE_LABELS = { left: "SRC", right: "DST" }
 
+// Function: currentPaneId
+// The id of the pane that owns the current directory: the focused pane while
+// focus is on source/destination, the anchor pane otherwise.
+function currentPaneId(session) {
+	return session.currentId?.value ?? session.active?.value ?? "left"
+}
+
+// Function: currentPane
+// The pane that owns the current directory: the focused pane while focus is
+// on source/destination, the anchor pane while it is on an auxiliary column
+// (see `core/session`). Path-changing commands — open, up, history,
+// breadcrumbs, relative arguments — target it; only cursor movement follows
+// the focused column. `core/commands` keeps `pane()` for the latter.
+function currentPane(session) {
+	return session.panes[currentPaneId(session)] ?? session.panes.left
+}
+
 // Function: createPane
 // Creates a pane bound to a filesystem adapter at `path`.
 //
@@ -31,10 +51,10 @@ const PANE_LABELS = { left: "SRC", right: "DST" }
 // await pane.refresh()
 // pane.entries.value // sorted, filtered FileEntry[]
 // ```
-function createPane({ fs, path: initialPath } = {}) {
+function createPane({ fs, path: initialPath, context } = {}) {
 	const pane = {}
 	pane.fs = fs
-	pane.directory = createDirectory({ fs, path: initialPath })
+	pane.directory = createDirectory({ fs, path: initialPath, context })
 
 	// Proxy cells mirror the directory, so views address the pane uniformly.
 	const dir = pane.directory
@@ -46,29 +66,32 @@ function createPane({ fs, path: initialPath } = {}) {
 	pane.sort = dir.sort
 	pane.entries = dir.entries
 	pane.cursor = dir.cursor
-	pane.cursorStat = dir.cursorStat
 	pane.marked = dir.marked
 	pane.disk = dir.disk
 	pane.segments = dir.segments
+	pane.history = dir.history
 
 	// Function: current
 	// The pane's directory.
 	pane.current = () => pane.directory
 
 	// Function: refresh / navigate / up / open / back / forward /
-	// currentEntry / toggleMark / clearFilter — delegate to the directory.
+	// currentEntry / toggleMark / setFilter / clearFilter — delegate to the
+	// directory.
 	pane.refresh = () => pane.directory.refresh()
-	pane.navigate = (path) => pane.directory.navigate(path)
+	pane.navigate = (path, options) => pane.directory.navigate(path, options)
 	pane.up = () => pane.directory.up()
 	pane.open = () => pane.directory.open()
 	pane.back = () => pane.directory.back()
 	pane.forward = () => pane.directory.forward()
 	pane.currentEntry = () => pane.directory.currentEntry()
 	pane.toggleMark = () => pane.directory.toggleMark()
+	pane.setFilter = (query) => pane.directory.setFilter(query)
 	pane.clearFilter = () => pane.directory.clearFilter()
+	pane.setContext = (context) => pane.directory.setContext(context)
 	pane.dispose = () => pane.directory.dispose()
 
 	return pane
 }
 
-export { PANE_BUFFERS, PANE_LABELS, createPane }
+export { PANE_BUFFERS, PANE_LABELS, createPane, currentPane, currentPaneId }

package/src/js/tcmd/core/panel.js

@@ -4,14 +4,17 @@
 // Created: 2026-10-09
 
 // Module: tcmd/core/panel
-// The command panel (Commando): a structured view over the operation registry.
-// It lists the operations alphabetically — ranked by match importance once a
-// query filters them (see `filterPanelOperations`) — and, for the selected
-// one, its arguments bound from
-// the live context — a selection argument shows the SRC/DST pane's marked paths
-// (falling back to the cursor entry) and lets the user toggle individual items;
-// a destination argument resolves to the DST pane's directory; textual
-// arguments (a name, a buffer label, a shell command) are typed in place.
+// The command panel (Commando): the one entry point for the CLI operations
+// (`copy`, `move`, `rename`, `delete`, `run` — the `core/operations` registry).
+// They are listed flat in one column, ranked by match importance once a query
+// filters them (see `filterPanelEntries`). The internal TinyCmd actions are not
+// listed here — they live on their own keys.
+//
+// For the selected operation, the panel binds its arguments from the live
+// context — a selection argument shows the SRC/DST pane's marked paths (falling
+// back to the cursor entry) and lets the user toggle individual items; a
+// destination argument resolves to the DST pane's directory; textual arguments
+// (a name, a buffer label, a shell command) are typed in place.
 //
 // The selection the user tweaks is *transient*: it lives in the draft bindings
 // (`session.panelDraft`), never in the real pane marks. When the draft runs,
@@ -23,71 +26,100 @@
 // `core/commands` assemble and run.
 
 import { hasMatch, score } from "../vendor/fzy.js"
-import { PANE_BUFFERS, PANE_LABELS } from "./pane.js"
+import { currentPaneId, PANE_BUFFERS, PANE_LABELS } from "./pane.js"
 import { basename, parent } from "./path.js"
 import { getOperations, pathToken } from "./operations.js"
 
 // Constant: PANEL_FOCUS
-// The two columns the panel's focus ring moves through: "ops" (the operation
-// list, where typing filters) and "args" (an argument row, where Space toggles
-// and a textual argument owns the keyboard).
+// The two regions the panel's focus ring moves through: "ops" (the filter and
+// the command list on the left) and "args" (an argument row or item in the
+// right pane, where a textual argument owns the keyboard and Space toggles a
+// selection item).
 const PANEL_FOCUS = { OPS: "ops", ARGS: "args" }
 
-// Function: panelOperations
-// The operations the panel lists: every visible registry entry that carries a
-// structured `args` signature (the ones that take arguments).
-function panelOperations() {
-	return getOperations().filter((op) => !op.hidden && Array.isArray(op.args))
+// Function: panelEntries
+// The entries the panel lists: the CLI operations. They are the only namespace
+// — the internal TinyCmd actions are reached by their own keys, not the panel.
+function panelEntries() {
+	return getOperations()
+		.filter((op) => !op.hidden)
+		.map((op) => ({
+			id: `op:${op.name}`,
+			name: op.name,
+			summary: `${op.signature ?? ""}`.replace(/^\S+\s*/, ""),
+			signature: op.signature ?? "",
+			risk: op.risk ?? null,
+			matchNames: [op.name, ...(op.aliases ?? [])],
+			op,
+		}))
 }
 
-// Function: compareOperations
-// Alphabetical order by name, the panel's default ordering.
-function compareOperations(a, b) {
+// Function: compareEntries
+// The panel's default ordering: alphabetically by name.
+function compareEntries(a, b) {
 	return `${a?.name ?? ""}`.localeCompare(`${b?.name ?? ""}`)
 }
 
-// Function: operationScore
-// The match importance of an operation for a query: the best fzy score across
-// its name and aliases, or `-Infinity` when neither matches (only the
-// signature does). Signature hits stay listable but rank below any name
-// match.
-function operationScore(op, query) {
+// Function: entryScore
+// The match importance of an entry for a query: the best fzy score across its
+// names, or `-Infinity` when none matches (only the signature does).
+function entryScore(entry, query) {
 	let best = -Infinity
-	for (const name of [op.name, ...(op.aliases ?? [])]) {
-		if (hasMatch(query, name)) best = Math.max(best, score(query, name))
+	for (const name of entry.matchNames ?? []) {
+		const haystack = `${name}`.toLowerCase()
+		if (hasMatch(query, haystack)) best = Math.max(best, score(query, haystack))
 	}
 	return best
 }
 
-// Function: filterPanelOperations
-// Narrows the operation list by a typed query and orders it: no query lists
-// every operation alphabetically; a query ranks the matches by importance
-// (the fzy score of the best name/alias match, so `open` outranks `copy` for
-// `op`), ties broken alphabetically. A query that only matches an operation's
-// signature (`buf` -> `sel [+|-][BUF] PATH...`) keeps it listable, at the
-// bottom.
-function filterPanelOperations(operations, query) {
-	const list = operations ?? []
+// Function: filterPanelEntries
+// Narrows the entry list by a typed query and orders it: no query lists the
+// operations alphabetically; a query ranks the matches by importance (the fzy
+// score of the best name match, so `open` outranks `copy` for `op`), ties
+// alphabetical. A query that only matches an operation's signature (`buf` ->
+// `sel [+|-][BUF] PATH...`) keeps it listable, at the bottom.
+function filterPanelEntries(entries, query) {
+	const list = entries ?? []
 	const q = `${query ?? ""}`.trim().toLowerCase()
-	if (!q) return [...list].sort(compareOperations)
+	if (!q) return [...list].sort(compareEntries)
 	const ranked = []
-	for (const op of list) {
-		const rank = operationScore(op, q)
-		const signatureMatch = `${op.signature ?? ""}`.toLowerCase().includes(q)
+	for (const entry of list) {
+		const rank = entryScore(entry, q)
+		const signatureMatch = `${entry.signature ?? ""}`.toLowerCase().includes(q)
 		if (rank === -Infinity && !signatureMatch) continue
-		ranked.push({ op, score: rank })
+		ranked.push({ entry, score: rank })
 	}
-	ranked.sort((a, b) => (a.score !== b.score ? b.score - a.score : compareOperations(a.op, b.op)))
-	return ranked.map((match) => match.op)
+	ranked.sort((a, b) => (a.score !== b.score ? b.score - a.score : compareEntries(a.entry, b.entry)))
+	return ranked.map((match) => match.entry)
+}
+
+// Function: panelEntryRows
+// Projects the filtered entries into the flat list the command-list column
+// renders: one `op` row per entry, tagged with its index in the *entries* list
+// (what the cursor `panelOpIndex` addresses).
+function panelEntryRows(entries) {
+	return (entries ?? []).map((entry, index) => ({
+		type: "op",
+		id: entry.id,
+		entryIndex: index,
+		name: entry.name,
+		summary: entry.summary,
+		risk: entry.risk,
+	}))
 }
 
 // Function: resolvePaneId
-// Maps an argument role to a pane id: "source" -> SRC (left), "dest" -> DST
-// (right), anything else -> the active pane.
+// Maps an argument role to a pane id: "source" -> the working pane (SRC in
+// commander; the pane the explorer is actually browsing, which may be either
+// side), "dest" -> DST (right), anything else -> the pane holding the current
+// directory (never an auxiliary column: operations run against the directory
+// being browsed).
 function resolvePaneId(session, role) {
-	if (role === "source") return "left"
 	if (role === "dest") return "right"
-	return session.active.value
+	if (role === "source") {
+		return session.viewMode?.value === "explorer" ? currentPaneId(session) : "left"
+	}
+	return currentPaneId(session)
 }
 
 // Function: paneSelectionPaths
@@ -136,7 +168,8 @@ function bindArg(session, arg, index) {
 		role,
 		optional: arg.optional === true,
 		variadic: arg.variadic === true,
-		textual: arg.kind === "literal" || arg.kind === "raw" || arg.kind === "buffer",
+		textual:
+			arg.kind === "literal" || arg.kind === "raw" || arg.kind === "buffer" || arg.kind === "path",
 	}
 	if (arg.kind === "selection") {
 		const paneId = resolvePaneId(session, role)
@@ -145,26 +178,37 @@ function bindArg(session, arg, index) {
 		return {
 			...common,
 			paneId,
+			// A variadic selection accepts many marked paths (checkboxes); a
+			// single-path argument accepts one (a radio list).
+			multi: arg.variadic === true,
 			items: paneSelectionPaths(pane).map((path) => itemFor(entries, path)),
 			value: "",
 		}
 	}
-	if (arg.kind === "dest") {
-		const pane = session.panes.right
-		const path = pane?.path?.value ?? ""
-		// The destination is editable in place, like a literal (no toggles).
-		return { ...common, paneId: "right", textual: true, items: [], value: path }
+	if (arg.kind === "dest" || arg.kind === "path") {
+		// A destination or a path argument is typeable in place, like a
+		// literal, and additionally browsable through the panel's file picker
+		// (`picker: true`, opened with `panel.browse`). In commander mode the
+		// DST pane is the natural destination, so a directory argument
+		// pre-fills from it; explorer mode has no destination pane, so it opens
+		// empty for the picker (or the user) to fill.
+		const mode = arg.kind === "dest" ? "dir" : arg.mode ?? "any"
+		const commander = (session.viewMode?.value ?? "commander") !== "explorer"
+		const value = mode === "dir" && commander ? session.panes?.right?.path?.value ?? "" : ""
+		return { ...common, textual: true, picker: true, mode, items: [], value }
 	}
 	if (arg.kind === "buffer") {
-		return { ...common, items: [], value: `+${PANE_BUFFERS[session.active.value] ?? "A"}` }
+		const label = PANE_BUFFERS[session.currentId?.value ?? session.active.value] ?? "A"
+		return { ...common, items: [], value: `+${label}` }
 	}
 	return { ...common, items: [], value: "" }
 }
 
 // Function: bindArgs
-// Binds every argument of `op` to the live context.
-function bindArgs(session, op) {
-	return (op?.args ?? []).map((arg, index) => bindArg(session, arg, index))
+// Binds every argument of the selected entry to the live context. Every
+// operation carries an `args` signature.
+function bindArgs(session, entry) {
+	return (entry?.op?.args ?? []).map((arg, index) => bindArg(session, arg, index))
 }
 
 // Function: selectedPaths
@@ -200,23 +244,31 @@ function argvFor(bindings) {
 	return args
 }
 
-// Function: missingArg
-// The name of the first argument that is not runnable: a required argument left
-// blank, an optional one before a filled one (a positional gap would shift the
-// following tokens), or a selection with nothing selected. Returns null when the
-// argv is runnable.
-function missingArg(bindings) {
+// Function: missingBinding
+// The first binding that is not runnable: a required argument left blank, an
+// optional one before a filled one (a positional gap would shift the following
+// tokens), or a selection with nothing selected. Returns null when the argv is
+// runnable. The panel uses it both to flag an unrunnable draft and to focus the
+// next thing to fill when Enter lands on an incomplete command.
+function missingBinding(bindings) {
 	const list = bindings ?? []
 	const args = argTokens(list)
 	for (let i = 0; i < args.length - 1; i++) {
-		if (args[i] === "") return list[i].name
+		if (args[i] === "") return list[i]
 	}
 	// A trailing required argument must still be filled.
 	const trailing = list[list.length - 1]
-	if (trailing && args[args.length - 1] === "" && trailing.optional !== true) return trailing.name
+	if (trailing && args[args.length - 1] === "" && trailing.optional !== true) return trailing
 	return null
 }
 
+// Function: missingArg
+// The name of the first argument that is not runnable (see `missingBinding`),
+// or null when the argv is runnable.
+function missingArg(bindings) {
+	return missingBinding(bindings)?.name ?? null
+}
+
 // Function: shellQuote
 // Quotes a token for display as it would appear in a shell: bare when it is
 // already safe (`/home/a`), single-quoted when it contains spaces or shell
@@ -269,41 +321,56 @@ function panelSummary(binding) {
 		const count = selectedPaths(binding).length
 		return `${pane} · ${count} selected`
 	}
-	if (binding.kind === "dest") return binding.value || "(none)"
+	if (binding.kind === "dest" || binding.kind === "path") return binding.value || "(none)"
 	if (binding.kind === "buffer") return binding.value || "(active)"
 	return binding.value ? binding.value : "(empty)"
 }
 
 // Function: panelRowList
-// Flattens the draft into the rows the panel's argument column renders: one
-// header row per argument, followed by one item row per item of a
-// selection/destination argument (so individual paths can be toggled). Row
-// focus is assigned by the view (comparing the row index to the cursor), the
-// same way list rows are; this stays pure and index-stable.
+// Flattens the draft into the rows the panel's right-hand argument pane
+// renders: one header row per argument (its label and value/summary),
+// followed by one item row per selected path of a selection argument (so
+// individual paths can be toggled). A variadic selection shows checkboxes
+// (`[x]`/`[ ]`); a single-path one shows radios (`(•)`/`( )`). Row focus is
+// assigned by the view (comparing the row index to the cursor), the same way
+// list rows are; this stays pure and index-stable.
 function panelRowList(bindings) {
 	const rows = []
 	for (const binding of bindings ?? []) {
+		const multi = binding.multi === true
+		const items = binding.items ?? []
+		// A selection that resolves to a single path is not a list: it renders
+		// as a pre-filled, read-only path (no checkbox/radio to pick from).
+		const single = items.length === 1
 		rows.push({
 			type: "arg",
 			key: `arg:${binding.index}`,
+			rowIndex: rows.length,
 			argIndex: binding.index,
 			itemIndex: -1,
 			name: binding.name,
-			summary: panelSummary(binding),
+			summary: single ? items[0].path : panelSummary(binding),
 			kind: binding.kind,
 			role: binding.role,
 			optional: binding.optional,
 			variadic: binding.variadic,
 			textual: binding.textual,
+			picker: binding.picker === true,
+			mode: binding.mode ?? null,
+			multi,
+			readonly: single,
 			value: binding.value,
-			count: (binding.items ?? []).length,
+			count: items.length,
 		})
-		for (let i = 0; i < (binding.items ?? []).length; i++) {
-			const item = binding.items[i]
+		if (single) continue
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i]
 			const selected = item.selected
+			const marker = multi ? (selected ? "[x]" : "[ ]") : selected ? "(•)" : "( )"
 			rows.push({
 				type: "item",
 				key: `item:${binding.index}:${item.path}`,
+				rowIndex: rows.length,
 				argIndex: binding.index,
 				itemIndex: i,
 				name: item.name,
@@ -311,7 +378,8 @@ function panelRowList(bindings) {
 				parent: item.parent ?? "",
 				isDir: item.isDir,
 				selected,
-				marker: selected ? "[x]" : "[ ]",
+				multi,
+				marker,
 			})
 		}
 	}
@@ -324,6 +392,23 @@ function rowAt(rows, index) {
 	return (rows ?? [])[index] ?? null
 }
 
+// Function: pickerRowList
+// Flattens the picker's visible listing into the rows the panel's argument
+// column renders while a path is being picked. The shape mirrors a
+// file-listing row (`name`, `path`, `isDir`) so the shared row component can
+// render both; a symlink carries its raw target for the summary.
+function pickerRowList(entries) {
+	return (entries ?? []).map((entry) => ({
+		type: "entry",
+		key: entry.path,
+		name: entry.name,
+		path: entry.path,
+		isDir: entry.isDir === true,
+		isSymlink: entry.isSymlink === true,
+		target: entry.target ?? null,
+	}))
+}
+
 // Function: isTextualRow
 // True when the cursor row is an argument header that takes free text, so the
 // panel focuses its edit field.
@@ -333,12 +418,13 @@ function isTextualRow(row) {
 
 // Function: withToggledItem
 // Returns a new draft with item `itemIndex` of argument `argIndex` toggled,
-// leaving the other bindings untouched.
-function withToggledItem(draft, argIndex, itemIndex) {
+// leaving the other bindings untouched. A single-path argument (`multi` false)
+// is a radio list: choosing one selects it alone.
+function withToggledItem(draft, argIndex, itemIndex, multi = true) {
 	return (draft ?? []).map((binding) => {
 		if (binding.index !== argIndex) return binding
 		const items = (binding.items ?? []).map((item, i) =>
-			i === itemIndex ? { ...item, selected: !item.selected } : item,
+			multi ? (i === itemIndex ? { ...item, selected: !item.selected } : item) : { ...item, selected: i === itemIndex },
 		)
 		return { ...binding, items }
 	})
@@ -365,17 +451,21 @@ export { decodePathToken, pathToken } from "./operations.js"
 export {
 	PANEL_FOCUS,
 	argvFor,
+	bindArg,
 	bindArgs,
 	bindingAt,
-	filterPanelOperations,
+	filterPanelEntries,
 	isTextualRow,
 	missingArg,
+	missingBinding,
 	panelCommand,
-	panelOperations,
+	panelEntries,
+	panelEntryRows,
 	panelRowList,
 	panelRunnable,
 	panelSummary,
 	paneSelectionPaths,
+	pickerRowList,
 	rowAt,
 	selectedPaths,
 	withArgValue,

package/src/js/tcmd/core/script.js

@@ -4,13 +4,13 @@
 // Created: 2026-09-27
 
 // Module: tcmd/core/script
-// The scripting language behind the command palette's scripting mode (`:`):
-// line tokenizer, operation parser and runner, plus the completion rows the
-// palette lists. A line starts with an operation name (or the `!` alias for
-// `run`); arguments may be filesets ($A, $B, $FILE), quoted paths, `~` or
-// paths relative to the active pane.
+// The TinyCmd scripting language: line tokenizer, operation parser and runner.
+// A line starts with an operation name (or the `!` alias for `run`); arguments
+// may be filesets ($A, $B, $FILE), quoted paths, `~` or paths relative to the
+// active pane. The command panel runs operations structurally and delegates to
+// the same `runLine` through `runOperation`.
 
-import { getOperation, getOperations, humanSize, runOperation } from "./operations.js"
+import { getOperation, runOperation } from "./operations.js"
 
 // Function: tokenize
 // Whitespace tokenizer with single/double quotes and backslash escapes.
@@ -93,94 +93,6 @@ async function runLine(session, line, options = {}) {
 	return runOperation(session, parsed.op, parsed.args, { ...options, line })
 }
 
-// Function: scriptItems
-// Palette rows for scripting mode: the session's available filesets first,
-// then every operation, then matching entries of the active pane (path
-// completion). Rows carry the full query replacement `completion` for Tab.
-function scriptItems(query, filesets, context = {}) {
-	const text = `${query ?? ""}`
-	const q = text.trim().toLowerCase()
-	const head = q.split(/\s+/)[0] ?? ""
-	const rows = []
-	const typingFileset = lastToken(q).startsWith("$")
-	for (const set of filesets ?? []) {
-		const id = set.id.toLowerCase()
-		if (head && !id.includes(head) && !q.includes(id) && !typingFileset) continue
-		rows.push({
-			id: set.id,
-			title: set.id,
-			kind: "fileset",
-			detail: `${set.count} file${set.count === 1 ? "" : "s"}`,
-			completion: completeFileset(text, set.id),
-		})
-	}
-	for (const op of getOperations()) {
-		if (op.hidden) continue
-		const names = [op.name, ...(op.aliases ?? [])]
-		const matchesName = !head || names.some((name) => name.toLowerCase().includes(head))
-		if (!matchesName && !op.signature.toLowerCase().includes(q)) continue
-		rows.push({
-			id: `op:${op.name}`,
-			title: op.name,
-			kind: "op",
-			detail: op.signature,
-			description: op.description,
-			completion: q.includes(" ") ? text.replace(/^\S+/, op.name) : `${op.name} `,
-		})
-	}
-	const last = lastToken(q)
-	const token = lastToken(text)
-	if (token && !token.startsWith("$")) {
-		const at = token.lastIndexOf("/")
-		const dirPart = at >= 0 ? token.slice(0, at + 1) : ""
-		const prefix = (at >= 0 ? token.slice(at + 1) : token).toLowerCase()
-		for (const entry of context.entries ?? []) {
-			if (!entry.name.toLowerCase().startsWith(prefix)) continue
-			const name = entry.isDir ? `${entry.name}/` : entry.name
-			rows.push({
-				id: `path:${entry.path}`,
-				title: name,
-				kind: "path",
-				detail: entry.isDir ? "dir" : humanSize(entry.size),
-				completion: replaceLastToken(text, `${dirPart}${name}`),
-			})
-		}
-	}
-	return rows
-}
-
-// Function: lastToken
-// The last whitespace-separated token, case preserved.
-function lastToken(text) {
-	const match = /(\S+)\s*$/.exec(`${text ?? ""}`)
-	return match ? match[1] : ""
-}
-
-// Function: completionToken
-// For a query whose last token contains "/", the directory part to read and
-// the name prefix being completed; null when the token is not a path.
-function completionToken(query) {
-	const token = lastToken(query)
-	if (!token || token.startsWith("$")) return null
-	const at = token.lastIndexOf("/")
-	if (at < 0) return null
-	return { dir: token.slice(0, at) || "/", prefix: token.slice(at + 1) }
-}
-
-// Function: replaceLastToken
-// Replaces the (possibly empty) last whitespace-separated token.
-function replaceLastToken(text, replacement) {
-	const match = /(\S*)\s*$/.exec(text)
-	return `${text.slice(0, match.index)}${replacement}`
-}
-
-// Function: completeFileset
-// Replaces the `$…` token being typed, or appends the fileset.
-function completeFileset(text, id) {
-	if (/\$\w*$/.test(text.trimEnd())) return replaceLastToken(text, id)
-	return `${text} ${id}`.trim()
-}
-
-export { completionToken, parseLine, runLine, scriptItems, tokenize }
+export { parseLine, runLine, tokenize }
 
 // EOF

package/src/js/tcmd/core/selection.js

@@ -26,6 +26,14 @@ function currentEntry(entries, cursor) {
 	return entries[cursor]
 }
 
+// Function: indexOfPath
+// The index of the entry whose path is `path`, or -1. Navigations that must
+// land on a known element use it: the directory `up` stepped out of, the
+// current directory in a mirror's listing.
+function indexOfPath(entries, path) {
+	return entries.findIndex((entry) => entry.path === path)
+}
+
 // Function: toggleMark
 // Returns a new Set with `path` toggled in `marks`.
 function toggleMark(marks, path) {
@@ -38,6 +46,6 @@ function toggleMark(marks, path) {
 	return next
 }
 
-export { clampCursor, currentEntry, moveCursor, toggleMark }
+export { clampCursor, currentEntry, indexOfPath, moveCursor, toggleMark }
 
 // EOF