@open-mercato/ui 0.6.2-develop.3461.1.605f31c2c9 → 0.6.2

package/src/ai/parts/MutationResultCard.tsx

@@ -122,35 +122,23 @@ export function MutationResultCard(props: MutationResultCardProps) {
         </AlertTitle>
         <div className="text-sm leading-relaxed">
           <p>
-            {result?.commandName
-              ? t(
-                  'ai_assistant.chat.mutation_cards.result.successWithCommand',
-                  'Completed',
-                ) + `: ${result.commandName}`
-              : t(
-                  'ai_assistant.chat.mutation_cards.result.successBody',
-                  'The mutation completed successfully.',
-                )}
+            {t(
+              'ai_assistant.chat.mutation_cards.result.successBody',
+              'The requested change was saved successfully.',
+            )}
           </p>
-          {recordId ? (
+          {recordId && href ? (
             <p className="mt-1 text-xs">
-              {href ? (
-                <a
-                  className="font-mono text-primary underline"
-                  href={href}
-                  data-ai-mutation-result-link
-                >
-                  {t(
-                    'ai_assistant.chat.mutation_cards.result.viewRecord',
-                    'View record',
-                  )}
-                  : {recordId}
-                </a>
-              ) : (
-                <span className="font-mono" data-ai-mutation-result-record-id>
-                  {recordId}
-                </span>
-              )}
+              <a
+                className="text-primary underline"
+                href={href}
+                data-ai-mutation-result-link
+              >
+                {t(
+                  'ai_assistant.chat.mutation_cards.result.viewRecord',
+                  'View record',
+                )}
+              </a>
             </p>
           ) : null}
         </div>

package/src/ai/parts/__tests__/MutationPreviewCard.test.tsx

@@ -155,7 +155,7 @@ describe('MutationPreviewCard', () => {
     unmount()
   })
 
-  it('Review details toggles the expanded diff section', async () => {
+  it('does not render Review details when the visible single-record diff is already complete', () => {
     installPollingMock(makeAction())
     renderWithProviders(
       <MutationPreviewCard
@@ -165,6 +165,31 @@ describe('MutationPreviewCard', () => {
       { dict },
     )
     expect(document.querySelector('[data-ai-mutation-preview-details]')).toBeNull()
+    expect(screen.queryByRole('button', { name: /Review details/i })).toBeNull()
+  })
+
+  it('Review details toggles the expanded batch diff section', async () => {
+    installPollingMock(
+      makeAction({
+        fieldDiff: [],
+        records: [
+          {
+            recordId: 'r-1',
+            entityType: 'customers.person',
+            label: 'Alice',
+            fieldDiff: [{ field: 'name', before: 'Alice', after: 'Alicia' }],
+          },
+        ],
+      }),
+    )
+    renderWithProviders(
+      <MutationPreviewCard
+        componentId="mutation-preview-card"
+        pendingActionId="pa-1"
+      />,
+      { dict },
+    )
+    expect(document.querySelector('[data-ai-mutation-preview-details]')).toBeNull()
     fireEvent.click(screen.getByRole('button', { name: /Review details/i }))
     await waitFor(() => {
       expect(document.querySelector('[data-ai-mutation-preview-details]')).not.toBeNull()

package/src/ai/parts/__tests__/MutationResultCard.test.tsx

@@ -16,7 +16,7 @@ import type { AiPendingActionCardAction } from '../types'
 
 const dict = {
   'ai_assistant.chat.mutation_cards.result.successTitle': 'Action applied',
-  'ai_assistant.chat.mutation_cards.result.successBody': 'The mutation completed successfully.',
+  'ai_assistant.chat.mutation_cards.result.successBody': 'The requested change was saved successfully.',
   'ai_assistant.chat.mutation_cards.result.successWithCommand': 'Completed',
   'ai_assistant.chat.mutation_cards.result.viewRecord': 'View record',
   'ai_assistant.chat.mutation_cards.result.partialTitle': 'Action applied with failures',
@@ -87,6 +87,21 @@ describe('MutationResultCard', () => {
     const link = document.querySelector('[data-ai-mutation-result-link]') as HTMLAnchorElement
     expect(link).not.toBeNull()
     expect(link.getAttribute('href')).toBe('/backend/customers/people/p-1')
+    expect(link.textContent).toBe('View record')
+    expect(screen.queryByText(/customers\.updatePerson/)).toBeNull()
+    expect(screen.queryByText(/p-1/)).toBeNull()
+  })
+
+  it('does not expose internal command names or record ids when no record link exists', () => {
+    installPollingMock(baseAction())
+    renderWithProviders(
+      <MutationResultCard componentId="mutation-result-card" pendingActionId="pa-1" />,
+      { dict },
+    )
+    expect(screen.getByText('The requested change was saved successfully.')).toBeInTheDocument()
+    expect(screen.queryByText(/customers\.updatePerson/)).toBeNull()
+    expect(screen.queryByText(/p-1/)).toBeNull()
+    expect(document.querySelector('[data-ai-mutation-result-record-id]')).toBeNull()
   })
 
   it('renders the partial success variant + list of failed records', () => {

package/src/ai/useAiChat.ts

@@ -4,6 +4,12 @@ import * as React from 'react'
 import { createAiAgentTransport } from '@open-mercato/ai-assistant/modules/ai_assistant/lib/agent-transport'
 import { apiFetch } from '../backend/utils/api'
 import type { LoopTracePanelTrace } from './LoopTracePanel'
+import {
+  createAiServerConversation,
+  importAiLocalConversation,
+  loadAiServerTranscript,
+  serverMessageToChatMessage,
+} from './conversation-store'
 
 /**
  * Chat message shape used by {@link AiChat}. Kept intentionally minimal so the
@@ -12,6 +18,7 @@ import type { LoopTracePanelTrace } from './LoopTracePanel'
  * shape for `messages`.
  */
 export interface AiChatMessageFile {
+  id?: string
   name: string
   type: string
   previewUrl?: string
@@ -166,6 +173,7 @@ function makeConversationId(): string {
 }
 
 const SESSION_STORAGE_PREFIX = 'om-ai-chat:'
+const SESSION_IMPORT_MARKER_PREFIX = 'om-ai-chat-imported:'
 const SESSION_STORAGE_VERSION = 1
 const SESSION_UPDATED_EVENT = 'om-ai-chat-session-updated'
 const SESSION_STREAM_STATE_EVENT = 'om-ai-chat-session-stream-state'
@@ -247,19 +255,20 @@ function writePersistedSession(
   if (typeof window === 'undefined') return
   try {
     // Strip transient blob/object preview URLs before persisting (they would
-    // not survive a reload). Self-contained `data:` URLs are kept so image
-    // previews come back unchanged after the chat is reopened — public
-    // attachment URLs are intentionally not used because the LLM provider
-    // cannot reach a localhost origin and we want a single durable shape
-    // that works for both transport and reload.
+    // not survive a reload). Self-contained `data:` URLs and same-origin
+    // attachment thumbnail URLs are durable enough for local fallback storage.
     const messages = session.messages.map((message) => {
       if (!message.files || message.files.length === 0) return message
-      const safeFiles = message.files.map(({ name, type, previewUrl }) => {
+      const safeFiles = message.files.map(({ id, name, type, previewUrl }) => {
         const durable =
-          typeof previewUrl === 'string' && previewUrl.startsWith('data:')
+          typeof previewUrl === 'string' &&
+          (previewUrl.startsWith('data:') ||
+            previewUrl.startsWith('/api/attachments/image/') ||
+            previewUrl.startsWith('/api/attachments/file/'))
             ? previewUrl
             : undefined
-        return durable ? { name, type, previewUrl: durable } : { name, type }
+        const base = id ? { id, name, type } : { name, type }
+        return durable ? { ...base, previewUrl: durable } : base
       })
       return { ...message, files: safeFiles }
     })
@@ -286,6 +295,28 @@ function clearPersistedSession(agent: string, conversationId?: string | null): v
   }
 }
 
+function getImportMarkerKey(agent: string, conversationId: string): string {
+  return `${SESSION_IMPORT_MARKER_PREFIX}${agent}:${conversationId}`
+}
+
+function hasImportMarker(agent: string, conversationId: string): boolean {
+  if (typeof window === 'undefined') return false
+  try {
+    return window.localStorage.getItem(getImportMarkerKey(agent, conversationId)) === '1'
+  } catch {
+    return false
+  }
+}
+
+function writeImportMarker(agent: string, conversationId: string): void {
+  if (typeof window === 'undefined') return
+  try {
+    window.localStorage.setItem(getImportMarkerKey(agent, conversationId), '1')
+  } catch {
+    // ignore local marker failures; the server import remains authoritative
+  }
+}
+
 function getTransportEndpoint(
   agent: string,
   apiPath?: string,
@@ -802,14 +833,19 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
   // Without this, closing the dock or switching agents while the assistant
   // is "Thinking" abandons the partial reply (issue #1816).
   const latestMessagesRef = React.useRef<AiChatMessage[]>(messages)
+  const latestStatusRef = React.useRef<'idle' | 'submitting' | 'streaming'>(status)
   const persistKeyRef = React.useRef<string | null>(null)
   const agentRef = React.useRef<string>(agent)
+  const pageContextRef = React.useRef<Record<string, unknown> | undefined>(pageContext)
   const effectiveConversationIdRef = React.useRef<string>(effectiveConversationId)
   const sessionStorageKeyRef = React.useRef<string>(sessionStorageKey)
   const mountedRef = React.useRef(true)
   React.useEffect(() => {
     latestMessagesRef.current = messages
   }, [messages])
+  React.useEffect(() => {
+    latestStatusRef.current = status
+  }, [status])
   React.useEffect(() => {
     persistKeyRef.current =
       typeof conversationIdInput === 'string' && conversationIdInput.length > 0
@@ -819,6 +855,9 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
   React.useEffect(() => {
     agentRef.current = agent
   }, [agent])
+  React.useEffect(() => {
+    pageContextRef.current = pageContext
+  }, [pageContext])
   React.useEffect(() => {
     effectiveConversationIdRef.current = effectiveConversationId
   }, [effectiveConversationId])
@@ -874,6 +913,53 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
     [persistSnapshot],
   )
 
+  React.useEffect(() => {
+    let cancelled = false
+    const localCandidate = readPersistedSession(agent, persistKey)
+
+    async function hydrateFromServer(): Promise<void> {
+      const transcript = await loadAiServerTranscript(effectiveConversationId, { limit: 100 })
+      if (cancelled || latestStatusRef.current !== 'idle') return
+
+      if (transcript) {
+        const serverMessages = transcript.messages
+          .map(serverMessageToChatMessage)
+          .filter((message): message is AiChatMessage => message !== null)
+        if (serverMessages.length > 0 || !localCandidate || localCandidate.messages.length === 0) {
+          updateMessages(serverMessages)
+          if (serverMessages.length > 0) persistSnapshot(serverMessages, true)
+          return
+        }
+      }
+
+      if (!localCandidate || localCandidate.messages.length === 0) {
+        if (!transcript) {
+          void createAiServerConversation({
+            agentId: agent,
+            conversationId: effectiveConversationId,
+            pageContext: pageContextRef.current ?? null,
+          })
+        }
+        return
+      }
+
+      if (hasImportMarker(agent, effectiveConversationId)) return
+      const imported = await importAiLocalConversation({
+        agentId: agent,
+        conversationId: effectiveConversationId,
+        pageContext: pageContextRef.current ?? null,
+        messages: localCandidate.messages,
+      })
+      if (cancelled || !imported) return
+      writeImportMarker(agent, effectiveConversationId)
+    }
+
+    void hydrateFromServer()
+    return () => {
+      cancelled = true
+    }
+  }, [agent, effectiveConversationId, persistKey, persistSnapshot, updateMessages])
+
   const setStatus = React.useCallback((next: 'idle' | 'submitting' | 'streaming') => {
     if (mountedRef.current) {
       setStatusInternal(next)
@@ -961,8 +1047,11 @@ export function useAiChat(input: UseAiChatInput): UseAiChatResult {
       const url = getTransportEndpoint(agent, apiPath, providerOverride, modelOverride)
       const body = {
         messages: outgoingHistory.map((message) => ({
+          id: message.id,
           role: message.role,
           content: message.content,
+          files: message.files,
+          uiParts: message.uiParts,
         })),
         pageContext,
         attachmentIds,

package/src/backend/AuthSessionGuard.tsx

@@ -0,0 +1,114 @@
+'use client'
+import * as React from 'react'
+import { apiCall } from './utils/apiCall'
+
+export const AUTH_IDENTITY_STORAGE_KEY = 'om:auth:identity'
+export const AUTH_IDENTITY_BROADCAST_CHANNEL = 'om-auth-identity'
+
+type FeatureCheckResponse = {
+  ok: boolean
+  granted?: string[]
+  userId?: string
+}
+
+export type AuthSessionGuardProps = {
+  serverUserId: string | null
+}
+
+export const __reload = {
+  fn: (): void => {
+    if (typeof window !== 'undefined') window.location.reload()
+  },
+}
+
+export function AuthSessionGuard({ serverUserId }: AuthSessionGuardProps) {
+  React.useEffect(() => {
+    if (typeof window === 'undefined') return
+    let cancelled = false
+    let reloadScheduled = false
+
+    const triggerReload = () => {
+      if (reloadScheduled) return
+      reloadScheduled = true
+      __reload.fn()
+    }
+
+    const checkIdentity = async () => {
+      if (cancelled || reloadScheduled) return
+      try {
+        const res = await apiCall<FeatureCheckResponse>('/api/auth/feature-check', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ features: [] }),
+          cache: 'no-store',
+        })
+        if (cancelled || reloadScheduled) return
+        if (res.status === 401) {
+          if (serverUserId) triggerReload()
+          return
+        }
+        if (!res.ok) return
+        const currentUserId = typeof res.result?.userId === 'string' ? res.result.userId : null
+        if (!currentUserId) return
+        if (currentUserId !== serverUserId) triggerReload()
+      } catch {
+        // network errors are ignored — next focus/storage event retries
+      }
+    }
+
+    const onVisibilityOrFocus = () => {
+      if (typeof document !== 'undefined' && document.visibilityState === 'hidden') return
+      void checkIdentity()
+    }
+
+    const onStorage = (event: StorageEvent) => {
+      if (event.key !== AUTH_IDENTITY_STORAGE_KEY) return
+      void checkIdentity()
+    }
+
+    let broadcastChannel: BroadcastChannel | null = null
+    if (typeof BroadcastChannel !== 'undefined') {
+      try {
+        broadcastChannel = new BroadcastChannel(AUTH_IDENTITY_BROADCAST_CHANNEL)
+        broadcastChannel.onmessage = () => { void checkIdentity() }
+      } catch {
+        broadcastChannel = null
+      }
+    }
+
+    window.addEventListener('focus', onVisibilityOrFocus)
+    document.addEventListener('visibilitychange', onVisibilityOrFocus)
+    window.addEventListener('storage', onStorage)
+
+    return () => {
+      cancelled = true
+      window.removeEventListener('focus', onVisibilityOrFocus)
+      document.removeEventListener('visibilitychange', onVisibilityOrFocus)
+      window.removeEventListener('storage', onStorage)
+      if (broadcastChannel) {
+        broadcastChannel.onmessage = null
+        broadcastChannel.close()
+      }
+    }
+  }, [serverUserId])
+
+  return null
+}
+
+export function notifyAuthIdentityChange(): void {
+  if (typeof window === 'undefined') return
+  try {
+    if (typeof BroadcastChannel !== 'undefined') {
+      const channel = new BroadcastChannel(AUTH_IDENTITY_BROADCAST_CHANNEL)
+      channel.postMessage('changed')
+      channel.close()
+    }
+  } catch {
+    // ignore — fall back to storage event below
+  }
+  try {
+    window.localStorage.setItem(AUTH_IDENTITY_STORAGE_KEY, String(Date.now()))
+  } catch {
+    // private mode / quota errors are non-fatal
+  }
+}

package/src/backend/CrudForm.tsx

@@ -77,8 +77,9 @@ import { buildFormFieldsFromCustomFields, buildFormFieldFromCustomFieldDef } fro
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { TagsInput } from './inputs/TagsInput'
 import { ComboboxInput } from './inputs/ComboboxInput'
-import { format, parseISO } from 'date-fns'
-import type { Locale } from 'date-fns'
+import { format } from 'date-fns/format'
+import { parseISO } from 'date-fns/parseISO'
+import type { Locale } from 'date-fns/locale'
 import { DateTimePicker } from './inputs/DateTimePicker'
 import { TimePicker } from './inputs/TimePicker'
 import { DatePicker } from './inputs/DatePicker'

package/src/backend/FilterOverlay.tsx

@@ -1,6 +1,6 @@
 "use client"
 import * as React from 'react'
-import { format } from 'date-fns'
+import { format } from 'date-fns/format'
 import { Button } from '../primitives/button'
 import { Checkbox } from '../primitives/checkbox'
 import { DateRangePicker } from '../primitives/date-range-picker'

package/src/backend/__tests__/AppShell.test.tsx

@@ -600,7 +600,7 @@ describe('AppShell', () => {
 
       await waitFor(() => {
         expect(screen.getByText('Pay Links')).toBeInTheDocument()
-      })
+      }, { timeout: 10_000 })
 
       const link = screen.getByRole('link', { name: 'Pay Links' })
       expect(link.querySelector('svg.lucide-ticket')).toBeTruthy()

package/src/backend/__tests__/AuthSessionGuard.test.tsx

@@ -0,0 +1,150 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import * as React from 'react'
+import { act, render, waitFor } from '@testing-library/react'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import {
+  __reload,
+  AUTH_IDENTITY_STORAGE_KEY,
+  AuthSessionGuard,
+  notifyAuthIdentityChange,
+} from '../AuthSessionGuard'
+
+jest.mock('@open-mercato/ui/backend/utils/apiCall', () => ({
+  apiCall: jest.fn(),
+}))
+
+const apiCallMock = apiCall as jest.MockedFunction<typeof apiCall>
+
+const originalReload = __reload.fn
+
+function mockLocationReload() {
+  const reloadSpy = jest.fn()
+  __reload.fn = reloadSpy
+  return reloadSpy
+}
+
+function restoreLocation() {
+  __reload.fn = originalReload
+}
+
+function makeApiResult(payload: { status?: number; userId?: string | null }) {
+  const status = payload.status ?? 200
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    result: payload.userId !== undefined ? { ok: true, granted: [], userId: payload.userId } : null,
+    response: { ok: status < 400, status } as unknown as Response,
+    cacheStatus: null,
+  }
+}
+
+describe('AuthSessionGuard', () => {
+  beforeEach(() => {
+    apiCallMock.mockReset()
+  })
+
+  afterEach(() => {
+    restoreLocation()
+  })
+
+  it('reloads when the cookie identity differs from the server-rendered identity', async () => {
+    const reload = mockLocationReload()
+    apiCallMock.mockResolvedValue(makeApiResult({ userId: 'admin-id' }))
+
+    render(<AuthSessionGuard serverUserId="employee-id" />)
+
+    await act(async () => {
+      window.dispatchEvent(new Event('focus'))
+    })
+
+    await waitFor(() => {
+      expect(reload).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  it('reloads when the cookie session has been cleared but the page still has a user', async () => {
+    const reload = mockLocationReload()
+    apiCallMock.mockResolvedValue(makeApiResult({ status: 401 }))
+
+    render(<AuthSessionGuard serverUserId="employee-id" />)
+
+    await act(async () => {
+      window.dispatchEvent(new Event('focus'))
+    })
+
+    await waitFor(() => {
+      expect(reload).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  it('does not reload when the cookie identity still matches', async () => {
+    const reload = mockLocationReload()
+    apiCallMock.mockResolvedValue(makeApiResult({ userId: 'employee-id' }))
+
+    render(<AuthSessionGuard serverUserId="employee-id" />)
+
+    await act(async () => {
+      window.dispatchEvent(new Event('focus'))
+    })
+
+    await waitFor(() => {
+      expect(apiCallMock).toHaveBeenCalled()
+    })
+    expect(reload).not.toHaveBeenCalled()
+  })
+
+  it('does not poll while the tab is hidden', async () => {
+    mockLocationReload()
+    apiCallMock.mockResolvedValue(makeApiResult({ userId: 'employee-id' }))
+
+    Object.defineProperty(document, 'visibilityState', {
+      configurable: true,
+      get: () => 'hidden',
+    })
+
+    render(<AuthSessionGuard serverUserId="employee-id" />)
+
+    await act(async () => {
+      document.dispatchEvent(new Event('visibilitychange'))
+    })
+
+    expect(apiCallMock).not.toHaveBeenCalled()
+
+    Object.defineProperty(document, 'visibilityState', {
+      configurable: true,
+      get: () => 'visible',
+    })
+  })
+
+  it('reacts to cross-tab storage broadcasts', async () => {
+    const reload = mockLocationReload()
+    apiCallMock.mockResolvedValue(makeApiResult({ userId: 'admin-id' }))
+
+    render(<AuthSessionGuard serverUserId="employee-id" />)
+
+    await act(async () => {
+      window.dispatchEvent(
+        new StorageEvent('storage', {
+          key: AUTH_IDENTITY_STORAGE_KEY,
+          newValue: String(Date.now()),
+        }),
+      )
+    })
+
+    await waitFor(() => {
+      expect(reload).toHaveBeenCalledTimes(1)
+    })
+  })
+})
+
+describe('notifyAuthIdentityChange', () => {
+  it('writes a sentinel value to localStorage so other tabs receive a storage event', () => {
+    const setItemSpy = jest.spyOn(window.localStorage.__proto__, 'setItem')
+    notifyAuthIdentityChange()
+    expect(setItemSpy).toHaveBeenCalledWith(AUTH_IDENTITY_STORAGE_KEY, expect.any(String))
+    setItemSpy.mockRestore()
+  })
+})

package/src/backend/__tests__/SidebarCustomizationEditor.test.tsx

@@ -55,6 +55,13 @@ jest.mock('../injection/mutationEvents', () => ({
   dispatchBackendMutationError: jest.fn(),
 }))
 
+jest.mock('../injection/useGuardedMutation', () => ({
+  useGuardedMutation: () => ({
+    runMutation: async ({ operation }: { operation: () => Promise<unknown> }) => operation(),
+    retryLastMutation: jest.fn(async () => false),
+  }),
+}))
+
 const fakeGroups = [
   {
     id: 'core',
@@ -218,7 +225,7 @@ describe('SidebarCustomizationEditor', () => {
     expect(screen.getByRole('dialog')).toBeInTheDocument()
 
     expect(screen.getAllByText(duplicateMessage)).toHaveLength(1)
-  })
+  }, 15_000)
 
   it('clears the inline dialog error when the user edits the name', async () => {
     const duplicateMessage = 'A variant with this name already exists. Choose a different name.'

package/src/backend/dashboard/widgetRegistry.ts

@@ -1,5 +1,6 @@
 import type { ModuleDashboardWidgetEntry } from '@open-mercato/shared/modules/registry'
 import type { DashboardWidgetModule } from '@open-mercato/shared/modules/dashboard/widgets'
+import { applyDashboardWidgetOverridesToEntries } from '@open-mercato/shared/modules/overrides'
 
 type Entry = ModuleDashboardWidgetEntry
 
@@ -10,7 +11,7 @@ export function registerDashboardWidgets(entries: Entry[]) {
   if (_dashboardWidgetEntries !== null && process.env.NODE_ENV === 'development') {
     console.debug('[Bootstrap] Dashboard widgets re-registered (this may occur during HMR)')
   }
-  _dashboardWidgetEntries = entries
+  _dashboardWidgetEntries = applyDashboardWidgetOverridesToEntries(entries)
 }
 
 export function getDashboardWidgets(): Entry[] {

package/src/backend/date-range/dateRanges.ts

@@ -1,21 +1,19 @@
-import {
-  startOfDay,
-  endOfDay,
-  startOfWeek,
-  endOfWeek,
-  startOfMonth,
-  endOfMonth,
-  startOfQuarter,
-  endOfQuarter,
-  startOfYear,
-  endOfYear,
-  subDays,
-  subWeeks,
-  subMonths,
-  subQuarters,
-  subYears,
-  differenceInDays,
-} from 'date-fns'
+import { differenceInDays } from 'date-fns/differenceInDays'
+import { endOfDay } from 'date-fns/endOfDay'
+import { endOfMonth } from 'date-fns/endOfMonth'
+import { endOfQuarter } from 'date-fns/endOfQuarter'
+import { endOfWeek } from 'date-fns/endOfWeek'
+import { endOfYear } from 'date-fns/endOfYear'
+import { startOfDay } from 'date-fns/startOfDay'
+import { startOfMonth } from 'date-fns/startOfMonth'
+import { startOfQuarter } from 'date-fns/startOfQuarter'
+import { startOfWeek } from 'date-fns/startOfWeek'
+import { startOfYear } from 'date-fns/startOfYear'
+import { subDays } from 'date-fns/subDays'
+import { subMonths } from 'date-fns/subMonths'
+import { subQuarters } from 'date-fns/subQuarters'
+import { subWeeks } from 'date-fns/subWeeks'
+import { subYears } from 'date-fns/subYears'
 
 export type DateRangePreset =
   | 'today'