@@ -10,6 +10,7 @@ import { registerCmdHandlers } from './cmd'
 import { registerI18nHandlers } from './i18n'
 import { registerDialogHandlers } from './dialog'
 import { registerDiagramHandlers } from './diagram'
+import { registerLinkHtmlHandler } from './linkHtml'
 
 export const registerSandboxIpcHandlers = (): void => {
   registerBootInfo()
@@ -24,4 +25,5 @@ export const registerSandboxIpcHandlers = (): void => {
   registerI18nHandlers()
   registerDialogHandlers()
   registerDiagramHandlers()
+  registerLinkHtmlHandler()
 }
@@ -0,0 +1,57 @@
+import { ipcMain, net } from 'electron'
+
+const TIMEOUT_MS = 1500
+const MAX_BYTES = 1024 * 1024
+
+type FetchLinkHtml = (url: string, init: RequestInit) => Promise<Response>
+
+export const fetchLinkHtml = async(url: string, fetchImpl: FetchLinkHtml): Promise<string> => {
+  let parsed: URL
+  try {
+    parsed = new URL(url)
+  } catch {
+    return ''
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol)) return ''
+
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS)
+  try {
+    const response = await fetchImpl(url, {
+      signal: controller.signal,
+      credentials: 'omit'
+    })
+    if (
+      response.status !== 200 ||
+      !/^text\/html\b/i.test(response.headers.get('content-type') ?? '')
+    ) {
+      await response.body?.cancel()
+      return ''
+    }
+    const reader = response.body?.getReader()
+    if (!reader) return ''
+    const decoder = new TextDecoder()
+    let html = ''
+    let size = 0
+    try {
+      for (;;) {
+        const { value, done } = await reader.read()
+        if (done) return html + decoder.decode()
+        size += value.byteLength
+        if (size > MAX_BYTES) return ''
+        html += decoder.decode(value, { stream: true })
+      }
+    } finally {
+      // Stop oversized or interrupted responses instead of leaving them streaming.
+      await reader.cancel().catch(() => {})
+    }
+  } catch {
+    return ''
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+export const registerLinkHtmlHandler = (): void => {
+  ipcMain.handle('mt::link::fetch-html', (_event, url: string) => fetchLinkHtml(url, net.fetch))
+}
@@ -244,6 +244,7 @@ const electronAPI = {
   ipcRenderer: ipcWrapper,
   shell: shellAPI,
   clipboard: clipboardAPI,
+  fetchLinkHtml: (url: string) => invoke('mt::link::fetch-html', url),
   webFrame: webFrameAPI,
   webUtils: webUtilsAPI,
   process: {
 
@@ -1804,6 +1804,7 @@ onMounted(() => {
     clipboardFilePath: guessClipboardFilePath,
     // Read the OS clipboard's plain text for "Paste as Plain Text" (execCommand('paste') no longer fires).
     clipboardText: () => window.electron.clipboard.readText(),
+    fetchLinkHtml: (url) => window.electron.fetchLinkHtml(url),
     // Image-persist callbacks read by the engine's clipboard + drag-drop handlers
     // from `muya.options.*` (distinct from the ImageEditTool plugin option above).
     // Without these, local-file drag-drop, screenshot/binary clipboard paste, and
 
@@ -54,6 +54,7 @@ export interface IpcInvokeChannels {
   'mt::boot-info-async': { args: []; ret: BootInfo }
   'mt::clipboard::guess-file-path': { args: []; ret: string | null }
   'mt::clipboard::read-text': { args: []; ret: string }
+  'mt::link::fetch-html': { args: [url: string]; ret: string }
   'mt::clipboard::write-image': { args: [png: Uint8Array]; ret: boolean }
   'mt::cmd::exists': { args: [name: string]; ret: boolean }
   'mt::diagram::fetch-plantuml': {
 
@@ -88,6 +88,7 @@ declare global {
     ipcRenderer: ElectronIpcRenderer
     shell: ElectronShellAPI
     clipboard: ElectronClipboardAPI
+    fetchLinkHtml(url: string): Promise<string>
     webFrame: ElectronWebFrameAPI
     webUtils: ElectronWebUtilsAPI
     process: {
 
@@ -0,0 +1,78 @@
+import { createServer, type Server } from 'node:http'
+import { expect, test } from '@playwright/test'
+import type { ElectronApplication, Page } from 'playwright'
+import { getMarkdownContent, launchWithMarkdown, placeCaretInEditor } from './helpers'
+
+let app: ElectronApplication
+let page: Page
+let server: Server
+let url: string
+let requests: string[]
+
+test.beforeAll(async() => {
+  requests = []
+  server = createServer((request, response) => {
+    requests.push(request.url ?? '')
+    response.setHeader('content-type', 'text/html; charset=utf-8')
+    response.end('<!doctype html><title>Example &amp; page title</title><p>Content</p>')
+  })
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const address = server.address()
+  if (!address || typeof address === 'string') throw new Error('Missing test server port')
+  url = `http://127.0.0.1:${address.port}`
+})
+
+test.beforeEach(async() => {
+  const launched = await launchWithMarkdown('\n')
+  app = launched.app
+  page = launched.page
+  await placeCaretInEditor(page)
+  requests.length = 0
+})
+
+test.afterEach(async() => {
+  if (app) await app.close()
+})
+
+test.afterAll(async() => {
+  server.closeAllConnections()
+  await new Promise<void>((resolve) => server.close(() => resolve()))
+})
+
+const paste = async(text: string) => {
+  await page.evaluate((text) => {
+    const target = document.querySelector('.mu-editor[contenteditable="true"]')
+    if (!target) throw new Error('Missing editor')
+    const data = new DataTransfer()
+    data.setData('text/plain', text)
+    target.dispatchEvent(new ClipboardEvent('paste', { clipboardData: data, bubbles: true, cancelable: true }))
+  }, text)
+}
+
+test('pasted URL gets its title despite renderer CSP and absent CORS headers', async() => {
+  expect(await page.evaluate(async(url) => {
+    try { await fetch(url); return true } catch { return false }
+  }, url)).toBe(false)
+  expect(requests).toEqual([])
+
+  await paste(url)
+  await expect(page.locator('.editor-component .mu-link').filter({ hasText: 'Example & page title' })).toHaveCount(1)
+  expect(requests).toEqual(['/'])
+  await page.screenshot({ path: test.info().outputPath('paste-url-title.png') })
+  expect(await getMarkdownContent(page, app)).toContain(`[Example & page title](${url})`)
+})
+
+test('plain-text paste does not fetch a page title', async() => {
+  await app.evaluate(({ clipboard }, value) => clipboard.writeText(value), url)
+  await app.evaluate(({ BrowserWindow }) => {
+    BrowserWindow.getAllWindows()[0].webContents.send('mt::cm-paste-as-plain-text')
+  })
+  await expect(page.locator('.editor-component')).toContainText(url)
+  expect(requests).toEqual([])
+  expect(await getMarkdownContent(page, app)).not.toContain('Example & page title')
+})
+
+test('failed title lookup preserves the URL', async() => {
+  await paste('http://127.0.0.1:1/unreachable')
+  await expect(page.locator('.editor-component')).toContainText('http://127.0.0.1:1/unreachable')
+})
@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from 'vitest'
+import { fetchLinkHtml, registerLinkHtmlHandler } from 'main_renderer/ipc/linkHtml'
+
+const { handle, fetchImpl } = vi.hoisted(() => ({ handle: vi.fn(), fetchImpl: vi.fn() }))
+vi.mock('electron', () => ({ ipcMain: { handle }, net: { fetch: fetchImpl } }))
+
+const htmlResponse = (body: string, init: ResponseInit = {}) =>
+  new Response(body, { headers: { 'content-type': 'text/html; charset=utf-8' }, ...init })
+
+describe('link HTML transport', () => {
+  it('returns HTML through a registered IPC handler without sending session cookies', async() => {
+    registerLinkHtmlHandler()
+    const handler = handle.mock.calls.find(([channel]) => channel === 'mt::link::fetch-html')?.[1]
+    fetchImpl.mockResolvedValueOnce(htmlResponse('<title>Example &amp; title</title>'))
+    expect(await handler({}, 'https://example.com')).toBe('<title>Example &amp; title</title>')
+    expect(fetchImpl).toHaveBeenCalledWith('https://example.com', {
+      signal: expect.any(AbortSignal), credentials: 'omit'
+    })
+  })
+
+  it.each(['file:///etc/passwd', 'javascript:alert(1)', 'data:text/html,test', 'invalid'])('rejects %s', async(url) => {
+    const fetcher = vi.fn()
+    expect(await fetchLinkHtml(url, fetcher)).toBe('')
+    expect(fetcher).not.toHaveBeenCalled()
+  })
+
+  it.each([
+    new Response('missing', { status: 404 }),
+    new Response('{}', { headers: { 'content-type': 'application/json' } })
+  ])('ignores unsuccessful or non-HTML responses', async(response) => {
+    expect(await fetchLinkHtml('https://example.com', async() => response)).toBe('')
+  })
+
+  it('stops reading oversized responses', async() => {
+    const cancel = vi.fn()
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) { controller.enqueue(new Uint8Array(1024 * 1024 + 1)) },
+      cancel
+    })
+    const response = new Response(body, { headers: { 'content-type': 'text/html' } })
+    expect(await fetchLinkHtml('https://example.com', async() => response)).toBe('')
+    expect(cancel).toHaveBeenCalled()
+  })
+
+  it('falls back on a network failure', async() => {
+    expect(await fetchLinkHtml('https://example.com', async() => { throw new Error('offline') })).toBe('')
+  })
+
+  it('aborts a slow network request', async() => {
+    vi.useFakeTimers()
+    try {
+      let signal: AbortSignal | null | undefined
+      const result = fetchLinkHtml('https://example.com', async(_url, init) => {
+        signal = init.signal
+        return new Promise((_resolve, reject) => {
+          init.signal?.addEventListener('abort', () => reject(new Error('aborted')))
+        })
+      })
+      await vi.advanceTimersByTimeAsync(1500)
+      expect(await result).toBe('')
+      expect(signal?.aborted).toBe(true)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
@@ -96,6 +96,28 @@ muya.init();
 
 A complete example, including a Vite project setup, lives under [`examples/`](./examples).
 
+## Pasted link titles
+
+Normal paste can turn a bare HTTP(S) URL into a link labeled with the page title.
+Muya fetches and parses the HTML, decodes title entities, and falls back to the
+URL if fetching fails or takes longer than 1.5 seconds. Plain-text paste skips
+this lookup.
+
+Browser fetching is subject to the host page's CSP and the target site's CORS
+headers. Hosts can provide `fetchLinkHtml` to use their own HTTP transport or
+backend proxy while leaving title parsing and paste behavior in Muya:
+
+```ts
+const muya = new Muya(container, {
+    fetchLinkHtml: url => hostNetwork.fetchHtml(url),
+});
+```
+
+The hook returns the HTML body, or an empty string for unsuccessful/non-HTML
+responses. It should enforce its own request timeout and response size limit;
+Muya's timeout stops waiting but cannot cancel a host request. MarkText supplies
+this hook through its sandboxed preload bridge to the main process.
+
 ## API at a glance
 
 The `Muya` instance returned from `new Muya(el, options)` exposes: