nastechai-desktop 18.1.0

package/src/lib/external-link.test.tsx

@@ -0,0 +1,168 @@
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  __resetLinkTitleCache,
+  ExternalLink,
+  fetchLinkTitle,
+  hostPathLabel,
+  isTitleFetchable,
+  LinkifiedText,
+  PrettyLink,
+  urlSlugTitleLabel
+} from './external-link'
+
+const desktopWindow = window as unknown as { NASTECHDesktop?: Window['NASTECHDesktop'] }
+const initialNasTechDesktop = desktopWindow.NASTECHDesktop
+
+function installDesktopBridge(partial: Partial<Window['NASTECHDesktop']> = {}) {
+  desktopWindow.NASTECHDesktop = {
+    fetchLinkTitle: vi.fn().mockResolvedValue(''),
+    openExternal: vi.fn().mockResolvedValue(undefined),
+    ...partial
+  } as unknown as Window['NASTECHDesktop']
+}
+
+afterEach(() => {
+  __resetLinkTitleCache()
+  vi.restoreAllMocks()
+  cleanup()
+
+  if (initialNasTechDesktop) {
+    desktopWindow.NASTECHDesktop = initialNasTechDesktop
+  } else {
+    delete desktopWindow.NASTECHDesktop
+  }
+})
+
+describe('external link helpers', () => {
+  it('formats URL fallbacks as host + path', () => {
+    expect(
+      hostPathLabel(
+        'https://www.getyourguide.com/culebra-island-l145468/from-fajardo-full-day-cordillera-islands-catamaran-tour-t19894/'
+      )
+    ).toBe('getyourguide.com/culebra-island-l145468/from-fajardo-full-day-cordillera-islands-catamaran-tour-t19894')
+  })
+
+  it('derives readable title fallbacks from URL slugs', () => {
+    expect(
+      urlSlugTitleLabel(
+        'https://www.getyourguide.com/fajardo-l882/from-fajardo-icacos-island-full-day-catamaran-trip-t19891/'
+      )
+    ).toBe('From Fajardo Icacos Island Full Day Catamaran Trip')
+  })
+
+  it('filters out local/non-http targets for title fetches', () => {
+    expect(isTitleFetchable('https://www.expedia.com/things-to-do/foo')).toBe(true)
+    expect(isTitleFetchable('http://localhost:5174')).toBe(false)
+    expect(isTitleFetchable('file:///tmp/demo.html')).toBe(false)
+    expect(isTitleFetchable('mailto:hello@example.com')).toBe(false)
+  })
+
+  it('deduplicates in-flight title fetches and caches results', async () => {
+    const bridge = vi.fn().mockResolvedValue('El Yunque Tour Water Slide, Rope Swing & Pickup')
+    installDesktopBridge({ fetchLinkTitle: bridge as unknown as Window['NASTECHDesktop']['fetchLinkTitle'] })
+
+    const url =
+      'https://www.expedia.com/things-to-do/puerto-rico-el-yunque-rainforest-adventure-with-transport.a46272756.activity-details'
+
+    const [first, second] = await Promise.all([fetchLinkTitle(url), fetchLinkTitle(url)])
+
+    expect(first).toBe('El Yunque Tour Water Slide, Rope Swing & Pickup')
+    expect(second).toBe('El Yunque Tour Water Slide, Rope Swing & Pickup')
+    expect(bridge).toHaveBeenCalledTimes(1)
+
+    const third = await fetchLinkTitle(url)
+
+    expect(third).toBe('El Yunque Tour Water Slide, Rope Swing & Pickup')
+    expect(bridge).toHaveBeenCalledTimes(1)
+  })
+
+  it('shares cache across protocol/www URL variants', async () => {
+    const bridge = vi.fn().mockResolvedValue('Shared Canonical Title')
+    installDesktopBridge({ fetchLinkTitle: bridge as unknown as Window['NASTECHDesktop']['fetchLinkTitle'] })
+
+    const first = 'https://www.getyourguide.com/san-juan-puerto-rico-l355/sunset-tours-tc306/'
+    const second = 'http://getyourguide.com/san-juan-puerto-rico-l355/sunset-tours-tc306/'
+
+    const [a, b] = await Promise.all([fetchLinkTitle(first), fetchLinkTitle(second)])
+
+    expect(a).toBe('Shared Canonical Title')
+    expect(b).toBe('Shared Canonical Title')
+    expect(bridge).toHaveBeenCalledTimes(1)
+  })
+
+  it('opens links via the desktop bridge', () => {
+    const openExternal = vi.fn().mockResolvedValue(undefined)
+    installDesktopBridge({ openExternal: openExternal as unknown as Window['NASTECHDesktop']['openExternal'] })
+
+    render(<ExternalLink href="https://example.com/path/to/resource">Example link</ExternalLink>)
+
+    fireEvent.click(screen.getByRole('link', { name: 'Example link' }))
+    expect(openExternal).toHaveBeenCalledWith('https://example.com/path/to/resource')
+  })
+
+  it('shows a trailing external-link icon', () => {
+    installDesktopBridge()
+
+    render(<ExternalLink href="https://example.com/path/to/resource">Example link</ExternalLink>)
+
+    const link = screen.getByRole('link', { name: 'Example link' })
+    expect(link.querySelector('svg')).toBeTruthy()
+  })
+
+  it('renders pretty links with fetched titles and no host suffix', async () => {
+    const bridge = vi.fn().mockResolvedValue('From Fajardo: Full-Day Culebra Islands Catamaran Tour')
+    installDesktopBridge({ fetchLinkTitle: bridge as unknown as Window['NASTECHDesktop']['fetchLinkTitle'] })
+
+    const url =
+      'https://www.getyourguide.com/culebra-island-l145468/from-fajardo-full-day-cordillera-islands-catamaran-tour-t19894/'
+
+    render(<LinkifiedText text={`Read ${url}`} />)
+
+    const link = screen.getByTitle(url)
+    expect(link.textContent).toContain('From Fajardo Full Day Cordillera Islands Catamaran Tour')
+
+    await waitFor(() => {
+      expect(link.textContent).toContain('From Fajardo: Full-Day Culebra Islands Catamaran Tour')
+    })
+    expect(link.textContent).not.toContain('getyourguide.com')
+  })
+
+  it('shows host/path fallback when title is unavailable', () => {
+    installDesktopBridge()
+    const url = 'https://www.expedia.com/things-to-do/puerto-rico-el-yunque'
+
+    render(<PrettyLink href={url} />)
+
+    const link = screen.getByTitle(url)
+
+    expect(link.textContent).toBe('Puerto Rico El Yunque')
+  })
+
+  it('ignores error-like fetched titles and falls back to slug label', async () => {
+    const bridge = vi.fn().mockResolvedValue('GetYourGuide – Error')
+    installDesktopBridge({ fetchLinkTitle: bridge as unknown as Window['NASTECHDesktop']['fetchLinkTitle'] })
+
+    const url =
+      'https://www.getyourguide.com/culebra-island-l145468/from-fajardo-full-day-cordillera-islands-catamaran-tour-t19894/'
+
+    render(<PrettyLink href={url} />)
+
+    const link = screen.getByTitle(url)
+    await waitFor(() => {
+      expect(link.textContent).toBe('From Fajardo Full Day Cordillera Islands Catamaran Tour')
+    })
+  })
+
+  it('normalizes scheme-less links before opening', () => {
+    installDesktopBridge()
+
+    render(<LinkifiedText text="Source expedia.com/things-to-do/puerto-rico-el-yunque-rainforest-adventure" />)
+
+    const link = screen.getByRole('link')
+    expect(link.getAttribute('href')).toBe(
+      'https://expedia.com/things-to-do/puerto-rico-el-yunque-rainforest-adventure'
+    )
+  })
+})

