nastech-tui 0.0.1

package/src/__tests__/creditsCommand.test.ts

@@ -0,0 +1,144 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { creditsCommands } from '../app/slash/commands/credits.js'
+import { getOverlayState, resetOverlayState } from '../app/overlayStore.js'
+import type { CreditsViewResponse } from '../gatewayTypes.js'
+
+// The command opens the top-up URL through this helper on confirm. Mock it so
+// the test never shells out to a real browser/`xdg-open` and we can assert the
+// success/failure messaging deterministically.
+vi.mock('../lib/openExternalUrl.js', () => ({
+  openExternalUrl: vi.fn(() => true)
+}))
+
+import { openExternalUrl } from '../lib/openExternalUrl.js'
+
+const openExternalUrlMock = vi.mocked(openExternalUrl)
+
+const creditsCommand = creditsCommands.find(cmd => cmd.name === 'credits')!
+
+const buildView = (overrides: Partial<CreditsViewResponse> = {}): CreditsViewResponse => ({
+  balance_lines: ['Grant: $9.50 left', 'Top-up: $25.00'],
+  depleted: false,
+  identity_line: 'Signed in as ada@example.com',
+  logged_in: true,
+  topup_url: 'https://portal.nastechai.com/billing/topup',
+  ...overrides
+})
+
+// Mirror createSlashHandler's real `guarded` wrapper: skip the handler when the
+// command is stale OR the response is falsy. Tests stay non-stale, so this is a
+// straightforward "run the handler when we got a response" shim.
+const guarded =
+  <T,>(fn: (r: T) => void) =>
+  (r: null | T) => {
+    if (r) {
+      fn(r)
+    }
+  }
+
+const buildCtx = (rpcResult: CreditsViewResponse) => {
+  const sys = vi.fn()
+  const rpc = vi.fn(() => Promise.resolve(rpcResult))
+  const guardedErr = vi.fn()
+
+  const ctx = {
+    gateway: { rpc },
+    guarded,
+    guardedErr,
+    sid: 'sid-abc',
+    stale: () => false,
+    transcript: { page: vi.fn(), panel: vi.fn(), sys }
+  }
+
+  // Run the command, then await the rpc promise so the .then() handler has
+  // flushed before assertions — deterministic, no polling/timeouts.
+  const run = async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    creditsCommand.run('', ctx as any, 'credits')
+    await rpc.mock.results[0]?.value
+    // Allow the chained .then() microtask to settle.
+    await Promise.resolve()
+  }
+
+  return { ctx, rpc, run, sys }
+}
+
+describe('/credits slash command', () => {
+  beforeEach(() => {
+    resetOverlayState()
+    openExternalUrlMock.mockClear()
+    openExternalUrlMock.mockReturnValue(true)
+  })
+
+  it('renders the balance (including top-up URL) and arms the confirm overlay', async () => {
+    const view = buildView()
+    const { rpc, run, sys } = buildCtx(view)
+
+    await run()
+
+    expect(rpc).toHaveBeenCalledWith('credits.view', { session_id: 'sid-abc' })
+
+    // (a) sys received the balance text including the topup_url
+    const printed = sys.mock.calls.map(call => call[0]).join('\n')
+    expect(printed).toContain('💳 NasTech credits')
+    expect(printed).toContain('Grant: $9.50 left')
+    expect(printed).toContain('Signed in as ada@example.com')
+    expect(printed).toContain(view.topup_url)
+
+    // (b) confirm overlay set with the expected label + detail
+    const confirm = getOverlayState().confirm
+    expect(confirm).toBeTruthy()
+    expect(confirm?.confirmLabel).toBe('Open top-up in browser')
+    expect(confirm?.cancelLabel).toBe('Cancel')
+    expect(confirm?.title).toBe('Add credits?')
+    expect(confirm?.detail).toBe(view.topup_url)
+
+    // onConfirm opens the URL and reports success back to the transcript
+    confirm?.onConfirm()
+    expect(openExternalUrlMock).toHaveBeenCalledWith(view.topup_url)
+    expect(sys).toHaveBeenCalledWith(
+      'Complete your top-up in the browser — credits will appear in /credits shortly.'
+    )
+  })
+
+  it('falls back to printing the URL when the browser open is rejected', async () => {
+    openExternalUrlMock.mockReturnValue(false)
+    const view = buildView()
+    const { run, sys } = buildCtx(view)
+
+    await run()
+
+    const confirm = getOverlayState().confirm
+    expect(confirm).toBeTruthy()
+    confirm?.onConfirm()
+    expect(sys).toHaveBeenCalledWith(`Open this URL to top up: ${view.topup_url}`)
+  })
+
+  it('does not arm the confirm overlay when there is no top-up URL', async () => {
+    const view = buildView({ topup_url: null })
+    const { run, sys } = buildCtx(view)
+
+    await run()
+
+    const printed = sys.mock.calls.map(call => call[0]).join('\n')
+    expect(printed).toContain('💳 NasTech credits')
+    expect(getOverlayState().confirm).toBeNull()
+  })
+
+  it('shows the not-logged-in message and does NOT arm the confirm overlay', async () => {
+    const view = buildView({
+      balance_lines: [],
+      identity_line: null,
+      logged_in: false,
+      topup_url: null
+    })
+    const { run, sys } = buildCtx(view)
+
+    await run()
+
+    expect(sys).toHaveBeenCalledWith('💳 Not logged into NasTech Portal — run /portal to log in.')
+    expect(getOverlayState().confirm).toBeNull()
+    expect(openExternalUrlMock).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/cursorDriftRegression.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Pinned regression for the multi-line composer cursor-drift bug.
+ *
+ * Symptom: in `nastech --tui`, typing into the composer until the input
+ * wraps across multiple visual rows would leave several blank cells
+ * between the last typed character and the (hardware) cursor block.
+ * Worse on narrow terminals (the Cursor IDE built-in terminal in
+ * particular).
+ *
+ * Root cause: the composer's `cursorLayout` (used by `useDeclaredCursor`
+ * to place the hardware cursor) ran a hand-rolled word-wrap algorithm,
+ * while Ink's `<Text wrap="wrap">` renders via `wrap-ansi`. The two
+ * disagreed on many real inputs — wrap-ansi would keep "branch
+ * investigate" on one row while cursorLayout claimed it had wrapped,
+ * etc. — so the declared cursor position drifted from where the text
+ * was actually rendered. The fix sources cursorLayout's line breaks
+ * directly from wrap-ansi, guaranteeing agreement.
+ *
+ * This test pins the contract: for every char that would be typed into
+ * the composer, the cursor position reported by cursorLayout MUST equal
+ * the end-of-text position that wrap-ansi would render. Any future
+ * regression that lets the two diverge re-introduces the drift.
+ */
+import { wrapAnsi } from '@nastechai/ink'
+import { describe, expect, it } from 'vitest'
+
+import { cursorLayout, inputVisualHeight } from '../lib/inputMetrics.js'
+
+function wrapAnsiEnd(text: string, cols: number): { line: number; column: number } {
+  const wrapped = wrapAnsi(text, cols, { hard: true, trim: false })
+  const lines = wrapped.split('\n')
+  const last = lines[lines.length - 1] ?? ''
+
+  return { line: lines.length - 1, column: last.length }
+}
+
+const USER_REPORT_MESSAGE =
+  // Paraphrase of the user's actual bug report, included verbatim so the
+  // test is grounded in a realistic typing pattern (long single line,
+  // mixed-length words, punctuation, no hard newlines).
+  'im in cursor terminal using nastech --tui and as i type multiline my caret at the end will often ' +
+  'go.. randomly.. like multiple spaces away lol and idk why. theres no rhyme/reason really but ' +
+  'there should literally never be a non-user added space at the end of my composer input right? ' +
+  'i dont think it happens on new sessions but only existing ones. there have been a few prs to ' +
+  'try to fix this and all not working. ok it just happened, to me, nowso attaching screenshot ' +
+  'and you can see its multiline, new session. on a new bb/<xxx> branch investigate'
+
+describe('cursor-drift regression — composer cursorLayout matches Ink rendering', () => {
+  it('agrees with wrap-ansi at every typing-prefix of the user-reported message', () => {
+    // Walks the message char-by-char (mirroring what the TUI sees when a
+    // user types). At every prefix, cursorLayout must place the cursor
+    // exactly where wrap-ansi would render the end of the text.
+    //
+    // Pre-fix: this failed on most narrow widths because the hand-rolled
+    // wrap algorithm broke at slightly different points than wrap-ansi.
+    for (const cols of [40, 50, 55, 60, 65, 70, 80]) {
+      let acc = ''
+
+      for (const ch of USER_REPORT_MESSAGE) {
+        acc += ch
+        const layout = cursorLayout(acc, acc.length, cols)
+        const expected = wrapAnsiEnd(acc, cols)
+
+        expect(
+          layout,
+          `mismatch at cols=${cols}, len=${acc.length}, last-char=${JSON.stringify(ch)}, ` +
+            `tail=${JSON.stringify(acc.slice(-30))}`
+        ).toEqual(expected)
+      }
+    }
+  })
+
+  it('keeps cursor on the same row when text exactly fills the terminal width', () => {
+    // wrap-ansi does NOT push exact-fill text onto a phantom next line.
+    // The previous algorithm did — that's what produced the visible
+    // "cursor parked one row below the last char" symptom on narrow
+    // terminals at certain message lengths.
+    for (const cols of [8, 12, 18, 24]) {
+      const text = 'a'.repeat(cols)
+      const layout = cursorLayout(text, text.length, cols)
+      const inkLines = wrapAnsi(text, cols, { hard: true, trim: false }).split('\n')
+
+      expect(layout.line).toBe(0)
+      expect(layout.column).toBe(cols)
+      expect(inkLines).toHaveLength(1)
+      expect(inputVisualHeight(text, cols)).toBe(1)
+    }
+  })
+
+  it('does not stuff a trailing whitespace word onto a phantom line', () => {
+    // "branch investigate" at cols=20 fits on one row in wrap-ansi. The
+    // bug claimed otherwise, parking the cursor at (line=1, col=?) and
+    // leaving the user's "branch investigate" rendered alone on row 0
+    // with the cursor block several cells past it.
+    const text = 'branch investigate'
+    const cols = 20
+
+    expect(cursorLayout(text, text.length, cols)).toEqual({ column: text.length, line: 0 })
+    expect(cursorLayout(text, text.length, cols)).toEqual(wrapAnsiEnd(text, cols))
+  })
+
+  it('agrees with wrap-ansi for word-wrap that pushes a word onto the next line', () => {
+    // "hello world" at cols=8 wraps to ["hello ", "world"] in wrap-ansi.
+    // The cursor at end-of-text must land at line=1, col=5 — where Ink
+    // actually renders the last 'd'. The previous algorithm reported
+    // (line=2, col=0) here (phantom extra wrap), which parked the
+    // cursor on a row Ink never painted.
+    const text = 'hello world'
+    const cols = 8
+
+    expect(cursorLayout(text, text.length, cols)).toEqual({ column: 5, line: 1 })
+    expect(cursorLayout(text, text.length, cols)).toEqual(wrapAnsiEnd(text, cols))
+  })
+})

package/src/__tests__/details.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from 'vitest'
+
+import { isSectionName, parseDetailsMode, resolveSections, SECTION_NAMES, sectionMode } from '../domain/details.js'
+
+describe('parseDetailsMode', () => {
+  it('accepts the canonical modes case-insensitively', () => {
+    expect(parseDetailsMode('hidden')).toBe('hidden')
+    expect(parseDetailsMode(' COLLAPSED ')).toBe('collapsed')
+    expect(parseDetailsMode('Expanded')).toBe('expanded')
+  })
+
+  it('rejects junk', () => {
+    expect(parseDetailsMode('truncated')).toBeNull()
+    expect(parseDetailsMode('')).toBeNull()
+    expect(parseDetailsMode(undefined)).toBeNull()
+    expect(parseDetailsMode(42)).toBeNull()
+  })
+})
+
+describe('isSectionName', () => {
+  it('only lets the four canonical sections through', () => {
+    expect(isSectionName('thinking')).toBe(true)
+    expect(isSectionName('tools')).toBe(true)
+    expect(isSectionName('subagents')).toBe(true)
+    expect(isSectionName('activity')).toBe(true)
+
+    expect(isSectionName('Thinking')).toBe(false) // case-sensitive on purpose
+    expect(isSectionName('bogus')).toBe(false)
+    expect(isSectionName('')).toBe(false)
+    expect(isSectionName(7)).toBe(false)
+  })
+
+  it('SECTION_NAMES exposes them all', () => {
+    expect([...SECTION_NAMES].sort()).toEqual(['activity', 'subagents', 'thinking', 'tools'])
+  })
+})
+
+describe('resolveSections', () => {
+  it('parses a well-formed sections object', () => {
+    expect(
+      resolveSections({
+        thinking: 'expanded',
+        tools: 'expanded',
+        subagents: 'collapsed',
+        activity: 'hidden'
+      })
+    ).toEqual({
+      thinking: 'expanded',
+      tools: 'expanded',
+      subagents: 'collapsed',
+      activity: 'hidden'
+    })
+  })
+
+  it('drops unknown section names and unknown modes', () => {
+    expect(
+      resolveSections({
+        thinking: 'expanded',
+        tools: 'maximised',
+        bogus: 'hidden',
+        activity: 'hidden'
+      })
+    ).toEqual({ thinking: 'expanded', activity: 'hidden' })
+  })
+
+  it('treats nullish/non-objects as empty overrides', () => {
+    expect(resolveSections(undefined)).toEqual({})
+    expect(resolveSections(null)).toEqual({})
+    expect(resolveSections('hidden')).toEqual({})
+    expect(resolveSections([])).toEqual({})
+  })
+})
+
+describe('sectionMode', () => {
+  it('falls back to the global mode for sections without a built-in default', () => {
+    expect(sectionMode('subagents', 'collapsed', {})).toBe('collapsed')
+    expect(sectionMode('subagents', 'expanded', undefined)).toBe('expanded')
+    expect(sectionMode('subagents', 'hidden', {})).toBe('hidden')
+  })
+
+  it('streams thinking + tools expanded by default for persisted config values', () => {
+    expect(sectionMode('thinking', 'collapsed', {})).toBe('expanded')
+    expect(sectionMode('thinking', 'hidden', undefined)).toBe('expanded')
+    expect(sectionMode('tools', 'collapsed', {})).toBe('expanded')
+    expect(sectionMode('tools', 'hidden', undefined)).toBe('expanded')
+  })
+
+  it('hides the activity panel by default for persisted config values', () => {
+    expect(sectionMode('activity', 'collapsed', {})).toBe('hidden')
+    expect(sectionMode('activity', 'expanded', undefined)).toBe('hidden')
+    expect(sectionMode('activity', 'hidden', {})).toBe('hidden')
+  })
+
+  it('applies in-session /details mode globally over built-in defaults', () => {
+    expect(sectionMode('thinking', 'collapsed', {}, true)).toBe('collapsed')
+    expect(sectionMode('tools', 'hidden', {}, true)).toBe('hidden')
+    expect(sectionMode('activity', 'expanded', undefined, true)).toBe('expanded')
+  })
+
+  it('honours per-section overrides over both the section default and global mode', () => {
+    expect(sectionMode('thinking', 'collapsed', { thinking: 'collapsed' })).toBe('collapsed')
+    expect(sectionMode('tools', 'collapsed', { tools: 'hidden' })).toBe('hidden')
+    expect(sectionMode('activity', 'collapsed', { activity: 'expanded' })).toBe('expanded')
+    expect(sectionMode('activity', 'expanded', { activity: 'collapsed' })).toBe('collapsed')
+  })
+
+  it('lets per-section overrides escape the global hidden mode', () => {
+    // Regression for the case where global details_mode: hidden used to
+    // short-circuit the entire accordion and prevent overrides from
+    // surfacing — `sections.tools: expanded` must still resolve to expanded.
+    expect(sectionMode('subagents', 'hidden', { subagents: 'expanded' })).toBe('expanded')
+    expect(sectionMode('thinking', 'hidden', { thinking: 'collapsed' })).toBe('collapsed')
+    expect(sectionMode('activity', 'hidden', { activity: 'expanded' })).toBe('expanded')
+  })
+})

package/src/__tests__/emoji.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest'
+
+import { ensureEmojiPresentation } from '../lib/emoji.js'
+
+const VS16 = '\uFE0F'
+
+describe('ensureEmojiPresentation', () => {
+  it('passes through ASCII unchanged', () => {
+    expect(ensureEmojiPresentation('hello world')).toBe('hello world')
+    expect(ensureEmojiPresentation('')).toBe('')
+  })
+
+  it('passes through emoji that already defaults to emoji presentation', () => {
+    expect(ensureEmojiPresentation('🚀 rocket')).toBe('🚀 rocket')
+    expect(ensureEmojiPresentation('😀')).toBe('😀')
+  })
+
+  it('injects VS16 after text-default emoji codepoints', () => {
+    expect(ensureEmojiPresentation('⚠ careful')).toBe(`⚠${VS16} careful`)
+    expect(ensureEmojiPresentation('ℹ info')).toBe(`ℹ${VS16} info`)
+    expect(ensureEmojiPresentation('love ❤ you')).toBe(`love ❤${VS16} you`)
+    expect(ensureEmojiPresentation('✔ done')).toBe(`✔${VS16} done`)
+  })
+
+  it('is idempotent when VS16 is already present', () => {
+    const already = `⚠${VS16} ℹ${VS16} ❤${VS16}`
+
+    expect(ensureEmojiPresentation(already)).toBe(already)
+    expect(ensureEmojiPresentation(ensureEmojiPresentation('⚠'))).toBe(`⚠${VS16}`)
+  })
+
+  it('leaves keycap sequences alone when the base is not a text-default emoji', () => {
+    expect(ensureEmojiPresentation('1\u20e3')).toBe('1\u20e3')
+  })
+
+  it('injects VS16 before ZWJ so text-default bases participate in emoji sequences', () => {
+    // ❤ + ZWJ + 🔥 → ❤️‍🔥 (heart on fire).  Without VS16 between the heart
+    // and the ZWJ, terminals render the heart in text/monochrome form and
+    // the ZWJ ligature can fail to form.
+    const heartFire = '\u2764\u200d\ud83d\udd25'
+
+    expect(ensureEmojiPresentation(heartFire)).toBe(`\u2764\uFE0F\u200d\ud83d\udd25`)
+  })
+
+  it('leaves explicit text-presentation selector (VS15) alone', () => {
+    // `❤︎` (U+2764 + U+FE0E) asks for text presentation — injecting VS16
+    // would create an invalid double-variation sequence.
+    const explicitText = '\u2764\ufe0e'
+
+    expect(ensureEmojiPresentation(explicitText)).toBe(explicitText)
+  })
+
+  it('returns the original reference when no change is needed', () => {
+    const already = `⚠${VS16} ℹ${VS16} ❤${VS16}`
+
+    // Reference equality — the lazy allocator should short-circuit to the
+    // input when nothing needed injection.
+    expect(ensureEmojiPresentation(already)).toBe(already)
+  })
+
+  it('handles mixed content', () => {
+    expect(ensureEmojiPresentation('⚠ path: /tmp/x ❤ done')).toBe(`⚠${VS16} path: /tmp/x ❤${VS16} done`)
+  })
+})

package/src/__tests__/externalLink.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  __resetLinkTitleCache,
+  fetchLinkTitle,
+  hostPathLabel,
+  isTitleFetchable,
+  normalizeExternalUrl,
+  urlSlugTitleLabel
+} from '../lib/externalLink.js'
+
+afterEach(() => {
+  __resetLinkTitleCache()
+  vi.restoreAllMocks()
+  vi.unstubAllGlobals()
+})
+
+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('keeps x.com status fallbacks link-like instead of generic Status labels', () => {
+    expect(urlSlugTitleLabel('https://x.com/grok/status/2056065022749479209')).toBe(
+      'x.com/grok/status/2056065022749479209'
+    )
+  })
+
+  it('normalizes scheme-less links', () => {
+    expect(normalizeExternalUrl(' expedia.com/things-to-do/puerto-rico-el-yunque ')).toBe(
+      'https://expedia.com/things-to-do/puerto-rico-el-yunque'
+    )
+  })
+
+  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('blocks private, link-local, and intranet hosts', () => {
+    expect(isTitleFetchable('http://10.0.0.12/path')).toBe(false)
+    expect(isTitleFetchable('http://172.22.5.4/path')).toBe(false)
+    expect(isTitleFetchable('http://192.168.1.22/path')).toBe(false)
+    expect(isTitleFetchable('http://169.254.169.254/latest/meta-data')).toBe(false)
+    expect(isTitleFetchable('http://[fd00::1]/')).toBe(false)
+    expect(isTitleFetchable('http://[fe80::1]/')).toBe(false)
+    expect(isTitleFetchable('http://printer.local/status')).toBe(false)
+    expect(isTitleFetchable('http://intranet/status')).toBe(false)
+    expect(isTitleFetchable('https://8.8.8.8/status')).toBe(true)
+  })
+
+  it('deduplicates in-flight title fetches and caches results', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response('<html><head><title>El Yunque Tour Water Slide, Rope Swing & Pickup</title></head></html>', {
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+        status: 200
+      })
+    )
+
+    vi.stubGlobal('fetch', fetchMock)
+
+    const url = 'https://www.expedia.com/things-to-do/puerto-rico-el-yunque-rainforest-adventure.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(fetchMock).toHaveBeenCalledTimes(1)
+
+    const third = await fetchLinkTitle(url)
+
+    expect(third).toBe('El Yunque Tour Water Slide, Rope Swing & Pickup')
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('shares cache across protocol/www URL variants', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response('<html><head><title>Shared Canonical Title</title></head></html>', {
+        headers: { 'content-type': 'text/html' },
+        status: 200
+      })
+    )
+
+    vi.stubGlobal('fetch', fetchMock)
+
+    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(fetchMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('ignores error-like fetched titles', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response('<html><head><title>Just a moment...</title></head></html>', {
+        headers: { 'content-type': 'text/html' },
+        status: 200
+      })
+    )
+
+    vi.stubGlobal('fetch', fetchMock)
+
+    const url = 'https://www.getyourguide.com/culebra-island-l145468/from-fajardo-full-day-cordillera-islands-catamaran-tour-t19894/'
+
+    await expect(fetchLinkTitle(url)).resolves.toBe('')
+  })
+
+  it('decodes HTML entities in fetched titles', async () => {
+    const fetchMock = vi.fn().mockResolvedValue(
+      new Response('<html><head><title>AT&amp;T &#39;Deals&#39;</title></head></html>', {
+        headers: { 'content-type': 'text/html' },
+        status: 200
+      })
+    )
+
+    vi.stubGlobal('fetch', fetchMock)
+
+    await expect(fetchLinkTitle('https://example.com/offers')).resolves.toBe("AT&T 'Deals'")
+  })
+
+  it('skips network fetch for non-fetchable targets', async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+
+    await expect(fetchLinkTitle('http://localhost:3000/path')).resolves.toBe('')
+    await expect(fetchLinkTitle('mailto:hello@example.com')).resolves.toBe('')
+    await expect(fetchLinkTitle('file:///tmp/demo.html')).resolves.toBe('')
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+})