@pheem49/mint 1.16.0 → 1.18.0

package/src/renderer/shared/utils/workspaceListPreferences.ts

@@ -0,0 +1,54 @@
+import { normalizeWorkspacePath, workspacePaths } from './workspaces'
+
+const REMOVED_WORKSPACES_KEY = 'mint:removed-workspace-paths'
+export const EMPTY_REMOVED_WORKSPACES: string[] = []
+
+/** List visibility only: workspace ownership, sessions and files remain untouched. */
+export function createWorkspaceListPreferences(storage: Pick<Storage, 'getItem' | 'setItem'>) {
+  let snapshot: string[] | null = null
+  let sessionOnly = false
+  const listeners = new Set<() => void>()
+  const read = () => {
+    try {
+      const value: unknown = JSON.parse(storage.getItem(REMOVED_WORKSPACES_KEY) || '[]')
+      return Array.isArray(value) ? workspacePaths(value.filter((path): path is string => typeof path === 'string')) : []
+    } catch { return snapshot ?? [] }
+  }
+  const getSnapshot = (): string[] => snapshot ??= read()
+  const update = (paths: string[], persist: boolean) => {
+    if (JSON.stringify(paths) === JSON.stringify(getSnapshot())) return
+    snapshot = paths
+    if (persist) {
+      try { storage.setItem(REMOVED_WORKSPACES_KEY, JSON.stringify(paths)); sessionOnly = false } catch { sessionOnly = true }
+    }
+    listeners.forEach(listener => listener())
+  }
+  return {
+    getSnapshot,
+    subscribe(listener: () => void) { listeners.add(listener); return () => { listeners.delete(listener) } },
+    remove(path: string) {
+      const normalized = normalizeWorkspacePath(path)
+      if (normalized) update(workspacePaths([...getSnapshot(), normalized]), true)
+    },
+    restore(path: string) {
+      const normalized = normalizeWorkspacePath(path)
+      update(getSnapshot().filter(path => path !== normalized), true)
+    },
+    reload() { if (!sessionOnly) update(read(), false) },
+  }
+}
+
+export const workspaceListPreferences = createWorkspaceListPreferences({
+  getItem: key => window.localStorage.getItem(key),
+  setItem: (key, value) => window.localStorage.setItem(key, value),
+})
+
+export function subscribeWorkspaceListPreferences(listener: () => void) {
+  const unsubscribe = workspaceListPreferences.subscribe(listener)
+  workspaceListPreferences.reload()
+  const onStorage = (event: StorageEvent) => {
+    if (!event.key || event.key === REMOVED_WORKSPACES_KEY) workspaceListPreferences.reload()
+  }
+  window.addEventListener('storage', onStorage)
+  return () => { unsubscribe(); window.removeEventListener('storage', onStorage) }
+}

package/src/renderer/shared/utils/workspaceMedia.ts

