Paste routes by recency: one internal copy no longer blocks image paste

Reported (and reproduced to the letter): copy a device on the canvas, and
for the REST OF THE SESSION pasting an image from the OS clipboard - one
verified fresh in Paint - pastes the stale device copy instead. Mechanism:
the Ctrl+V keydown handler preventDefault()ed whenever the object clipboard
was non-empty, which suppresses the browser's paste EVENT - the only place
image pasting (and the OS clipboard itself) lives. Only New Diagram or a
reload cleared it, which is exactly the save/new/hard-refresh dance that
"fixed" it in the field.

The fix is a recency rule, not a priority swap ("image always wins" would
break stamping copies of a device while an old screenshot sits in the OS
clipboard). Internal copies now also STAMP the OS clipboard - a marker
type plus the copied labels as plain text, so pasting into a text editor
yields something meaningful - making the OS clipboard's own
last-writer-wins ordering the arbiter. The paste event routes: marker
present -> the objects are newest, paste them; image without marker -> the
image is newest, paste it; neither -> object-clipboard fallback (old
behavior, covers a failed stamp). The Ctrl+V keydown no longer touches
preventDefault; its only job is an 80ms fallback timer for the one case
that fires no paste event at all (empty OS clipboard). Duplicate (Ctrl+D)
deliberately does not stamp - it should not clobber the user's clipboard.
execCommand does the stamping because navigator.clipboard requires a
secure context and plain-HTTP LAN deployments are a supported layout.

Verified: five new harness checks drive the REAL listeners with synthetic
ClipboardEvents - marker routes to objects, image-without-marker pastes
the image (the reported bug, pinned), text-only falls back, the timer
fallback fires when no paste event arrives (127/127) - and headless
Chromium with real clipboard permissions confirms Ctrl+C writes the actual
OS clipboard (readText returned every sample label, zone included).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: RootSwitch

app.js

@@ -3150,7 +3150,7 @@
     const toolbarActions = {
         'undo': () => undo(),
         'redo': () => redo(),
-        'copy': () => copySelection(),
+        'copy': () => { if (copySelection()) stampOsClipboard(); },
         'paste': () => pasteClipboard(),
         'delete': () => deleteSelected(),
         'arrange-front': () => arrangeSelected('front'),
@@ -3229,7 +3229,7 @@
         'export-drawio':      () => exportDrawio(),
         'undo': () => undo(),
         'redo': () => redo(),
-        'copy': () => copySelection(),
+        'copy': () => { if (copySelection()) stampOsClipboard(); },
         'paste': () => pasteClipboard(),
         'delete': () => deleteSelected(),
         'arrange-front': () => arrangeSelected('front'),
@@ -4374,7 +4374,7 @@
         items.push({ label: 'Redo', key: 'Ctrl+Y', disabled: redoStack.length === 0, action: () => redo() });
         items.push({ sep: true });
         if (anySel) {
-            items.push({ label: 'Copy', key: 'Ctrl+C', action: () => copySelection() });
+            items.push({ label: 'Copy', key: 'Ctrl+C', action: () => { if (copySelection()) stampOsClipboard(); } });
         }
         items.push({ label: 'Paste', key: 'Ctrl+V', disabled: !state.clipboard, action: () => pasteClipboard() });
         if (anySel) {
@@ -8368,10 +8368,27 @@
     }
 
     document.addEventListener('paste', (e) => {
+        // Seen BEFORE the guards: a paste that lands in an input must still
+        // cancel the keydown handler's internal-paste fallback timer, or
+        // typing Ctrl+V into a label field would also stamp objects onto the
+        // canvas 80ms later.
+        pasteEventSeen = true;
         if (e.target.tagName === 'INPUT' || e.target.tagName === 'SELECT' || e.target.tagName === 'TEXTAREA' || e.target.isContentEditable) return;
         if (state.inlineEditing && state.inlineEditing.element.contains(e.target)) return;
         const items = e.clipboardData?.items;
         if (!items) return;
+        // Recency routing: the marker means the newest thing copied was OUR
+        // objects (internal copies stamp it; any later external copy
+        // overwrites it) - so objects win. No marker + an image = the image
+        // is newer - it wins. Neither = fall through to the object clipboard,
+        // which keeps internal paste working when the stamp failed.
+        if (Array.from(e.clipboardData.types || []).includes(CLIPBOARD_MARKER)) {
+            if (state.clipboard) {
+                e.preventDefault();
+                pasteClipboard();
+                return;
+            }
+        }
         for (const item of items) {
             if (item.type.startsWith('image/')) {
                 e.preventDefault();
@@ -8419,6 +8436,12 @@
                 return;
             }
         }
+        // No image and no marker (external text, or a stamp that never took):
+        // the object clipboard is the only thing paste can mean here.
+        if (state.clipboard) {
+            e.preventDefault();
+            pasteClipboard();
+        }
     });
 
     // --- Find on canvas (Ctrl+F) -------------------------------------------
@@ -8647,16 +8670,62 @@
             }
         }
 
