From abad09a6c1f60cafd6964e31f09d77790fd699a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mindaugas=20Kasparavic=CC=8Cius?= <kasp.mindaugas@gmail.com>
Date: Fri, 14 Aug 2026 20:56:48 +0300
Subject: [PATCH] =?UTF-8?q?Either=20side=20of=20the=20diff,=20onto=20the?=
 =?UTF-8?q?=20clipboard=20=E2=80=94=20and=20the=20.har=20that=20crashed=20?=
 =?UTF-8?q?it?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Copying a SIDE is not copying the diff: each slot now carries a copy control
that puts that file's own text on the clipboard verbatim, reachable from the
slot, Edit ▸ Copy Left/Right Side, the palette and CmdOrCtrl+Shift+1/2 —
Shift over the digit that OPENS that side.

A side with no text to give — a spreadsheet carries sheets, a streamed file
only a path — shows no control at all rather than one that refuses. utils/
sideText.js answers that once for both the button and the action, so no
surface can offer what another declines.

Two files sat at their exact ratchets and forced the extraction rather than a
raised cap: diffStore (747/747) hands its copy actions to stores/diffCopy.js,
the way snippetStore already hands off tags, colour and history; buildMenus
(87/87) hands its Edit section to editSection(). Both ratchets TIGHTEN —
747→710 and 87→67.

The crash a .har produced took three faults, and all three are fixed:

  - .har was in no extension map, so it fell through to content sniffing.
  - Sniffing sees a 50k prefix, which cuts a multi-MB capture into JSON that
    no longer parses; HTML_RE then matched the <div>/<script> inside the
    captured response bodies and named the whole file HTML.
  - Monaco's HTML worker walks document symbols by plain recursion with no
    depth guard, and every tag inside a JSON string is unclosed to an HTML
    parser, so the nesting accumulated until the stack went.

har/map/webmanifest now resolve to json outright; the two sniffers that scan
anywhere skip JSON-shaped text; and documentSymbols is off for HTML, which
removes the crash surface for ANY deeply nested HTML rather than this one
route. Nothing here consumes symbols — no outline, no breadcrumbs, and the
palette that would offer Go to Symbol is already unbound.

detectLanguage.js was itself at 250/250, so the claude.ai link helpers — never
language detection — moved to utils/claudeLink.js.

The all-20 theme check for the new control lives in e2e, not theme-sweep:
every surface there opens through paste mode, which replaces the slots row,
and the control exists only once a real file is loaded. It caught .btn-icon's
--text-dim falling under the 3:1 mark floor on five light grounds (sepia 2.09,
solar 2.37, bloom 2.58, linen 2.72, meridian 2.91), so the revealed state
takes full ink. The first run of that probe was itself wrong — .btn transitions
colour over 120ms and getComputedStyle reports the interpolated value — so it
settles before measuring and carries a control probe that fails the
INSTRUMENT, not the theme, when the reading is impossible.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 e2e/copy-side-themes.spec.mjs                 |  98 +++++++++++
 e2e/copy-side.spec.mjs                        | 154 ++++++++++++++++++
 e2e/deep-html.spec.mjs                        |  42 +++++
 scripts/lib/legacySize.mjs                    |   4 +-
 src/main/menuSections.js                      |  11 ++
 src/renderer/src/adapters/textAdapter.js      |   6 +
 src/renderer/src/components/FileSlot.vue      |  44 +++--
 src/renderer/src/components/FileSlotsRow.vue  |   2 +
 .../src/components/styles/FileSlot.css        |  55 ++++++-
 .../src/composables/useSnippetRowActions.js   |   2 +-
 src/renderer/src/menus.js                     |  39 ++---
 src/renderer/src/monaco-setup.js              |  13 ++
 src/renderer/src/stores/diffCopy.js           |  53 ++++++
 src/renderer/src/stores/diffStore.js          |  43 +----
 src/renderer/src/utils/claudeLink.js          |  13 ++
 src/renderer/src/utils/commands.js            |   5 +
 src/renderer/src/utils/detectLanguage.js      |  22 +--
 src/renderer/src/utils/shortcuts.js           |   2 +
 src/renderer/src/utils/sideText.js            |  44 +++++
 src/shared/i18n/en-XA.json                    |  15 +-
 src/shared/i18n/en.json                       |  15 +-
 tests/renderer/adapters/textAdapter.test.js   |  38 +++++
 tests/renderer/stores/diffCopy.test.js        | 113 +++++++++++++
 tests/renderer/utils/commands.test.js         |   1 +
 tests/renderer/utils/sideText.test.js         |  98 +++++++++++
 25 files changed, 827 insertions(+), 105 deletions(-)
 create mode 100644 e2e/copy-side-themes.spec.mjs
 create mode 100644 e2e/copy-side.spec.mjs
 create mode 100644 e2e/deep-html.spec.mjs
 create mode 100644 src/renderer/src/stores/diffCopy.js
 create mode 100644 src/renderer/src/utils/claudeLink.js
 create mode 100644 src/renderer/src/utils/sideText.js
 create mode 100644 tests/renderer/stores/diffCopy.test.js
 create mode 100644 tests/renderer/utils/sideText.test.js

