jaitus 0.3.14 → 0.3.17

package/src/machine.js

@@ -0,0 +1,227 @@
+// ─── This computer's identifiers, for the free tier ───────────────────────────────
+//
+// Only so many accounts on one computer get free prompts (the server decides; see
+// backend/services/deviceGuard.js). The CLI tells it which computer it is on with
+// several identifiers, each one HASHED here — the raw values never leave the machine:
+//
+//   m  the operating system's machine id: Windows MachineGuid, Linux /etc/machine-id
+//   h  the firmware's hardware UUID (SMBIOS / macOS IOPlatformUUID) — survives an OS
+//      reinstall
+//   i  this CLI's install id, kept in two places (~/.jaitus and the OS's app-data
+//      folder), each restoring the other
+//   n  the address of each physical network adapter (virtual and randomised ones are
+//      skipped: they change by themselves)
+//   g  the git identity this computer commits as (global user.email) — the same on
+//      every computer one person sets up, so it recognises the person, not the machine
+//
+// A VPN, a new network or a new email changes none of these. They are reported by this
+// program, so they identify a computer for an honest client — the same ceiling every
+// product that does this has (Cursor's machine ids are reset by published tools).
+//
+// Everything here is best-effort and never blocks or breaks a request: a probe that
+// fails just leaves its identifier out. The slow one (Windows SMBIOS, ~1 s through
+// PowerShell) runs once in the background and is cached.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawn, spawnSync } from 'node:child_process';
+import { HOME } from './config.js';
+import { deviceId } from './session.js';
+
+const CACHE_FILE = path.join(HOME, 'machine.json');
+const hash = (kind, raw) => crypto.createHash('sha256').update(`jaitus-device:${kind}:${String(raw).trim().toLowerCase()}`).digest('hex');
+
+// Values firmware vendors ship unset, shared by thousands of boards.
+const JUNK_UUID = /^(0{8}-0{4}-0{4}-0{4}-0{12}|f{8}-f{4}-f{4}-f{4}-f{12}|03000200-0400-0500-0006-000700080009|00020003-0004-0005-0006-000700080009)$/i;
+// Adapters that are virtual or move by themselves: Hyper-V, VirtualBox, VMware,
+// Parallels, Docker/WSL bridges.
+const VIRTUAL_OUI = /^(00:15:5d|08:00:27|0a:00:27|00:05:69|00:0c:29|00:1c:14|00:50:56|00:1c:42|02:42)/i;
+
+function readCache() {
+  try { return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8')) || {}; } catch { return {}; }
+}
+function writeCache(obj) {
+  try {
+    fs.mkdirSync(HOME, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(obj, null, 2), { mode: 0o600 });
+  } catch { /* unwritable home: probed again next launch */ }
+}
+
+/** The OS machine id (fast: one registry read or one file). */
+function osMachineId() {
+  try {
+    if (process.platform === 'win32') {
+      const r = spawnSync('reg', ['query', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid'], { encoding: 'utf8', timeout: 2000, windowsHide: true });
+      const m = /MachineGuid\s+REG_SZ\s+([0-9a-f-]{36})/i.exec(r.stdout || '');
+      return m ? m[1] : null;
+    }
+    if (process.platform === 'linux') {
+      for (const f of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
+        try { const v = fs.readFileSync(f, 'utf8').trim(); if (/^[0-9a-f]{32}$/i.test(v)) return v; } catch { /* next */ }
+      }
+    }
+  } catch { /* left out */ }
+  return null;
+}
+
+/** The firmware's hardware UUID, synchronously where that is cheap (macOS, Linux). */
+function hardwareIdSync() {
+  try {
+    if (process.platform === 'darwin') {
+      const r = spawnSync('ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice'], { encoding: 'utf8', timeout: 2000 });
+      const m = /"IOPlatformUUID"\s*=\s*"([0-9A-F-]{36})"/i.exec(r.stdout || '');
+      return m && !JUNK_UUID.test(m[1]) ? m[1] : null;
+    }
+    if (process.platform === 'linux') {
+      const v = fs.readFileSync('/sys/class/dmi/id/product_uuid', 'utf8').trim(); // root-only on most distros
+      return /^[0-9a-f-]{36}$/i.test(v) && !JUNK_UUID.test(v) ? v : null;
+    }
+  } catch { /* left out */ }
+  return null;
+}
+
+let smbiosProbe = null;
+/** Windows: SMBIOS UUID through CIM, in the background, cached. */
+function probeWindowsHardware() {
+  if (process.platform !== 'win32' || smbiosProbe) return smbiosProbe;
+  smbiosProbe = new Promise((resolve) => {
+    let out = '';
+    let child;
+    try {
+      child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', '(Get-CimInstance -ClassName Win32_ComputerSystemProduct).UUID'], { windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch { resolve(null); return; }
+    const t = setTimeout(() => { try { child.kill(); } catch { /* gone */ } resolve(null); }, 8000);
+    t.unref?.();
+    child.stdout.on('data', (d) => { out += d; });
+    child.on('error', () => { clearTimeout(t); resolve(null); });
+    child.on('close', () => {
+      clearTimeout(t);
+      const v = String(out).trim();
+      resolve(/^[0-9a-f-]{36}$/i.test(v) && !JUNK_UUID.test(v) ? v : null);
+    });
+  }).then((v) => {
+    const cache = readCache();
+    cache.h = v ? hash('h', v) : '';
+    cache.hAt = new Date().toISOString();
+    writeCache(cache);
+    return v;
+  });
+  return smbiosProbe;
+}
+
+/** Physical adapters' addresses, globally administered only, at most three. */
+function adapterIds() {
+  const out = new Set();
+  try {
+    for (const list of Object.values(os.networkInterfaces())) {
+      for (const a of list || []) {
+        const mac = String(a.mac || '').toLowerCase();
+        if (a.internal || !/^([0-9a-f]{2}:){5}[0-9a-f]{2}$/.test(mac) || mac === '00:00:00:00:00:00') continue;
+        if (parseInt(mac.slice(0, 2), 16) & 0x02) continue; // locally administered / randomised
+        if (VIRTUAL_OUI.test(mac)) continue;
+        out.add(mac);
+      }
+    }
+  } catch { /* none */ }
+  return [...out].sort().slice(0, 3);
+}
+
+/** Hostname, OS user, CPU model, memory and OS — together, never one alone. */
+function softFingerprint() {
+  try {
+    let user = '';
+    try { user = os.userInfo().username; } catch { /* no user database */ }
+    const cpu = (os.cpus()?.[0]?.model || '').replace(/\s+/g, ' ').trim();
+    const gb = Math.round(os.totalmem() / 2 ** 30);
+    const host = os.hostname();
+    if (!host && !user) return null;
+    return [process.platform, os.arch(), host, user, cpu, `${gb}GB`].join('|');
+  } catch { return null; }
+}
+
+// Addresses git ships as examples or that many people leave unset-looking: not a person.
+const PLACEHOLDER_EMAIL = /(^|@)(example\.(com|org|net)|localhost)$|^(you|your[._-]?email|email|user|root|test|admin)@/i;
+
+/** The global git identity (user.email), or null when unset or a placeholder. */
+function gitIdentity() {
+  try {
+    const r = spawnSync('git', ['config', '--global', 'user.email'], { encoding: 'utf8', timeout: 2000, windowsHide: true });
+    const v = String(r.stdout || '').trim().toLowerCase();
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v) || PLACEHOLDER_EMAIL.test(v)) return null;
+    return v;
+  } catch { return null; }
+}
+
+/**
+ * Where the install id's second copy lives: outside ~/.jaitus, in the OS's app-data
+ * folder. Always under os.homedir() (not LOCALAPPDATA / XDG_DATA_HOME), so a test run
+ * with its own home never writes into the real one.
+ */
+function mirrorPath() {
+  if (process.platform === 'win32') return path.join(os.homedir(), 'AppData', 'Local', 'Jaitus', 'install-id');
+  if (process.platform === 'darwin') return path.join(os.homedir(), 'Library', 'Application Support', 'Jaitus', 'install-id');
+  return path.join(os.homedir(), '.local', 'share', 'jaitus', 'install-id');
+}
+
+/** The install id, restored from either copy and written back to both. */
+function installId() {
+  const mirror = mirrorPath();
+  let fromMirror = null;
+  try { const v = fs.readFileSync(mirror, 'utf8').trim(); if (/^[A-Za-z0-9_-]{8,80}$/.test(v)) fromMirror = v; } catch { /* first run */ }
+  const deviceFile = path.join(HOME, 'device.json');
+  let id = null;
+  try { const saved = JSON.parse(fs.readFileSync(deviceFile, 'utf8')); if (/^[A-Za-z0-9_-]{8,80}$/.test(saved?.id || '')) id = saved.id; } catch { /* none */ }
+  if (!id && fromMirror) {
+    id = fromMirror;
+    try { fs.mkdirSync(HOME, { recursive: true, mode: 0o700 }); fs.writeFileSync(deviceFile, JSON.stringify({ id, createdAt: new Date().toISOString() }, null, 2), { mode: 0o600 }); } catch { /* best effort */ }
+  }
+  if (!id) id = deviceId();
+  if (fromMirror !== id) {
+    try { fs.mkdirSync(path.dirname(mirror), { recursive: true }); fs.writeFileSync(mirror, id); } catch { /* best effort */ }
+  }
+  return id;
+}
+
+let header = null;
+/**
+ * The `x-jaitus-device` header: "m=<hash>,h=<hash>,i=<hash>,n=<hash>,…". Built once
+ * per process; the Windows hardware id joins it once its background probe is done.
+ */
+export function machineHeader() {
+  if (process.env.JAITUS_DEVICE_HEADER !== undefined) return process.env.JAITUS_DEVICE_HEADER; // tests
+  if (header) return header;
+  const cache = readCache();
+  const parts = [];
+  try {
+    const m = cache.m || (osMachineId() ? hash('m', osMachineId()) : '');
+    if (m) parts.push(`m=${m}`);
+    let h = cache.h;
+    if (h === undefined) {
+      const sync = hardwareIdSync();
+      h = sync ? hash('h', sync) : undefined;
+      if (h === undefined && process.platform === 'win32') {
+        probeWindowsHardware()?.then(() => { header = null; }).catch(() => {});
+      }
+    }
+    if (h) parts.push(`h=${h}`);
+    parts.push(`i=${hash('i', installId())}`);
+    for (const mac of adapterIds()) parts.push(`n=${hash('n', mac)}`);
+    // s: the computer as it describes itself — what an id-reset tool leaves alone. The
+    // server links it only together with a network both accounts were used from, so two
+    // people with the same laptop model are never taken for one.
+    const soft = softFingerprint();
+    if (soft) parts.push(`s=${hash('s', soft)}`);
+    const git = gitIdentity();
+    if (git) parts.push(`g=${hash('g', git)}`);
+    if (m && cache.m !== m) writeCache({ ...cache, m, ...(h ? { h } : {}) });
+  } catch { /* whatever was gathered */ }
+  header = parts.join(',');
+  return header;
+}
+
+/** Start the slow probe early (at launch), so the first request already carries it. */
+export function warmMachineHeader() {
+  try { if (readCache().h === undefined) probeWindowsHardware(); } catch { /* best effort */ }
+}

package/src/tui/ansi.js

@@ -188,6 +188,12 @@ export function truncateRow(row, width, ellipsis = '…') {
  * bullet or a wrapped tool row stay visually attached to its marker.
  */
 export function wrapRow(row, width, indent = '') {
+  // A newline inside a span is a line break, never a character to print: Ink would draw
+  // it as an extra screen line the layout never counted, and every row below it — and
+  // the selection — would be off by one. Pasted multi-line text arrives exactly so.
+  if (row.some((span) => typeof span.t === 'string' && span.t.includes('\n'))) {
+    return splitAtNewlines(row).flatMap((line) => wrapRow(line, width, indent));
+  }
   if (width < 4) return [row];
   if (rowWidth(row) <= width) return [row];
 
@@ -200,10 +206,15 @@ export function wrapRow(row, width, indent = '') {
   // Every line after the first opens with the hanging indent, so a wrapped bullet or a
   // wrapped tool row stays visually attached to its marker instead of resetting to
   // column zero and reading as a new item.
+  // A continuation line is the same line of text, so copying rejoins it (SOFT): the
+  // marker carries what the break swallowed — a space between words, nothing in a word
+  // cut mid-way. The hanging indent is layout, so it is never copied.
+  let breakJoin = ' ';
   const flush = () => {
     lines.push(current.length ? current : [{ t: '' }]);
-    current = indent ? [...indentSpan] : [];
+    current = [{ t: '', soft: breakJoin }, ...(indent ? [{ ...indentSpan[0], copy: '' }] : [])];
     used = indent ? indentWidth : 0;
+    breakJoin = ' ';
   };
 
   for (const span of row) {
@@ -228,6 +239,7 @@ export function wrapRow(row, width, indent = '') {
           // `cut` marks a word split mid-way, so a URL cut here can be rejoined when it is
           // clicked (the renderer ignores the field).
           current.push(piece ? { ...span, t: piece, cut: true } : { ...span, t: piece });
+          breakJoin = '';
           flush();
           piece = '';
           pieceWidth = 0;
@@ -255,6 +267,58 @@ export function wrapRows(rows, width, indent = '') {
 /** The plain text of a row of spans, for selection, search and the clipboard. */
 export const rowText = (row) => (row || []).map((span) => span.t).join('');
 
+/** One row with newlines in its spans → one row per line, styles kept. */
+export function splitAtNewlines(row) {
+  const lines = [[]];
+  for (const span of row) {
+    const parts = String(span.t ?? '').split('\n');
+    parts.forEach((part, i) => {
+      if (i > 0) lines.push([]);
+      if (part) lines[lines.length - 1].push({ ...span, t: part });
+    });
+  }
+  return lines.map((line) => (line.length ? line : [{ t: '' }]));
+}
+
+// ── Copying what is on screen ──────────────────────────────────────────────────
+//
+// A row on screen is source text plus decoration: the bar beside a message, a code
+// block's gutter and frame, a quote mark, a table's column rules, a bullet glyph, the
+// indent under a wrapped line. A span says what it contributes to a COPY with `copy`
+// (absent = its own text; '' = nothing; '- ' for a bullet), and a wrapped line says how
+// it rejoins the line above with a `soft` marker. Copying a command out of an answer
+// used to bring the gutter's ▐ (| in plain terminals) and the bullet with it.
+
+/** True for a row that is decoration only (a code block's frame, a rule). */
+export const isDecorationRow = (row) => (row || []).length > 0
+  && row.every((span) => span.copy === '' || !span.t)
+  && row.some((span) => span.t && span.copy === '');
+
+/** How a row joins the row above when both are copied: null = a new line. */
+export const softJoin = (row) => {
+  const marker = (row || []).find((span) => span.soft !== undefined);
+  return marker ? marker.soft : null;
+};
+
+/** The copy text of the cells [from, to) of a row (string offsets, as selection uses). */
+export function copyText(row, from = 0, to = Infinity) {
+  let at = 0;
+  let out = '';
+  for (const span of row || []) {
+    const t = String(span.t ?? '');
+    const start = at;
+    const end = at + t.length;
+    at = end;
+    if (end <= from || start >= to) {
+      // A zero-width marker inside the range still counts (it is how bullets survive).
+      if (!(t.length === 0 && start >= from && start < to)) continue;
+    }
+    if (span.copy !== undefined) { out += span.copy; continue; }
+    out += t.slice(Math.max(0, from - start), Math.min(t.length, to - start));
+  }
+  return out;
+}
+
 /**
  * Invert the cells between two columns of a row, splitting spans where the range falls
  * inside one. Used to show a drag selection: the terminal's own highlight is gone once

package/src/tui/entries.js

@@ -10,7 +10,7 @@
 
 import { palette, mix, ramp } from './theme.js';
 import { renderMarkdown, inlineSpans } from './markdown.js';
-import { ansiToRows, wrapRows, wrapRow, truncateRow, stringWidth, plain } from './ansi.js';
+import { ansiToRows, wrapRows, wrapRow, truncateRow, stringWidth, plain, padRow } from './ansi.js';
 import { highlightLine, languageForPath } from './highlight.js';
 import { wordRows, wordSize } from './wordmark.js';
 import { MASCOT_ROWS } from '../brand.js';
@@ -137,14 +137,26 @@ const BUILDERS = {
   // ── What the user said ───────────────────────────────────────────────────────
   user(data, width) {
     const p = palette();
-    const bar = { t: pick(['▌', '|']), color: p.brand };
+    // One mark beside the message, on its first row — not a bar on every row: a pasted
+    // command or log used to arrive striped with ▌ (| in plain terminals) down its whole
+    // length. Later rows sit under the text, indented. Neither is ever copied.
+    const bar = { t: pick(['▌', '|']), color: p.brand, copy: '' };
+    const gap = { t: ' ', copy: '' };
+    const indent = { t: '  ', copy: '' };
     const inner = Math.max(12, width - 2);
-    const body = wrapRow([{ t: String(data.text || ''), color: p.body, bold: true }], inner);
-    const rows = body.map((row) => [bar, { t: ' ' }, ...row]);
+    const text = String(data.text || '').replace(/\r\n?/g, '\n').replace(/\t/g, '    ');
+    const body = wrapRow([{ t: text, color: p.body, bold: true }], inner);
+    const rows = body.map((row, index) => (index === 0 ? [bar, gap, ...row] : [indent, ...row]));
     if (data.attachments?.length) {
-      rows.push([bar, { t: ' ' }, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
+      rows.push([indent, { t: data.attachments.map((a) => `⧉ ${a}`).join('  '), color: p.purple }]);
     }
-    return rows;
+    // The whole message sits on a faint band the full width of the window, with a row of
+    // it above and below, so what the person said never reads as part of the answer. The
+    // band is drawn, never copied (the padding is decoration).
+    const band = p.raised;
+    const shade = (row) => padRow(row.map((span) => ({ ...span, backgroundColor: span.backgroundColor || band })), width, { backgroundColor: band, copy: '' });
+    const edge = [{ t: ' '.repeat(Math.max(1, width)), backgroundColor: band, copy: '' }];
+    return [edge, ...rows.map(shade), edge];
   },
 
   // ── What the model said ──────────────────────────────────────────────────────
@@ -156,8 +168,8 @@ const BUILDERS = {
     // A lead mark on the first row only: it identifies the speaker without spending a
     // whole line on a name label, and the indent keeps the column under it aligned.
     return body.map((row, index) => (index === 0
-      ? [{ t: pick(['● ', '* ']), color: p.teal }, ...row]
-      : [{ t: '  ' }, ...row]));
+      ? [{ t: pick(['● ', '* ']), color: p.teal, copy: '' }, ...row]
+      : [{ t: '  ', copy: '' }, ...row]));
   },
 
   // ── A tool call ──────────────────────────────────────────────────────────────
@@ -197,11 +209,11 @@ const BUILDERS = {
         const tinted = highlightLine(line.replace(/\t/g, '  '), language, state);
         state = tinted.state;
         const spans = tinted.spans.length ? tinted.spans : [{ t: '' }];
-        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, ...truncateRow(spans, Math.max(8, width - 6))]);
+        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft, copy: '' }, ...truncateRow(spans, Math.max(8, width - 6))]);
       }
       if (preview.more > 0) {
         const hint = openable && !data.expanded ? ' — click the row to show all' : '';
-        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}${hint}`, color: p.faint, italic: true }]);
+        rows.push([{ t: `    ${pick(['│', '|'])} `, color: p.lineSoft, copy: '' }, { t: `+${preview.more} more line${preview.more === 1 ? '' : 's'}${hint}`, color: p.faint, italic: true }]);
       }
     }
     return rows;
@@ -262,7 +274,7 @@ const BUILDERS = {
   error(data, width) {
     const p = palette();
     const rows = [];
-    const bar = { t: pick(['▌', '|']), color: p.red };
+    const bar = { t: pick(['▌', '|']), color: p.red, copy: '' };
     const inner = Math.max(12, width - 2);
 
     rows.push([bar, { t: ' ' }, { t: `${pick(['✗', 'x'])} ${data.title || 'Error'}`, color: p.red, bold: true }]);

package/src/tui/markdown.js

@@ -122,14 +122,14 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
       for (const row of wrapRow(content, w)) rows.push(row);
       if (level <= 2) {
         const ruleWidth = Math.min(w, Math.max(8, contentWidth(content)));
-        rows.push([{ t: (level === 1 ? g('━', '=') : g('─', '-')).repeat(ruleWidth), color: level === 1 ? p.brandDeep : p.line }]);
+        rows.push([{ t: (level === 1 ? g('━', '=') : g('─', '-')).repeat(ruleWidth), color: level === 1 ? p.brandDeep : p.line, copy: '' }]);
       }
       i += 1;
       continue;
     }
 
     // ── horizontal rule ────────────────────────────────────────────────────────
-    if (RULE.test(line)) { rows.push([{ t: g('─', '-').repeat(w), color: p.line }]); i += 1; continue; }
+    if (RULE.test(line)) { rows.push([{ t: g('─', '-').repeat(w), color: p.line, copy: '' }]); i += 1; continue; }
 
     // ── blockquote ─────────────────────────────────────────────────────────────
     const quote = QUOTE.exec(line);
@@ -138,7 +138,7 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
       while (i < lines.length && QUOTE.test(lines[i])) { body.push(QUOTE.exec(lines[i])[1]); i += 1; }
       if (!compact) blank();
       for (const inner of renderMarkdown(body.join('\n'), w - 2, { compact: true })) {
-        rows.push([{ t: g('▏ ', '| '), color: p.teal }, ...inner]);
+        rows.push([{ t: g('▏ ', '| '), color: p.teal, copy: '> ' }, ...inner]);
       }
       if (!compact) rows.push([]);
       continue;
@@ -159,10 +159,10 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
         const done = !!task && /[xX]/.test(task[1]);
         let marker;
         if (task) {
-          marker = { t: done ? g('✔ ', '[x] ') : g('○ ', '[ ] '), color: done ? p.green : p.dim };
+          marker = { t: done ? g('✔ ', '[x] ') : g('○ ', '[ ] '), color: done ? p.green : p.dim, copy: done ? '- [x] ' : '- [ ] ' };
           content = task[2];
         } else if (b) {
-          marker = { t: `${(ascii() ? ['-', '*', '+'] : ['•', '◦', '▪'])[depth % 3]} `, color: p.brand };
+          marker = { t: `${(ascii() ? ['-', '*', '+'] : ['•', '◦', '▪'])[depth % 3]} `, color: p.brand, copy: '- ' };
         } else {
           marker = { t: `${o[2]}. `, color: p.brand };
         }
@@ -206,6 +206,28 @@ export function renderMarkdown(text, width, { compact = false } = {}) {
 
 const contentWidth = (spans) => spans.reduce((sum, s) => sum + stringWidth(s.t), 0);
 
+/** Spans cut into rows of at most `width` cells, character by character, styles kept. */
+function hardWrap(spans, width) {
+  const rows = [[]];
+  let used = 0;
+  for (const span of spans) {
+    let piece = '';
+    for (const ch of String(span.t ?? '')) {
+      const cw = stringWidth(ch);
+      if (used + cw > width && used > 0) {
+        if (piece) rows[rows.length - 1].push({ ...span, t: piece });
+        rows.push([]);
+        piece = '';
+        used = 0;
+      }
+      piece += ch;
+      used += cw;
+    }
+    if (piece) rows[rows.length - 1].push({ ...span, t: piece });
+  }
+  return rows.map((r) => (r.length ? r : [{ t: '' }]));
+}
+
 /**
  * A fenced block: a language tag, a tinted body, and a left gutter that makes the code
  * a distinct object on the page without the cost of a full border (which would eat two
@@ -214,14 +236,14 @@ const contentWidth = (spans) => spans.reduce((sum, s) => sum + stringWidth(s.t),
 function codeBlock(body, language, width) {
   const p = palette();
   const rows = [];
-  const gutter = { t: g('▐ ', '| '), color: p.tealDeep };
+  const gutter = { t: g('▐ ', '| '), color: p.tealDeep, copy: '' };
   const label = language && isKnownLanguage(language) ? language : language || '';
   const inner = Math.max(8, width - 2);
 
   rows.push([
-    { t: g('▛', '+'), color: p.tealDeep },
-    { t: label ? `${g('─', '-')} ${label} ` : g('─', '-'), color: p.dim },
-    { t: g('─', '-').repeat(Math.max(0, width - 2 - (label ? label.length + 3 : 1))), color: p.lineSoft },
+    { t: g('▛', '+'), color: p.tealDeep, copy: '' },
+    { t: label ? `${g('─', '-')} ${label} ` : g('─', '-'), color: p.dim, copy: '' },
+    { t: g('─', '-').repeat(Math.max(0, width - 2 - (label ? label.length + 3 : 1))), color: p.lineSoft, copy: '' },
   ]);
 
   let state = {};
@@ -231,11 +253,13 @@ function codeBlock(body, language, width) {
     state = result.state;
     const spans = result.spans.length ? result.spans : [{ t: '' }];
     // Code is not prose: wrapping it on spaces would move a token onto a line where it
-    // does not belong. Long lines are cut with a marker instead, which is honest about
-    // there being more and keeps the block rectangular.
-    rows.push([gutter, ...truncateRow(spans, inner, g('›', '>'))]);
+    // does not belong — so a long line is cut at the edge, character by character, and
+    // carries on under a fainter gutter. It used to be cut off with › and the rest was
+    // gone: a long command copied out of an answer came back truncated.
+    const pieces = hardWrap(spans, inner);
+    pieces.forEach((piece, k) => rows.push(k === 0 ? [gutter, ...piece] : [{ ...gutter, t: g('┆ ', ': '), color: p.faint }, { t: '', soft: '' }, ...piece]));
   }
-  rows.push([{ t: g('▙', '+'), color: p.tealDeep }, { t: g('─', '-').repeat(Math.max(0, width - 2)), color: p.lineSoft }]);
+  rows.push([{ t: g('▙', '+'), color: p.tealDeep, copy: '' }, { t: g('─', '-').repeat(Math.max(0, width - 2)), color: p.lineSoft, copy: '' }]);
   return rows;
 }
 
@@ -265,7 +289,8 @@ function table(block, width) {
     const header = index === 0;
     const spans = [];
     for (let col = 0; col < columns; col++) {
-      if (col) spans.push({ t: g(' │ ', ' | '), color: p.line });
+      // Copied as a tab: a table pasted into a sheet lands in cells.
+      if (col) spans.push({ t: g(' │ ', ' | '), color: p.line, copy: '\t' });
       const content = truncateRow(inlineSpans(row[col] || '', header ? { bold: true, color: p.tealSoft } : {}), widths[col]);
       spans.push(...content);
       const gap = widths[col] - contentWidth(content);
@@ -273,7 +298,7 @@ function table(block, width) {
     }
     rows.push(spans);
     if (header) {
-      rows.push(widths.flatMap((w, col) => (col ? [{ t: g('─┼─', '-+-'), color: p.line }, { t: g('─', '-').repeat(w), color: p.line }] : [{ t: g('─', '-').repeat(w), color: p.line }])));
+      rows.push(widths.flatMap((w, col) => (col ? [{ t: g('─┼─', '-+-'), color: p.line, copy: '' }, { t: g('─', '-').repeat(w), color: p.line, copy: '' }] : [{ t: g('─', '-').repeat(w), color: p.line, copy: '' }])));
     }
   });
   return rows;