@brimveyn/aimux 1.20.4 → 1.22.0

package/src/state/reducers/tab-state.ts

@@ -1,4 +1,5 @@
-import type { AppAction, AppState, TabSession } from '../types'
+import type { AppAction } from '../actions'
+import type { AppState, TabSession } from '../types'
 
 import {
   allLeafIds,
@@ -14,12 +15,13 @@ import {
   setSplitRatio,
   splitNode,
 } from '../layout-tree'
-import { normalizeGroupedTabOrder } from '../session-persistence'
+import { normalizeGroupedTabOrder } from '../project-persistence'
 import {
-  filterTabsForActiveWorktree,
-  orderTabsByWorktree,
-  withActiveWorktree,
-} from '../session-worktrees'
+  clearWorkspaceDone,
+  filterTabsForActiveWorkspace,
+  orderTabsByWorkspace,
+  withActiveWorkspace,
+} from '../project-workspaces'
 import { createDefaultTerminalModes } from '../terminal-modes'
 
 const MAX_BUFFER_LENGTH = 50_000
@@ -197,47 +199,61 @@ function getActiveIndex(state: AppState): number {
   return state.tabs.findIndex((tab) => tab.id === state.activeTabId)
 }
 
-function getCurrentSession(state: AppState) {
-  return state.currentSessionId != null && state.currentSessionId !== ''
-    ? state.sessions.find((session) => session.id === state.currentSessionId)
+function getCurrentProject(state: AppState) {
+  return state.currentProjectId != null && state.currentProjectId !== ''
+    ? state.projects.find((project) => project.id === state.currentProjectId)
     : undefined
 }
 
-function withActiveTabWorktree(
+function withActiveTabWorkspace(
   state: AppState,
   tabId: string | null,
   opts?: { onlyIfMissing?: boolean }
 ): AppState {
-  if (
-    tabId == null ||
-    tabId === '' ||
-    !(state.currentSessionId != null && state.currentSessionId !== '')
-  )
-    return state
-  const tab = state.tabs.find((entry) => entry.id === tabId)
-  if (!(tab?.worktreeId != null && tab?.worktreeId !== '')) return state
-  const worktreeId = tab.worktreeId
-  // When `onlyIfMissing` is set, we leave the session's worktree alone if it
-  // already points at a known worktree. Used by `hydrate-workspace` so that
-  // a backend re-attach after a user-initiated worktree switch (j/k cycling)
-  // doesn't clobber the freshly chosen worktree by re-syncing from the
+  if (tabId == null || tabId === '') return state
+  // Opening the tab is reading its notification, whatever else this helper
+  // decides about the workspace. Every path that makes a tab the active one
+  // goes through here.
+  const seen = { ...state, tabs: clearTabUnseen(state.tabs, tabId) }
+  if (!(seen.currentProjectId != null && seen.currentProjectId !== '')) return seen
+  const tab = seen.tabs.find((entry) => entry.id === tabId)
+  if (!(tab?.workspaceId != null && tab?.workspaceId !== '')) return seen
+  const workspaceId = tab.workspaceId
+  // Opening one of a workspace's tabs is seeing that workspace, so it drops the
+  // finished-a-turn tick — otherwise a background tab finishing in the workspace
+  // you are already in leaves a ✓ that only a workspace switch could clear.
+  const workspaceActivity = clearWorkspaceDone(seen.workspaceActivity, workspaceId)
+  // When `onlyIfMissing` is set, we leave the project's workspace alone if it
+  // already points at a known workspace. Used by `hydrate-project` so that
+  // a backend re-attach after a user-initiated workspace switch (j/k cycling)
+  // doesn't clobber the freshly chosen workspace by re-syncing from the
   // restored active tab.
   if (opts?.onlyIfMissing === true) {
-    const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
-    const hasValidWorktree =
-      session?.activeWorktreeId != null &&
-      session.activeWorktreeId !== '' &&
-      (session.worktrees?.some((w) => w.id === session.activeWorktreeId) ?? false)
-    if (hasValidWorktree) return state
+    const project = seen.projects.find((entry) => entry.id === seen.currentProjectId)
+    const hasValidWorkspace =
+      project?.activeWorkspaceId != null &&
+      project.activeWorkspaceId !== '' &&
+      (project.workspaces?.some((w) => w.id === project.activeWorkspaceId) ?? false)
+    if (hasValidWorkspace) return { ...seen, workspaceActivity }
   }
   return {
-    ...state,
-    sessions: state.sessions.map((session) =>
-      session.id === state.currentSessionId ? withActiveWorktree(session, worktreeId) : session
+    ...seen,
+    projects: seen.projects.map((project) =>
+      project.id === seen.currentProjectId ? withActiveWorkspace(project, workspaceId) : project
     ),
+    workspaceActivity,
   }
 }
 
+/**
+ * Drop one tab's unseen mark. Returns the same array when it holds none, so a
+ * caller can run it on every activation without re-rendering the tab list.
+ */
+function clearTabUnseen(tabs: TabSession[], tabId: string): TabSession[] {
+  if (!tabs.some((tab) => tab.id === tabId && tab.unseen === true)) return tabs
+  return tabs.map((tab) => (tab.id === tabId ? { ...tab, unseen: undefined } : tab))
+}
+
 function closeTabAtIndex(state: AppState, indexToClose: number): AppState {
   if (indexToClose < 0 || indexToClose >= state.tabs.length) {
     return state
@@ -262,7 +278,12 @@ function closeTabAtIndex(state: AppState, indexToClose: number): AppState {
           getAdjacentLeaf(groupTree, closingTabId, 'down') ??
           getAdjacentLeaf(groupTree, closingTabId, 'up'))
         : null
-    nextActiveTabId = layoutNeighbor ?? tabs[indexToClose]?.id ?? tabs[indexToClose - 1]?.id ?? null
+    // Positional fallbacks must skip hidden tabs: landing `activeTabId` on one
+    // would render a pane the user cannot see in any tab bar.
+    const positional = [tabs[indexToClose], tabs[indexToClose - 1]].find(
+      (tab) => tab !== undefined && tab.hidden !== true
+    )
+    nextActiveTabId = layoutNeighbor ?? positional?.id ?? null
   } else {
     nextActiveTabId = tabs.find((tab) => tab.id === state.activeTabId)?.id ?? null
   }
@@ -292,7 +313,7 @@ function closeTabAtIndex(state: AppState, indexToClose: number): AppState {
     }
   }
 
-  return withActiveTabWorktree(
+  return withActiveTabWorkspace(
     {
       ...state,
       activeTabId: nextActiveTabId,
@@ -309,35 +330,41 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
   switch (action.type) {
     case 'add-tab': {
       const newTab = { ...action.tab, activity: action.tab.activity ?? 'idle' }
-      return withActiveTabWorktree(
+      // A hidden tab is chrome-invisible, so adding it must be invisible too:
+      // no focus steal, no modal dismissal, and — critically — no workspace
+      // re-sync, which would teleport a user sitting on another workspace.
+      if (newTab.hidden === true) {
+        return { ...state, tabs: [...state.tabs, newTab] }
+      }
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: newTab.id,
           focusMode: 'navigation',
-          modal: { editBuffer: null, selectedIndex: 0, sessionTargetId: null, type: null },
+          modal: { editBuffer: null, projectTargetId: null, selectedIndex: 0, type: null },
           tabs: [...state.tabs, newTab],
         },
         newTab.id
       )
     }
-    case 'hydrate-workspace': {
-      // The session's activeWorktreeId may have just been switched by the
+    case 'hydrate-project': {
+      // The project's activeWorkspaceId may have just been switched by the
       // user (j/k cycle, sidebar click) before the backend attached. Honor
-      // that choice by only considering tabs visible in that worktree —
+      // that choice by only considering tabs visible in that workspace —
       // otherwise we'd land the active tab on whatever the backend picked
-      // (typically the worktree we *last* persisted, not the current one).
-      const currentSession =
-        state.currentSessionId != null && state.currentSessionId !== ''
-          ? state.sessions.find((s) => s.id === state.currentSessionId)
+      // (typically the workspace we *last* persisted, not the current one).
+      const currentProject =
+        state.currentProjectId != null && state.currentProjectId !== ''
+          ? state.projects.find((s) => s.id === state.currentProjectId)
           : undefined
-      const visibleForWorktree = filterTabsForActiveWorktree(action.tabs, currentSession)
-      const visibleIds = new Set(visibleForWorktree.map((t) => t.id))
+      const visibleForWorkspace = filterTabsForActiveWorkspace(action.tabs, currentProject)
+      const visibleIds = new Set(visibleForWorkspace.map((t) => t.id))
       const hydratedActiveTabId =
         action.activeTabId != null &&
         action.activeTabId !== '' &&
         visibleIds.has(action.activeTabId)
           ? action.activeTabId
-          : (visibleForWorktree[0]?.id ?? null)
+          : (visibleForWorkspace[0]?.id ?? null)
       const tabIds = new Set(action.tabs.map((t) => t.id))
 
       // Restore from new multi-tree format or migrate from legacy single tree
@@ -368,7 +395,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         }
       }
 
-      return withActiveTabWorktree(
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: hydratedActiveTabId,
@@ -389,24 +416,24 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
     case 'close-active-tab':
       return closeTabAtIndex(state, getActiveIndex(state))
     case 'set-active-tab':
-      return withActiveTabWorktree({ ...state, activeTabId: action.tabId }, action.tabId)
+      return withActiveTabWorkspace({ ...state, activeTabId: action.tabId }, action.tabId)
     case 'move-active-tab': {
       if (state.tabs.length === 0) {
         return state
       }
-      const session = getCurrentSession(state)
-      const visibleTabs = filterTabsForActiveWorktree(state.tabs, session)
+      const project = getCurrentProject(state)
+      const visibleTabs = filterTabsForActiveWorkspace(state.tabs, project)
       if (visibleTabs.length === 0) {
         return state
       }
-      const orderedTabs = orderTabsByWorktree(visibleTabs, session)
+      const orderedTabs = orderTabsByWorkspace(visibleTabs, project)
       const currentIndex = orderedTabs.findIndex((tab) => tab.id === state.activeTabId)
       const safeIndex = currentIndex === -1 ? 0 : currentIndex
       const nextIndex = (safeIndex + action.delta + orderedTabs.length) % orderedTabs.length
       const nextTabId = orderedTabs[nextIndex]?.id
       return nextTabId == null || nextTabId === '' || nextTabId === state.activeTabId
         ? state
-        : withActiveTabWorktree({ ...state, activeTabId: nextTabId }, nextTabId)
+        : withActiveTabWorkspace({ ...state, activeTabId: nextTabId }, nextTabId)
     }
     case 'reorder-active-tab': {
       const activeIndex = getActiveIndex(state)
@@ -436,8 +463,14 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         return { ...state, tabs }
       }
 
-      // Standalone tab reorder
-      const nextIndex = activeIndex + action.delta
+      // Standalone tab reorder. Step over hidden tabs rather than swapping with
+      // one: the swap would look like a dead keypress and shuffle the hidden
+      // tab out of its append-order slot.
+      let nextIndex = activeIndex + action.delta
+      const step = action.delta < 0 ? -1 : 1
+      while (state.tabs[nextIndex]?.hidden === true) {
+        nextIndex += step
+      }
       if (nextIndex < 0 || nextIndex >= state.tabs.length) {
         return state
       }
@@ -473,7 +506,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       // Drag-and-drop reorder of the visible tab strip. `orderedTabIds` is the
       // flattened new order of the currently-visible tabs (group members already
       // expanded into contiguous runs). We only rewrite the slots those tabs
-      // occupy in `state.tabs`, leaving tabs from other worktrees anchored in
+      // occupy in `state.tabs`, leaving tabs from other workspaces anchored in
       // place. Because group members arrive contiguous, splits stay intact.
       const visibleSet = new Set(action.orderedTabIds)
       const byId = new Map(state.tabs.map((tab) => [tab.id, tab]))
@@ -486,8 +519,8 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       })
       return { ...state, tabs }
     }
-    case 'reset-tab-session':
-      return withActiveTabWorktree(
+    case 'reset-tab-project':
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: action.tabId,
@@ -527,7 +560,20 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
     case 'set-tab-activity':
       return {
         ...state,
-        tabs: updateTab(state.tabs, action.tabId, (tab) => ({ ...tab, activity: action.activity })),
+        tabs: updateTab(state.tabs, action.tabId, (tab) => ({
+          ...tab,
+          activity: action.activity,
+          // Back to work: whatever it wanted to tell you is out of date.
+          unseen:
+            action.activity === 'working' || action.activity === 'waiting-input'
+              ? undefined
+              : tab.unseen,
+        })),
+      }
+    case 'mark-tab-unseen':
+      return {
+        ...state,
+        tabs: updateTab(state.tabs, action.tabId, (tab) => ({ ...tab, unseen: true })),
       }
     case 'set-tab-error':
       return {
@@ -555,6 +601,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
         tabs: updateTab(state.tabs, action.tabId, (tab) => ({
           ...tab,
           autoRenameStatus: action.autoRenameStatus ?? tab.autoRenameStatus,
+          hidden: action.hidden ?? tab.hidden,
           title: action.title ?? tab.title,
         })),
       }
@@ -590,7 +637,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       }
       const tabs = [...state.tabs.slice(0, insertIndex), newTab, ...state.tabs.slice(insertIndex)]
 
-      return withActiveTabWorktree(
+      return withActiveTabWorkspace(
         {
           ...state,
           activeTabId: newTab.id,
@@ -621,7 +668,7 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       if (!(neighbor != null && neighbor !== '')) {
         return state
       }
-      return withActiveTabWorktree({ ...state, activeTabId: neighbor }, neighbor)
+      return withActiveTabWorkspace({ ...state, activeTabId: neighbor }, neighbor)
     }
     case 'resize-pane': {
       const resizeGroupId = getGroupIdForTab(state.tabGroupMap, action.tabId)

package/src/state/reducers/ui-state.ts

@@ -1,21 +1,92 @@
-import type { AppAction, AppState } from '../types'
+import type { AppAction } from '../actions'
+import type { AppState, BarSide, BarState, BarWidget } from '../types'
+
+import {
+  boundaryDeltaFromRatio,
+  clampBarWidth,
+  findWidgetBar,
+  shiftBoundary,
+  visibleWidgets,
+} from '../bars'
+
+function withBar(state: AppState, side: BarSide, next: BarState): AppState {
+  if (next === state.bars[side]) return state
+  return { ...state, bars: { ...state.bars, [side]: next } }
+}
+
+function setBarWidth(state: AppState, side: BarSide, width: number): AppState {
+  const bar = state.bars[side]
+  const next = clampBarWidth(width)
+  if (next === bar.width) return state
+  return withBar(state, side, { ...bar, width: next })
+}
+
+/**
+ * Move `widgetId` to `side` at `index`. Covers both cross-bar moves and
+ * in-bar reordering — removing then re-inserting is the same operation.
+ */
+function moveWidget(state: AppState, widgetId: string, side: BarSide, index: number): AppState {
+  const from = findWidgetBar(state.bars, widgetId)
+  if (from === null) return state
+  const widget = state.bars[from].widgets.find((w) => w.id === widgetId)
+  if (!widget) return state
+
+  const source = state.bars[from].widgets.filter((w) => w.id !== widgetId)
+  const target: BarWidget[] = from === side ? source : [...state.bars[side].widgets]
+  const at = Math.max(0, Math.min(target.length, index))
+  target.splice(at, 0, widget)
+
+  const bars = { ...state.bars }
+  bars[from] = { ...state.bars[from], widgets: from === side ? target : source }
+  // Showing a widget in a hidden bar would silently swallow it.
+  bars[side] = { ...bars[side], visible: bars[side].visible || widget.visible, widgets: target }
+  return { ...state, bars }
+}
 
 export function reduceUIState(state: AppState, action: AppAction): AppState | null {
   switch (action.type) {
-    case 'toggle-sidebar':
-      return { ...state, sidebar: { ...state.sidebar, visible: !state.sidebar.visible } }
-    case 'resize-sidebar': {
-      const width = Math.min(
-        state.sidebar.maxWidth,
-        Math.max(state.sidebar.minWidth, state.sidebar.width + action.delta)
+    case 'toggle-bar': {
+      const bar = state.bars[action.side]
+      return withBar(state, action.side, { ...bar, visible: !bar.visible })
+    }
+    case 'resize-bar':
+      return setBarWidth(state, action.side, state.bars[action.side].width + action.delta)
+    case 'set-bar-width':
+      return setBarWidth(state, action.side, action.width)
+    case 'toggle-widget': {
+      const side = findWidgetBar(state.bars, action.widgetId)
+      if (side === null) return state
+      const bar = state.bars[side]
+      const widgets = bar.widgets.map((w) =>
+        w.id === action.widgetId ? { ...w, visible: !w.visible } : w
       )
-      if (width === state.sidebar.width) return state
-      return { ...state, sidebar: { ...state.sidebar, width } }
+      const revealed = widgets.some((w) => w.id === action.widgetId && w.visible)
+      return withBar(state, side, { ...bar, visible: bar.visible || revealed, widgets })
+    }
+    case 'move-widget':
+      return moveWidget(state, action.widgetId, action.side, action.index)
+    case 'set-bar-boundary': {
+      const bar = state.bars[action.side]
+      const delta = boundaryDeltaFromRatio(bar, action.index, action.ratio)
+      const widgets = shiftBoundary(bar, action.index, delta)
+      if (widgets === bar.widgets) return state
+      return withBar(state, action.side, { ...bar, widgets })
     }
-    case 'set-sidebar-width': {
-      const width = Math.min(state.sidebar.maxWidth, Math.max(state.sidebar.minWidth, action.width))
-      if (width === state.sidebar.width) return state
-      return { ...state, sidebar: { ...state.sidebar, width } }
+    case 'resize-widget': {
+      // Keyboard resize: grow/shrink this widget against its neighbour. The
+      // widget below owns the boundary above it, so the sign flips there.
+      const side = findWidgetBar(state.bars, action.widgetId)
+      if (side === null) return state
+      const bar = state.bars[side]
+      const visible = visibleWidgets(bar)
+      const at = visible.findIndex((w) => w.id === action.widgetId)
+      if (at === -1) return state
+      const total = visible.reduce((sum, w) => sum + w.grow, 0)
+      const index = at > 0 ? at - 1 : at
+      const deltaGrow = action.delta * total * (at > 0 ? -1 : 1)
+      const widgets = shiftBoundary(bar, index, deltaGrow)
+      if (widgets === bar.widgets) return state
+      return withBar(state, side, { ...bar, widgets })
     }
     case 'set-focus-mode':
       return { ...state, focusMode: action.focusMode }
@@ -29,10 +100,10 @@ export function reduceUIState(state: AppState, action: AppAction): AppState | nu
         return state
       }
       return { ...state, pendingChords: action.chords }
-    case 'toggle-session-bar':
+    case 'toggle-project-bar':
       return {
         ...state,
-        sessionBar: { ...state.sessionBar, visible: !state.sessionBar.visible },
+        projectBar: { ...state.projectBar, visible: !state.projectBar.visible },
       }
     default:
       return null

package/src/state/selectors.ts

@@ -1,38 +1,39 @@
-import type { AssistantOption } from '../pty/command-registry'
-import type { AssistantId, SessionRecord, SnippetRecord, WorktreeRecord } from './types'
+import type { ProjectRecord, SnippetRecord, WorkspaceRecord } from './types'
+
+import { type AssistantOption, getAllAssistantOptions } from '../pty/command-registry'
 
 export interface BaseRefOption {
-  /** Git ref the new worktree is forked from. */
+  /** Git ref the new workspace is forked from. */
   ref: string
   label: string
-  kind: 'worktree' | 'branch'
-  /** Worktree name, for the 'worktree' kind. */
+  kind: 'workspace' | 'branch'
+  /** Workspace name, for the 'workspace' kind. */
   detail?: string
 }
 
 /**
- * Ordered, filtered base-ref candidates for the worktree-create "Base" picker:
- * branches checked out in the session's worktrees first (labelled with the
- * worktree name), then the remaining local branches. A branch already surfaced
- * via a worktree is not repeated. Throwaway `aimux/` branches are skipped unless
- * a live worktree is on them — `git worktree remove` leaves the branch behind,
- * so deleted temp worktrees would otherwise haunt the list as orphan branches.
+ * Ordered, filtered base-ref candidates for the workspace-create "Base" picker:
+ * branches checked out in the project's workspaces first (labelled with the
+ * workspace name), then the remaining local branches. A branch already surfaced
+ * via a workspace is not repeated. Throwaway `aimux/` branches are skipped unless
+ * a live workspace is on them — `git worktree remove` leaves the branch behind,
+ * so deleted temp workspaces would otherwise haunt the list as orphan branches.
  */
 export function buildBaseRefOptions(
-  worktrees: WorktreeRecord[],
+  workspaces: WorkspaceRecord[],
   localBranches: string[],
   query: string
 ): BaseRefOption[] {
   const seen = new Set<string>()
   const options: BaseRefOption[] = []
-  for (const worktree of worktrees) {
-    if (worktree.branch == null || worktree.branch === '' || seen.has(worktree.branch)) continue
-    seen.add(worktree.branch)
+  for (const workspace of workspaces) {
+    if (workspace.branch == null || workspace.branch === '' || seen.has(workspace.branch)) continue
+    seen.add(workspace.branch)
     options.push({
-      detail: worktree.name,
-      kind: 'worktree',
-      label: worktree.branch,
-      ref: worktree.branch,
+      detail: workspace.name,
+      kind: 'workspace',
+      label: workspace.branch,
+      ref: workspace.branch,
     })
   }
   for (const branch of localBranches) {
@@ -45,16 +46,6 @@ export function buildBaseRefOptions(
   return options.filter((option) => option.label.toLowerCase().includes(trimmed))
 }
 
-/**
- * 0 when the template picker should NOT show the "None" fallback (no assistant
- * was picked — typical for the template shortcut path), 1 otherwise. Shared
- * by the modal reducer, the side-effect that resolves templateId, and the
- * picker UI so the three stay in sync.
- */
-export function getTemplateNoneOffset(selectedAssistantId: AssistantId | null): 0 | 1 {
-  return selectedAssistantId == null ? 0 : 1
-}
-
 export function filterAssistants(
   options: AssistantOption[],
   filter: string | null
@@ -66,18 +57,39 @@ export function filterAssistants(
   )
 }
 
-export function filterSessions(sessions: SessionRecord[], filter: string | null): SessionRecord[] {
+/**
+ * Assistants offered by the new-tab picker. One source of truth on purpose: the
+ * modal renders this list while `launch-selected-assistant` indexes into it, so
+ * a divergence launches the row above or below the one the user highlighted.
+ *
+ * Chained from `<C-p>`, the prompt is pasted into the assistant and drives the
+ * workspace's name — neither of which a plain shell can do — so Terminal is not
+ * offered there. A bare `<C-n>` still lists it.
+ */
+export function getNewTabAssistantOptions(
+  customCommands: Record<string, string>,
+  filter: string | null,
+  excludeTerminal: boolean
+): AssistantOption[] {
+  const all = getAllAssistantOptions(customCommands)
+  return filterAssistants(
+    excludeTerminal ? all.filter((option) => option.id !== 'terminal') : all,
+    filter
+  )
+}
+
+export function filterProjects(projects: ProjectRecord[], filter: string | null): ProjectRecord[] {
   if (!(filter != null && filter !== '')) {
-    return sessions
+    return projects
   }
 
   const lower = filter.toLowerCase()
-  return sessions.filter(
-    (session) =>
-      session.name.toLowerCase().includes(lower) ||
-      (session.projectPath != null &&
-        session.projectPath !== '' &&
-        session.projectPath.toLowerCase().includes(lower))
+  return projects.filter(
+    (project) =>
+      project.name.toLowerCase().includes(lower) ||
+      (project.projectPath != null &&
+        project.projectPath !== '' &&
+        project.projectPath.toLowerCase().includes(lower))
   )
 }