@@ -0,0 +1,49 @@
+import type { WorkspaceMediaSource } from '../types'
+
+const WEB_MEDIA_LIMIT = 256 * 1024 * 1024
+
+/** Native media uses one authorized asset file with Range support; Web owns a bounded Blob. */
+export function createWorkspaceMediaReader(environment: {
+  isNative(): boolean
+  apiBase(): string
+  convertFileSrc(path: string): string
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+  createObjectURL?: (blob: Blob) => string
+}) {
+  return async (path: string, workspacePath: string): Promise<WorkspaceMediaSource> => {
+    let cleanPath = path
+    if (workspacePath) {
+      const normWorkspace = workspacePath.replace(/\\/g, '/').replace(/\/+$/, '')
+      const normPath = cleanPath.replace(/\\/g, '/')
+      if (normPath.startsWith(normWorkspace + '/')) {
+        cleanPath = normPath.slice(normWorkspace.length + 1)
+      }
+    }
+    if (environment.isNative()) {
+      const { invoke } = await import('@tauri-apps/api/core')
+      const source = await invoke<{ path: string; mimeType: string; byteLength: number }>('prepare_workspace_media', { path: cleanPath, workspacePath })
+      return { url: environment.convertFileSrc(source.path), mimeType: source.mimeType, byteLength: source.byteLength, range: true }
+    }
+    const response = await environment.fetch(`${environment.apiBase()}/file/media?${new URLSearchParams({ path: cleanPath, workspace: workspacePath })}`)
+    if (!response.ok) { const value = await response.json().catch(() => ({})); throw Error(value.error || 'Could not read workspace media') }
+    const mimeType = response.headers.get('Content-Type')?.split(';')[0] || ''
+    if (!/^(application\/pdf|audio\/[\w.+-]+|video\/[\w.+-]+)$/.test(mimeType)) { await response.body?.cancel(); throw Error('Unsupported media response') }
+    if (Number(response.headers.get('Content-Length')) > WEB_MEDIA_LIMIT) { await response.body?.cancel(); throw Error('Web media preview supports files up to 256 MiB. Open this file in Desktop for larger media.') }
+    const reader = response.body?.getReader()
+    if (!reader) throw Error('Media content is unavailable')
+    const chunks: Uint8Array<ArrayBuffer>[] = []
+    let byteLength = 0
+    try {
+      for (;;) {
+        const { value, done } = await reader.read()
+        if (done) break
+        byteLength += value.byteLength
+        if (byteLength > WEB_MEDIA_LIMIT) throw Error('Web media preview supports files up to 256 MiB. Open this file in Desktop for larger media.')
+        chunks.push(value as Uint8Array<ArrayBuffer>)
+      }
+    } catch (error) { await reader.cancel().catch(() => {}); throw error }
+    finally { reader.releaseLock() }
+    const blob = new Blob(chunks, { type: mimeType })
+    return { url: (environment.createObjectURL ?? URL.createObjectURL)(blob), mimeType, byteLength, objectUrl: true }
+  }
+}

package/src/renderer/shared/utils/workspacePreview.test.ts

@@ -1,8 +1,95 @@
 import { describe, expect, it } from 'vitest'
-import { createWorkspacePreview } from './workspacePreview'
+import { createWorkspacePreview, createWorkspacePreviewOpener } from './workspacePreview'
+import { parseWorkspaceFileDrag, workspaceFileUrl, workspacePreviewId } from './workspaceDrag'
+import { createWorkspaceImageReader } from './workspaceImage'
+import { createWorkspaceMediaReader } from './workspaceMedia'
+import { PreviewObjectUrls } from './previewObjectUrls'
+import { readPdfRange } from './pdfRange'
 
 const root = '/projects/Demo'
