@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/renderer/src/hooks.ts

@@ -0,0 +1,574 @@
+import { useEffect, useLayoutEffect, useMemo, useRef, useCallback, useState, useSyncExternalStore } from 'react'
+import { useTranslation } from 'react-i18next'
+import { useAppStore } from './store'
+import { getAppliedThemeId, subscribeAppliedTheme } from './utils/theme'
+import { DEFAULT_SETTINGS } from '../../shared/default-settings'
+import { BUILTIN_SOURCE, type PiCommand } from '../../shared/pi-command'
+import type { WorkspaceActivationIntent } from '../../shared/ipc-contracts'
+import { t } from '../../shared/i18n'
+
+/**
+ * Subscribes to Pi events from the main process and routes them to the store.
+ * Must be called once in the top-level component tree.
+ */
+export function usePiEvents(): void {
+  const handlePiEvent = useAppStore((state) => state.handlePiEvent)
+  const handlePendingPromptCounts = useAppStore((state) => state.handlePendingPromptCounts)
+  const handleWorkspaceActivity = useAppStore((state) => state.handleWorkspaceActivity)
+  const handleSessionRuntime = useAppStore((state) => state.handleSessionRuntime)
+  const recoverPendingPrompts = useAppStore((state) => state.recoverPendingPrompts)
+
+  useEffect(() => {
+    // Subscribe to Pi events (status changes arrive here too, as 'status_change').
+    const unsubscribeEvent = window.piDesktop.onEvent(handlePiEvent)
+    const unsubscribeCounts = window.piDesktop.onPendingPrompts(handlePendingPromptCounts)
+    const unsubscribeActivity = window.piDesktop.onWorkspaceActivity(handleWorkspaceActivity)
+    const unsubscribeSessionRuntime = window.piDesktop.onSessionRuntime(handleSessionRuntime)
+
+    // A desktop-notification click hands the renderer the switch intent so the
+    // usual streaming/dirty-editor confirms still run; landing on chat shows
+    // the finished (or waiting) turn the notification was about.
+    const activateWorkspaceIntent = (intent: WorkspaceActivationIntent): void => {
+      const state = useAppStore.getState()
+      const { workspaceId, sessionPath } = intent
+      // A stale intent for a removed workspace must not run confirm dialogs
+      // for a doomed switch. An empty list means it just hasn't loaded yet
+      // (boot) — proceed and let main validate.
+      if (state.workspaces.length > 0 && !state.workspaces.some((ws) => ws.id === workspaceId)) return
+
+      void (async () => {
+        if (sessionPath) {
+          if (state.activeWorkspace?.id !== workspaceId) {
+            if (!(await state.activateWorkspace(workspaceId, { awaitingSession: true }))) return
+          }
+          const workspace = useAppStore.getState().activeWorkspace
+          if (!workspace) return
+          await useAppStore.getState().switchSession(sessionPath, workspace.path)
+          useAppStore.getState().setCurrentView('chat')
+          return
+        }
+        if (state.activeWorkspace?.id === workspaceId) {
+          if (state.currentView !== 'chat') state.setCurrentView('chat')
+          return
+        }
+        const switched = await state.activateWorkspace(workspaceId)
+        if (switched) useAppStore.getState().setCurrentView('chat')
+      })()
+    }
+    const unsubscribeActivate = window.piDesktop.onActivateWorkspace((intent) => {
+      // Main stashes every click's intent in case this broadcast never lands
+      // (boot/reload race). It did land — consume the stash so a later boot
+      // cannot replay a long-stale activation.
+      void window.piDesktop.workspace.takePendingActivation().catch(() => undefined)
+      activateWorkspaceIntent(intent)
+    })
+
+    // A reload leaves the dialog slot empty while main still holds the prompt.
+    void recoverPendingPrompts()
+
+    // A notification clicked while no window existed stashed its intent in
+    // main; deliver it now that the subscriptions above are live.
+    void window.piDesktop.workspace
+      .takePendingActivation()
+      .then((intent) => {
+        if (intent) activateWorkspaceIntent(intent)
+      })
+      .catch(() => {
+        // Non-fatal: the user can switch manually.
+      })
+
+    return () => {
+      unsubscribeEvent()
+      unsubscribeCounts()
+      unsubscribeActivity()
+      unsubscribeSessionRuntime()
+      unsubscribeActivate()
+    }
+  }, [handlePiEvent, handlePendingPromptCounts, handleWorkspaceActivity, handleSessionRuntime, recoverPendingPrompts])
+}
+
+/**
+ * Subscribes to menu actions from the application menu.
+ */
+export function useMenuActions(): void {
+  const createNewSession = useAppStore((state) => state.createNewSession)
+  const setCurrentView = useAppStore((state) => state.setCurrentView)
+
+  useEffect(() => {
+    const unsubscribe = window.piDesktop.onMenuAction((action) => {
+      switch (action) {
+        case 'menu:new-session':
+          createNewSession()
+          break
+        case 'menu:new-workspace':
+          setCurrentView('settings') // Open settings where workspace creation lives
+          break
+        case 'menu:open-project': {
+          void window.piDesktop.system.openDialog({ title: t('dialogs.openProject.title') }).then((path) => {
+            if (path) void useAppStore.getState().openFolderAsWorkspace(path)
+          })
+          break
+        }
+      }
+    })
+
+    return unsubscribe
+  }, [createNewSession, setCurrentView])
+}
+
+/**
+ * The workflow navigator's scope, as the store holds it. Structural so the
+ * predicate below can be exercised without building a whole store state.
+ */
+interface WorkflowPanelScope {
+  workflowPanelOpen: boolean
+  workflowPanelFilter: string | null
+  workflowPanelWorkspaceId: string | null
+}
+
+/**
+ * Whether the global "All Workflows" surface owns the main pane — the navigator
+ * opened with neither a session nor a project scope. Session-scoped and
+ * project-scoped runs render in the docked panel instead and leave the current
+ * view on screen. Shared so every consumer (main pane, workspace tabs, sidebar,
+ * chat scroll) agrees on what "global" means.
+ */
+export function isGlobalWorkflowOpen(scope: WorkflowPanelScope): boolean {
+  return (
+    scope.workflowPanelOpen && !scope.workflowPanelFilter && scope.workflowPanelWorkspaceId === null
+  )
+}
+
+/** Component-side subscription to {@link isGlobalWorkflowOpen}. */
+export function useGlobalWorkflowOpen(): boolean {
+  return useAppStore(isGlobalWorkflowOpen)
+}
+
+// Distance (px) from the bottom within which we consider the user "at bottom"
+// and keep following new content.
+const AT_BOTTOM_THRESHOLD = 48
+
+// A content-relative scroll position. We store this instead of a raw scrollTop
+// so the reading spot survives content-height changes that happen while the chat
+// is hidden — chiefly toggling Show Thinking in Settings, which shows/hides every
+// thinking block. A raw scrollTop would then point at different content.
+type ScrollAnchor =
+  | { kind: 'bottom' }
+  // Preserve distance from the bottom. Used when no prose is on screen to anchor
+  // against (e.g. the viewport shows only tool boxes).
+  | { kind: 'fromBottom'; distanceFromBottom: number }
+  // `id` identifies a message's *text body* (the `data-scroll-anchor` marker on
+  // assistant text / user messages — never on tool boxes or thinking blocks).
+  // `viewportOffset` is its top edge relative to the container's top (often
+  // negative — it starts above the fold). Anchoring to the prose the reader is
+  // actually looking at — below any thinking block, even one in the same message
+  // — means collapsing thinking above it doesn't shift it. `distanceFromBottom`
+  // is a last-resort fallback if the element is somehow gone on restore.
+  | { kind: 'body'; id: string; viewportOffset: number; distanceFromBottom: number }
+
+// Snapshot the current reading position of the scroll container.
+function captureAnchor(el: HTMLElement): ScrollAnchor {
+  const distanceFromBottom = el.scrollHeight - el.clientHeight - el.scrollTop
+  if (distanceFromBottom <= AT_BOTTOM_THRESHOLD) return { kind: 'bottom' }
+  const containerTop = el.getBoundingClientRect().top
+  const nodes = el.querySelectorAll<HTMLElement>('[data-scroll-anchor]')
+  for (const node of nodes) {
+    const rect = node.getBoundingClientRect()
+    // First text body whose bottom edge is below the container's top — i.e. the
+    // topmost at least partially visible piece of prose.
+    if (rect.bottom > containerTop) {
+      return {
+        kind: 'body',
+        id: node.dataset.scrollAnchor as string,
+        viewportOffset: rect.top - containerTop,
+        distanceFromBottom,
+      }
+    }
+  }
+  return { kind: 'fromBottom', distanceFromBottom }
+}
+
+// Restore a previously captured anchor, absorbing any height change above it.
+function restoreAnchor(el: HTMLElement, anchor: ScrollAnchor): void {
+  if (anchor.kind === 'bottom') {
+    el.scrollTop = el.scrollHeight
+    return
+  }
+  if (anchor.kind === 'fromBottom') {
+    el.scrollTop = el.scrollHeight - el.clientHeight - anchor.distanceFromBottom
+    return
+  }
+  const node = el.querySelector<HTMLElement>(`[data-scroll-anchor="${CSS.escape(anchor.id)}"]`)
+  if (!node) {
+    el.scrollTop = el.scrollHeight - el.clientHeight - anchor.distanceFromBottom
+    return
+  }
+  const containerTop = el.getBoundingClientRect().top
+  const currentOffset = node.getBoundingClientRect().top - containerTop
+  el.scrollTop += currentOffset - anchor.viewportOffset
+}
+
+/**
+ * Manages the chat scroll container:
+ *  - remembers each session's scroll offset and restores it when you switch back
+ *  - follows new/streamed content (a new prompt or live tokens) while Auto Scroll
+ *    is enabled; leaves the position alone when it's off
+ *  - jumps to the bottom when `chatScrollBottomNonce` changes (Home resume)
+ *
+ * `active` is whether the chat view is currently visible; while hidden the panel
+ * stays mounted (so scrollTop persists) but we defer any scrolling until it's
+ * shown again, so measurements are valid.
+ */
+export function useChatScroll(active: boolean): {
+  scrollRef: React.RefObject<HTMLDivElement | null>
+  onScroll: () => void
+  atBottom: boolean
+  scrollToBottom: () => void
+} {
+  const ref = useRef<HTMLDivElement>(null)
+  const autoScroll = useAppStore(
+    (state) => state.settingsDraft.autoScroll ?? state.settings?.autoScroll ?? DEFAULT_SETTINGS.autoScroll
+  )
+  const sessionId = useAppStore((state) => state.sessionState?.sessionId ?? null)
+  const messages = useAppStore((state) => state.messages)
+  const streamingContent = useAppStore((state) => state.streamingContent)
+  const scrollBottomNonce = useAppStore((state) => state.chatScrollBottomNonce)
+
+  const positions = useRef<Map<string, ScrollAnchor>>(new Map())
+  const activeSession = useRef<string | null>(null)
+  const seenNonce = useRef(scrollBottomNonce)
+  const forceBottom = useRef(false)
+  // Whether the chat was visible on the previous run, so we can re-anchor when it
+  // becomes visible again (e.g. returning from Settings after toggling thinking).
+  const prevActive = useRef(false)
+  // While a just-switched session's messages are still loading (async), keep
+  // re-applying the target scroll until content is actually present.
+  const pendingRestore = useRef(false)
+  // Track content size to distinguish genuinely new content from unrelated
+  // re-renders (e.g. re-showing the panel), so returning to chat doesn't scroll.
+  const prevMsgCount = useRef(0)
+  const prevStreamLen = useRef(0)
+
+  // Whether the viewport is at (or within a hair of) the bottom. `atBottom` (state)
+  // drives the jump-to-bottom button; `atBottomRef` is read synchronously in the
+  // layout effect to decide whether streamed content should keep following.
+  const [atBottom, setAtBottom] = useState(true)
+  const atBottomRef = useRef(true)
+
+  // Recompute at-bottom from the live DOM and publish it to both the ref and the
+  // button state (setState no-ops when unchanged, so this is cheap to call often).
+  const syncAtBottom = useCallback(() => {
+    const el = ref.current
+    if (!el) return
+    const next = el.scrollHeight - el.clientHeight - el.scrollTop <= AT_BOTTOM_THRESHOLD
+    atBottomRef.current = next
+    setAtBottom(next)
+  }, [])
+
+  const scrollToBottom = useCallback(() => {
+    const el = ref.current
+    if (!el) return
+    el.scrollTop = el.scrollHeight
+    atBottomRef.current = true
+    setAtBottom(true)
+  }, [])
+
+  const onScroll = useCallback(() => {
+    const el = ref.current
+    if (!el) return
+    const scrollable = el.scrollHeight - el.clientHeight
+    // Only remember a position while there's a real scroll range — avoids
+    // clobbering the saved offset with 0 when messages are momentarily cleared
+    // during a session switch.
+    if (activeSession.current !== null && scrollable > AT_BOTTOM_THRESHOLD) {
+      positions.current.set(activeSession.current, captureAnchor(el))
+    }
+    const next = scrollable - el.scrollTop <= AT_BOTTOM_THRESHOLD
+    atBottomRef.current = next
+    setAtBottom(next)
+  }, [])
+
+  useLayoutEffect(() => {
+    const el = ref.current
+
+    // Did content actually grow (new message or streamed text)? Tracked even
+    // while hidden so re-showing the panel isn't mistaken for new content.
+    const messagesGrew = messages.length > prevMsgCount.current
+    const grew = messagesGrew || streamingContent.length > prevStreamLen.current
+    prevMsgCount.current = messages.length
+    prevStreamLen.current = streamingContent.length
+
+    // Defer scrolling while hidden: a display:none element has no layout, so
+    // scrollHeight is 0 and any positioning would be wrong.
+    if (!el || !active) {
+      prevActive.current = active
+      return
+    }
+
+    const becameActive = !prevActive.current
+    prevActive.current = active
+
+    if (scrollBottomNonce !== seenNonce.current) {
+      seenNonce.current = scrollBottomNonce
+      forceBottom.current = true
+    }
+
+    const sessionKey = sessionId ?? '__none__'
+    if (activeSession.current !== sessionKey) {
+      activeSession.current = sessionKey
+      pendingRestore.current = true
+    }
+
+    if (pendingRestore.current) {
+      const saved = positions.current.get(sessionKey)
+      if (forceBottom.current || saved === undefined) {
+        el.scrollTop = el.scrollHeight
+      } else {
+        restoreAnchor(el, saved)
+      }
+      // Consider the switch settled once the session's messages have loaded.
+      if (messages.length > 0) {
+        pendingRestore.current = false
+        forceBottom.current = false
+      }
+      syncAtBottom()
+      return
+    }
+
+    // Returned to the chat view (e.g. from Settings) in the same session. The
+    // content height may have changed while hidden — Show Thinking toggles every
+    // thinking block — so re-anchor to the saved reading position rather than
+    // leaving the now-stale scrollTop, which would show different content.
+    if (becameActive) {
+      const saved = positions.current.get(sessionKey)
+      if (forceBottom.current || saved === undefined) {
+        el.scrollTop = el.scrollHeight
+      } else {
+        restoreAnchor(el, saved)
+      }
+      forceBottom.current = false
+      // Refresh the jump-to-bottom button against the restored position: content
+      // height may have changed while hidden (e.g. Show Thinking toggled), so the
+      // stale at-bottom state would otherwise hide the chevron until the next scroll.
+      syncAtBottom()
+      return
+    }
+
+    if (forceBottom.current) {
+      el.scrollTop = el.scrollHeight
+      forceBottom.current = false
+      syncAtBottom()
+      return
+    }
+
+    // A new user message means the user just sent a prompt — always reveal it.
+    const lastIsUser = messagesGrew && messages[messages.length - 1]?.role === 'user'
+
+    // Follow new/streamed content only when Auto Scroll is on AND the user was
+    // already at the bottom. If they scrolled up, leave their position put and
+    // let the jump-to-bottom button take them down on demand.
+    if (autoScroll && (lastIsUser || (grew && atBottomRef.current))) {
+      el.scrollTop = el.scrollHeight
+    }
+
+    syncAtBottom()
+  }, [active, sessionId, messages, streamingContent, scrollBottomNonce, autoScroll, syncAtBottom])
+
+  return { scrollRef: ref, onScroll, atBottom, scrollToBottom }
+}
+
+/**
+ * Escape aborts the running turn unless another surface (an extension prompt
+ * hiding itself, for example) already consumed the key press.
+ */
+export function isAbortShortcut(event: { key: string; defaultPrevented: boolean }, isStreaming: boolean): boolean {
+  return event.key === 'Escape' && isStreaming && !event.defaultPrevented
+}
+
+/**
+ * Keyboard shortcut handler for the chat input.
+ */
+export function useChatKeyboard(
+  onSend: (message: string) => void,
+  onAbort: () => void,
+  inputRef: React.RefObject<HTMLTextAreaElement | null>
+): void {
+  const isStreaming = useAppStore((state) => state.isStreaming)
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (isAbortShortcut(e, isStreaming)) {
+        e.preventDefault()
+        onAbort()
+        return
+      }
+
+      // Enter: send message (without Shift)
+      if (e.key === 'Enter' && !e.shiftKey && document.activeElement === inputRef.current) {
+        e.preventDefault()
+        const value = inputRef.current?.value.trim()
+        if (value) {
+          onSend(value)
+          if (inputRef.current) inputRef.current.value = ''
+        }
+      }
+    }
+
+    window.addEventListener('keydown', handleKeyDown)
+    return () => window.removeEventListener('keydown', handleKeyDown)
+  }, [isStreaming, onSend, onAbort, inputRef])
+}
+
+/** A Pi built-in that maps to a GUI action rather than being inserted as text. */
+export interface BuiltinCommand {
+  name: string
+  description: string
+  run: () => void
+}
+
+/**
+ * The command set offered by both command UIs (Ctrl+K palette and the
+ * composer's inline slash popup): everything the agent reports plus the GUI's
+ * built-in actions, ready for filtering. Built-ins cover Pi commands with a
+ * direct GUI equivalent; ones that need an argument or aren't supported in the
+ * GUI (e.g. /name, /tree) are excluded.
+ */
+export function useCommandCatalog(): { builtins: BuiltinCommand[]; allCommands: PiCommand[] } {
+  const { t } = useTranslation()
+  const commands = useAppStore((s) => s.commands)
+  const compactContext = useAppStore((s) => s.compactContext)
+  const cloneBranch = useAppStore((s) => s.cloneBranch)
+  const createNewSession = useAppStore((s) => s.createNewSession)
+  const setTaskLauncherOpen = useAppStore((s) => s.setTaskLauncherOpen)
+  const setCurrentView = useAppStore((s) => s.setCurrentView)
+  const piEngine = useAppStore((s) => s.piEngine)
+
+  const builtins = useMemo<BuiltinCommand[]>(
+    () => [
+      { name: 'compact', description: t('commands.compact.description'), run: () => { void compactContext() } },
+      // OMP has no clone RPC command, so the action is not offered there.
+      ...(piEngine === 'omp'
+        ? []
+        : [{ name: 'clone', description: t('commands.clone.description'), run: () => { void cloneBranch() } }]),
+      { name: 'new', description: t('commands.new.description'), run: () => { void createNewSession() } },
+      { name: 'task', description: t('commands.task.description'), run: () => setTaskLauncherOpen(true) },
+      { name: 'resume', description: t('commands.resume.description'), run: () => setCurrentView('sessions') },
+      { name: 'fork', description: t('commands.fork.description'), run: () => setCurrentView('timeline') },
+      { name: 'settings', description: t('commands.settings.description'), run: () => setCurrentView('settings') },
+    ],
+    [compactContext, cloneBranch, createNewSession, setTaskLauncherOpen, setCurrentView, piEngine, t]
+  )
+
+  const allCommands = useMemo<PiCommand[]>(
+    () => [
+      ...commands,
+      ...builtins.map((b) => ({ name: b.name, description: b.description, source: BUILTIN_SOURCE })),
+    ],
+    [commands, builtins]
+  )
+
+  return { builtins, allCommands }
+}
+
+/**
+ * Loads initial data on mount — workspaces, settings, then Pi.
+ */
+export function useInitialize(): void {
+  const startPi = useAppStore((state) => state.startPi)
+  const loadSettings = useAppStore((state) => state.loadSettings)
+  const loadWorkspaces = useAppStore((state) => state.loadWorkspaces)
+  const refreshSessionStats = useAppStore((state) => state.refreshSessionStats)
+  const refreshSessionList = useAppStore((state) => state.refreshSessionList)
+
+  const initialized = useRef(false)
+
+  useEffect(() => {
+    if (initialized.current) return
+    initialized.current = true
+
+    const initialize = async (): Promise<void> => {
+      await loadSettings()
+      const openToHome = useAppStore.getState().settings?.openToHomeOnLaunch ?? DEFAULT_SETTINGS.openToHomeOnLaunch
+
+      // Workspaces are needed for the shell chrome; land the UI immediately after.
+      await loadWorkspaces()
+      void window.piDesktop.session.listRuntimes()
+        .then((runtimes) => runtimes.forEach((runtime) => useAppStore.getState().handleSessionRuntime(runtime)))
+        .catch(() => undefined)
+
+      if (openToHome) {
+        // Interactive ASAP — do NOT wait on the session-store walk (can be tens
+        // of seconds on a large ~/.pi/agent/sessions tree and freezes main IPC).
+        useAppStore.getState().setCurrentView('home')
+      } else {
+        useAppStore.getState().setCurrentView('chat')
+      }
+
+      // The status bar is on screen before any agent starts, and the engine is
+      // only carried on status payloads. Ask once at boot, or the bar reads
+      // "Pi stopped" for a user whose configured engine is OMP. Only the
+      // engine is adopted: the status itself is owned by the lifecycle
+      // actions, which may already be starting a session by now.
+      void window.piDesktop.pi.getStatus()
+        .then((status) => {
+          if (status.engine) useAppStore.setState({ piEngine: status.engine })
+        })
+        .catch(() => undefined)
+
+      // Background: session list, tags, notes, models, updates.
+      void refreshSessionList()
+      // Load the workflow journal once at boot so the status-bar badge and the
+      // sidebar workflow entries show live runs before the navigator is first
+      // opened (its poll loop keeps it fresh afterwards).
+      void useAppStore.getState().refreshWorkflowRuns()
+      void useAppStore.getState().loadTags()
+      void useAppStore.getState().loadArchivedSessions()
+      void useAppStore.getState().loadNotes()
+      void useAppStore.getState().loadCustomModels()
+      void useAppStore.getState().checkForUpdates()
+
+      if (openToHome) {
+        // Pi starts lazily on first action from Home.
+        return
+      }
+
+      // Boot Pi in the background. The shell is already interactive; the
+      // session-runtime running event hydrates Chat when the process is ready.
+      void startPi().then(() => refreshSessionStats()).catch(() => undefined)
+      void window.piDesktop.workspace.getActivity()
+        .then((activity) => useAppStore.getState().handleWorkspaceActivity(activity))
+        .catch(() => undefined)
+    }
+
+    initialize()
+  }, [startPi, loadSettings, loadWorkspaces, refreshSessionStats, refreshSessionList])
+}
+
+/**
+ * Global shortcut (Ctrl+Shift+P) that toggles the quick note picker, letting
+ * the user insert a saved prompt from anywhere in the app. (Ctrl+Shift+N is
+ * reserved for the New Workspace menu accelerator.)
+ */
+export function useNotePickerShortcut(): void {
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent): void => {
+      if (e.ctrlKey && e.shiftKey && (e.key === 'P' || e.key === 'p')) {
+        e.preventDefault()
+        const { notePickerOpen, setNotePickerOpen } = useAppStore.getState()
+        setNotePickerOpen(!notePickerOpen)
+      }
+    }
+
+    window.addEventListener('keydown', handleKeyDown)
+    return () => window.removeEventListener('keydown', handleKeyDown)
+  }, [])
+}
+
+/**
+ * The concrete id of the theme on screen ('system' already resolved). Changes
+ * on every applied theme switch, including an OS light/dark change under the
+ * System theme, which the saved `theme` setting does not reflect.
+ */
+export function useAppliedThemeId(): string | null {
+  return useSyncExternalStore(subscribeAppliedTheme, getAppliedThemeId)
+}

