@ssebastien/tcmd 0.1.3 → 0.1.7

package/src/js/tcmd/components/App.js

@@ -4,11 +4,13 @@
 // Created: 2026-09-26
 
 // Module: tcmd/components/App
-// Root component: a header, two panes (breadcrumbs + FileList + summary each),
-// an optional preview column, the command bar and the command palette overlay.
+// Root component: a header, two panes (breadcrumbs + FileList + detail each),
+// an optional preview column, the command bar and the command panel overlay.
 // App is the controller seam: component events (published bubbles) and key
 // chords are translated into `session.dispatch(commandId, payload)` calls; it
-// never mutates model state directly.
+// never mutates model state directly. It also owns the shared modal key
+// routing — the fullscreen viewer overlay included — so both renderers behave
+// alike.
 //
 // Environment: `normalizeKey(event)` (optional; identity when omitted) and
 // `quit(self)`. Renderer-specific bindings (pane borders, status color) live in
@@ -17,31 +19,40 @@
 import { derived, unwrap } from "select/state/cells"
 import { DEFAULT_KEYMAP, matchKeymap } from "../core/keymap.js"
 import { PANEL_FOCUS } from "../core/panel.js"
+import { isNarrow } from "./Frame.js"
+
+// Constant: DOUBLE_CLICK_MS
+// Two clicks on the same listing row within this window count as a double
+// click, which opens the row like Enter (see `createEvents#list:select`).
+const DOUBLE_CLICK_MS = 400
 
 // Function: createInit
 // State initializer binding the root component to a `session`.
 function createInit(session) {
 	const left = session.panes.left
 	const right = session.panes.right
+	const parent = session.panes.parent ?? {}
+	const preview = session.panes.preview ?? {}
 	// Pane-focus flags so the listing can render the cursor differently in the
 	// inactive pane. Shared by both engines.
 	const leftActive = derived([session.active], ([active]) => active === "left")
 	const rightActive = derived([session.active], ([active]) => active === "right")
+	const parentActive = derived([session.active], ([active]) => active === "parent")
+	const previewActive = derived([session.active], ([active]) => active === "preview")
 	return () => ({
 		active: session.active,
-		// The preview target entry, so the inspector can show a directory card
-		// even when there is no text/card preview.
+		// The preview target entry, so the inspector can show a directory
+		// column even when there is no text/card preview.
 		appEntry: session.previewEntry,
 		appHost: session.host,
 		appPath: session.activePath,
 		bookmarkIndex: session.bookmarkIndex,
 		bookmarkItems: session.bookmarkItems,
-		bookmarkMode: session.bookmarkMode,
 		bookmarkOpen: session.bookmarkOpen,
 		bookmarkQuery: session.bookmarkQuery,
-		bookmarkTarget: session.bookmarkTarget,
 		commandBarItems: session.commandBarItems,
 		confirm: session.confirm,
+		currentId: session.currentId,
 		dispatch: session.dispatch,
 		filtering: session.filtering,
 		leftActive,
@@ -55,28 +66,53 @@ function createInit(session) {
 		leftLoading: left.loading,
 		leftMarked: left.marked,
 		leftSegments: left.segments,
+		leftSetFilter: (value) => left.setFilter(value),
 		notice: session.notice,
-		paletteIndex: session.paletteIndex,
-		paletteItems: session.paletteItems,
-		paletteMode: session.paletteMode,
-		paletteOpen: session.paletteOpen,
-		paletteQuery: session.paletteQuery,
-		panelCommand: session.panelCommand,
+		// The shared list overlay (`u` history / `⇧T` trash).
+		overlay: session.overlay,
+		overlayIndex: session.overlayIndex,
+		overlayItems: session.overlayItems,
 		panelDraft: session.panelDraft,
 		panelCursorRow: session.panelCursorRow,
+		panelEntry: session.panelEntry,
 		panelFiltered: session.panelFiltered,
 		panelFocus: session.panelFocus,
 		panelOpIndex: session.panelOpIndex,
 		panelItems: session.panelItems,
 		panelOpen: session.panelOpen,
-		panelOperation: session.panelOperation,
+		panelPermBit: session.panelPermBit,
+		panelPreview: session.panelPreview,
 		panelQuery: session.panelQuery,
 		panelRowIndex: session.panelRowIndex,
 		panelRows: session.panelRows,
-		panelRunnable: session.panelRunnable,
 		panelTextual: session.panelTextual,
 		panelValue: session.panelValue,
+		// The explorer's first column: the parent of the current directory.
+		parentActive,
+		parentCursor: parent.cursor,
+		parentDisk: parent.disk,
+		parentEntries: parent.entries,
+		parentEntry: session.parentCursorEntry,
+		parentError: parent.error,
+		parentFilter: parent.filter,
+		parentId: "parent",
+		parentLoading: parent.loading,
+		parentMarked: parent.marked,
+		parentSegments: parent.segments,
+		parentSetFilter: (value) => parent.setFilter(value),
 		preview: session.preview,
+		previewFull: session.previewFull,
+		// The full previews apply body scroll requests through this cell.
+		previewScroll: session.previewScroll,
+		// The third column: the directory the inspector previews, so it reads
+		// as a pane. Over a file the inspector stays a card and these idle.
+		previewActive,
+		previewCursor: preview.cursor,
+		previewEntries: preview.entries,
+		previewId: "preview",
+		previewLoading: preview.loading,
+		previewMarked: preview.marked,
+		previewSegments: preview.segments,
 		rightActive,
 		rightCursor: right.cursor,
 		rightDisk: right.disk,
@@ -88,52 +124,149 @@ function createInit(session) {
 		rightLoading: right.loading,
 		rightMarked: right.marked,
 		rightSegments: right.segments,
+		rightSetFilter: (value) => right.setFilter(value),
 		showPreview: session.showPreview,
+		viewMode: session.viewMode,
+		// The panel's file picker: its open mode, editable path, focus region
+		// and rows, so the panel can render the picker view.
+		pickerOpen: session.pickerOpen,
+		pickerPathText: session.pickerPathText,
+		pickerFocus: session.pickerFocus,
+		pickerRows: session.pickerRows,
+		pickerQuery: session.pickerQuery,
 	})
 }
 
+// Function: fieldOwnsKeys
+// True when one of the panel's inputs owns the keyboard: the command filter
+// (`PANEL_FOCUS.OPS`) or a textual argument's value field (`panelTextual`).
+// While an input owns the keyboard the shared handler leaves text editing to
+// it — typing, Backspace, Delete, caret movement. A plain argument row or an
+// item row has no input pressed, so the handler handles the key itself.
+function fieldOwnsKeys(data, focus) {
+	return focus === PANEL_FOCUS.OPS || Boolean(unwrap(data.panelTextual))
+}
+
+// Function: isFilePreview
+// True when the inspector shows a file — a text body or a metadata card — as
+// opposed to a directory column, which keeps its listing cursor navigation.
+function isFilePreview(data) {
+	const entry = unwrap(data.appEntry)
+	return Boolean(entry) && !entry.isDir
+}
+
+// Function: routePreviewKeys
+// The arrows of a full preview: Up/Down scroll the body, Left/Right step to
+// the previous/next entry (the cursor movement the preview already follows).
+// Returns true when the key was handled, so the caller can stop routing.
+function routePreviewKeys(data, key) {
+	if (!isFilePreview(data)) return false
+	const name = key?.name
+	if (name === "up" || name === "down") {
+		data.dispatch("preview.scroll", { delta: name === "up" ? -1 : 1 })
+		return true
+	}
+	if (name === "left" || name === "right") {
+		data.dispatch(name === "left" ? "nav.up" : "nav.down")
+		return true
+	}
+	return false
+}
+
 // Function: createBehaviors
 // Builds the App data/key behavior map for the given renderer environment.
 // Published events are registered separately via `createEvents()` (`.sub`).
 function createBehaviors(env) {
 	return {
-		// Global key handling: confirm dialogs first, palette mode, then the
-		// keymap.
+		// Global key handling: the fullscreen viewer modal first, then confirm
+		// dialogs, the command panel, and finally the keymap.
 		keys: (self, data, event) => {
 			const key = env.normalizeKey ? env.normalizeKey(event) : event
+			// The fullscreen inspector overlay is modal at any width: it opens
+			// from Enter on a file the host cannot edit (see `core/commands`)
+			// and from `v` below the inline breakpoint (below). While open it
+			// owns the keyboard — Esc or `v` closes it, ⇧O/⇧E act on the file,
+			// everything else is swallowed.
+			if (unwrap(data.viewerOpen)) {
+				if (key?.name === "escape" || (key?.name === "v" && !key.shift)) {
+					data.dispatch("view.toggleViewer")
+				} else if (key?.shift && key?.name === "o") {
+					data.dispatch("file.open", { paneId: unwrap(data.active) })
+				} else if (key?.shift && key?.name === "e") {
+					data.dispatch("file.edit", { paneId: unwrap(data.active) })
+				} else {
+					routePreviewKeys(data, key)
+				}
+				return
+			}
 			if (unwrap(data.confirm)) {
 				const name = key?.name
 				if (name === "y" || name === "return" || name === "enter") data.dispatch("confirm.yes")
 				else if (name === "n" || name === "escape") data.dispatch("confirm.no")
 				return
 			}
-			if (unwrap(data.paletteOpen)) {
-				if (key?.name === "escape") {
-					data.dispatch("palette.toggle")
-					return
-				}
-				if (key?.name === "up") {
-					data.dispatch("palette.up")
-					return
-				}
-				if (key?.name === "down") {
-					data.dispatch("palette.down")
-					return
-				}
-				if (key?.name === "tab") {
-					// Shift-Tab walks the palette list backwards.
-					data.dispatch(key.shift ? "palette.up" : "palette.complete")
-					return
-				}
-				if (key?.name === "return" || key?.name === "enter") {
-					self.pub("palette:confirm", `${unwrap(data.paletteQuery) ?? ""}`)
+			if (unwrap(data.panelOpen)) {
+				// The picker is a sub-mode of the panel: its editable path owns
+				// typing, and the entry list owns navigation once focused.
+				if (unwrap(data.pickerOpen)) {
+					const field = unwrap(data.pickerFocus) === "rows" ? "rows" : "path"
+					if (key?.name === "escape") {
+						data.dispatch("picker.cancel")
+						return
+					}
+					if (key?.name === "tab") {
+						data.dispatch(field === "path" ? "picker.focusRows" : "picker.focusPath")
+						return
+					}
+					if (field === "path") {
+						// Typing, Backspace and caret movement belong to the path
+						// input. Up/Down hand over to the entries, Enter commits
+						// the typed path.
+						if (key?.name === "up" || key?.name === "down") {
+							data.dispatch("picker.focusRows")
+							return
+						}
+						if (key?.name === "return" || key?.name === "enter") {
+							data.dispatch("picker.path")
+							return
+						}
+						return
+					}
+					if (key?.name === "up") {
+						data.dispatch("picker.up")
+						return
+					}
+					if (key?.name === "down") {
+						data.dispatch("picker.down")
+						return
+					}
+					if (key?.name === "left") {
+						data.dispatch("picker.focusPath")
+						return
+					}
+					if (key?.name === "right") {
+						data.dispatch("picker.descend")
+						return
+					}
+					if (key?.name === "backspace") {
+						// An empty path (the current directory) steps up; a
+						// typed fragment is edited in the path input instead.
+						if (`${unwrap(data.pickerQuery) ?? ""}` === "") data.dispatch("picker.parent")
+						return
+					}
+					if (key?.name === "return" || key?.name === "enter") {
+						data.dispatch(key.ctrl ? "picker.chooseDir" : "picker.enter")
+						return
+					}
+					// Typing anywhere in the picker narrows the path.
+					const char = key?.name === "space" ? " " : key?.name
+					if (char && char.length === 1 && !key.ctrl && !key.meta) {
+						data.dispatch("picker.type", { char })
+					}
 					return
 				}
-				// Let the focused input handle typing.
-				return
-			}
-			if (unwrap(data.panelOpen)) {
 				const focus = unwrap(data.panelFocus)
+				const fieldOwns = fieldOwnsKeys(data, focus)
 				// Escape closes; Tab cycles the focus ring (command ⇄ args);
 				// arrows move within the focused column; Enter runs the command.
 				if (key?.name === "escape") {
@@ -152,29 +285,40 @@ function createBehaviors(env) {
 					data.dispatch(focus === PANEL_FOCUS.ARGS ? "panel.nextArg" : "panel.down")
 					return
 				}
+				if (key?.name === "o" && key.ctrl) {
+					// Browse a path/destination argument in the file picker.
+					data.dispatch("panel.browse")
+					return
+				}
 				if (key?.name === "return" || key?.name === "enter") {
-					// A focused textual-argument field owns Enter (its `on:enter`
-					// publishes `panel:confirm`), so the command is not run twice.
-					if (focus === PANEL_FOCUS.ARGS && unwrap(data.panelTextual)) return
-					// Enter runs the highlighted command with the current draft.
+					// Enter runs a complete command, or walks to the next
+					// missing field (see `panel.run`); the root routes it for
+					// every renderer, so no per-input `on:enter` is needed.
 					data.dispatch("panel.run")
 					return
 				}
-				// Space toggles a selection item in the argument column.
-				if (key?.name === "space" && focus === PANEL_FOCUS.ARGS && !unwrap(data.panelTextual)) {
+				// While an input owns the keyboard (the command filter, or a
+				// textual argument's value field) it also owns text editing:
+				// typing, Backspace, Delete and caret movement pass through to
+				// it. Intercepting Backspace here used to bounce the cursor
+				// back to the command filter mid-edit.
+				if (fieldOwns) return
+				// A focused permission row: Left/Right walk its r/w/x cells.
+				if ((key?.name === "left" || key?.name === "right") && focus === PANEL_FOCUS.ARGS) {
+					data.dispatch("panel.moveBit", { delta: key.name === "left" ? -1 : 1 })
+					return
+				}
+				// A focused non-textual argument row: Space toggles its
+				// selection, any other printable key jumps back to the command
+				// filter and appends the character; Backspace edits the filter.
+				if (key?.name === "space") {
 					data.dispatch("panel.toggleItem")
 					return
 				}
-				if (key?.name === "backspace" && focus === PANEL_FOCUS.ARGS) {
-					// Editing the command filter from the argument column.
+				if (key?.name === "backspace") {
 					data.dispatch("panel.type", { backspace: true })
 					return
 				}
-				// While the command column is focused, or a textual argument
-				// owns the cursor, the focused input handles typing.
-				if (focus !== PANEL_FOCUS.ARGS || unwrap(data.panelTextual)) return
-				// Typing on a non-textual argument jumps back to the command
-				// filter and appends the character.
 				if (key?.name && key.name.length === 1 && !key.ctrl && !key.meta) {
 					data.dispatch("panel.type", { char: key.name })
 					return
@@ -182,20 +326,14 @@ function createBehaviors(env) {
 				return
 			}
 			if (unwrap(data.bookmarkOpen)) {
-				const mode = unwrap(data.bookmarkMode)
+				// One panel: the filter input owns typing, arrows move the
+				// list, Enter activates the row. Backspace edits the query while
+				// it has text and removes the selected bookmark once it is
+				// empty; Delete always removes.
 				if (key?.name === "escape") {
 					data.dispatch("bookmark.cancel")
 					return
 				}
-				if (mode === "name") {
-					// The input owns typing; Enter saves.
-					if (key?.name === "return" || key?.name === "enter") {
-						self.pub("bookmark:confirm")
-						return
-					}
-					return
-				}
-				// List mode: arrows move, Enter jumps.
 				if (key?.name === "up") {
 					data.dispatch("bookmark.up")
 					return
@@ -204,11 +342,42 @@ function createBehaviors(env) {
 					data.dispatch("bookmark.down")
 					return
 				}
+				if (key?.name === "delete") {
+					data.dispatch("bookmark.remove")
+					return
+				}
+				if (key?.name === "backspace" && !`${unwrap(data.bookmarkQuery) ?? ""}`.trim()) {
+					data.dispatch("bookmark.remove")
+					return
+				}
 				if (key?.name === "return" || key?.name === "enter") {
 					self.pub("bookmark:confirm")
 					return
 				}
-				// Let the focused input handle typing the fuzzy query.
+				// Let the focused input handle typing the filter.
+				return
+			}
+			// The shared list overlay (history / trash) is modal: arrows move,
+			// Enter activates the row (jump in history, restore from trash), Esc
+			// closes. The key that opened it also closes it.
+			if (unwrap(data.overlay)) {
+				const mode = unwrap(data.overlay)
+				if (key?.name === "escape" || (key?.name === "u" && mode === "history") || (key?.name === "t" && key?.shift && mode === "trash")) {
+					data.dispatch("overlay.cancel")
+					return
+				}
+				if (key?.name === "up") {
+					data.dispatch("overlay.up")
+					return
+				}
+				if (key?.name === "down") {
+					data.dispatch("overlay.down")
+					return
+				}
+				if (key?.name === "return" || key?.name === "enter") {
+					data.dispatch("overlay.activate")
+					return
+				}
 				return
 			}
 			const active = unwrap(data.active)
@@ -244,21 +413,34 @@ function createBehaviors(env) {
 			// filter (or on Shift-Esc) the keymap decides — Esc steps back
 			// through the pane's directory history.
 			if (key?.name === "escape" && !key.shift) {
-				const filter = active === "left" ? unwrap(data.leftFilter) : unwrap(data.rightFilter)
+				const filters = {
+					left: data.leftFilter,
+					parent: data.parentFilter,
+					right: data.rightFilter,
+				}
+				const filter = unwrap(filters[active])
 				if (filter) {
 					data.dispatch("filter.clear")
 					return
 				}
 			}
+			// The maximized inspector (`⇧V`) previews a file full-width: the
+			// arrows scroll and step through files instead of driving the pane
+			// underneath. A directory column keeps its listing navigation.
+			if (unwrap(data.previewFull) && routePreviewKeys(data, key)) return
+			// Below the inline breakpoint the viewer overlay replaces the side
+			// panel, so `v` opens it instead of toggling `showPreview` (⇧V
+			// still maximizes over the columns, via the keymap).
+			if (key?.name === "v" && !key?.shift && isNarrow(data, self)) {
+				data.dispatch("view.toggleViewer")
+				return
+			}
 			const id = matchKeymap(DEFAULT_KEYMAP, key)
 			if (!id) return
 			if (id === "app.quit") {
 				env.quit(self)
 				return
 			}
-			// The command panel is a TUI-only view; the web renderer omits the
-			// capability so `m` never opens an invisible modal there.
-			if (id === "panel.toggle" && !env.panel) return
 			data.dispatch(id, { paneId: unwrap(data.active) })
 		},
 	}
@@ -266,90 +448,133 @@ function createBehaviors(env) {
 
 // Function: createEvents
 // App event subscriptions, registered with `.sub(...)`. Handlers receive
-// `(self, data, event)` with the published payload in `event.data`. The
-// environment carries the renderer's `quit` hook, so the command bar's Quit
-// entry takes the same path as the `q` key.
-function createEvents(env = {}) {
+// `(self, data, event)` with the published payload in `event.data`.
+function createEvents() {
+	// Last listing row clicked, for the double-click-to-open gesture: a second
+	// click on the same row within `DOUBLE_CLICK_MS` opens it like Enter.
+	let lastRowClick = { paneId: null, index: -1, at: 0 }
 	return {
-		"commandbar:run": (_self, data, event) => {
-			if (event.data === "app.quit") {
-				env.quit?.(_self)
+		"commandbar:run": (self, data, event) => {
+			// Below the inline breakpoint the bar's `[Preview v]` opens the
+			// viewer overlay, the same as the key (see `createBehaviors#keys`).
+			if (event.data === "view.togglePreview" && isNarrow(data, self)) {
+				data.dispatch("view.toggleViewer")
 				return
 			}
 			if (event.data) data.dispatch(event.data)
 		},
 		"panel:select": (_self, data, event) => {
-			// Clicking an operation row moves the cursor to it; clicking an
-			// argument/item row focuses the argument column (toggling an item).
+			// Clicking a command row moves the cursor to it (a group header is
+			// inert); clicking an argument/item row focuses the right pane
+			// (toggling an item); clicking a picker row chooses or navigates it.
 			const items = unwrap(data.panelItems) ?? []
-			const index = items.findIndex((row) => row.id === event.data)
-			if (index >= 0) {
-				data.dispatch("panel.setOp", { index })
+			const item = items.find((row) => row.key === event.data)
+			if (item?.type === "op") {
+				data.dispatch("panel.setOp", { index: item.entryIndex })
 				return
 			}
+			if (item) return
 			const rows = unwrap(data.panelRows) ?? []
 			const rowIndex = rows.findIndex((row) => row.key === event.data)
 			if (rowIndex < 0) return
+			const row = rows[rowIndex]
+			if (row?.type === "entry" || row?.type === "parent") {
+				data.dispatch("panel.focusArg")
+				data.dispatch("picker.setCursor", { index: rowIndex })
+				data.dispatch(row.type === "parent" ? "picker.parent" : "picker.enter")
+				return
+			}
+			if (row?.type === "run") {
+				data.dispatch("panel.focusArg")
+				data.dispatch("panel.setRow", { index: rowIndex })
+				data.dispatch("panel.run")
+				return
+			}
+			// A read-only value (a single-path selection, resolved from the
+			// pane) is a path worth copying: clicking it sends the value to the
+			// host clipboard. Copy runs last so its confirmation is not cleared
+			// by the focus dispatches (each dispatch resets the notice).
 			data.dispatch("panel.focusArg")
 			data.dispatch("panel.setRow", { index: rowIndex })
-			const row = rows[rowIndex]
 			if (row?.type === "item") data.dispatch("panel.toggleItem")
+			if (row?.type === "arg" && row.readonly === true && row.summary) {
+				data.dispatch("panel.copy", { text: row.summary })
+			}
 		},
 		"panel:confirm": (_self, data) => {
+			// Published by a focused panel input's `on:enter`; the key handler
+			// leaves Enter to it (see `fieldOwnsKeys`).
 			if (!unwrap(data.panelOpen)) return
+			if (unwrap(data.pickerOpen)) {
+				data.dispatch("picker.enter")
+				return
+			}
 			data.dispatch("panel.run")
 		},
+		"panel:perm": (_self, data, event) => {
+			// A click on one r/w/x cell: focus its class row, then toggle the
+			// bit. The payload is `argIndex:itemIndex:rowIndex` (see
+			// `core/panel#panelRowList`).
+			const [argIndex, itemIndex, rowIndex] = `${event.data ?? ""}`.split(":").map(Number)
+			if (![argIndex, itemIndex, rowIndex].every(Number.isInteger)) return
+			data.dispatch("panel.focusArg")
+			data.dispatch("panel.setRow", { index: rowIndex })
+			data.dispatch("panel.togglePerm", { argIndex, itemIndex })
+		},
+		"panel:close": (_self, data) => {
+			// The dialog's upper-right close shorthand: back out of the picker
+			// sub-mode first, otherwise close the panel.
+			if (!unwrap(data.panelOpen)) return
+			data.dispatch(unwrap(data.pickerOpen) ? "picker.cancel" : "panel.cancel")
+		},
 		"crumbs:go": (_self, data, event) => {
 			// The "…" truncation marker carries no path.
 			if (!event.data?.path) return
 			data.dispatch("pane.setPath", event.data)
 		},
-		"list:select": (_self, data, event) => data.dispatch("list.cursor", event.data),
+		"list:select": (_self, data, event) => {
+			const paneId = event.data?.paneId
+			const index = event.data?.index
+			const now = Date.now()
+			// A click selects (focus + cursor); a second click on the same row
+			// within the window opens it like Enter. `list.cursor` activates the
+			// pane synchronously, so `pane.enter` then acts on the clicked pane.
+			const isDouble =
+				paneId === lastRowClick.paneId &&
+				index === lastRowClick.index &&
+				now - lastRowClick.at <= DOUBLE_CLICK_MS
+			lastRowClick = { paneId, index, at: isDouble ? 0 : now }
+			data.dispatch("list.cursor", event.data)
+			if (isDouble) data.dispatch("pane.enter", { paneId })
+		},
 		"pane:activate": (_self, data, event) => data.dispatch("pane.activate", { paneId: event.data }),
+		// Clicking the identity bar's view-mode word flips explorer/commander.
+		"view:toggleMode": (_self, data) => data.dispatch("view.toggleMode"),
 		"bookmark:select": (_self, data, event) => {
-			// Clicking a bookmark row selects and jumps to it.
+			// Clicking a bookmark (or the add) row selects and activates it.
 			if (!unwrap(data.bookmarkOpen)) return
 			const items = unwrap(data.bookmarkItems) ?? []
-			const index = items.findIndex((row) => row.name === event.data)
+			const index = items.findIndex((row) => row.key === event.data)
 			if (index < 0) return
 			data.dispatch("bookmark.setIndex", { index })
 			data.dispatch("bookmark.select")
 		},
 		"bookmark:confirm": (_self, data) => {
 			if (!unwrap(data.bookmarkOpen)) return
-			if (unwrap(data.bookmarkMode) === "name") data.dispatch("bookmark.save")
-			else data.dispatch("bookmark.select")
-		},
-		"palette:confirm": (_self, data, event) => {
-			// The global key handler and the input's on:enter can both fire;
-			// only the first one (while the palette is open) acts.
-			if (!unwrap(data.paletteOpen)) return
-			if (unwrap(data.paletteMode) === "script") {
-				// Submit the typed line: run it, or complete the highlighted row
-				// when the input is empty.
-				data.dispatch("palette.submit")
-				return
-			}
-			const items = unwrap(data.paletteItems) ?? []
-			const index = Math.max(0, Math.min(unwrap(data.paletteIndex) ?? 0, items.length - 1))
-			const match = items[index] ?? items[0]
-			if (match?.id) data.dispatch(match.id)
-			data.dispatch("palette.toggle")
+			data.dispatch("bookmark.select")
 		},
-		"palette:run": (_self, data, event) => {
-			if (!event.data) return
-			if (unwrap(data.paletteMode) === "script") {
-				// Clicking a script row completes it; running stays on Enter.
-				const item = (unwrap(data.paletteItems) ?? []).find((row) => row.id === event.data)
-				if (item?.completion) data.dispatch("palette.setQuery", { query: item.completion })
-				return
-			}
-			data.dispatch(event.data)
-			data.dispatch("palette.toggle")
+		"overlay:select": (_self, data, event) => {
+			// Clicking an overlay row moves the cursor to it and activates it.
+			if (!unwrap(data.overlay)) return
+			const rows = unwrap(data.overlayItems) ?? []
+			const index = rows.findIndex((row) => row.key === event.data)
+			if (index < 0) return
+			data.dispatch("overlay.setIndex", { index })
+			data.dispatch("overlay.activate")
 		},
 	}
 }
 
-export { createBehaviors, createEvents, createInit }
+export { createBehaviors, createEvents, createInit, DOUBLE_CLICK_MS }
 
 // EOF