@pheem49/mint 1.15.0 → 1.17.0

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

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest'
+import { viewedImagesFrom, viewedImageDataUri } from './viewedImages'
+import type { AgentProgress } from '../types'
+
+describe('viewedImagesFrom', () => {
+  it('extracts legacy inline data URI from ToolEnd', () => {
+    const dataUri = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII='
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolEnd',
+        data: {
+          action: 'view_image',
+          callId: 'call-1',
+          input: { path: '/workspace/photos/photo.png' },
+          result: `${dataUri}\n\n[Hook] Viewed`,
+          status: 'success',
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(1)
+    expect(items[0]).toEqual({
+      id: 'call-1',
+      src: dataUri,
+      path: '/workspace/photos/photo.png',
+      name: 'photo.png',
+    })
+  })
+
+  it('extracts artifact-backed view_image seamlessly', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolArtifacts',
+        data: {
+          callId: 'call-view',
+          warnings: [],
+          artifacts: [
+            {
+              id: 'art-12345',
+              name: 'example-com-shot.png',
+              mimeType: 'image/png',
+              kind: 'image',
+              size: 88239,
+              chatId: 'chat-test',
+              callId: 'call-view',
+              server: 'view_image',
+            },
+          ],
+        },
+      },
+      {
+        type: 'ToolEnd',
+        data: {
+          action: 'view_image',
+          callId: 'call-view',
+          input: { path: '.mint-screenshots/example-com-shot.png' },
+          result: 'Image saved: example-com-shot.png (artifactId: art-12345). Original: 1440 × 900.',
+          status: 'success',
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(1)
+    expect(items[0]).toEqual({
+      id: 'call-view',
+      artifactId: 'art-12345',
+      path: '.mint-screenshots/example-com-shot.png',
+      name: 'example-com-shot.png',
+    })
+  })
+
+  it('recovers view_image artifacts even if ToolEnd was compacted or missing', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolArtifacts',
+        data: {
+          callId: 'call-compacted',
+          warnings: [],
+          artifacts: [
+            {
+              id: 'art-recovered',
+              name: 'recovered.png',
+              mimeType: 'image/png',
+              kind: 'image',
+              size: 5000,
+              chatId: 'chat-test',
+              callId: 'call-compacted',
+              server: 'view_image',
+            },
+          ],
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(1)
+    expect(items[0].artifactId).toBe('art-recovered')
+    expect(items[0].name).toBe('recovered.png')
+  })
+
+  it('ignores non-view_image artifacts so they remain in their respective tool handlers', () => {
+    const progress: AgentProgress[] = [
+      {
+        type: 'ToolArtifacts',
+        data: {
+          callId: 'call-browser',
+          warnings: [],
+          artifacts: [
+            {
+              id: 'art-browser',
+              name: 'browser.png',
+              mimeType: 'image/png',
+              kind: 'image',
+              size: 5000,
+              chatId: 'chat-test',
+              callId: 'call-browser',
+              server: 'browser',
+            },
+          ],
+        },
+      },
+    ]
+
+    const items = viewedImagesFrom(progress)
+    expect(items).toHaveLength(0)
+  })
+})

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

@@ -0,0 +1,97 @@
+import type { AgentProgress, McpArtifact } from '../types'
+
+/** view_image returns an inline image, optionally followed by post-tool hook notes. */
+export function viewedImageDataUri(result: string): string | null {
+  const firstLine = result.trim().split('\n', 1)[0].trim()
+  return /^data:image\/(?:png|jpeg|gif|webp|svg\+xml);base64,[A-Za-z0-9+/]+={0,2}$/.test(firstLine)
+    ? firstLine : null
+}
+
+export interface ViewedImageItem {
+  id: string
+  src?: string
+  artifactId?: string
+  path: string
+  name: string
+}
+
+export function viewedImagesFrom(progress: AgentProgress[]): ViewedImageItem[] {
+  const images = new Map<string, ViewedImageItem>()
+  const artifactsByCallId = new Map<string, McpArtifact>()
+  const artifactsById = new Map<string, McpArtifact>()
+  const viewImageArtifacts: McpArtifact[] = []
+
+  progress.forEach(event => {
+    if (event.type === 'ToolArtifacts') {
+      for (const artifact of event.data.artifacts) {
+        if (artifact.kind === 'image') {
+          artifactsById.set(artifact.id, artifact)
+          if (event.data.callId) artifactsByCallId.set(event.data.callId, artifact)
+          if (artifact.callId) artifactsByCallId.set(artifact.callId, artifact)
+          if (artifact.server === 'view_image') {
+            viewImageArtifacts.push(artifact)
+          }
+        }
+      }
+    }
+  })
+
+  let anonymousCount = 0
+  const handledCallIds = new Set<string>()
+  const handledArtifactIds = new Set<string>()
+
+  progress.forEach(event => {
+    if (event.type !== 'ToolEnd' || event.data.action !== 'view_image'
+      || (event.data.status && event.data.status !== 'success')) return
+
+    const callId = event.data.callId
+    const path = typeof event.data.input.path === 'string' ? event.data.input.path : ''
+    const fallbackName = path.replaceAll('\\', '/').split('/').at(-1) || 'Image'
+    const id = callId || `view-image-${anonymousCount++}`
+
+    // 1. Try inline data URI first (legacy or direct)
+    const src = viewedImageDataUri(event.data.result)
+    if (src) {
+      if (callId) handledCallIds.add(callId)
+      images.set(id, { id, src, path, name: fallbackName })
+      return
+    }
+
+    // 2. Check if there is an artifact associated with this callId or mentioned in result
+    let artifact = (callId ? artifactsByCallId.get(callId) : undefined)
+    if (!artifact) {
+      const match = event.data.result.match(/artifactId:\s*([a-f0-9-]+)/i)
+      if (match) {
+        artifact = artifactsById.get(match[1])
+      }
+    }
+
+    if (artifact) {
+      if (callId) handledCallIds.add(callId)
+      handledArtifactIds.add(artifact.id)
+      images.set(id, {
+        id,
+        artifactId: artifact.id,
+        path: path || artifact.name,
+        name: artifact.name || fallbackName,
+      })
+    }
+  })
+
+  // 3. Fallback for ToolArtifacts tagged as view_image when ToolEnd might be compacted or delayed
+  for (const artifact of viewImageArtifacts) {
+    if (handledArtifactIds.has(artifact.id) || (artifact.callId && handledCallIds.has(artifact.callId))) {
+      continue
+    }
+    const id = artifact.callId || artifact.id
+    images.set(id, {
+      id,
+      artifactId: artifact.id,
+      path: artifact.name,
+      name: artifact.name || 'Image',
+    })
+  }
+
+  return [...images.values()]
+}
+

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

@@ -0,0 +1,30 @@
+import { normalizeWorkspacePath } from './workspaces'
+
+export const WORKSPACE_FILE_MIME = 'application/x-mint-workspace-file'
+export interface WorkspaceFileDrag { root: string; path: string; kind: 'file' }
+
+/** Only explicit Workspace file drags are accepted; text mentions and folders stay separate. */
+export function parseWorkspaceFileDrag(raw: string): WorkspaceFileDrag {
+  let value: Partial<WorkspaceFileDrag>
+  try { value = JSON.parse(raw) } catch { throw Error('Drag a file from Workspace to preview it.') }
+  if (!value || value.kind !== 'file' || typeof value.root !== 'string' || typeof value.path !== 'string') throw Error('Drag a file from Workspace to preview it.')
+  const root = normalizeWorkspacePath(value.root)
+  const path = value.path.replace(/\\/g, '/')
+  if (!root || !/^(\/|[a-z]:\/)/i.test(root) || /\0/.test(root + path) || !path || /^(\/|[a-z]:)/i.test(path) || path.split('/').includes('..')) throw Error('This file is outside its source workspace.')
+  const relative = path.split('/').filter(part => part && part !== '.').join('/')
+  if (!relative) throw Error('Choose a file to preview.')
+  return { root, path: relative, kind: 'file' }
+}
+
+export function workspacePreviewId(root: string, path: string): string {
+  const file = parseWorkspaceFileDrag(JSON.stringify({ root, path, kind: 'file' }))
+  return `preview:${JSON.stringify([file.root, file.path])}`
+}
+
+export function workspaceFileUrl(root: string, path: string): string {
+  const file = parseWorkspaceFileDrag(JSON.stringify({ root, path, kind: 'file' }))
+  const full = `${file.root.replace(/\/$/, '')}/${file.path}`
+  const encoded = full.split('/').map(part => encodeURIComponent(part)).join('/')
+  if (/^[a-z]:\//i.test(full)) return `file:///${full.slice(0, 2)}${encoded.slice(encoded.indexOf('/'))}`
+  return `${full.startsWith('//') ? 'file:' : 'file://'}${encoded}`
+}

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

@@ -0,0 +1,17 @@
+/** Read through native IPC or the existing authenticated API; never start a preview service. */
+export function createWorkspaceImageReader(environment: {
+  isNative(): boolean
+  apiBase(): string
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>
+}) {
+  return async (path: string, workspacePath: string): Promise<string> => {
+    if (environment.isNative()) {
+      const { invoke } = await import('@tauri-apps/api/core')
+      return invoke<string>('read_workspace_image', { path, workspacePath })
+    }
+    const response = await environment.fetch(`${environment.apiBase()}/file/image?${new URLSearchParams({ path, workspace: workspacePath })}`)
+    const value = await response.json()
+    if (!response.ok) throw Error(value.error || 'Could not read workspace image')
+    return value.dataUrl
+  }
+}

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

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+import { createWorkspaceListPreferences } from './workspaceListPreferences'
+import { workspacePaths } from './workspaces'
+
+function storage() {
+  const data = new Map<string, string>()
+  return { getItem: (key: string) => data.get(key) ?? null, setItem: (key: string, value: string) => { data.set(key, value) } }
+}
+
+describe('workspace list removal', () => {
+  it('hides removed paths even when current workspace and saved sessions still reference them', () => {
+    const saved = storage()
+    const preferences = createWorkspaceListPreferences(saved)
+    preferences.remove(' /projects/Demo/ ')
+    expect(workspacePaths(['/projects/Demo', '/projects/Mint'], '/projects/Demo', ['/projects/Demo/'], preferences.getSnapshot()))
+      .toEqual(['/projects/Mint'])
+    const reloaded = createWorkspaceListPreferences(saved)
+    expect(workspacePaths([], '/projects/Demo', ['/projects/Demo'], reloaded.getSnapshot())).toEqual([])
+  })
+
+  it('notifies every picker and allows explicitly reopening the folder to restore it', () => {
+    const preferences = createWorkspaceListPreferences(storage())
+    const chat: string[][] = [], code: string[][] = []
+    preferences.subscribe(() => chat.push(preferences.getSnapshot()))
+    const unsubscribe = preferences.subscribe(() => code.push(preferences.getSnapshot()))
+    preferences.remove('C:\\Projects\\Demo\\')
+    expect(chat).toEqual([['C:/Projects/Demo']])
+    expect(code).toEqual([['C:/Projects/Demo']])
+    unsubscribe()
+    preferences.restore('C:/Projects/Demo/')
+    expect(chat).toEqual([['C:/Projects/Demo'], []])
+    expect(code).toHaveLength(1)
+    expect(workspacePaths(['C:/Projects/Demo'], '', [], preferences.getSnapshot())).toEqual(['C:/Projects/Demo'])
+  })
+
+  it('keeps list removal usable when browser storage is blocked', () => {
+    const preferences = createWorkspaceListPreferences({ getItem: () => { throw Error('blocked') }, setItem: () => { throw Error('blocked') } })
+    preferences.remove('/projects/Demo')
+    expect(preferences.getSnapshot()).toEqual(['/projects/Demo'])
+    preferences.restore('/projects/Demo')
+    expect(preferences.getSnapshot()).toEqual([])
+  })
+
+  it('retains session-only removals when storage can be read but is full', () => {
+    const preferences = createWorkspaceListPreferences({ getItem: () => null, setItem: () => { throw Error('quota exceeded') } })
+    preferences.remove('/projects/Demo')
+    preferences.reload()
+    expect(preferences.getSnapshot()).toEqual(['/projects/Demo'])
+  })
+
+  it('ignores malformed stored preferences and reloads changes from another window', () => {
+    const saved = storage()
+    const otherWindow = createWorkspaceListPreferences(saved)
+    const preferences = createWorkspaceListPreferences(saved)
+    expect(preferences.getSnapshot()).toEqual([])
+    otherWindow.remove('/projects/Demo')
+    preferences.reload()
+    expect(preferences.getSnapshot()).toEqual(['/projects/Demo'])
+    otherWindow.restore('/projects/Demo')
+    preferences.reload()
+    expect(preferences.getSnapshot()).toEqual([])
+    expect(createWorkspaceListPreferences({ getItem: () => '{invalid', setItem: () => {} }).getSnapshot()).toEqual([])
+  })
+})

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,41 @@
+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> => {
+    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, 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, 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/workspacePane.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+import { workspacePaneLayout, workspacePaneKeyWidth, readWorkspacePaneWidth } from './workspacePane'
+
+describe('Workspace pane sizing', () => {
+  it('enforces the minimum and maximum on a wide window', () => {
+    expect(workspacePaneLayout(100, 1600).width).toBe(280)
+    expect(workspacePaneLayout(1000, 1600).width).toBe(720)
+  })
+  it('reserves space for the conversation and restores the preferred width after shrinking', () => {
+    expect(workspacePaneLayout(650, 1000)).toMatchObject({ width: 522, max: 522, stacked: false })
+    expect(workspacePaneLayout(650, 1500).width).toBe(650)
+  })
+  it('stacks the panes when their minimum widths cannot fit', () => {
+    expect(workspacePaneLayout(400, 757).stacked).toBe(true)
+    expect(workspacePaneLayout(400, 758).stacked).toBe(false)
+  })
+  it('validates persisted sizes and tolerates unavailable storage', () => {
+    for (const value of [null, '', 'oops', 'Infinity']) expect(readWorkspacePaneWidth(() => value)).toBe(400)
+    expect(readWorkspacePaneWidth(() => '560')).toBe(560)
+    expect(readWorkspacePaneWidth(() => '9999')).toBe(720)
+    expect(readWorkspacePaneWidth(() => { throw new Error('blocked') })).toBe(400)
+  })
+  it('supports keyboard resizing, bounded Home/End and default reset', () => {
+    const layout = workspacePaneLayout(400, 1000)
+    expect(workspacePaneKeyWidth('ArrowLeft', layout)).toBe(376)
+    expect(workspacePaneKeyWidth('ArrowRight', layout)).toBe(424)
+    expect(workspacePaneKeyWidth('Home', layout)).toBe(280)
+    expect(workspacePaneKeyWidth('End', layout)).toBe(522)
+    expect(workspacePaneKeyWidth('Enter', layout)).toBe(400)
+    expect(workspacePaneKeyWidth('Tab', layout)).toBeNull()
+    expect(workspacePaneKeyWidth('ArrowRight', workspacePaneLayout(720, 1600))).toBe(720)
+  })
+})

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

@@ -0,0 +1,20 @@
+export const WORKSPACE_PANE_STORAGE_KEY = 'mint:workspace-panel-width'
+const MIN = 280
+const MAX = 720
+const DEFAULT = 400
+const clamp = (width: number, max = MAX) => Math.min(max, Math.max(MIN, Number.isFinite(width) ? width : DEFAULT))
+
+export function workspacePaneLayout(preferred: number, available: number) {
+  const max = Math.max(MIN, Math.min(MAX, available - 460 - 18))
+  return { width: clamp(preferred, max), min: MIN, max, stacked: available < MIN + 460 + 18 }
+}
+export function workspacePaneKeyWidth(key: string, layout: ReturnType<typeof workspacePaneLayout>): number | null {
+  const width = { ArrowLeft: layout.width - 24, ArrowRight: layout.width + 24, Home: layout.min, End: layout.max, Enter: DEFAULT }[key]
+  return width === undefined ? null : clamp(width, layout.max)
+}
+export function readWorkspacePaneWidth(read: () => string | null) {
+  try {
+    const value = read()
+    return value?.trim() && Number.isFinite(Number(value)) ? clamp(Number(value)) : DEFAULT
+  } catch { return DEFAULT }
+}

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

@@ -0,0 +1,169 @@
+import { describe, expect, it } from 'vitest'
+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**' },
+      startHtmlPreview: async () => { throw new Error('Markdown should not start a server') },
+    })
+    expect(artifact).toEqual({ path: 'docs/README.md', workspacePath: root, type: 'markdown', content: '# Hello\n\n**Mint**' })
+  })
+  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') },
+        startHtmlPreview: async (workspace, file) => { expect([workspace, file]).toEqual([root, path]); return { url: `http://127.0.0.1:12345/${path}`, jobId: 'preview-1' } },
+      })
+      expect(artifact.path).toBe(path)
+      expect((artifact as any).workspacePath).toBe(root)
+      expect((artifact as any).url).toBe(`http://127.0.0.1:12345/${path}`)
+    })
+  }
+})
+
+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)
+  })
+})