-        // Copy: Ctrl+C
+        // Copy: Ctrl+C - and stamp the OS clipboard so paste can order the
+        // two clipboards by recency (see stampOsClipboard).
         if ((e.ctrlKey || e.metaKey) && e.key === 'c') {
-            if (copySelection()) e.preventDefault();
+            if (copySelection()) {
+                e.preventDefault();
+                stampOsClipboard();
+            }
         }
 
-        // Paste: Ctrl+V
+        // Paste: Ctrl+V. The routing lives in the 'paste' EVENT - the only
+        // place the OS clipboard is readable - so the keydown must NOT
+        // preventDefault (that suppressed the paste event, and with it image
+        // pasting, for the rest of the session after one internal copy). The
+        // timer is the fallback for the one case that fires no paste event at
+        // all: a completely empty OS clipboard, possible when the copy stamp
+        // failed. 80ms is far beyond the keydown->paste dispatch gap.
         if ((e.ctrlKey || e.metaKey) && e.key === 'v') {
-            if (state.clipboard) e.preventDefault();
-            pasteClipboard();
-        }
+            if (state.clipboard) {
+                pasteEventSeen = false;
+                setTimeout(() => { if (!pasteEventSeen) pasteClipboard(); }, 80);
+            }
+        }
+    });
+
+    // --- OS-clipboard stamp: makes paste routing RECENCY-correct ------------
+    // The object clipboard (state.clipboard) and the OS clipboard are two
+    // stores with no shared ordering, so "which did the user copy LAST?" -
+    // the only paste rule that matches intent - is unanswerable unless every
+    // internal copy also writes the OS clipboard. Stamping a marker type (plus
+    // the copied labels as plain text, so pasting into a text editor gives
+    // something meaningful) means the OS clipboard's own last-writer-wins
+    // ordering becomes the arbiter: marker present = the internal copy is
+    // newest; an image present without it = the image is newest. Without this,
+    // one internal Ctrl+C suppressed image paste for the whole session - the
+    // keydown handler preventDefault()ed the paste event that image pasting
+    // lives on, and a fresh screenshot pasted the morning's stale device copy.
+    // execCommand is the one clipboard-write API that works on plain-HTTP
+    // deployments (navigator.clipboard needs a secure context); the stamp is
+    // best-effort - if it fails, paste falls back to the object clipboard
+    // whenever the OS clipboard offers no image, which is the old behavior.
+    const CLIPBOARD_MARKER = 'application/x-crosscanvas-objects';
+    let stampingCopy = false;
+    let pasteEventSeen = false;
+    function stampOsClipboard() {
+        stampingCopy = true;
+        try { document.execCommand('copy'); } catch (err) { /* best-effort */ }
+        stampingCopy = false;
+    }
+    document.addEventListener('copy', (e) => {
+        if (!stampingCopy || !state.clipboard || !e.clipboardData) return;
+        const labels = [...state.clipboard.devices, ...state.clipboard.zones,
+                        ...state.clipboard.textBoxes, ...(state.clipboard.images || [])]
+            .map(o => String(o.label || o.text || '').trim()).filter(Boolean).join('\n');
+        e.clipboardData.setData(CLIPBOARD_MARKER, '1');
+        if (labels) e.clipboardData.setData('text/plain', labels);
+        e.preventDefault();
     });
 
     function copySelection() {

tools/tests.html

@@ -304,10 +304,80 @@
   routingSuite(t);
   labelSlideSuite(t);
   connectIntentSuite(t);
+  await clipboardSuite(t);
   await corpusSuite(t);
   render();
 }
 