package/apps/sessrumnir/src/renderer/src/i18n.test.ts

@@ -0,0 +1,54 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { bootLanguageFrom, languagePickerOptions, loadedI18nEnvironment, loadI18nEnvironment } from './i18n'
+import { PSEUDO_LANGUAGE, SOURCE_LANGUAGE, SYSTEM_LANGUAGE } from '../../shared/i18n/languages'
+
+const ENVIRONMENT_LOAD_FAILURE = new Error('environment load failed')
+const RETRIED_ENVIRONMENT = { systemLanguages: [], pseudoLanguageEnabled: false }
+
+test('bootLanguageFrom accepts a stored available code', () => {
+  assert.equal(bootLanguageFrom(SOURCE_LANGUAGE), SOURCE_LANGUAGE)
+  assert.equal(bootLanguageFrom(PSEUDO_LANGUAGE), PSEUDO_LANGUAGE)
+})
+
+test('bootLanguageFrom falls back to English for missing or unknown values', () => {
+  assert.equal(bootLanguageFrom(null), SOURCE_LANGUAGE)
+  assert.equal(bootLanguageFrom('xx-unknown'), SOURCE_LANGUAGE)
+})
+
+test('the picker starts with System default and names the resolved system language', () => {
+  const options = languagePickerOptions({ systemLanguages: ['fr-FR'], pseudoLanguageEnabled: false })
+  assert.deepEqual(options, [
+    { value: SYSTEM_LANGUAGE, label: 'System default (English)' },
+    { value: SOURCE_LANGUAGE, label: 'English' },
+  ])
+})
+
+test('the picker offers the pseudo-language only when enabled', () => {
+  const values = languagePickerOptions({ systemLanguages: [], pseudoLanguageEnabled: true }).map((o) => o.value)
+  assert.ok(values.includes(PSEUDO_LANGUAGE))
+  const plain = languagePickerOptions({ systemLanguages: [], pseudoLanguageEnabled: false }).map((o) => o.value)
+  assert.ok(!plain.includes(PSEUDO_LANGUAGE))
+})
+
+test('loadI18nEnvironment retries after a failed request instead of caching the rejection', async () => {
+  let callCount = 0
+  const originalWindow = (globalThis as { window?: unknown }).window
+  ;(globalThis as { window: unknown }).window = {
+    piDesktop: {
+      i18n: {
+        getEnvironment: () => {
+          callCount += 1
+          return callCount === 1 ? Promise.reject(ENVIRONMENT_LOAD_FAILURE) : Promise.resolve(RETRIED_ENVIRONMENT)
+        },
+      },
+    },
+  }
+  try {
+    await assert.rejects(loadI18nEnvironment(), ENVIRONMENT_LOAD_FAILURE)
+    assert.deepEqual(await loadI18nEnvironment(), RETRIED_ENVIRONMENT)
+    assert.deepEqual(loadedI18nEnvironment(), RETRIED_ENVIRONMENT)
+  } finally {
+    ;(globalThis as { window?: unknown }).window = originalWindow
+  }
+})