@pheem49/mint 1.16.0 → 1.18.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

@@ -1,4 +1,4 @@
-import type { AgentProgress } from '../types'
+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 {
@@ -7,20 +7,91 @@ export function viewedImageDataUri(result: string): string | null {
     ? firstLine : null
 }
 
-export function viewedImagesFrom(progress: AgentProgress[]) {
-  const images = new Map<string, { id: string; src: string; path: string; name: string }>()
+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 src = viewedImageDataUri(event.data.result)
-    if (!src) return
+
+    const callId = event.data.callId
     const path = typeof event.data.input.path === 'string' ? event.data.input.path : ''
-    const name = path.replaceAll('\\', '/').split('/').at(-1) || 'Image'
-    // Legacy/parallel results may omit callId. Count only retained images so
-    // trimming unrelated progress cannot remount an image and close its dialog.
-    const id = event.data.callId || `view-image-${anonymousCount++}`
-    images.set(id, { id, src, path, name })
+    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.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest'
+import {
+  WORKSPACE_FILE_MIME,
+  WORKSPACE_PATH_MIME,
+  WORKSPACE_IMAGE_MIME,
+  isImageFileName,
+  formatWorkspaceReference,
+  setWorkspaceDragData,
+  resolveImageToDataUri,
+} from './workspaceDrag'
+
+describe('workspaceDrag utility', () => {
+  it('defines the standard workspace path MIME constant', () => {
+    expect(WORKSPACE_PATH_MIME).toBe('application/x-mint-workspace-path')
+    expect(WORKSPACE_FILE_MIME).toBe('application/x-mint-workspace-file')
+    expect(WORKSPACE_IMAGE_MIME).toBe('application/x-mint-workspace-image')
+  })
+
+  describe('isImageFileName', () => {
+    it('identifies common image extensions', () => {
+      expect(isImageFileName('photo.png')).toBe(true)
+      expect(isImageFileName('mockup.JPG')).toBe(true)
+      expect(isImageFileName('diagram.svg')).toBe(true)
+      expect(isImageFileName('asset.webp')).toBe(true)
+      expect(isImageFileName('anim.gif')).toBe(true)
+    })
+
+    it('rejects non-image files', () => {
+      expect(isImageFileName('presentation.pdf')).toBe(false)
+      expect(isImageFileName('script.py')).toBe(false)
+      expect(isImageFileName('README.md')).toBe(false)
+    })
+  })
+
+  describe('formatWorkspaceReference', () => {
+    it('preserves existing @ prefix', () => {
+      expect(formatWorkspaceReference('@src/main.rs')).toBe('@src/main.rs')
+    })
+
+    it('adds @ prefix to relative paths', () => {
+      expect(formatWorkspaceReference('Harness_Presentation.pdf')).toBe('@Harness_Presentation.pdf')
+      expect(formatWorkspaceReference('docs/api.md')).toBe('@docs/api.md')
+    })
+
+    it('resolves absolute path to relative reference when inside workspace root', () => {
+      expect(
+        formatWorkspaceReference(
+          '/home/user/project/docs/guide.pdf',
+          '/home/user/project'
+        )
+      ).toBe('@docs/guide.pdf')
+    })
+
+    it('handles Windows paths and trailing slashes in workspace root', () => {
+      expect(
+        formatWorkspaceReference(
+          'C:\\Users\\dev\\project\\assets\\logo.png',
+          'C:/Users/dev/project/'
+        )
+      ).toBe('@assets/logo.png')
+    })
+
+    it('returns empty string for empty input', () => {
+      expect(formatWorkspaceReference('')).toBe('')
+    })
+  })
+
+  describe('setWorkspaceDragData', () => {
+    it('sets path MIME, text/plain, and workspace file MIME on DataTransfer', () => {
+      const store: Record<string, string> = {}
+      const mockDataTransfer = {
+        setData: (format: string, data: string) => {
+          store[format] = data
+        },
+        effectAllowed: 'none',
+      } as unknown as DataTransfer
+
+      setWorkspaceDragData(mockDataTransfer, {
+        path: 'Harness_Presentation.pdf',
+        root: '/home/user/project',
+        kind: 'file',
+      })
+
+      expect(store[WORKSPACE_PATH_MIME]).toBe('@Harness_Presentation.pdf')
+      expect(store['text/plain']).toBe('@Harness_Presentation.pdf')
+      expect(store[WORKSPACE_FILE_MIME]).toContain('Harness_Presentation.pdf')
+      expect(mockDataTransfer.effectAllowed).toBe('copy')
+    })
+
+    it('omits workspace file MIME when kind is directory', () => {
+      const store: Record<string, string> = {}
+      const mockDataTransfer = {
+        setData: (format: string, data: string) => {
+          store[format] = data
+        },
+        effectAllowed: 'none',
+      } as unknown as DataTransfer
+
+      setWorkspaceDragData(mockDataTransfer, {
+        path: 'src',
+        root: '/home/user/project',
+        kind: 'directory',
+      })
+
+      expect(store[WORKSPACE_PATH_MIME]).toBe('@src')
+      expect(store['text/plain']).toBe('@src')
+      expect(store[WORKSPACE_FILE_MIME]).toBeUndefined()
+      expect(store[WORKSPACE_IMAGE_MIME]).toBeUndefined()
+    })
+
+    it('sets WORKSPACE_IMAGE_MIME when dragged item is an image file', () => {
+      const store: Record<string, string> = {}
+      const mockDataTransfer = {
+        setData: (format: string, data: string) => {
+          store[format] = data
+        },
+        effectAllowed: 'none',
+      } as unknown as DataTransfer
+
+      setWorkspaceDragData(mockDataTransfer, {
+        path: 'assets/hero.png',
+        root: '/home/user/project',
+        kind: 'file',
+        url: 'data:image/png;base64,abc1234',
+      })
+
+      expect(store[WORKSPACE_IMAGE_MIME]).toBeDefined()
+      const parsed = JSON.parse(store[WORKSPACE_IMAGE_MIME])
+      expect(parsed.path).toBe('assets/hero.png')
+      expect(parsed.url).toBe('data:image/png;base64,abc1234')
+      expect(parsed.name).toBe('hero.png')
+    })
+  })
+
+  describe('resolveImageToDataUri', () => {
+    it('returns dataUri directly if target already starts with data:image/', async () => {
+      const dataUri = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUg=='
+      const result = await resolveImageToDataUri(dataUri)
+      expect(result).toBe(dataUri)
+    })
+
+    it('falls back to platformReader for workspace image paths', async () => {
+      const mockReader = async (path: string, _root: string) => `data:image/jpeg;base64,mock_${path}`
+      const result = await resolveImageToDataUri('images/sample.jpg', '/workspace', mockReader)
+      expect(result).toBe('data:image/jpeg;base64,mock_images/sample.jpg')
+    })
+
+    it('returns empty string if resolution fails', async () => {
+      const result = await resolveImageToDataUri('nonexistent.jpg')
+      expect(result).toBe('')
+    })
+  })
+})

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

@@ -0,0 +1,172 @@
+import { normalizeWorkspacePath } from './workspaces'
+
+export const WORKSPACE_FILE_MIME = 'application/x-mint-workspace-file'
+export const WORKSPACE_PATH_MIME = 'application/x-mint-workspace-path'
+export const WORKSPACE_IMAGE_MIME = 'application/x-mint-workspace-image'
+
+export interface WorkspaceFileDrag { root: string; path: string; kind: 'file' }
+
+const IMAGE_EXT_RE = /\.(png|jpe?g|gif|webp|ico|svg|bmp|avif)$/i
+
+export function isImageFileName(path: string): boolean {
+  return IMAGE_EXT_RE.test(path.trim())
+}
+
+/**
+ * Format a reference token suitable for dragging into chat or prompt input.
+ * Ensures the result starts with '@' and prefers a workspace-relative path or clean filename.
+ */
+export function formatWorkspaceReference(path: string, workspaceRoot?: string | null): string {
+  const clean = path.replace(/\\/g, '/').trim()
+  if (!clean) return ''
+  if (clean.startsWith('@')) return clean
+
+  if (workspaceRoot) {
+    const rootNorm = workspaceRoot.replace(/\\/g, '/').replace(/\/+$/, '')
+    if (clean === rootNorm || clean.startsWith(`${rootNorm}/`)) {
+      const rel = clean.slice(rootNorm.length + 1)
+      if (rel) return `@${rel}`
+    }
+  }
+
+  // Strip leading slash if workspace reference
+  const trimmed = clean.startsWith('/') ? clean.slice(1) : clean
+  return `@${trimmed}`
+}
+
+export interface SetWorkspaceDragDataOptions {
+  path: string
+  root?: string | null
+  kind?: 'file' | 'directory'
+  url?: string | null
+}
+
+/**
+ * Populate DataTransfer with standard Mint workspace file / reference drag data.
+ * Sets both the proprietary MIME types and text/plain fallback so drop targets
+ * (Chat composer, form, conversation panel) receive the expected @reference.
+ */
+export function setWorkspaceDragData(
+  dataTransfer: DataTransfer,
+  options: SetWorkspaceDragDataOptions
+): void {
+  const dragText = formatWorkspaceReference(options.path, options.root)
+  if (!dragText) return
+
+  dataTransfer.setData(WORKSPACE_PATH_MIME, dragText)
+  dataTransfer.setData('text/plain', dragText)
+
+  const isImg =
+    isImageFileName(options.path) ||
+    Boolean(options.url?.startsWith('data:image/') || options.url?.startsWith('blob:'))
+  if (isImg && options.kind !== 'directory') {
+    const fileName = options.path.split(/[\\/]/).pop() || options.path
+    try {
+      dataTransfer.setData(
+        WORKSPACE_IMAGE_MIME,
+        JSON.stringify({
+          path: options.path,
+          root: options.root || '',
+          url: options.url || '',
+          name: fileName,
+        })
+      )
+    } catch {
+      // ignore
+    }
+  }
+
+  if (options.kind !== 'directory' && options.path) {
+    const root = options.root ? normalizeWorkspacePath(options.root) : ''
+    const relativePath = dragText.startsWith('@') ? dragText.slice(1) : options.path
+    try {
+      dataTransfer.setData(
+        WORKSPACE_FILE_MIME,
+        JSON.stringify({ root, path: relativePath, kind: 'file' })
+      )
+    } catch {
+      // ignore
+    }
+  }
+
+  dataTransfer.effectAllowed = 'copy'
+}
+
+/**
+ * Resolves a dragged image reference (data URI, blob URL, web URL, or workspace path)
+ * into a base64 dataUri that can be directly attached to a multimodal prompt.
+ */
+export async function resolveImageToDataUri(
+  target: string,
+  root?: string | null,
+  platformReader?: (path: string, workspacePath: string) => Promise<string>
+): Promise<string> {
+  const clean = target.trim()
+  if (!clean) return ''
+
+  if (clean.startsWith('data:image/')) {
+    return clean
+  }
+
+  if (
+    clean.startsWith('blob:') ||
+    clean.startsWith('http://') ||
+    clean.startsWith('https://') ||
+    clean.startsWith('/api/') ||
+    (clean.startsWith('/') && IMAGE_EXT_RE.test(clean))
+  ) {
+    try {
+      const res = await fetch(clean)
+      if (res.ok) {
+        const blob = await res.blob()
+        return await new Promise<string>((resolve, reject) => {
+          const reader = new FileReader()
+          reader.onload = () => resolve(reader.result as string)
+          reader.onerror = reject
+          reader.readAsDataURL(blob)
+        })
+      }
+    } catch {
+      // fallback
+    }
+  }
+
+  if (platformReader) {
+    try {
+      const res = await platformReader(clean, root || '')
+      if (res && res.startsWith('data:image/')) return res
+    } catch {
+      // ignore
+    }
+  }
+
+  return ''
+}
+
+
+
+/** 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([])
+  })
+})