+// --- clipboard routing (recency marker) ----------------------------------
+// The object clipboard and the OS clipboard have no shared ordering, so paste
+// routes by a marker the app stamps into the OS clipboard on internal copy:
+// marker present -> objects are newest -> paste objects; image without the
+// marker -> the image is newest -> paste it (the bug this pins: one internal
+// Ctrl+C used to suppress the paste EVENT forever, so a fresh screenshot
+// pasted the morning's stale device); neither -> object-clipboard fallback.
+// Everything here goes through the REAL listeners via synthetic events.
+async function clipboardSuite(t) {
+  const MARKER = 'application/x-crosscanvas-objects';   // pinned: a rename must break this test
+  const frame = document.querySelector('iframe');
+  const idoc = frame.contentDocument, iwin = frame.contentWindow;
+  const counts = () => ({ d: t.state.devices.length, i: t.state.images.length });
+  const key = (k) => idoc.body.dispatchEvent(new iwin.KeyboardEvent('keydown',
+    { key: k, ctrlKey: true, bubbles: true, cancelable: true }));
+  const paste = (dt) => idoc.body.dispatchEvent(new iwin.ClipboardEvent('paste',
+    { clipboardData: dt, bubbles: true, cancelable: true }));
+  const AP = (w, h) => [{ rx: w/2, ry: 0 }, { rx: w, ry: 0 }, { rx: w, ry: h/2 }, { rx: w, ry: h },
+                        { rx: w/2, ry: h }, { rx: 0, ry: h }, { rx: 0, ry: h/2 }, { rx: 0, ry: 0 }];
+  const dev = (i) => ({
+    id: 'cb' + i, templateId: 'cb' + i + 't', image: '@Server', originalImage: '@Server',
+    x: 80 + i * 150, y: 80, w: 60, h: 60, label: 'clip-' + i, labelPosition: 'bottom',
+    fontSize: 14, fontColor: '#333333', lineFormats: [{ bold: false, italic: false }],
+    spans: [[{ text: 'clip-' + i, bold: false, italic: false }]], tintColor: null,
+    attachmentPoints: AP(60, 60), fields: {}
+  });
+  t.applyDiagramData({ version: 6, appVersion: 'cctest', diagramTitle: 'clip-test', diagramVersion: 1,
+    devices: [dev(0), dev(1)], connections: [], zones: [], textBoxes: [], images: [], groups: [],
+    deviceTemplates: [], imageTable: {}, nextId: 900 });
+  key('a'); key('c');                     // select all -> internal copy (real handlers)
+  const r = {};
+  r.base = counts();
+
+  let dt = new iwin.DataTransfer();       // 1. marker -> objects win
+  dt.setData(MARKER, '1');
+  paste(dt);
+  r.marker = counts();
+
+  dt = new iwin.DataTransfer();           // 2. image, no marker -> IMAGE wins (the bug)
+  const png = Uint8Array.from(atob(
+    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=='),
+    c => c.charCodeAt(0));
+  dt.items.add(new iwin.File([png], 'clip.png', { type: 'image/png' }));
+  paste(dt);
+  // FileReader + Image decode are async, and the hidden test iframe
+  // deprioritizes decode - poll for the image instead of guessing a delay.
+  for (let w = 0; w < 40 && counts().i === 0; w++) { await new Promise(res => setTimeout(res, 100)); }
+  r.image = counts();
+
+  dt = new iwin.DataTransfer();           // 3. neither -> object fallback
+  dt.setData('text/plain', 'external text');
+  paste(dt);
+  r.text = counts();
+
+  key('v');                               // 4. Ctrl+V, NO paste event at all -> timer fallback
+  await new Promise(res => setTimeout(res, 180));
+  r.timer = counts();
+
+  suite('Clipboard routing (recency marker)', () => {
+    ok('setup: two devices copied internally', r.base.d === 2 && r.base.i === 0, JSON.stringify(r.base));
+    ok('marker in OS clipboard -> objects paste', r.marker.d === 4 && r.marker.i === 0, JSON.stringify(r.marker));
+    ok('image without marker -> the IMAGE pastes, not the stale copy',
+      r.image.i === 1 && r.image.d === 4, JSON.stringify(r.image));
+    ok('no image, no marker -> object-clipboard fallback', r.text.d === 6 && r.text.i === 1, JSON.stringify(r.text));
+    ok('Ctrl+V with no paste event -> timer fallback still pastes objects',
+      r.timer.d === 8 && r.timer.i === 1, JSON.stringify(r.timer));
+  });
+}
+
 // --- routing invariant ---------------------------------------------------
 // An orthogonal (or rounded, which is orthogonal with filleted corners) route
 // has NO legitimate diagonal segment, ever. That makes this an absolute