package/src/lib/external-link.tsx

@@ -0,0 +1,303 @@
+import type { ComponentProps, ReactNode } from 'react'
+import { useEffect, useMemo, useState } from 'react'
+
+import { ArrowUpRight } from '@/lib/icons'
+
+import { cn } from './utils'
+
+const titleCache = new Map<string, string>()
+const titleInflight = new Map<string, Promise<string>>()
+const titleSubs = new Map<string, Set<(value: string) => void>>()
+
+const URL_RE =
+  /(?:https?:\/\/|www\.)[^\s<>"'`]+[^\s<>"'`.,;:!?)]|[a-z0-9](?:[a-z0-9-]*\.)+[a-z]{2,}(?:\/[^\s<>"'`.,;:!?)]*)?/gi
+
+const DOMAIN_RE = /^(?:www\.)?[a-z0-9](?:[a-z0-9-]*\.)+[a-z]{2,}(?::\d+)?(?:[/?#][^\s]*)?$/i
+const SKIP_PROTO_RE = /^(?:file|data|mailto|javascript|blob|chrome|about|NASTECH):/i
+const LOCAL_HOST_RE = /^(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])(?::\d+)?$/i
+
+const ERROR_TITLE_RE =
+  /\b(?:access denied|attention required|captcha|error|forbidden|just a moment|request blocked|too many requests)\b/i
+
+export function normalizeExternalUrl(value: string): string {
+  const trimmed = value.trim()
+
+  if (!trimmed || /^https?:\/\//i.test(trimmed)) {
+    return trimmed
+  }
+
+  return DOMAIN_RE.test(trimmed) ? `https://${trimmed}` : trimmed
+}
+
+function parseUrl(value: string): null | URL {
+  try {
+    return new URL(normalizeExternalUrl(value))
+  } catch {
+    return null
+  }
+}
+
+function titleCacheKey(value: string): string {
+  const url = parseUrl(value)
+
+  if (!url) {
+    return normalizeExternalUrl(value)
+  }
+
+  const host = url.hostname.replace(/^www\./i, '').toLowerCase()
+  const pathname = url.pathname === '/' ? '/' : url.pathname.replace(/\/+$/, '') || '/'
+
+  return `${host}${pathname}${url.search || ''}`
+}
+
+export function shortHostLabel(value: string): string {
+  return parseUrl(value)?.hostname.replace(/^www\./, '') ?? value
+}
+
+export function hostPathLabel(value: string): string {
+  const url = parseUrl(value)
+
+  if (!url) {
+    return value
+  }
+
+  const host = url.hostname.replace(/^www\./, '')
+  const path = url.pathname && url.pathname !== '/' ? url.pathname.replace(/\/$/, '') : ''
+
+  return `${host}${path}`
+}
+
+function cleanSlug(segment: string): string {
+  try {
+    return decodeURIComponent(segment)
+      .replace(/\.a\d+\..*$/i, '')
+      .replace(/\.(?:html?|php|aspx?)$/i, '')
+      .replace(/(?:[-_.](?:[a-z]{1,3}\d{2,}|i\d{2,}))+$/i, '')
+      .replace(/[_-]+/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim()
+  } catch {
+    return ''
+  }
+}
+
+export function urlSlugTitleLabel(value: string): string {
+  const url = parseUrl(value)
+
+  for (const segment of url?.pathname.split('/').filter(Boolean).reverse() ?? []) {
+    const cleaned = cleanSlug(segment)
+
+    if (!cleaned || !/[a-z]/i.test(cleaned)) {
+      continue
+    }
+
+    if (/^(?:[a-z]{1,3}\d+|\d+)$/i.test(cleaned.replace(/\s+/g, ''))) {
+      continue
+    }
+
+    const titled = cleaned.replace(/\b[a-z]/g, c => c.toUpperCase())
+
+    if (titled.length >= 4) {
+      return titled
+    }
+  }
+
+  return hostPathLabel(value)
+}
+
+export function isTitleFetchable(value: string): boolean {
+  if (!value || SKIP_PROTO_RE.test(value)) {
+    return false
+  }
+
+  const url = parseUrl(value)
+
+  return Boolean(url && /^https?:$/.test(url.protocol) && !LOCAL_HOST_RE.test(url.host))
+}
+
+export function fetchLinkTitle(url: string): Promise<string> {
+  const normalizedUrl = normalizeExternalUrl(url)
+  const key = titleCacheKey(normalizedUrl)
+
+  if (!isTitleFetchable(normalizedUrl)) {
+    return Promise.resolve('')
+  }
+
+  if (titleCache.has(key)) {
+    return Promise.resolve(titleCache.get(key) ?? '')
+  }
+
+  const pending = titleInflight.get(key)
+
+  if (pending) {
+    return pending
+  }
+
+  const bridge = typeof window === 'undefined' ? undefined : window.NASTECHDesktop?.fetchLinkTitle
+
+  if (!bridge) {
+    titleCache.set(key, '')
+
+    return Promise.resolve('')
+  }
+
+  const promise = bridge(normalizedUrl)
+    .then(value => (value || '').replace(/\s+/g, ' ').trim())
+    .then(clean => (clean && !ERROR_TITLE_RE.test(clean) ? clean : ''))
+    .catch(() => '')
+    .then(safe => {
+      titleCache.set(key, safe)
+      titleInflight.delete(key)
+      titleSubs.get(key)?.forEach(sub => sub(safe))
+
+      return safe
+    })
+
+  titleInflight.set(key, promise)
+
+  return promise
+}
+
+export function useLinkTitle(url?: null | string): string {
+  const normalizedUrl = useMemo(() => (url ? normalizeExternalUrl(url) : ''), [url])
+  const key = useMemo(() => (normalizedUrl ? titleCacheKey(normalizedUrl) : ''), [normalizedUrl])
+  const [title, setTitle] = useState(() => (key ? (titleCache.get(key) ?? '') : ''))
+
+  useEffect(() => {
+    setTitle(key ? (titleCache.get(key) ?? '') : '')
+
+    if (!key || !isTitleFetchable(normalizedUrl)) {
+      return
+    }
+
+    const subs = titleSubs.get(key) ?? new Set<(value: string) => void>()
+
+    subs.add(setTitle)
+    titleSubs.set(key, subs)
+    void fetchLinkTitle(normalizedUrl)
+
+    return () => {
+      subs.delete(setTitle)
+
+      if (!subs.size) {
+        titleSubs.delete(key)
+      }
+    }
+  }, [key, normalizedUrl])
+
+  return title
+}
+
+export function openExternalLink(href: string): void {
+  if (href) {
+    void window.NASTECHDesktop?.openExternal?.(href)
+  }
+}
+
+interface ExternalLinkProps extends Omit<ComponentProps<'a'>, 'href' | 'target'> {
+  href: string
+  children?: ReactNode
+  showExternalIcon?: boolean
+}
+
+export function ExternalLinkIcon({ className }: { className?: string }) {
+  return <ArrowUpRight aria-hidden className={cn('ml-1 inline size-[0.78em] align-[-0.08em] opacity-70', className)} />
+}
+
+export function ExternalLink({
+  children,
+  className,
+  href,
+  onClick,
+  showExternalIcon = true,
+  ...rest
+}: ExternalLinkProps) {
+  const target = normalizeExternalUrl(href)
+
+  return (
+    <a
+      className={cn('font-semibold text-foreground underline underline-offset-4 decoration-current/20', className)}
+      href={target}
+      onClick={event => {
+        event.stopPropagation()
+        onClick?.(event)
+
+        if (event.defaultPrevented) {
+          return
+        }
+
+        event.preventDefault()
+        openExternalLink(target)
+      }}
+      rel="noopener noreferrer"
+      target="_blank"
+      {...rest}
+    >
+      {children ?? urlSlugTitleLabel(target)}
+      {showExternalIcon && <ExternalLinkIcon />}
+    </a>
+  )
+}
+
+interface PrettyLinkProps extends Omit<ComponentProps<'a'>, 'href' | 'target'> {
+  href: string
+  label?: string
+  fallbackLabel?: string
+}
+
+export function PrettyLink({ className, fallbackLabel, href, label, ...rest }: PrettyLinkProps) {
+  const target = useMemo(() => normalizeExternalUrl(href), [href])
+  const fetched = useLinkTitle(label ? null : target)
+  const display = fetched || label?.trim() || fallbackLabel?.trim() || urlSlugTitleLabel(target)
+
+  return (
+    <ExternalLink className={cn('wrap-break-word', className)} href={target} title={target} {...rest}>
+      <span className="font-medium">{display}</span>
+    </ExternalLink>
+  )
+}
+
+interface LinkifiedTextProps {
+  className?: string
+  text: string
+  pretty?: boolean
+}
+
+export function LinkifiedText({ className, pretty = true, text }: LinkifiedTextProps) {
+  const nodes: ReactNode[] = []
+  let cursor = 0
+
+  for (const match of text.matchAll(URL_RE)) {
+    const raw = match[0]
+    const url = normalizeExternalUrl(raw)
+    const index = match.index ?? 0
+
+    if (index > cursor) {
+      nodes.push(text.slice(cursor, index))
+    }
+
+    nodes.push(
+      pretty ? (
+        <PrettyLink href={url} key={`${url}-${index}`} />
+      ) : (
+        <ExternalLink href={url} key={`${url}-${index}`}>
+          {raw}
+        </ExternalLink>
+      )
+    )
+
+    cursor = index + raw.length
+  }
+
+  if (cursor < text.length) {
+    nodes.push(text.slice(cursor))
+  }
+
+  return <span className={className}>{nodes.length ? nodes : text}</span>
+}
+
+export function __resetLinkTitleCache(): void {
+  titleCache.clear()
+  titleInflight.clear()
+  titleSubs.clear()
+}

package/src/lib/gateway-events.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import { gatewayEventRequiresSessionId } from './gateway-events'
+
+describe('gateway event routing', () => {
+  it('drops only unscoped subagent events (genuinely background work)', () => {
+    expect(gatewayEventRequiresSessionId('subagent.progress')).toBe(true)
+    expect(gatewayEventRequiresSessionId('subagent.start')).toBe(true)
+  })
+
+  it('attributes unscoped foreground turn events to the active chat', () => {
+    // These must NOT be dropped when unscoped — they are the focused turn's own
+    // output, and dropping them loses the live response until a refetch (#42178).
+    expect(gatewayEventRequiresSessionId('message.delta')).toBe(false)
+    expect(gatewayEventRequiresSessionId('message.complete')).toBe(false)
+    expect(gatewayEventRequiresSessionId('reasoning.delta')).toBe(false)
+    expect(gatewayEventRequiresSessionId('tool.start')).toBe(false)
+    expect(gatewayEventRequiresSessionId('approval.request')).toBe(false)
+  })
+
+  it('allows global events to remain unscoped', () => {
+    expect(gatewayEventRequiresSessionId('gateway.ready')).toBe(false)
+    expect(gatewayEventRequiresSessionId('preview.restart.progress')).toBe(false)
+    expect(gatewayEventRequiresSessionId('session.info')).toBe(false)
+    expect(gatewayEventRequiresSessionId(undefined)).toBe(false)
+  })
+})

package/src/lib/gateway-events.ts

@@ -0,0 +1,49 @@
+import type { StatusbarMenuItem } from '@/app/shell/statusbar-controls'
+
+const LOG_TAIL = 5
+
+interface RpcEventLike {
+  payload?: unknown
+  type?: string
+}
+
+function asRecord(payload: unknown): Record<string, unknown> {
+  return payload && typeof payload === 'object' ? (payload as Record<string, unknown>) : {}
+}
+
+const SCOPED_EVENT_PREFIXES = ['subagent.']
+
+export function gatewayEventRequiresSessionId(type: string | undefined): boolean {
+  if (type == null) return false
+  return SCOPED_EVENT_PREFIXES.some(prefix => type.startsWith(prefix))
+}
+
+export function gatewayEventCompletedFileDiff(event: RpcEventLike): boolean {
+  if (event.type !== 'tool.complete') {
+    return false
+  }
+
+  const diff = asRecord(event.payload).inline_diff
+
+  return typeof diff === 'string' && diff.trim().length > 0
+}
+
+export function buildGatewayLogItems(lines: readonly string[]): readonly StatusbarMenuItem[] {
+  if (lines.length === 0) {
+    return [
+      {
+        className: 'text-muted-foreground',
+        disabled: true,
+        id: 'gateway-log-empty',
+        label: 'No recent gateway log lines'
+      }
+    ]
+  }
+
+  return lines.slice(-LOG_TAIL).map((line, index) => ({
+    className: 'font-mono text-[0.68rem] text-muted-foreground',
+    disabled: true,
+    id: `gateway-log:${index}`,
+    label: line.trim().slice(0, 120) || '(blank log line)'
+  }))
+}

package/src/lib/gateway-ws-url.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { GatewayReauthRequiredError, isGatewayReauthRequired, resolveGatewayWsUrl } from './gateway-ws-url'
+
+const oauthConn = { authMode: 'oauth' as const, wsUrl: 'ws://host/api/ws?ticket=stale' }
+const tokenConn = { authMode: 'token' as const, wsUrl: 'ws://host/api/ws?token=abc' }
+
+describe('resolveGatewayWsUrl', () => {
+  describe('oauth mode', () => {
+    it('uses the freshly minted URL', async () => {
+      const getGatewayWsUrl = vi.fn().mockResolvedValue('ws://host/api/ws?ticket=fresh')
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn)).resolves.toBe('ws://host/api/ws?ticket=fresh')
+      expect(getGatewayWsUrl).toHaveBeenCalledOnce()
+    })
+
+    it('throws a reauth error instead of falling back to the stale cached ticket', async () => {
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(new Error('401 cookie expired'))
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn)).rejects.toBeInstanceOf(
+        GatewayReauthRequiredError
+      )
+    })
+
+    it('preserves the underlying mint failure as the cause', async () => {
+      const cause = new Error('401 cookie expired')
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(cause)
+      const error = await resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn).catch(e => e)
+      expect(error).toBeInstanceOf(GatewayReauthRequiredError)
+      expect((error as GatewayReauthRequiredError).cause).toBe(cause)
+    })
+
+    it('throws a reauth error when the preload cannot mint (no method)', async () => {
+      await expect(resolveGatewayWsUrl({}, oauthConn)).rejects.toBeInstanceOf(GatewayReauthRequiredError)
+    })
+
+    it('never returns the stale cached ticket on failure', async () => {
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(new Error('boom'))
+      const result = await resolveGatewayWsUrl({ getGatewayWsUrl }, oauthConn).catch(() => 'threw')
+      expect(result).toBe('threw')
+      expect(result).not.toBe(oauthConn.wsUrl)
+    })
+  })
+
+  describe('token / local mode', () => {
+    it('uses the minted URL when available', async () => {
+      const getGatewayWsUrl = vi.fn().mockResolvedValue('ws://host/api/ws?token=fresh')
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, tokenConn)).resolves.toBe('ws://host/api/ws?token=fresh')
+    })
+
+    it('falls back to the cached URL when minting fails (token is long-lived)', async () => {
+      const getGatewayWsUrl = vi.fn().mockRejectedValue(new Error('transient'))
+      await expect(resolveGatewayWsUrl({ getGatewayWsUrl }, tokenConn)).resolves.toBe(tokenConn.wsUrl)
+    })
+
+    it('falls back to the cached URL when the preload method is absent', async () => {
+      await expect(resolveGatewayWsUrl({}, tokenConn)).resolves.toBe(tokenConn.wsUrl)
+    })
+
+    it('treats a missing authMode as non-oauth (falls back safely)', async () => {
+      await expect(resolveGatewayWsUrl({}, { wsUrl: tokenConn.wsUrl })).resolves.toBe(tokenConn.wsUrl)
+    })
+  })
+})
+
+describe('isGatewayReauthRequired', () => {
+  it('detects the dedicated error class', () => {
+    expect(isGatewayReauthRequired(new GatewayReauthRequiredError('x'))).toBe(true)
+  })
+
+  it('detects plain objects tagged with needsOauthLogin (from the main process)', () => {
+    expect(isGatewayReauthRequired({ needsOauthLogin: true })).toBe(true)
+  })
+
+  it('rejects generic errors', () => {
+    expect(isGatewayReauthRequired(new Error('connection closed'))).toBe(false)
+    expect(isGatewayReauthRequired(null)).toBe(false)
+    expect(isGatewayReauthRequired('string')).toBe(false)
+  })
+})