diff --git a/e2e/copy-side-themes.spec.mjs b/e2e/copy-side-themes.spec.mjs
new file mode 100644
index 00000000..5ad9b188
--- /dev/null
+++ b/e2e/copy-side-themes.spec.mjs
@@ -0,0 +1,98 @@
+import { test, expect, openSettings, stubOpenDialog } from './fixtures.mjs'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { THEMES } from '../src/renderer/src/utils/themes.js'
+
+// The slot's copy control is the one surface theme-sweep cannot reach: every
+// surface there is opened through paste mode, which replaces the slots row, and
+// the control only exists once a real FILE is loaded. So the all-20 check lives
+// here instead, measuring the same thing the sweep would — the computed colours
+// off the live DOM, composited against what is actually behind them.
+
+// It carries an icon, not prose: --text-dim at the mark floor, the same one
+// check-theme-depth holds dim ink to.
+const DIM = 3.0
+
+const contrastOf = (page, selector) =>
+  page.evaluate((sel) => {
+    const parse = (c) => (c.match(/[\d.]+/g) ?? []).map(Number)
+    const over = (fg, bg) => {
+      const a = fg.length > 3 ? fg[3] : 1
+      return [0, 1, 2].map((i) => fg[i] * a + bg[i] * (1 - a))
+    }
+    const lum = (rgb) => {
+      const [r, g, b] = rgb.map((v) => {
+        const s = v / 255
+        return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4
+      })
+      return 0.2126 * r + 0.7152 * g + 0.0722 * b
+    }
+    // Walk up compositing every translucent layer, or a veil like --btn-face
+    // measures against nothing and reads as perfect contrast.
+    const groundOf = (el) => {
+      let acc = [255, 255, 255]
+      const chain = []
+      for (let n = el; n; n = n.parentElement) chain.unshift(n)
+      for (const n of chain) {
+        const bg = parse(getComputedStyle(n).backgroundColor)
+        if (bg.length >= 3 && (bg.length < 4 || bg[3] > 0)) acc = over(bg, acc)
+      }
+      return acc
+    }
+    const el = document.querySelector(sel)
+    if (!el) return null
+    const ground = groundOf(el.parentElement ?? el)
+    const surface = (() => {
+      const own = parse(getComputedStyle(el).backgroundColor)
+      return own.length >= 3 && (own.length < 4 || own[3] > 0) ? over(own, ground) : ground
+    })()
+    const ink = over(parse(getComputedStyle(el).color), surface)
+    const [a, b] = [lum(ink), lum(surface)].sort((x, y) => y - x)
+    return (a + 0.05) / (b + 0.05)
+  }, selector)
+
+test('the slot copy control is legible on every theme', async ({ app, page }) => {
+  const dir = mkdtempSync(join(tmpdir(), 'diffbro-copyside-themes-'))
+  const left = join(dir, 'alpha.txt')
+  const right = join(dir, 'beta.txt')
+  writeFileSync(left, 'one\ntwo\n')
+  writeFileSync(right, 'one\nTWO\n')
+
+  try {
+    await stubOpenDialog(app, left)
+    await page.locator('.slot[data-side="left"] .open').click()
+    await stubOpenDialog(app, right)
+    await page.locator('.slot[data-side="right"] .open').click()
+    await expect(page.locator('.slot[data-side="left"] .name')).toHaveText('alpha.txt')
+
+    const failures = []
+    const rows = []
+    for (const theme of THEMES) {
+      await openSettings(page)
+      const dlg = page.getByRole('dialog', { name: 'Settings' })
+      await dlg.getByRole('button', { name: `Use the ${theme.label} theme` }).click()
+      await page.keyboard.press('Escape')
+      await dlg.waitFor({ state: 'hidden' })
+      await expect(page.locator('html')).toHaveAttribute('data-theme', theme.id)
+
+      // Hovered is the only state it is ever seen in. .btn transitions colour
+      // over 120ms and getComputedStyle reports the INTERPOLATED value, so
+      // measuring straight after the hover reads a colour no one ever sees.
+      await page.locator('.slot[data-side="left"]').hover()
+      await page.waitForTimeout(250)
+      const ratio = await contrastOf(page, '.slot[data-side="left"] .copy')
+      // The file name beside it is --text on the same ground and is already held
+      // above the reading floor, so it calibrates the instrument: if this ever
+      // dips, the measurement is wrong before the control is.
+      const control = await contrastOf(page, '.slot[data-side="left"] .name')
+      rows.push(`${theme.id.padEnd(10)} copy ${ratio?.toFixed(2)}  name ${control?.toFixed(2)}`)
+      if (!(control >= 4.5)) failures.push(`${theme.id}: INSTRUMENT name=${control?.toFixed(2)}`)
+      if (!(ratio >= DIM)) failures.push(`${theme.id}: ${ratio?.toFixed(2)}`)
+    }
+
+    expect(failures, `measured:\n${rows.join('\n')}\n`).toEqual([])
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
diff --git a/e2e/copy-side.spec.mjs b/e2e/copy-side.spec.mjs
new file mode 100644
index 00000000..1d3de5a6
--- /dev/null
+++ b/e2e/copy-side.spec.mjs
@@ -0,0 +1,154 @@
+import { test, expect, clickAppMenuItem, stubOpenDialog } from './fixtures.mjs'
+import { zipSync, strToU8 } from 'fflate'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+// Copying one SIDE puts that file's own text on the real OS clipboard, which is
+// the half a unit test cannot see: the write goes main-process (clipboard:write,
+// since navigator.clipboard is denied here) and the control only exists once the
+// slot has laid out. So drive it the way a reader does and read the clipboard
+// back through Electron.
+
+const LEFT_TEXT = 'one\ntwo\nthree\n'
+const RIGHT_TEXT = 'one\nTWO\nthree\n'
+
+function twoFiles() {
+  const dir = mkdtempSync(join(tmpdir(), 'diffbro-copyside-'))
+  const left = join(dir, 'alpha.txt')
+  const right = join(dir, 'beta.txt')
+  writeFileSync(left, LEFT_TEXT)
+  writeFileSync(right, RIGHT_TEXT)
+  return { dir, left, right }
+}
+
+async function loadPair(app, page, left, right) {
+  await stubOpenDialog(app, left)
+  await page.locator('.slot[data-side="left"] .open').click()
+  await stubOpenDialog(app, right)
+  await page.locator('.slot[data-side="right"] .open').click()
+  await expect(page.locator('.slot[data-side="right"] .name')).toHaveText('beta.txt')
+}
+
+const readClipboard = (app) => app.evaluate(({ clipboard }) => clipboard.readText())
+const clearClipboard = (app) => app.evaluate(({ clipboard }) => clipboard.clear())
+
+const copyButton = (page, side) => page.locator(`.slot[data-side="${side}"] .copy`)
+
+test('each slot copies its own side verbatim, not the diff between them', async ({ app, page }) => {
+  const { dir, left, right } = twoFiles()
+  try {
+    await loadPair(app, page, left, right)
+
+    await clearClipboard(app)
+    await copyButton(page, 'left').click()
+    await expect(page.locator('.notice')).toContainText('alpha.txt')
+    expect(await readClipboard(app)).toBe(LEFT_TEXT)
+
+    await clearClipboard(app)
+    await copyButton(page, 'right').click()
+    expect(await readClipboard(app)).toBe(RIGHT_TEXT)
+
+    // The give-away that this is the side and not Copy Diff as Patch, which
+    // shares the toolbar and would have written a ---/+++ header.
+    expect(await readClipboard(app)).not.toContain('---')
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+// The Edit menu (and so the palette and Cmd+Shift+1/2, which dispatch the same
+// two actions) reaches the same two sides. Driven through the menu item rather
+// than a keypress: a CDP-injected key never reaches a native accelerator, so
+// asserting on one would prove nothing about the binding.
+test('the Edit menu reaches the same two sides', async ({ app, page }) => {
+  const { dir, left, right } = twoFiles()
+  try {
+    await loadPair(app, page, left, right)
+
+    await clearClipboard(app)
+    await clickAppMenuItem(app, 'Copy Left Side')
+    await expect.poll(() => readClipboard(app)).toBe(LEFT_TEXT)
+
+    await clearClipboard(app)
+    await clickAppMenuItem(app, 'Copy Right Side')
+    await expect.poll(() => readClipboard(app)).toBe(RIGHT_TEXT)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+// An opacity-0 button still takes clicks, so the thing that keeps it from
+// stealing one meant for the slot is that it sits BESIDE the name, never over
+// it. Assert the boxes are disjoint rather than trusting the flex row to stay
+// that way.
+test('the copy control stays out of the resting row and clear of the name', async ({
+  app,
+  page
+}) => {
+  const { dir, left, right } = twoFiles()
+  try {
+    await loadPair(app, page, left, right)
+    const copy = copyButton(page, 'left')
+
+    await expect(copy).toHaveCSS('opacity', '0')
+    await page.locator('.slot[data-side="left"]').hover()
+    await expect(copy).toHaveCSS('opacity', '1')
+
+    const open = await page.locator('.slot[data-side="left"] .open').boundingBox()
+    const box = await copy.boundingBox()
+    expect(box.x).toBeGreaterThanOrEqual(open.x + open.width - 1)
+
+    // Icon buttons come off the control scale, never padding + font-size.
+    const scale = await page.evaluate(() =>
+      getComputedStyle(document.documentElement).getPropertyValue('--control-h-sm').trim()
+    )
+    expect(Math.round(box.height)).toBe(parseInt(scale, 10))
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+// A spreadsheet side carries sheets and no text, so there is nothing to put on
+// the clipboard — it gets no control rather than one that refuses.
+test('a spreadsheet side offers no copy control at all', async ({ app, page }) => {
+  const XML = '<?xml version="1.0" encoding="UTF-8"?>'
+  const cell = (ref, text) => `<c r="${ref}" t="inlineStr"><is><t>${text}</t></is></c>`
+  const book = (value) =>
+    Buffer.from(
+      zipSync({
+        'xl/workbook.xml': strToU8(
+          `${XML}<workbook xmlns:r="r"><sheets>` +
+            '<sheet name="Budget" sheetId="1" r:id="rId1"/></sheets></workbook>'
+        ),
+        'xl/_rels/workbook.xml.rels': strToU8(
+          `${XML}<Relationships><Relationship Id="rId1" ` +
+            'Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" ' +
+            'Target="worksheets/sheet1.xml"/></Relationships>'
+        ),
+        'xl/worksheets/sheet1.xml': strToU8(
+          `${XML}<worksheet><sheetData><row r="1">` +
+            `${cell('A1', 'Region')}${cell('B1', value)}</row></sheetData></worksheet>`
+        )
+      })
+    )
+
+  const dir = mkdtempSync(join(tmpdir(), 'diffbro-copyside-xlsx-'))
+  const left = join(dir, 'a.xlsx')
+  const right = join(dir, 'b.xlsx')
+  writeFileSync(left, book('100'))
+  writeFileSync(right, book('150'))
+  try {
+    await stubOpenDialog(app, left)
+    await page.locator('.slot[data-side="left"] .open').click()
+    await stubOpenDialog(app, right)
+    await page.locator('.slot[data-side="right"] .open').click()
+    await expect(page.locator('.slot[data-side="right"] .name')).toHaveText('b.xlsx')
+
+    await page.locator('.slot[data-side="left"]').hover()
+    await expect(copyButton(page, 'left')).toHaveCount(0)
+    await expect(copyButton(page, 'right')).toHaveCount(0)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
diff --git a/e2e/deep-html.spec.mjs b/e2e/deep-html.spec.mjs
new file mode 100644
index 00000000..f45b26ce
--- /dev/null
+++ b/e2e/deep-html.spec.mjs
@@ -0,0 +1,42 @@
+import { test, expect, stubOpenDialog } from './fixtures.mjs'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+// Monaco's HTML worker walks the document tree to build symbols with a plain
+// recursion and no depth guard (provideFileSymbolsInternal → children.forEach →
+// itself). An unclosed tag nests everything after it, so a generated or
+// truncated HTML file recurses once per line and overflows the stack — which
+// reaches the reader as a crash-report dialog over a file the app should simply
+// have shown. Only a real launch runs the worker at all, so this lives here.
+
+// Two frames per level, against a ~10k frame budget.
+const DEPTH = 9000
+
+const nested = (marker) =>
+  `<html><body>\n${'<div>\n'.repeat(DEPTH)}${marker}\n${'</div>\n'.repeat(DEPTH)}</body></html>\n`
+
+test('a deeply nested HTML file compares without overflowing the worker', async ({ app, page }) => {
+  const dir = mkdtempSync(join(tmpdir(), 'diffbro-deep-html-'))
+  const left = join(dir, 'left.html')
+  const right = join(dir, 'right.html')
+  writeFileSync(left, nested('ALPHA'))
+  writeFileSync(right, nested('OMEGA'))
+
+  try {
+    await stubOpenDialog(app, left)
+    await page.locator('.slot[data-side="left"] .open').click()
+    await stubOpenDialog(app, right)
+    await page.locator('.slot[data-side="right"] .open').click()
+
+    // The diff itself must land: one changed line, deep inside the nesting.
+    await expect(page.locator('.status-band .del')).toContainText('1 removed', { timeout: 30_000 })
+
+    // The symbol walk is kicked off after the model settles, so give it the
+    // chance to blow up before declaring the file safe to open.
+    await page.waitForTimeout(2000)
+    await expect(page.getByRole('dialog', { name: 'Something went wrong' })).toHaveCount(0)
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
diff --git a/scripts/lib/legacySize.mjs b/scripts/lib/legacySize.mjs
index bcf51c6f..893da7fb 100644
--- a/scripts/lib/legacySize.mjs
+++ b/scripts/lib/legacySize.mjs
@@ -22,9 +22,9 @@ export const LEGACY_SIZE = {
   'src/renderer/src/composables/useStreamedDiff.js': { fn: 99 },
   'src/renderer/src/composables/useTabContextMenu.js': { fn: 70 },
   'src/renderer/src/composables/useTagInput.js': { fn: 84 },
-  'src/renderer/src/menus.js': { fn: 87 },
+  'src/renderer/src/menus.js': { fn: 67 },
   'src/renderer/src/monaco-mermaid.js': { fn: 94 },
-  'src/renderer/src/stores/diffStore.js': { file: 747 },
+  'src/renderer/src/stores/diffStore.js': { file: 710 },
   'src/renderer/src/stores/snippetStore.js': { file: 448 },
   'src/renderer/src/stores/tabsStore.js': { file: 323 },
   'src/renderer/src/stores/vaultStore.js': { file: 362 },
diff --git a/src/main/menuSections.js b/src/main/menuSections.js
index 20975bb0..81f2abe2 100644
--- a/src/main/menuSections.js
+++ b/src/main/menuSections.js
@@ -41,6 +41,17 @@ export const editMenu = (send, isMac) => ({
       accelerator: 'CmdOrCtrl+Shift+F',
       click: () => send('copy-diff-file')
     },
+    // Shift over the digit that OPENS that side (CmdOrCtrl+1 / +2).
+    {
+      label: t('menu.edit.copyLeft'),
+      accelerator: 'CmdOrCtrl+Shift+1',
+      click: () => send('copy-left')
+    },
+    {
+      label: t('menu.edit.copyRight'),
+      accelerator: 'CmdOrCtrl+Shift+2',
+      click: () => send('copy-right')
+    },
     { label: t('menu.edit.applyPatch'), click: () => send('apply-patch') },
     { type: 'separator' },
     {
diff --git a/src/renderer/src/adapters/textAdapter.js b/src/renderer/src/adapters/textAdapter.js
index 0216e7ef..82162365 100644
--- a/src/renderer/src/adapters/textAdapter.js
+++ b/src/renderer/src/adapters/textAdapter.js
@@ -13,6 +13,12 @@ const EXT_TO_LANGUAGE = {
   tsx: 'typescript',
   jsx: 'javascript',
   json: 'json',
+  // JSON by spec, and all three routinely carry other languages inside their
+  // string values — a HAR holds whole captured HTML responses. Naming them here
+  // keeps that payload from deciding what the file is.
+  har: 'json',
+  map: 'json',
+  webmanifest: 'json',
   css: 'css',
   scss: 'scss',
   html: 'html',
diff --git a/src/renderer/src/components/FileSlot.vue b/src/renderer/src/components/FileSlot.vue
index bb966d4d..9c9442bd 100644
--- a/src/renderer/src/components/FileSlot.vue
+++ b/src/renderer/src/components/FileSlot.vue
@@ -1,6 +1,10 @@
 <script setup>
+import { computed } from 'vue'
 import { shaped } from '../utils/props'
-defineProps({
+import { isCopyableSide } from '../utils/sideText'
+import AppIcon from './AppIcon.vue'
+
+const props = defineProps({
   side: { type: String, required: true },
   /** @type {import('vue').PropType<import('../types').LoadedFile|null>} */
   file: {
@@ -13,23 +17,35 @@ defineProps({
   // can visibly prompt for the second file.
   awaiting: { type: Boolean, default: false }
 })
-const emit = defineEmits(['pick'])
+const emit = defineEmits(['pick', 'copy'])
+// A spreadsheet or a streamed side has no text to give, so it gets no control
+// at all rather than one that refuses — see utils/sideText.
+const copyable = computed(() => isCopyableSide(props.file))
 // Drag & drop is window-level (App.vue); the slot just tags itself data-side.
 </script>
 
 <template>
-  <button
-    class="slot"
-    :class="{ filled: !!file, awaiting }"
-    :data-side="side"
-    :data-tip="file ? file.path : $t('fileSlot.chooseSideFile', { side })"
-    @click="emit('pick')"
-  >
-    <span v-if="file" class="name">{{ file.name }}</span>
-    <span v-else class="placeholder">{{
-      awaiting ? `drop the ${side} file here` : `${side} file…`
-    }}</span>
-  </button>
+  <div class="slot" :class="{ filled: !!file, awaiting, copyable }" :data-side="side">
+    <button
+      class="open"
+      :data-tip="file ? file.path : $t('fileSlot.chooseSideFile', { side })"
+      @click="emit('pick')"
+    >
+      <span v-if="file" class="name">{{ file.name }}</span>
+      <span v-else class="placeholder">{{
+        awaiting ? `drop the ${side} file here` : `${side} file…`
+      }}</span>
+    </button>
+    <button
+      v-if="copyable"
+      class="btn btn-icon copy"
+      :data-tip="$t('fileSlot.copySide', { name: file.name })"
+      :aria-label="$t('fileSlot.copySide', { name: file.name })"
+      @click="emit('copy')"
+    >
+      <AppIcon name="copy" />
+    </button>
+  </div>
 </template>
 
 <style scoped src="./styles/FileSlot.css"></style>
diff --git a/src/renderer/src/components/FileSlotsRow.vue b/src/renderer/src/components/FileSlotsRow.vue
index a473c342..7654f4c7 100644
--- a/src/renderer/src/components/FileSlotsRow.vue
+++ b/src/renderer/src/components/FileSlotsRow.vue
@@ -16,6 +16,7 @@ const store = useDiffStore()
         :file="store.left"
         :awaiting="!store.left && !!store.right"
         @pick="store.pick('left')"
+        @copy="store.copySide('left')"
       />
     </div>
     <button
@@ -33,6 +34,7 @@ const store = useDiffStore()
         :file="store.right"
         :awaiting="!store.right && !!store.left"
         @pick="store.pick('right')"
+        @copy="store.copySide('right')"
       />
     </div>
   </div>
diff --git a/src/renderer/src/components/styles/FileSlot.css b/src/renderer/src/components/styles/FileSlot.css
index fe09cc69..91ba1ba1 100644
--- a/src/renderer/src/components/styles/FileSlot.css
+++ b/src/renderer/src/components/styles/FileSlot.css
@@ -1,19 +1,37 @@
+/* The slot is the field; `.open` is the click target that fills it and `.copy`
+   rides at its trailing edge. Height comes from the control scale rather than
+   padding + line-height, so adding the button cannot drift the row. */
 .slot {
   flex: 1;
   min-width: 0;
-  text-align: left;
+  display: flex;
+  align-items: center;
+  height: var(--control-h);
   background: var(--bg);
   border: 1px dashed var(--border);
   border-radius: var(--radius);
   color: var(--text-dim);
-  padding: 6px 10px;
-  cursor: pointer;
+  padding: 0 4px 0 0;
   overflow: hidden;
 }
 .slot.filled {
   border-style: solid;
   color: var(--text);
 }
+.open {
+  flex: 1;
+  min-width: 0;
+  height: 100%;
+  text-align: left;
+  padding: 0 10px;
+  background: none;
+  border: 0;
+  border-radius: inherit;
+  color: inherit;
+  font: inherit;
+  cursor: pointer;
+  overflow: hidden;
+}
 /* `.hover` is the DRAG-over state (set from JS). This is the pointer one: the
    slot is a button that opens a file dialog, and at rest it reads as a field.
    Same three cues the .btn ladder uses — face, keyline, lift — so it says
@@ -23,7 +41,7 @@
   border-color: var(--btn-edge);
   box-shadow: var(--shadow-1);
 }
-.slot:active:not(.hover) {
+.slot:has(.open:active):not(.hover) {
   background: var(--btn-face-press);
   box-shadow: none;
 }
@@ -58,3 +76,32 @@
 .placeholder {
   text-transform: capitalize;
 }
+/* Secondary to the slot's own job, so it stays out of the resting row and
+   arrives on hover. It sits BESIDE the name rather than over it, so a pointer
+   can only be on it while the slot is hovered and it is already visible — no
+   invisible target ever takes a click meant for the slot, and suppressing its
+   pointer events would only make it unhittable. Tab reaches it either way, and
+   focus reveals it. */
+.copy {
+  flex: none;
+  opacity: 0;
+}
+/* Full ink, not .btn-icon's --text-dim: revealed is the only state this is ever
+   SEEN in, and dim over the hovered slot's face falls under the 3:1 mark floor
+   on five light themes — sepia 2.09, solar 2.37, bloom 2.58, linen 2.72,
+   meridian 2.91. Measured in e2e/copy-side-themes.spec.mjs. */
+.slot:hover .copy,
+.copy:focus-visible {
+  opacity: 1;
+  color: var(--text);
+}
+.copy:hover {
+  border-color: var(--btn-edge);
+  background: var(--btn-face-hover);
+  color: var(--text);
+}
+@media (prefers-reduced-motion: reduce) {
+  .slot.awaiting {
+    animation: none;
+  }
+}
diff --git a/src/renderer/src/composables/useSnippetRowActions.js b/src/renderer/src/composables/useSnippetRowActions.js
index da334e04..b00b495e 100644
--- a/src/renderer/src/composables/useSnippetRowActions.js
+++ b/src/renderer/src/composables/useSnippetRowActions.js
@@ -3,7 +3,7 @@ import { useSnippetStore, languageOf } from '../stores/snippetStore'
 import { useDiffStore } from '../stores/diffStore'
 import { useUiStore } from '../stores/uiStore'
 import { useCopyFeedback } from './useCopyFeedback'
-import { firstClaudeUrl } from '../utils/detectLanguage'
+import { firstClaudeUrl } from '../utils/claudeLink'
 import { parseTemplateVars } from '../utils/templateVars'
 import { t } from '../i18n'
 
diff --git a/src/renderer/src/menus.js b/src/renderer/src/menus.js
index 490c68b6..7d28b325 100644
--- a/src/renderer/src/menus.js
+++ b/src/renderer/src/menus.js
@@ -89,6 +89,23 @@ const viewSection = (run) => ({
   ]
 })
 
+const editSection = (run) => ({
+  id: 'edit',
+  label: t('menu.edit.title'),
+  items: [
+    { label: t('menu.edit.swapSides'), keys: `${MOD}+Shift+S`, run: () => run('swap') },
+    { label: t('menu.edit.clear'), keys: `${MOD}+K`, run: () => run('clear') },
+    { label: t('menu.edit.copyPatch'), keys: `${MOD}+Shift+C`, run: () => run('copy-diff') },
+    { label: t('menu.edit.copyFile'), keys: `${MOD}+Shift+F`, run: () => run('copy-diff-file') },
+    // Shift over the digit that OPENS that side (MOD+1 / MOD+2).
+    { label: t('menu.edit.copyLeft'), keys: `${MOD}+Shift+1`, run: () => run('copy-left') },
+    { label: t('menu.edit.copyRight'), keys: `${MOD}+Shift+2`, run: () => run('copy-right') },
+    { label: t('menu.edit.applyPatch'), run: () => run('apply-patch') },
+    { sep: true },
+    { label: t('menu.edit.pasteTextMode'), keys: `${MOD}+T`, run: () => run('toggle-paste') }
+  ]
+})
+
 export function buildMenus(run) {
   return [
     {
@@ -131,27 +148,7 @@ export function buildMenus(run) {
         { label: t('menu.file.quit'), paletteHidden: true, run: () => window.api.quit() }
       ]
     },
-    {
-      id: 'edit',
-      label: t('menu.edit.title'),
-      items: [
-        { label: t('menu.edit.swapSides'), keys: `${MOD}+Shift+S`, run: () => run('swap') },
-        { label: t('menu.edit.clear'), keys: `${MOD}+K`, run: () => run('clear') },
-        {
-          label: t('menu.edit.copyPatch'),
-          keys: `${MOD}+Shift+C`,
-          run: () => run('copy-diff')
-        },
-        {
-          label: t('menu.edit.copyFile'),
-          keys: `${MOD}+Shift+F`,
-          run: () => run('copy-diff-file')
-        },
-        { label: t('menu.edit.applyPatch'), run: () => run('apply-patch') },
-        { sep: true },
-        { label: t('menu.edit.pasteTextMode'), keys: `${MOD}+T`, run: () => run('toggle-paste') }
-      ]
-    },
+    editSection(run),
     viewSection(run),
     { id: 'terminal', label: t('menu.terminal.title'), items: terminalItems(run) },
     { id: 'security', label: t('menu.security.title'), items: securityItems(run) },
diff --git a/src/renderer/src/monaco-setup.js b/src/renderer/src/monaco-setup.js
index 9d8766ee..6d7d2eac 100644
--- a/src/renderer/src/monaco-setup.js
+++ b/src/renderer/src/monaco-setup.js
@@ -29,6 +29,19 @@ monaco.editor.addKeybindingRules?.([
   { keybinding: monaco.KeyMod.Shift | monaco.KeyCode.F7, command: null }
 ])
 
+// Monaco's HTML worker builds document symbols by plain recursion with no depth
+// guard (provideFileSymbolsInternal → children.forEach → itself), so an unclosed
+// tag — which nests everything after it — overflows the stack and reaches the
+// reader as a crash report over a file we should just have shown. Nothing here
+// consumes symbols: there is no outline, no breadcrumbs, and the palette that
+// would offer Go to Symbol is unbound above. setModeConfiguration REPLACES, so
+// the rest of the features have to be carried across.
+const htmlDefaults = monaco.languages.html?.htmlDefaults
+htmlDefaults?.setModeConfiguration({
+  ...htmlDefaults.modeConfiguration,
+  documentSymbols: false
+})
+
 self.MonacoEnvironment = {
   getWorker(_, label) {
     if (label === 'json') return new jsonWorker()
diff --git a/src/renderer/src/stores/diffCopy.js b/src/renderer/src/stores/diffCopy.js
new file mode 100644
index 00000000..fbf878ad
--- /dev/null
+++ b/src/renderer/src/stores/diffCopy.js
@@ -0,0 +1,53 @@
+import { diffPatchFile } from '../utils/copyAsFile'
+import { copyableSide } from '../utils/sideText'
+import { STREAMED_LIMITS } from '../utils/streamedLimits'
+import { t } from '../i18n'
+
+// Everything that puts the comparison on the clipboard. Its own module because
+// the store is at its size cap. Clipboard writes go through main —
+// navigator.clipboard is denied here by the permission handler.
+
+// The builder returns a sentinel for the streamed case so it need not carry the
+// store's own wording for a limit the store already owns.
+const patchError = (reason) => (reason === 'streamed' ? t(STREAMED_LIMITS.copy) : reason)
+
+export const copyActions = {
+  // Recompute a clean git-style patch (Monaco's on-screen diff isn't one).
+  async copyDiff() {
+    const file = diffPatchFile(this)
+    if (file.error) return this.showNotice(patchError(file.error))
+    const out = await window.api.copyText(file.content)
+    this.showNotice(
+      out?.ok ? t('diffNotices.unifiedDiffCopiedToClipboard') : t('diffNotices.couldNotCopyTheDiff')
+    )
+  },
+  // The twin: a real .patch file on the clipboard, for a destination that
+  // wants a file rather than characters.
+  async copyDiffAsFile() {
+    const file = diffPatchFile(this)
+    if (file.error) return this.showNotice(patchError(file.error))
+    const out = await window.api.copyAsFile(file.name, file.content)
+    this.showNotice(
+      out?.ok
+        ? t('diffNotices.copiedAsFile', { name: out.name })
+        : t('diffNotices.couldNotCopyThatAs')
+    )
+  },
+  /**
+   * One side, verbatim — not the patch. Declines silently when that side has no
+   * text to give: the slot hides its copy control in the same case, so reaching
+   * here means a shortcut or menu fired against a spreadsheet or a streamed
+   * file, and a notice about an action nothing offered would be noise.
+   * @param {'left'|'right'} side
+   */
+  async copySide(side) {
+    const file = copyableSide(this, side)
+    if (!file) return
+    const out = await window.api.copyText(file.content)
+    this.showNotice(
+      out?.ok
+        ? t('diffNotices.sideCopied', { name: file.name })
+        : t('diffNotices.couldNotCopyTheSide')
+    )
+  }
+}
diff --git a/src/renderer/src/stores/diffStore.js b/src/renderer/src/stores/diffStore.js
index 44acc830..b9b9a23d 100644
--- a/src/renderer/src/stores/diffStore.js
+++ b/src/renderer/src/stores/diffStore.js
@@ -12,7 +12,8 @@ import { isSecret } from '../utils/secretSnippet'
 import { snippetSource } from '../utils/snippetSource'
 import { detectTextFormat, formatJson, formatXml } from '../utils/textFormats'
 import { applyUnifiedDiff } from '../utils/unifiedDiff'
-import { diffPatchFile } from '../utils/copyAsFile'
+import { comparedSides } from '../utils/sideText'
+import { copyActions } from './diffCopy'
 import { diffToHtml } from '../utils/diffHtml'
 import { changeRegister, toCsv } from '../utils/changeRegister'
 import { clipboardSnippetName } from '../utils/cliCommand'
@@ -23,10 +24,6 @@ import { STREAMED_LIMITS } from '../utils/streamedLimits'
 import { mergeFormatBanner } from '../utils/formatBanner'
 import { t } from '../i18n'
 
-// The builder returns a sentinel for the streamed case so it need not carry the
-// store's own wording for a limit the store already owns.
-const patchError = (reason) => (reason === 'streamed' ? t(STREAMED_LIMITS.copy) : reason)
-
 let noticeTimer = null
 let diskNoticeTimer = null
 
@@ -41,17 +38,6 @@ function formatHintFor(file, dismissedContent) {
   return { kind: detected.kind, valid: true }
 }
 
-// The two compared sides as { name, content }, whether in files or paste mode.
-function comparedSides(s) {
-  if (s.mode === 'paste') {
-    return [
-      s.pasteLeftFile ?? { name: 'Left', content: s.pasteLeft },
-      s.pasteRightFile ?? { name: 'Right', content: s.pasteRight }
-    ]
-  }
-  return [s.left ?? { name: 'Left', content: '' }, s.right ?? { name: 'Right', content: '' }]
-}
-
 const reloadedNote = (names) => {
   if (!names.length) return ''
   if (names.length === 1) return `"${names[0]}" changed on disk — diff reloaded.`
@@ -587,30 +573,7 @@ export const useDiffStore = defineStore('diff', {
       clearTimeout(diskNoticeTimer)
       this.diskNotice = null
     },
-    // Recompute a clean git-style patch (Monaco's on-screen diff isn't one).
-    // Clipboard goes through main — navigator.clipboard is denied here.
-    async copyDiff() {
-      const file = diffPatchFile(this)
-      if (file.error) return this.showNotice(patchError(file.error))
-      const out = await window.api.copyText(file.content)
-      this.showNotice(
-        out?.ok
-          ? t('diffNotices.unifiedDiffCopiedToClipboard')
-          : t('diffNotices.couldNotCopyTheDiff')
-      )
-    },
-    // The twin: a real .patch file on the clipboard, for a destination that
-    // wants a file rather than characters.
-    async copyDiffAsFile() {
-      const file = diffPatchFile(this)
-      if (file.error) return this.showNotice(patchError(file.error))
-      const out = await window.api.copyAsFile(file.name, file.content)
-      this.showNotice(
-        out?.ok
-          ? t('diffNotices.copiedAsFile', { name: out.name })
-          : t('diffNotices.couldNotCopyThatAs')
-      )
-    },
+    ...copyActions,
     swap() {
       ;[this.left, this.right] = [this.right, this.left]
       // A swapped comparison no longer matches the saved snapshot's side order.
diff --git a/src/renderer/src/utils/claudeLink.js b/src/renderer/src/utils/claudeLink.js
new file mode 100644
index 00000000..76e13f18
--- /dev/null
+++ b/src/renderer/src/utils/claudeLink.js
@@ -0,0 +1,13 @@
+// Recognising a claude.ai link in snippet text. Only the categorisation happens
+// here; opening is gated by the main-process allowlist (src/main/links.js) and
+// never by these loose matches.
+
+const CLAUDE_LINK_RE = /^https:\/\/(www\.)?claude\.ai\/\S*$/i
+
+/** Whether the text is nothing but a claude.ai URL — a stored artifact or chat. */
+export const isClaudeLink = (t) => !t.includes('\n') && CLAUDE_LINK_RE.test(t)
+
+const CLAUDE_URL_G = /https:\/\/(?:www\.)?claude\.ai\/\S*/i
+
+/** First claude.ai URL embedded anywhere, for the row's "Open link" action. */
+export const firstClaudeUrl = (t) => String(t ?? '').match(CLAUDE_URL_G)?.[0] ?? null
diff --git a/src/renderer/src/utils/commands.js b/src/renderer/src/utils/commands.js
index 97cb56d4..86f8cbf2 100644
--- a/src/renderer/src/utils/commands.js
+++ b/src/renderer/src/utils/commands.js
@@ -37,6 +37,11 @@ export const COMMANDS = {
   },
   'copy-diff': ({ diff }) => diff.copyDiff(),
   'copy-diff-file': ({ diff }) => diff.copyDiffAsFile(),
+  // One side verbatim, rather than the patch between them. The store declines
+  // when that side has no text, which is the same answer the slot gives by
+  // hiding its copy control — so no surface can offer what another refuses.
+  'copy-left': ({ diff }) => diff.copySide('left'),
+  'copy-right': ({ diff }) => diff.copySide('right'),
   'apply-patch': ({ diff }) => diff.applyPatch(),
   'export-html': ({ diff }) => diff.exportDiff(),
   'export-image': ({ imageExport }) => imageExport.exportCurrentImage(),
diff --git a/src/renderer/src/utils/detectLanguage.js b/src/renderer/src/utils/detectLanguage.js
index 78205f22..afd9aa84 100644
--- a/src/renderer/src/utils/detectLanguage.js
+++ b/src/renderer/src/utils/detectLanguage.js
@@ -3,6 +3,7 @@
 // miss only lands on plaintext), ordered most-distinctive-first, and bounded —
 // the content can come from a snippet somebody else sealed.
 import { validateJson } from './textFormats'
+import { isClaudeLink } from './claudeLink'
 import { looksLikeMermaid } from './mermaid'
 
 // The picker's options live in src/shared so the CLI prompt offers the same set.
@@ -172,11 +173,13 @@ function looksLikeShell(t) {
 }
 
 // Ordered most-distinctive-first; the first detector to claim the text wins.
+// The two that scan anywhere skip JSON-shaped text, which isJson misses once a
+// file is too big to parse inside the window — else its quoted markup names it.
 const DETECTORS = [
   detectShebang,
-  (t) => (PHP_RE.test(t) ? 'php' : null),
+  (t) => (!jsonShaped(t) && PHP_RE.test(t) ? 'php' : null),
   (t) => (XML_DECL_RE.test(t) ? 'xml' : null),
-  (t) => (HTML_RE.test(t) ? 'html' : null),
+  (t) => (!jsonShaped(t) && HTML_RE.test(t) ? 'html' : null),
   (t) => (looksLikeXml(t) ? 'xml' : null),
   (t) => (looksLikeDockerfile(t) ? 'dockerfile' : null),
   (t) => (looksLikeCss(t) ? 'css' : null),
@@ -198,19 +201,8 @@ const MARKDOWN_FENCE = /^```/m
 // After the code detectors, so a lone `#` can't pre-empt a real program.
 const MARKDOWN_STRONG = [/^#{1,6}\s+\S/m, /\[[^\]]+\]\([^)]+\)/]
 const MARKDOWN_WEAK = [/^[-*+]\s+\S/m, /^\d+\.\s+\S/m, /^>\s+\S/m]
-
-const isJson = (t) => (t[0] === '{' || t[0] === '[') && validateJson(t).valid
-
-// A snippet that is just a claude.ai URL is a stored artifact/chat link. Only
-// the categorisation is done here; opening is gated by the main-process
-// allowlist (src/main/links.js), never by this loose match.
-const CLAUDE_LINK_RE = /^https:\/\/(www\.)?claude\.ai\/\S*$/i
-const isClaudeLink = (t) => !t.includes('\n') && CLAUDE_LINK_RE.test(t)
-
-// First claude.ai URL embedded anywhere in the text — the candidate the row's
-// "Open link" action hands to main, which re-validates it against the allowlist.
-const CLAUDE_URL_G = /https:\/\/(?:www\.)?claude\.ai\/\S*/i
-export const firstClaudeUrl = (t) => String(t ?? '').match(CLAUDE_URL_G)?.[0] ?? null
+const jsonShaped = (t) => t[0] === '{' || t[0] === '['
+const isJson = (t) => jsonShaped(t) && validateJson(t).valid
 
 // A heading or link alone is enough; the weaker list/quote signals (also common
 // in plain prose) must appear at least twice together.
diff --git a/src/renderer/src/utils/shortcuts.js b/src/renderer/src/utils/shortcuts.js
index 4ef59e0b..10d221aa 100644
--- a/src/renderer/src/utils/shortcuts.js
+++ b/src/renderer/src/utils/shortcuts.js
@@ -41,6 +41,8 @@ export const SHORTCUT_GROUPS = [
       { keys: `${MOD}+K`, labelKey: 'shortcuts.clear' },
       { keys: `${MOD}+Shift+C`, labelKey: 'shortcuts.copyPatch' },
       { keys: `${MOD}+Shift+F`, labelKey: 'shortcuts.copyFile' },
+      { keys: `${MOD}+Shift+1`, labelKey: 'shortcuts.copyLeft' },
+      { keys: `${MOD}+Shift+2`, labelKey: 'shortcuts.copyRight' },
       { keys: `${MOD}+T`, labelKey: 'shortcuts.pasteTextMode' },
       { keys: `${MOD}+V`, labelKey: 'shortcuts.pasteToCompare' }
     ]
diff --git a/src/renderer/src/utils/sideText.js b/src/renderer/src/utils/sideText.js
new file mode 100644
index 00000000..7e8d73b0
--- /dev/null
+++ b/src/renderer/src/utils/sideText.js
@@ -0,0 +1,44 @@
+// The text of each compared side, and whether a side has any to give.
+//
+// Two callers with one answer between them: the slot decides whether to offer a
+// copy control at all, and the copy action reads what to put on the clipboard.
+// Splitting that decision would let a button appear over a side that copies
+// nothing.
+
+/**
+ * The two compared sides as { name, content }, whether in files or paste mode.
+ * @param {object} store the diff store
+ * @returns {[{ name: string, content?: string }, { name: string, content?: string }]}
+ */
+export function comparedSides(store) {
+  if (store.mode === 'paste') {
+    return [
+      store.pasteLeftFile ?? { name: 'Left', content: store.pasteLeft },
+      store.pasteRightFile ?? { name: 'Right', content: store.pasteRight }
+    ]
+  }
+  return [
+    store.left ?? { name: 'Left', content: '' },
+    store.right ?? { name: 'Right', content: '' }
+  ]
+}
+
+/**
+ * Whether this side holds text a reader could copy. A spreadsheet carries
+ * `sheets` and a streamed file carries only a path, so neither has `content` —
+ * both answer false, which is what keeps the copy control off them.
+ * @param {{ content?: string }|null} file
+ */
+export const isCopyableSide = (file) => typeof file?.content === 'string' && file.content.length > 0
+
+/**
+ * The side to copy, or null when there is nothing to put on the clipboard.
+ * @param {object} store the diff store
+ * @param {'left'|'right'} side
+ * @returns {{ name: string, content: string }|null}
+ */
+export function copyableSide(store, side) {
+  const [left, right] = comparedSides(store)
+  const file = side === 'right' ? right : left
+  return isCopyableSide(file) ? { name: file.name, content: file.content } : null
+}
diff --git a/src/shared/i18n/en-XA.json b/src/shared/i18n/en-XA.json
index 6165123a..e0946f2e 100644
--- a/src/shared/i18n/en-XA.json
+++ b/src/shared/i18n/en-XA.json
@@ -79,7 +79,9 @@
       "copyPatch": "[Çōƥŷ Đĩƒƒ àş Ƥàţçĥ ·øé·øé]",
       "copyFile": "[Çōƥŷ Đĩƒƒ àş Ƒĩłé ·øé·øé]",
       "applyPatch": "[Àƥƥłŷ Ƥàţçĥ… ·øé·]",
-      "pasteTextMode": "[Ƥàşţé Ţéẋţ Ṁōđé ·øé·øé]"
+      "pasteTextMode": "[Ƥàşţé Ţéẋţ Ṁōđé ·øé·øé]",
+      "copyLeft": "[Çōƥŷ Łéƒţ Šĩđé ·øé·ø]",
+      "copyRight": "[Çōƥŷ Řĩğĥţ Šĩđé ·øé·øé]"
     },
     "view": {
       "title": "[Ṽĩéŵ ·ø]",
@@ -241,7 +243,9 @@
       "splitView": "[şƥłĩţ ṽĩéŵ ·øé·]",
       "clear": "[çłéàř ·ø]"
     },
-    "quickLookAppWide": "[Ɋūĩçķ łōōķ-ūƥ (ŵōřķş àƥƥ-ŵĩđé) ·øé·øé·øé·]"
+    "quickLookAppWide": "[Ɋūĩçķ łōōķ-ūƥ (ŵōřķş àƥƥ-ŵĩđé) ·øé·øé·øé·]",
+    "copyLeft": "[Çōƥŷ łéƒţ şĩđé ·øé·ø]",
+    "copyRight": "[Çōƥŷ řĩğĥţ şĩđé ·øé·øé]"
   },
   "shortcutBar": {
     "hideTip": "[Ĥĩđé ţĥĩş ƀàř — ƀřĩńğ ĩţ ƀàçķ ĩń Šéţţĩńğş ·øé·øé·øé·øé·]",
@@ -1452,7 +1456,9 @@
     "copiedAsFile": "[{name} çōƥĩéđ àş à ƒĩłé — ƥàşţé ĩţ ŵĥéřé ŷōū ńééđ ĩţ. ·øé·øé·øé·øé·øé·]",
     "bothSidesLookLike": "[Ɓōţĥ şĩđéş łōōķ łĩķé {kind} — ƥřéţţŷ-ƥřĩńţ? ·øé·øé·øé·øé·]",
     "savedExpiresIn": "[Šàṽéđ — éẋƥĩřéş ĩń {hours} ĥ. ·øé·øé·ø]",
-    "importedSnippets": "[Ĩɱƥōřţéđ ōńé şńĩƥƥéţ. | Ĩɱƥōřţéđ {n} şńĩƥƥéţş. ·øé·øé·øé·øé·ø]"
+    "importedSnippets": "[Ĩɱƥōřţéđ ōńé şńĩƥƥéţ. | Ĩɱƥōřţéđ {n} şńĩƥƥéţş. ·øé·øé·øé·øé·ø]",
+    "sideCopied": "[Çōƥĩéđ {name} ·øé·]",
+    "couldNotCopyTheSide": "[Çōūłđ ńōţ çōƥŷ ţĥàţ şĩđé. ·øé·øé·ø]"
   },
   "errorNotices": {
     "unknownError": "[Ūńķńōŵń éřřōř ·øé·ø]"
@@ -1612,7 +1618,8 @@
     "hiddenByFilter": "[\"{name}\" ŵàş àđđéđ, ƀūţ ţĥé çūřřéńţ ƒĩłţéř ĥĩđéş ĩţ. ·øé·øé·øé·øé·øé·]"
   },
   "fileSlot": {
-    "chooseSideFile": "[Çĥōōşé {side} ƒĩłé ·øé·øé]"
+    "chooseSideFile": "[Çĥōōşé {side} ƒĩłé ·øé·øé]",
+    "copySide": "[Çōƥŷ {name} ·øé·]"
   },
   "sectionHeader": {
     "dragToReorder": "[Đřàğ ţō řéōřđéř ·øé·øé]"
diff --git a/src/shared/i18n/en.json b/src/shared/i18n/en.json
index 4187e1d7..aa99091f 100644
--- a/src/shared/i18n/en.json
+++ b/src/shared/i18n/en.json
@@ -79,7 +79,9 @@
       "copyPatch": "Copy Diff as Patch",
       "copyFile": "Copy Diff as File",
       "applyPatch": "Apply Patch…",
-      "pasteTextMode": "Paste Text Mode"
+      "pasteTextMode": "Paste Text Mode",
+      "copyLeft": "Copy Left Side",
+      "copyRight": "Copy Right Side"
     },
     "view": {
       "title": "View",
@@ -241,7 +243,9 @@
       "splitView": "split view",
       "clear": "clear"
     },
-    "quickLookAppWide": "Quick look-up (works app-wide)"
+    "quickLookAppWide": "Quick look-up (works app-wide)",
+    "copyLeft": "Copy left side",
+    "copyRight": "Copy right side"
   },
   "shortcutBar": {
     "hideTip": "Hide this bar — bring it back in Settings",
@@ -1452,7 +1456,9 @@
     "copiedAsFile": "{name} copied as a file — paste it where you need it.",
     "bothSidesLookLike": "Both sides look like {kind} — pretty-print?",
     "savedExpiresIn": "Saved — expires in {hours} h.",
-    "importedSnippets": "Imported one snippet. | Imported {n} snippets."
+    "importedSnippets": "Imported one snippet. | Imported {n} snippets.",
+    "sideCopied": "Copied {name}",
+    "couldNotCopyTheSide": "Could not copy that side."
   },
   "errorNotices": {
     "unknownError": "Unknown error"
@@ -1612,7 +1618,8 @@
     "hiddenByFilter": "\"{name}\" was added, but the current filter hides it."
   },
   "fileSlot": {
-    "chooseSideFile": "Choose {side} file"
+    "chooseSideFile": "Choose {side} file",
+    "copySide": "Copy {name}"
   },
   "sectionHeader": {
     "dragToReorder": "Drag to reorder"
diff --git a/tests/renderer/adapters/textAdapter.test.js b/tests/renderer/adapters/textAdapter.test.js
index 4bfd8b6d..2d0b6348 100644
--- a/tests/renderer/adapters/textAdapter.test.js
+++ b/tests/renderer/adapters/textAdapter.test.js
@@ -48,3 +48,41 @@ describe('textAdapter', () => {
     expect(textAdapter.toComparable({ name: 'noext' }).language).toBe('plaintext')
   })
 })
+
+// A .har is JSON by spec, but it is JSON whose string values hold whole captured
+// HTML responses. Sniffing only sees the first 50k, which cuts a multi-MB
+// capture into unparseable JSON, and the `<div`/`<script` inside those bodies
+// then hands the file to the HTML detector. Monaco parses the WHOLE file as
+// HTML, every unclosed tag nests the next, and its symbol walk recurses until
+// the stack goes.
+describe('a HAR capture is JSON, not the HTML it carries', () => {
+  const harOverDetectLimit = () => {
+    const entry = (i) =>
+      JSON.stringify({
+        request: { url: `https://example.test/page/${i}` },
+        response: {
+          content: {
+            mimeType: 'text/html',
+            text: `<html><body><div class="a"><span>row ${i}</span><script src="x.js">`
+          }
+        }
+      })
+    const entries = Array.from({ length: 400 }, (_, i) => entry(i)).join(',')
+    return `{"log":{"version":"1.2","entries":[${entries}]}}`
+  }
+
+  it('reads a .har as json from its extension', () => {
+    const har = harOverDetectLimit()
+    expect(har.length).toBeGreaterThan(50_000)
+    expect(textAdapter.toComparable({ name: 'session.har', content: har }).language).toBe('json')
+  })
+
+  it('does not call JSON-shaped text HTML even when the sniff window is cut short', () => {
+    // No extension to lean on — the content is all there is to go on.
+    const language = textAdapter.toComparable({
+      name: 'capture',
+      content: harOverDetectLimit()
+    }).language
+    expect(language).not.toBe('html')
+  })
+})
diff --git a/tests/renderer/stores/diffCopy.test.js b/tests/renderer/stores/diffCopy.test.js
new file mode 100644
index 00000000..71fdf4f3
--- /dev/null
+++ b/tests/renderer/stores/diffCopy.test.js
@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { runCommand } from '../../../src/renderer/src/utils/commands'
+import { useDiffStore } from '../../../src/renderer/src/stores/diffStore'
+
+beforeEach(() => {
+  setActivePinia(createPinia())
+  localStorage.clear()
+  window.api = {}
+})
+
+const clipboard = (result = { ok: true }) => {
+  const writes = []
+  window.api.copyText = async (text) => (writes.push(text), result)
+  return writes
+}
+
+const loaded = (store) => {
+  store.left = { path: '/tmp/a.txt', name: 'a.txt', content: 'left contents\n' }
+  store.right = { path: '/tmp/b.txt', name: 'b.txt', content: 'right contents\n' }
+}
+
+// Copying a SIDE is not copying the diff: it puts that file's own text on the
+// clipboard, verbatim, so it can be pasted back into whatever it came from.
+describe('copySide', () => {
+  it('copies each side verbatim, not the patch between them', async () => {
+    const store = useDiffStore()
+    loaded(store)
+    const writes = clipboard()
+
+    await store.copySide('left')
+    expect(writes).toEqual(['left contents\n'])
+
+    await store.copySide('right')
+    expect(writes[1]).toBe('right contents\n')
+    // The give-away that this is not the patch path.
+    expect(writes.join()).not.toContain('---')
+  })
+
+  it('names the file it copied, so two slots cannot be confused', async () => {
+    const store = useDiffStore()
+    loaded(store)
+    clipboard()
+    await store.copySide('left')
+    expect(store.notice).toContain('a.txt')
+  })
+
+  it('says so when the clipboard write fails', async () => {
+    const store = useDiffStore()
+    loaded(store)
+    clipboard({ ok: false })
+    await store.copySide('right')
+    expect(store.notice).toContain('Could not copy')
+  })
+
+  it('copies the pasted buffers in paste mode', async () => {
+    const store = useDiffStore()
+    store.mode = 'paste'
+    store.pasteLeft = 'typed on the left'
+    store.pasteRight = 'typed on the right'
+    const writes = clipboard()
+    await store.copySide('right')
+    expect(writes).toEqual(['typed on the right'])
+  })
+
+  // The slot hides its copy control for these, so reaching the action means a
+  // shortcut or menu fired. It must not write a stale clipboard or claim it did.
+  it('does nothing for a side with no text to give', async () => {
+    const store = useDiffStore()
+    const sheets = [{ name: 'S1', rows: [['Region', 100]] }]
+    store.left = { path: '/tmp/l.xlsx', name: 'l.xlsx', kind: 'spreadsheet', sheets }
+    store.right = { path: '/tmp/huge.log', name: 'huge.log', kind: 'streamed' }
+    const writes = clipboard()
+
+    await store.copySide('left')
+    await store.copySide('right')
+    expect(writes).toEqual([])
+    expect(store.notice).toBe(null)
+  })
+
+  it('does nothing when the slot is empty', async () => {
+    const store = useDiffStore()
+    const writes = clipboard()
+    await store.copySide('left')
+    expect(writes).toEqual([])
+  })
+
+  // One uncopyable side must not disable the other.
+  it('still copies the text side of a mixed comparison', async () => {
+    const store = useDiffStore()
+    store.left = { path: '/tmp/l.xlsx', name: 'l.xlsx', kind: 'spreadsheet', sheets: [] }
+    store.right = { path: '/tmp/b.csv', name: 'b.csv', content: 'a,b\n1,2\n' }
+    const writes = clipboard()
+
+    await store.copySide('left')
+    expect(writes).toEqual([])
+    await store.copySide('right')
+    expect(writes).toEqual(['a,b\n1,2\n'])
+  })
+})
+
+// The menu, the palette and Cmd+Shift+1/2 all arrive here.
+describe('the copy-left / copy-right commands', () => {
+  it('reach the store action for their own side', async () => {
+    const diff = useDiffStore()
+    loaded(diff)
+    const writes = clipboard()
+
+    await runCommand('copy-left', { diff })
+    await runCommand('copy-right', { diff })
+    expect(writes).toEqual(['left contents\n', 'right contents\n'])
+  })
+})
diff --git a/tests/renderer/utils/commands.test.js b/tests/renderer/utils/commands.test.js
index c04f05af..5b72d4cd 100644
--- a/tests/renderer/utils/commands.test.js
+++ b/tests/renderer/utils/commands.test.js
@@ -37,6 +37,7 @@ const stores = () => ({
     isSavedDiff: false,
     copyDiff: spy(),
     copyDiffAsFile: spy(),
+    copySide: spy(),
     applyPatch: spy(),
     exportDiff: spy(),
     importSnippets: spy(),
diff --git a/tests/renderer/utils/sideText.test.js b/tests/renderer/utils/sideText.test.js
new file mode 100644
index 00000000..85ac2717
--- /dev/null
+++ b/tests/renderer/utils/sideText.test.js
@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest'
+import {
+  comparedSides,
+  copyableSide,
+  isCopyableSide
+} from '../../../src/renderer/src/utils/sideText'
+
+const files = (left, right) => ({ mode: 'files', left, right })
+const pasted = (over = {}) => ({
+  mode: 'paste',
+  pasteLeft: '',
+  pasteRight: '',
+  pasteLeftFile: null,
+  pasteRightFile: null,
+  ...over
+})
+
+describe('comparedSides', () => {
+  it('reads the loaded files in files mode', () => {
+    const store = files({ name: 'a.json', content: 'A' }, { name: 'b.json', content: 'B' })
+    expect(comparedSides(store).map((s) => s.name)).toEqual(['a.json', 'b.json'])
+  })
+
+  it('names an empty slot rather than returning nothing', () => {
+    expect(comparedSides(files(null, null))).toEqual([
+      { name: 'Left', content: '' },
+      { name: 'Right', content: '' }
+    ])
+  })
+
+  it('reads the pasted buffers in paste mode', () => {
+    const store = pasted({ pasteLeft: 'typed left', pasteRight: 'typed right' })
+    expect(comparedSides(store).map((s) => s.content)).toEqual(['typed left', 'typed right'])
+  })
+
+  // A file dropped onto a paste side replaces the buffer for that side only.
+  it('prefers a file dropped on a paste side over its buffer', () => {
+    const store = pasted({
+      pasteLeft: 'ignored',
+      pasteLeftFile: { name: 'dropped.txt', content: 'from the file' }
+    })
+    expect(comparedSides(store)[0]).toEqual({ name: 'dropped.txt', content: 'from the file' })
+  })
+})
+
+// This is what keeps the copy control off a side that cannot produce text. A
+// spreadsheet carries `sheets` and a streamed file carries only a path, so
+// neither has `content` at all — asking for the button's answer here means the
+// button and the action can never disagree.
+describe('isCopyableSide', () => {
+  it('says yes to a text side with content', () => {
+    expect(isCopyableSide({ name: 'a.txt', content: 'hello' })).toBe(true)
+  })
+
+  it('says no to a spreadsheet, which carries sheets and no content', () => {
+    expect(isCopyableSide({ name: 'book.xlsx', kind: 'spreadsheet', sheets: [] })).toBe(false)
+  })
+
+  it('says no to a streamed file, which carries only a path', () => {
+    expect(isCopyableSide({ name: 'huge.log', kind: 'streamed', path: '/tmp/huge.log' })).toBe(
+      false
+    )
+  })
+
+  it('says no to an empty side, and to no side at all', () => {
+    expect(isCopyableSide({ name: 'empty.txt', content: '' })).toBe(false)
+    expect(isCopyableSide(null)).toBe(false)
+    expect(isCopyableSide(undefined)).toBe(false)
+  })
+})
+
+describe('copyableSide', () => {
+  it('gives the name and content of the side asked for', () => {
+    const store = files({ name: 'a.json', content: 'A' }, { name: 'b.json', content: 'B' })
+    expect(copyableSide(store, 'left')).toEqual({ name: 'a.json', content: 'A' })
+    expect(copyableSide(store, 'right')).toEqual({ name: 'b.json', content: 'B' })
+  })
+
+  it('works the same in paste mode', () => {
+    const store = pasted({ pasteLeft: 'L', pasteRight: 'R' })
+    expect(copyableSide(store, 'left')).toEqual({ name: 'Left', content: 'L' })
+    expect(copyableSide(store, 'right')).toEqual({ name: 'Right', content: 'R' })
+  })
+
+  it('gives null for a side with nothing to copy', () => {
+    const store = files({ name: 'book.xlsx', kind: 'spreadsheet' }, null)
+    expect(copyableSide(store, 'left')).toBe(null)
+    expect(copyableSide(store, 'right')).toBe(null)
+  })
+
+  // One side being uncopyable must not take the other with it — a spreadsheet
+  // compared against a CSV still has one side worth copying.
+  it('answers each side on its own', () => {
+    const store = files({ name: 'book.xlsx', kind: 'spreadsheet' }, { name: 'b.csv', content: 'B' })
+    expect(copyableSide(store, 'left')).toBe(null)
+    expect(copyableSide(store, 'right')).toEqual({ name: 'b.csv', content: 'B' })
+  })
+})