+describe('direct media resources', () => {
+  it('reads authenticated Web media into a Blob rather than Base64', async () => {
+    let saved: Blob | undefined
+    const read = createWorkspaceMediaReader({
+      isNative: () => false, apiBase: () => 'http://localhost/api', convertFileSrc: () => { throw Error('Not native') },
+      fetch: async input => {
+        const url = new URL(String(input)); expect(url.pathname).toBe('/api/file/media'); expect(url.searchParams.get('workspace')).toBe(root)
+        return new Response(new Uint8Array([0, 255, 128]), { headers: { 'Content-Type': 'audio/wav', 'Content-Length': '3' } })
+      }, createObjectURL: blob => { saved = blob; return 'blob:audio' },
+    })
+    expect(await read('sound.wav', root)).toEqual({ url: 'blob:audio', mimeType: 'audio/wav', byteLength: 3, objectUrl: true })
+    expect(new Uint8Array(await saved!.arrayBuffer())).toEqual(new Uint8Array([0, 255, 128]))
+  })
+  it('rejects oversized Web responses before allocating a Blob', async () => {
+    const read = createWorkspaceMediaReader({ isNative: () => false, apiBase: () => '/api', convertFileSrc: path => path, fetch: async () => new Response('', { headers: { 'Content-Type': 'video/mp4', 'Content-Length': String(257 * 1024 * 1024) } }), createObjectURL: () => { throw Error('Must not allocate') } })
+    await expect(read('large.mp4', root)).rejects.toThrow('256 MiB')
+  })
+  it('releases a shared Blob only after the last preview tab is closed, including late loads after unmount', () => {
+    const revoked: string[] = [], owner = new PreviewObjectUrls(url => revoked.push(url))
+    const file = { path: 'sound.wav', url: 'blob:audio', objectUrl: true }
+    expect(owner.accept(file)).toBe(true)
+    owner.update([file, file]); owner.update([file]); expect(revoked).toEqual([])
+    owner.update([]); expect(revoked).toEqual(['blob:audio'])
+    owner.dispose(); expect(owner.accept({ ...file, url: 'blob:late' })).toBe(false)
+    expect(revoked).toEqual(['blob:audio', 'blob:late'])
+  })
+  it('assembles partial PDF byte ranges when the native file protocol returns shorter chunks', async () => {
+    const requests: string[] = []
+    const data = await readPdfRange('asset://localhost/book.pdf', 2, 9, new AbortController().signal, async (_url, init) => {
+      const header = new Headers(init?.headers).get('Range')!; requests.push(header)
+      return header === 'bytes=2-8' ? new Response(new Uint8Array([2, 3, 4]), { status: 206, headers: { 'Content-Range': 'bytes 2-4/10' } }) : new Response(new Uint8Array([5, 6, 7, 8]), { status: 206, headers: { 'Content-Range': 'bytes 5-8/10' } })
+    })
+    expect(data).toEqual(new Uint8Array([2, 3, 4, 5, 6, 7, 8])); expect(requests).toEqual(['bytes=2-8', 'bytes=5-8'])
+  })
+})
+
+describe('direct image transport', () => {
+  it('reads through the existing API with the original workspace and encoded file path', async () => {
+    const read = createWorkspaceImageReader({
+      isNative: () => false, apiBase: () => 'http://localhost:3000/api',
+      fetch: async input => {
+        const url = new URL(String(input))
+        expect(url.pathname).toBe('/api/file/image')
+        expect(url.searchParams.get('workspace')).toBe(root)
+        expect(url.searchParams.get('path')).toBe('images/รูป #1.png')
+        return new Response(JSON.stringify({ dataUrl: 'data:image/png;base64,AP+AAQ==' }))
+      },
+    })
+    expect(await read('images/รูป #1.png', root)).toBe('data:image/png;base64,AP+AAQ==')
+  })
+  it('surfaces a denied or unavailable image read', async () => {
+    const read = createWorkspaceImageReader({ isNative: () => false, apiBase: () => '/api', fetch: async () => new Response(JSON.stringify({ error: 'Image unavailable' }), { status: 400 }) })
+    await expect(read('missing.png', root)).rejects.toThrow('Image unavailable')
+  })
+})
+
 describe('workspace preview loading', () => {
+  for (const [path, type, mimeType] of [['guide.pdf', 'pdf', 'application/pdf'], ['song.mp3', 'audio', 'audio/mpeg'], ['clip.mp4', 'video', 'video/mp4'], ['clip.webm', 'video', 'video/webm']]) {
+    it(`opens ${path} directly without a preview server or text decoding`, async () => {
+      const artifact = await createWorkspacePreview(root, path, {
+        readWorkspaceFile: async () => { throw Error('Do not decode media as text') },
+        readWorkspaceMedia: async (file, workspace) => { expect([file, workspace]).toEqual([path, root]); return { url: 'blob:preview-media', mimeType, objectUrl: true } },
+        startHtmlPreview: async () => { throw Error('Media must not start a service') },
+      })
+      expect(artifact).toEqual({ path, workspacePath: root, type, url: 'blob:preview-media', mimeType, objectUrl: true })
+    })
+  }
+  for (const path of ['src/main.py', 'notes.txt', 'config.toml', '.env', 'Dockerfile']) {
+    it(`reads ${path} as text without starting a preview server`, async () => {
+      const artifact = await createWorkspacePreview(root, path, {
+        readWorkspaceFile: async () => 'file contents',
+        startHtmlPreview: async () => { throw Error('Text must not start a server') },
+      })
+      expect(artifact).toEqual({ path, workspacePath: root, type: 'code', content: 'file contents' })
+    })
+  }
+  it('shows unsupported file information without trying to decode binary content', async () => {
+    const artifact = await createWorkspacePreview(root, 'archive.zip', {
+      readWorkspaceFile: async () => { throw Error('Do not decode binaries') },
+      startHtmlPreview: async () => { throw Error('Do not serve unsupported files') },
+    })
+    expect(artifact).toEqual({ path: 'archive.zip', workspacePath: root, type: 'file' })
+  })
   it('reads Markdown from the selected root and pins that root to the tab', async () => {
     const artifact = await createWorkspacePreview(root, 'docs/README.md', {
       readWorkspaceFile: async (path, workspace) => { expect([path, workspace]).toEqual(['docs/README.md', root]); return '# Hello\n\n**Mint**' },
@@ -10,7 +97,21 @@ describe('workspace preview loading', () => {
     })
     expect(artifact).toEqual({ path: 'docs/README.md', workspacePath: root, type: 'markdown', content: '# Hello\n\n**Mint**' })
   })
-  for (const path of ['site/index.html', 'assets/photo.png', 'assets/icon.svg']) {
+  for (const path of ['assets/photo.png', 'assets/icon.svg']) {
+    it(`reads ${path} directly without a background preview service`, async () => {
+      const artifact = await createWorkspacePreview(root, path, {
+        readWorkspaceFile: async () => { throw Error('Do not decode images as text') },
+        readWorkspaceImage: async (file, workspace) => {
+          expect([file, workspace]).toEqual([path, root])
+          return 'data:image/png;base64,iVBORw=='
+        },
+        startHtmlPreview: async () => { throw Error('Images must not start a preview service') },
+      })
+      expect(artifact.url).toBe('data:image/png;base64,iVBORw==')
+      expect(artifact.workspacePath).toBe(root)
+    })
+  }
+  for (const path of ['site/index.html']) {
     it(`serves ${path} without reading it as plain text before opening`, async () => {
       const artifact = await createWorkspacePreview(root, path, {
         readWorkspaceFile: async () => { throw new Error('The panel loads text separately; binary images must not be read as UTF-8') },
@@ -22,3 +123,47 @@ describe('workspace preview loading', () => {
     })
   }
 })
+
+describe('workspace file drops', () => {
+  it('keeps file ownership and canonical tab identity across equivalent paths', () => {
+    expect(parseWorkspaceFileDrag(JSON.stringify({ root: '/projects/Demo/', path: './docs/notes.md', kind: 'file' }))).toEqual({ root, path: 'docs/notes.md', kind: 'file' })
+    expect(workspacePreviewId(root, 'docs/notes.md')).toBe(workspacePreviewId(`${root}/`, './docs/notes.md'))
+    expect(workspacePreviewId('/projects/Other', 'docs/notes.md')).not.toBe(workspacePreviewId(root, 'docs/notes.md'))
+  })
+  for (const value of ['not JSON', 'null', JSON.stringify({ root, path: 'docs', kind: 'directory' }), JSON.stringify({ root, path: '../outside.txt', kind: 'file' }), JSON.stringify({ root, path: '/etc/passwd', kind: 'file' })]) {
+    it(`rejects invalid file drop ${value}`, () => { expect(() => parseWorkspaceFileDrag(value)).toThrow() })
+  }
+  it('encodes external file URLs without treating filename punctuation as URL instructions', () => {
+    expect(workspaceFileUrl('/projects/Demo', 'รูป #100%.zip')).toBe('file:///projects/Demo/%E0%B8%A3%E0%B8%B9%E0%B8%9B%20%23100%25.zip')
+    expect(workspaceFileUrl('C:\\Projects\\Demo', 'a b.zip')).toBe('file:///C:/Projects/Demo/a%20b.zip')
+  })
+  it('coalesces simultaneous drops and selects an existing tab without reading or serving it again', async () => {
+    let resolve!: (value: string) => void
+    let calls = 0, opened = 0, selected = 0
+    const tabs = new Set<string>()
+    const open = createWorkspacePreviewOpener({
+      readWorkspaceFile: async () => { throw Error('Image must not be read as text') },
+      readWorkspaceImage: async () => { calls++; return new Promise(value => { resolve = value }) },
+      startHtmlPreview: async () => { throw Error('Images must not start a server') },
+      selectIfOpen: id => { if (!tabs.has(id)) return false; selected++; return true },
+      open: file => { opened++; tabs.add(workspacePreviewId(file.workspacePath!, file.path)) },
+    })
+    const first = open(root, 'photo.png'), second = open(root, './photo.png')
+    resolve('data:image/png;base64,iVBORw==')
+    await Promise.all([first, second])
+    await open(root, 'photo.png')
+    expect([calls, opened, selected]).toEqual([1, 1, 2])
+  })
+  it('allows retrying a failed drop', async () => {
+    let failed = true, opened = 0
+    const open = createWorkspacePreviewOpener({
+      readWorkspaceFile: async () => { if (failed) throw Error('File unavailable'); return 'recovered' },
+      startHtmlPreview: async () => { throw Error('Text must not start a server') },
+      selectIfOpen: () => false, open: () => { opened++ },
+    })
+    await expect(open(root, 'notes.txt')).rejects.toThrow('File unavailable')
+    failed = false
+    await open(root, 'notes.txt')
+    expect(opened).toBe(1)
+  })
+})

package/src/renderer/shared/utils/workspacePreview.ts

@@ -1,16 +1,47 @@
-import { detectArtifactType, type ArtifactFile } from '../components/ArtifactPreviewPanel'
+import { detectArtifactType, type ArtifactFile } from './artifacts'
+import { parseWorkspaceFileDrag, workspacePreviewId } from './workspaceDrag'
 
 interface PreviewApi {
   readWorkspaceFile(path: string, root?: string): Promise<string>
+  readWorkspaceImage?(path: string, root: string): Promise<string>
+  readWorkspaceMedia?(path: string, root: string): Promise<import('../types').WorkspaceMediaSource>
   startHtmlPreview(root: string, path: string): Promise<{ url: string; jobId: string }>
 }
 
 export async function createWorkspacePreview(root: string, path: string, api: PreviewApi): Promise<ArtifactFile> {
   const type = detectArtifactType(path)
-  if (type === 'code') throw new Error('This file type does not support Preview')
-  if (type === 'markdown') {
+  if (type === 'pdf' || type === 'audio' || type === 'video') {
+    if (!api.readWorkspaceMedia) throw Error('Direct media reading is unavailable')
+    return { path, workspacePath: root, type, ...await api.readWorkspaceMedia(path, root) }
+  }
+  if (type === 'image' || type === 'svg') {
+    if (!api.readWorkspaceImage) throw Error('Direct image reading is unavailable')
+    return { path, workspacePath: root, type, url: await api.readWorkspaceImage(path, root) }
+  }
+  const name = path.replace(/\\/g, '/').split('/').pop() || ''
+  const text = /\.(txt|log|csv|tsv|jsonl?|ya?ml|toml|ini|conf|cfg|env|lock|js|jsx|mjs|cjs|ts|tsx|css|scss|sass|less|xml|sql|rs|py|pyi|sh|bash|zsh|fish|ps1|bat|cmd|go|java|kt|kts|c|h|cpp|hpp|cc|cs|rb|php|swift|dart|vue|svelte|lua|r|ex|exs|erl|hs|clj|proto|graphql|gql|gitignore|gitattributes|editorconfig)$/i.test(name) || /^(Dockerfile|Containerfile|Makefile|Gemfile|Procfile|LICENSE|NOTICE|README|\.env(?:\..*)?)$/i.test(name)
+  if (type === 'code' && !text) return { path, workspacePath: root, type: 'file' }
+  if (type === 'markdown' || type === 'code') {
     return { path, workspacePath: root, type, content: await api.readWorkspaceFile(path, root) }
   }
   const { url } = await api.startHtmlPreview(root, path)
   return { path, workspacePath: root, type, url }
 }
+
+/** Reuse open tabs and coalesce simultaneous drops before starting preview servers. */
+export function createWorkspacePreviewOpener(api: PreviewApi & {
+  selectIfOpen: (id: string) => boolean
+  open: (artifact: ArtifactFile) => void
+}) {
+  const pending = new Map<string, Promise<void>>()
+  return async (root: string, path: string): Promise<void> => {
+    const file = parseWorkspaceFileDrag(JSON.stringify({ root, path, kind: 'file' }))
+    const id = workspacePreviewId(file.root, file.path)
+    if (api.selectIfOpen(id)) return
+    const existing = pending.get(id)
+    if (existing) { await existing; api.selectIfOpen(id); return }
+    const request = createWorkspacePreview(file.root, file.path, api).then(api.open)
+    pending.set(id, request)
+    try { await request } finally { pending.delete(id) }
+  }
+}

package/src/renderer/shared/utils/workspaces.ts

@@ -5,6 +5,7 @@ export function normalizeWorkspacePath(path?: string | null): string {
   return normalized.replace(/\/+$/, '') || (normalized.startsWith('/') ? '/' : '')
 }
 
-export function workspacePaths(recentPaths: string[], currentPath?: string, sessionPaths: (string | undefined)[] = []): string[] {
-  return [...new Set([...recentPaths, currentPath, ...sessionPaths].map(normalizeWorkspacePath).filter(Boolean))]
+export function workspacePaths(recentPaths: string[], currentPath?: string, sessionPaths: (string | undefined)[] = [], removedPaths: string[] = []): string[] {
+  const removed = new Set(removedPaths.map(normalizeWorkspacePath))
+  return [...new Set([...recentPaths, currentPath, ...sessionPaths].map(normalizeWorkspacePath).filter(path => Boolean(path) && !removed.has(path)))]
 }

package/src/renderer/src/App.tsx

@@ -1,11 +1,10 @@
 import React, { lazy, Suspense, useEffect, useState } from 'react'
-import AuthGate from '../shared/components/AuthGate'
-import ChunkErrorBoundary from '../shared/components/ChunkErrorBoundary'
-import ModalErrorBoundary from '../shared/components/ModalErrorBoundary'
-import { lazyWithRetry } from '../shared/utils/lazyWithRetry'
+import AuthGate from '../shared/components/app/AuthGate'
+import ChunkErrorBoundary from '../shared/components/app/ChunkErrorBoundary'
+import ModalErrorBoundary from '../shared/components/app/ModalErrorBoundary'
+import { ErrorRecovery } from '../shared/components/ui/error-recovery'
+import { lazyWithRetry, scheduleIdlePreload } from '../shared/utils/lazyWithRetry'
 import { listen } from './tauri'
-import BrowserShell from './components/BrowserShell'
-import BrowserSuggestionsPopup from './components/BrowserSuggestionsPopup'
 
 const SettingsWindow = lazyWithRetry(() => import('./components/SettingsWindow'))
 const SpotlightWindow = lazy(() => import('./components/SpotlightWindow'))
@@ -22,8 +21,6 @@ function getCurrentRoute(): string {
 }
 
 export default function App() {
-  const isBrowserShell = typeof window !== 'undefined' && new URLSearchParams(window.location.search).get('mint-browser-shell') === '1'
-  const isBrowserSuggestions = typeof window !== 'undefined' && new URLSearchParams(window.location.search).get('mint-browser-suggestions') === '1'
   const [route, setRoute] = useState(getCurrentRoute)
 
   useEffect(() => {
@@ -47,11 +44,9 @@ export default function App() {
   }, [])
 
   useEffect(() => {
-    // Preload SettingsWindow chunk in background so opening settings is instantaneous
-    const timer = setTimeout(() => {
+    return scheduleIdlePreload(() => {
       import('./components/SettingsWindow').catch(() => {})
-    }, 1200)
-    return () => clearTimeout(timer)
+    })
   }, [])
 
   useEffect(() => {
@@ -67,10 +62,6 @@ export default function App() {
     return () => window.removeEventListener('vite:preloadError', handlePreloadError)
   }, [])
 
-  if (isBrowserShell) return <BrowserShell />
-  if (isBrowserSuggestions) return <BrowserSuggestionsPopup />
-
-
   // Auxiliary overlay windows (spotlight/widget/proactive-glow/screen-picker)
   // belong to an already-running, already-authenticated main session, so
   // they render without their own login gate.
@@ -110,6 +101,19 @@ export default function App() {
     )
   }
 
+  if (route.startsWith('/error-preview') || route.startsWith('/error-recovery')) {
+    return (
+      <div style={{ width: '100%', height: '100vh', display: 'flex', flexDirection: 'column', background: 'var(--bg-canvas, #09090b)' }}>
+        <ErrorRecovery
+          onBackToChat={() => {
+            window.location.hash = '#/'
+          }}
+          onRefresh={() => window.location.reload()}
+        />
+      </div>
+    )
+  }
+
   const content = route.startsWith('/settings') ? (
     <>
       <MintDashboard />

package/src/renderer/src/agentProgress.ts

@@ -5,6 +5,7 @@ export {
   thoughtsFrom,
   trimAgentProgress,
   hasAgentToolActivity,
+  hasAgentDrawerActivity,
   mergeActivitySnapshots,
   parseAgentActivity,
   parseFileChangesFromProgress,

package/src/renderer/src/components/ChatPanel.tsx

@@ -1,3 +1,3 @@
 // Re-export from the shared module — do NOT add logic here.
 // Edit src/renderer/shared/components/ChatPanel.tsx instead.
-export { default } from '../../shared/components/ChatPanel'
+export { default } from '../../shared/components/chat/ChatPanel'

package/src/renderer/src/components/DashboardSidebar.tsx

@@ -1,4 +1,4 @@
 // Re-export from the shared module — do NOT add logic here.
 // Edit src/renderer/shared/components/DashboardSidebar.tsx instead.
-export { default } from '../../shared/components/DashboardSidebar'
-export type { DashboardView } from '../../shared/components/DashboardSidebar'
+export { default } from '../../shared/components/app/DashboardSidebar'
+export type { DashboardView } from '../../shared/components/app/DashboardSidebar'

package/src/renderer/src/components/ImageStudioPanel.tsx

@@ -1,3 +1,3 @@
 // Re-export from the shared module — do NOT add logic here.
 // Edit src/renderer/shared/components/ImageStudioPanel.tsx instead.
-export { default } from '../../shared/components/ImageStudioPanel'
+export { default } from '../../shared/components/studio/ImageStudioPanel'

package/src/renderer/src/components/LiveTranslateControls.tsx

@@ -1,4 +1,4 @@
-import SelectField from '../../shared/components/SelectField'
+import SelectField from '../../shared/components/ui/SelectField'
 import { useState } from 'react'
 import { invoke } from '@tauri-apps/api/core'
 import { emitTo } from '@tauri-apps/api/event'

package/src/renderer/src/components/MintDashboard.tsx

@@ -2,4 +2,4 @@
 import '../css/dashboard.css'
 
 // Re-export from the shared module — edit its logic there.
-export { default } from '../../shared/components/MintDashboard'
+export { default } from '../../shared/components/app/MintDashboard'

package/src/renderer/src/components/ProactiveGlow.tsx

@@ -8,7 +8,7 @@ export default function ProactiveGlow() {
             position: absolute;
             inset: 0;
             pointer-events: none;
-            box-shadow: inset 0 0 70px rgba(16, 185, 129, 0.2);
+            box-shadow: inset 0 0 70px var(--accent-glow, rgba(16, 185, 129, 0.2));
             opacity: 0.7;
             z-index: 100;
         }

package/src/renderer/src/components/ScreenPicker.css

@@ -197,7 +197,7 @@
   position: absolute;
   z-index: 1;
   outline: 2px solid var(--accent);
-  border-radius: 4px;
+  border-radius: var(--radius-2xs, 4px);
   box-shadow: 0 0 16px color-mix(in srgb, var(--accent) 38%, transparent);
   pointer-events: none;
 }

package/src/renderer/src/components/ScreenPicker.tsx

@@ -1,4 +1,4 @@
-import SelectField from '../../shared/components/SelectField'
+import SelectField from '../../shared/components/ui/SelectField'
 import { useEffect, useRef, useState, type PointerEvent } from 'react'
 import { invoke } from '@tauri-apps/api/core'
 import { createFrameChangeTracker, sampleFrame } from './liveTranslateFrames'