@tobq/boardclip 2.1.114 → 2.1.115

package/index.html

@@ -827,7 +827,8 @@ function renderShortcutSettings(settings, { clearStatus = true } = {}) {
   const quickRecord = shortcutRecordEl('quickPaste');
   const quickShortcut = info.quickPaste || '';
   if (quickShortcut) {
-    quickRecord.textContent = `${shortcutLabel(quickShortcut).replace(/\s\+\s[1-9]$/, '')} + 1-9`;
+    const numpad = /\+num[1-9]$/i.test(quickShortcut);
+    quickRecord.textContent = `${shortcutLabel(quickShortcut.replace(/\+(?:num)?[1-9]$/i, ''))} + ${numpad ? 'Num ' : ''}1-9`;
     quickRecord.title = `${quickShortcut.replace(/[1-9]$/, '1')} ... ${quickShortcut.replace(/[1-9]$/, '9')}`;
   } else {
     quickRecord.textContent = 'Not set';
@@ -945,25 +946,35 @@ for (const kind of Object.keys(SHORTCUT_KINDS)) {
   shortcutResetEl(kind).addEventListener('click', (e) => applyShortcut(kind, e.currentTarget.dataset.apply || ''));
 }
 
-document.addEventListener('keydown', async (e) => {
-  if (!shortcutRecording) return;
+// The recording row takes one chord: shortcut = its accelerator ('' = not a
+// shortcut), key = its non-modifier key's name ('' = none or no name).
+async function recordShortcut(shortcut, key) {
   const kind = shortcutRecording;
-  e.preventDefault();
-  e.stopPropagation();
-  if (e.key === 'Escape') {
-    await cancelShortcutRecording();
-    return;
-  }
-  const shortcut = shortcutFromEvent(e);
+  if (!kind) return;
   if (!shortcut) {
-    setShortcutStatus(kind, shortcutKeyFromEvent(e) ? 'Add a shortcut modifier.' : 'Press a non-modifier key.', true);
+    setShortcutStatus(kind, key ? 'Add a shortcut modifier.' : 'Press a non-modifier key.', true);
     return;
   }
   const resolved = kind === 'show' && window.api.resolveShowShortcut
     ? await window.api.resolveShowShortcut(shortcut)
     : shortcut;
   await applyShortcut(kind, resolved);
+}
+
+document.addEventListener('keydown', async (e) => {
+  if (!shortcutRecording) return;
+  e.preventDefault();
+  e.stopPropagation();
+  if (e.key === 'Escape') {
+    await cancelShortcutRecording();
+    return;
+  }
+  await recordShortcut(shortcutFromEvent(e), shortcutKeyFromEvent(e));
 }, true);
+// Windows: every Win/Ctrl/Alt chord pressed while recording is taken by the
+// keyboard hook before Windows acts on it (Win+1 would switch to a taskbar
+// app and hide the popup) and arrives here instead of as a keydown.
+if (window.api.onShortcutRecorded) window.api.onShortcutRecorded((chord) => recordShortcut(chord.shortcut, chord.key));
 
 document.getElementById('addGroupBtn').addEventListener('click', () => controller.addGroup(null));
 document.getElementById('syncAccounts').addEventListener('change', async (e) => {

package/lib/windows-hook-policy.js

@@ -4,6 +4,8 @@
 // decision, kept Win32-free so it is unit-tested without installing a hook
 // (test/windows-hook.test.js):
 //   - STATE: the SharedArrayBuffer layout main writes and the worker reads;
+//   - the chord table: the Win chords main hands the hook (writeChords) and
+//     the accelerator <-> key-code names both sides read them by;
 //   - createHookClaimer: which key presses the hook takes.
 
 // --- Shared state layout (one byte each; main writes, the worker reads) ---
@@ -11,8 +13,12 @@ const STATE = Object.freeze({
   POPUP_VISIBLE: 0,    // the popup is open: plain numpad keys type into it
   SLOT_FIRST: 1,       // bytes 1-9: numpad slot N holds a clip
   SLOT_LAST: 9,
-  NEW_NOTE_HOTKEY: 10, // Win+N is the new-note shortcut (not off, not a recorded chord, not recording)
-  SIZE: 16,
+  RECORDING: 10,       // a Settings shortcut row is recording: chords go to it
+  CHORD_COUNT: 11,     // live entries in the chord table
+  CHORDS: 12,          // CHORD_BYTES each: key code, MOD bits, action, slot
+  CHORD_BYTES: 4,
+  MAX_CHORDS: 12,      // show + new note + quick paste 1-9 = 11
+  SIZE: 64,
 });
 
 const VK = Object.freeze({
@@ -20,18 +26,102 @@ const VK = Object.freeze({
   LWIN: 0x5B, RWIN: 0x5C,
   N: 0x4E, V: 0x56,
   NUMPAD1: 0x61, NUMPAD9: 0x69,
+  OEM_PLUS: 0xBB,
 });
 const LLKHF_ALTDOWN = 0x20;
+// The modifiers held at a keydown, as bits (a chord matches on all four).
+const MOD = Object.freeze({ WIN: 1, CTRL: 2, ALT: 4, SHIFT: 8 });
+const PRIMARY = MOD.WIN | MOD.CTRL | MOD.ALT; // what makes a press a shortcut
+// Shift / Ctrl / Alt, generic and left / right (the hook sees the sided codes).
+const MODIFIER_KEYS = new Set([VK.SHIFT, VK.CONTROL, VK.MENU, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5]);
 
-// A claimed key fires only with EXACTLY its modifiers: never with Ctrl, Shift
-// or Alt held, and Win as `win` says (true = held, false = up, null = either).
-// A Win chord is Win alone (Win+Ctrl+N is Windows' Narrator settings, Win+Ctrl+V
-// its sound output panel: those stay Windows'); a numpad slot is a plain digit
-// or Win+digit (both documented), never Alt+digit (Alt codes) or Ctrl+digit.
-// mods = { win, ctrl, shift, alt } as held at the keydown.
-function exactModifiers(mods, { win = false } = {}) {
-  if (mods.ctrl || mods.shift || mods.alt) return false;
-  return win == null || !!mods.win === win;
+function modBits(mods) {
+  return (mods.win ? MOD.WIN : 0) | (mods.ctrl ? MOD.CTRL : 0) | (mods.alt ? MOD.ALT : 0) | (mods.shift ? MOD.SHIFT : 0);
+}
+
+// --- Key names: the accelerator spelling of each key code ---
+// The names the Settings recorder writes for a key it sees (index.html
+// shortcutKeyFromEvent), so a chord the hook hears while recording reads and
+// saves exactly like one the page heard; punctuation at its US position.
+const KEY_NAMES = new Map([
+  [0x08, 'Backspace'], [0x09, 'Tab'], [0x0D, 'Enter'], [0x14, 'Capslock'], [0x20, 'Space'],
+  [0x21, 'PageUp'], [0x22, 'PageDown'], [0x23, 'End'], [0x24, 'Home'],
+  [0x25, 'Left'], [0x26, 'Up'], [0x27, 'Right'], [0x28, 'Down'], [0x2D, 'Insert'], [0x2E, 'Delete'],
+  [0x90, 'Numlock'], [0x91, 'Scrolllock'],
+  [0xBA, ';'], [VK.OEM_PLUS, '='], [0xBC, ','], [0xBD, 'Minus'], [0xBE, '.'], [0xBF, '/'], [0xC0, '`'],
+  [0xDB, '['], [0xDC, 'Backslash'], [0xDD, ']'], [0xDE, "'"],
+]);
+for (let i = 0; i <= 9; i++) KEY_NAMES.set(0x30 + i, String(i));
+for (let i = 0; i < 26; i++) KEY_NAMES.set(0x41 + i, String.fromCharCode(0x41 + i));
+for (let i = 1; i <= 24; i++) KEY_NAMES.set(0x6F + i, `F${i}`);
+for (let i = 0; i <= 9; i++) KEY_NAMES.set(0x60 + i, `num${i}`);
+// Numpad operators last: the page names them like the main keys, so a saved
+// name reads back as the main key (what Electron registers for it too).
+for (const [vk, name] of [[0x6A, '*'], [0x6B, 'Plus'], [0x6D, 'Minus'], [0x6E, '.'], [0x6F, '/']]) KEY_NAMES.set(vk, name);
+
+const KEY_CODES = new Map([['plus', VK.OEM_PLUS], ['esc', 0x1B], ['escape', 0x1B], ['return', 0x0D],
+  ['numadd', 0x6B], ['numsub', 0x6D], ['nummult', 0x6A], ['numdiv', 0x6F], ['numdec', 0x6E]]);
+for (const [vk, name] of KEY_NAMES) if (!KEY_CODES.has(name.toLowerCase())) KEY_CODES.set(name.toLowerCase(), vk);
+
+const MOD_NAMES = new Map([
+  ['super', MOD.WIN], ['meta', MOD.WIN],
+  ['control', MOD.CTRL], ['ctrl', MOD.CTRL], ['commandorcontrol', MOD.CTRL], ['commandorctrl', MOD.CTRL], ['cmdorctrl', MOD.CTRL],
+  ['alt', MOD.ALT], ['option', MOD.ALT],
+  ['shift', MOD.SHIFT],
+]);
+
+function acceleratorParts(accelerator) {
+  return String(accelerator || '').split('+').map(p => p.trim().toLowerCase()).filter(Boolean);
+}
+
+// A Win chord: Windows' shell holds most of them at the RegisterHotKey layer
+// (Win+V Clipboard History, Win+N notifications, Win+1-9 the taskbar), where
+// a globalShortcut silently loses, so on Windows every one is the hook's.
+function isWinChord(accelerator) {
+  return acceleratorParts(accelerator).some(part => MOD_NAMES.get(part) === MOD.WIN);
+}
+
+// accelerator -> { vk, mods } for the chord table; null when it is not one
+// key with a shortcut modifier, or names a key the hook has no code for.
+function chordFromAccelerator(accelerator) {
+  let mods = 0;
+  let vk = 0;
+  for (const part of acceleratorParts(accelerator)) {
+    if (MOD_NAMES.has(part)) { mods |= MOD_NAMES.get(part); continue; }
+    if (vk || !KEY_CODES.has(part)) return null;
+    vk = KEY_CODES.get(part);
+  }
+  return vk && (mods & PRIMARY) ? { vk, mods } : null;
+}
+
+// What a recording heard, as the page recorder writes it: Super, Control,
+// Alt, Shift, then the key. key '' = a key with no name ("Press a
+// non-modifier key."); shortcut '' with a key = no shortcut modifier.
+function recordedChord(vk, mods) {
+  const key = vk === VK.OEM_PLUS && (mods & MOD.SHIFT) ? 'Plus' : (KEY_NAMES.get(vk) || '');
+  const parts = [[MOD.WIN, 'Super'], [MOD.CTRL, 'Control'], [MOD.ALT, 'Alt'], [MOD.SHIFT, 'Shift']]
+    .filter(([bit]) => mods & bit).map(([, name]) => name);
+  return { key, shortcut: key && (mods & PRIMARY) ? [...parts, key].join('+') : '' };
+}
+
+// --- Chord table (main writes it whole, the hook reads it per key) ---
+const ACTIONS = Object.freeze(['show', 'new-note', 'quick-paste']); // stored as index + 1
+
+// chords = [{ vk, mods, type, slot? }]. The count drops to 0 while the
+// entries change, so the hook never reads a half-written one. Returns
+// whether every chord fit.
+function writeChords(state, chords) {
+  const list = chords.slice(0, STATE.MAX_CHORDS);
+  Atomics.store(state, STATE.CHORD_COUNT, 0);
+  list.forEach((chord, i) => {
+    const at = STATE.CHORDS + i * STATE.CHORD_BYTES;
+    state[at] = chord.vk;
+    state[at + 1] = chord.mods;
+    state[at + 2] = ACTIONS.indexOf(chord.type) + 1;
+    state[at + 3] = chord.slot || 0;
+  });
+  Atomics.store(state, STATE.CHORD_COUNT, list.length);
+  return list.length === chords.length;
 }
 
 // One verdict per press: a key's auto-repeats and its keyup follow its first
@@ -47,6 +137,7 @@ function exactModifiers(mods, { win = false } = {}) {
 function createPressTracker() {
   const held = new Map(); // vk -> claimed, for keys down since their first keydown
   return {
+    holds(vk) { return held.has(vk); },
     event(vk, down, claim, wasDown) {
       if (!down) {
         const claimed = held.get(vk) === true;
@@ -66,30 +157,55 @@ function createPressTracker() {
 
 // The hook's claim decision for one key event. `state` is the shared-state
 // byte array; io.readMods(flags) and io.isKeyDown(vk) are the worker's Win32
-// reads (GetAsyncKeyState), called only when a decision needs them, so a key
-// the hook never takes costs a Map lookup.
-//   Win+V      -> post { type: 'show' }, Clipboard History never opens;
-//   Win+N      -> post { type: 'new-note' } while STATE.NEW_NOTE_HOTKEY;
-//   Numpad1-9  -> post { type: 'numpad', slot } with the popup closed and the
-//                 slot assigned (open, the digit types into the search).
+// reads (GetAsyncKeyState), called only for a key the shared bytes say could
+// be claimed, so any other key costs a few byte reads.
+//   recording  -> every press with Win, Ctrl or Alt, while the popup is open:
+//                 post { type: 'record', vk, mods } (Windows never acts on it,
+//                 so Win+1 records instead of switching to a taskbar app);
+//   a chord    -> its EXACT modifiers: post { type } ('show', 'new-note') or
+//                 { type: 'quick-paste', slot };
+//   Numpad1-9  -> plain or with Win, the popup closed and the slot assigned:
+//                 post { type: 'numpad', slot } (open, the digit types into
+//                 the search; Ctrl/Shift/Alt+digit stay the apps', Alt codes).
 // The Win key itself always passes. A press swallowed while Win was held
 // leaves Windows a bare Win tap, so the Win release after one says
 // markWinUsed and the worker taps a key that keeps the Start menu shut.
 // Returns { swallow, post, markWinUsed }.
 const PASS = Object.freeze({ swallow: false, post: null, markWinUsed: false });
 function createHookClaimer(state, io) {
-  // Win+<key> chords taken before Windows sees them: Win+V (Clipboard
-  // History's) shows the popup; Win+N (the notification panel's) opens a new
-  // note while main says it is the new-note shortcut. win = the Win rule for
-  // exactModifiers; ready() = main wants the key now.
-  const KEYS = new Map([
-    [VK.V, { type: 'show', win: true, ready: () => true }],
-    [VK.N, { type: 'new-note', win: true, ready: () => state[STATE.NEW_NOTE_HOTKEY] === 1 }],
-  ]);
-  for (let slot = 1; slot <= 9; slot++) {
-    KEYS.set(VK.NUMPAD1 + slot - 1, { type: 'numpad', slot, win: null,
-      ready: () => state[STATE.POPUP_VISIBLE] !== 1 && state[STATE.SLOT_FIRST + slot - 1] === 1 });
-  }
+  const recording = () => state[STATE.RECORDING] === 1 && state[STATE.POPUP_VISIBLE] === 1;
+  // The table entry for vk (with exactly `mods`, or any when null), else -1.
+  const chordIndex = (vk, mods) => {
+    const count = Math.min(state[STATE.CHORD_COUNT], STATE.MAX_CHORDS);
+    for (let i = 0; i < count; i++) {
+      const at = STATE.CHORDS + i * STATE.CHORD_BYTES;
+      if (state[at] === vk && (mods == null || state[at + 1] === mods)) return i;
+    }
+    return -1;
+  };
+  const isNumpadDigit = (vk) => vk >= VK.NUMPAD1 && vk <= VK.NUMPAD9;
+  const numpadSlot = (vk) => {
+    const slot = isNumpadDigit(vk) ? vk - VK.NUMPAD1 + 1 : 0;
+    return slot && state[STATE.POPUP_VISIBLE] !== 1 && state[STATE.SLOT_FIRST + slot - 1] === 1 ? slot : 0;
+  };
+  // Tracked keys get one verdict per press. A numpad digit always is, so a
+  // press that began as a digit stays one when the popup closes mid-press.
+  const tracked = (vk) => !MODIFIER_KEYS.has(vk) && (recording() || isNumpadDigit(vk) || chordIndex(vk, null) >= 0);
+  // Whether this press could be claimed at all, from the shared bytes alone:
+  // only then are the modifiers read.
+  const claimable = (vk) => recording() || numpadSlot(vk) > 0 || chordIndex(vk, null) >= 0;
+  const decide = (vk, mods) => {
+    if (recording()) return mods & PRIMARY ? { type: 'record', vk, mods } : null;
+    const i = chordIndex(vk, mods);
+    if (i >= 0) {
+      const at = STATE.CHORDS + i * STATE.CHORD_BYTES;
+      const type = ACTIONS[state[at + 2] - 1];
+      if (type === 'quick-paste') return { type, slot: state[at + 3] };
+      if (type) return { type };
+    }
+    const slot = numpadSlot(vk);
+    return slot && !(mods & (MOD.CTRL | MOD.ALT | MOD.SHIFT)) ? { type: 'numpad', slot } : null;
+  };
   const tracker = createPressTracker();
   let winUsed = false;
   return {
@@ -99,16 +215,15 @@ function createHookClaimer(state, io) {
         winUsed = false;
         return { swallow: false, post: null, markWinUsed: true };
       }
-      const key = KEYS.get(vk);
-      if (!key) return PASS;
-      let mods = null;
+      if (!tracker.holds(vk) && !(down && tracked(vk))) return PASS;
+      let mods = 0;
+      let post = null;
       const r = tracker.event(vk, down,
-        () => key.ready() && exactModifiers(mods = io.readMods(flags), { win: key.win }),
+        () => claimable(vk) && !!(post = decide(vk, mods = modBits(io.readMods(flags)))),
         () => io.isKeyDown(vk));
       if (!r.swallow) return PASS;
-      if (r.fire && mods.win) winUsed = true;
-      const post = !r.fire ? null : key.slot ? { type: key.type, slot: key.slot } : { type: key.type };
-      return { swallow: true, post, markWinUsed: false };
+      if (r.fire && (mods & MOD.WIN)) winUsed = true;
+      return { swallow: true, post: r.fire ? post : null, markWinUsed: false };
     },
   };
 }
@@ -124,4 +239,7 @@ function modsFrom(isKeyDown, flags) {
   };
 }
 
-module.exports = { STATE, VK, LLKHF_ALTDOWN, exactModifiers, createPressTracker, createHookClaimer, modsFrom };
+module.exports = {
+  STATE, VK, MOD, LLKHF_ALTDOWN, modBits, isWinChord, chordFromAccelerator, recordedChord,
+  writeChords, createPressTracker, createHookClaimer, modsFrom,
+};

package/lib/windows-hook-worker.js

@@ -103,8 +103,8 @@ const keybd_event = user32.func(
 );
 
 const isKeyDown = (vk) => (GetAsyncKeyState(vk) & 0x8000) !== 0;
-// Win+V, Win+N and Numpad1-9: each claimed only with exactly its modifiers,
-// one verdict per press (lib/windows-hook-policy.js).
+// Main's chord table, a Settings recording and Numpad1-9: each claimed only
+// with exactly its modifiers, one verdict per press (lib/windows-hook-policy.js).
 const claimer = createHookClaimer(sharedState, {
   isKeyDown,
   readMods: (flags) => modsFrom(isKeyDown, flags),

package/lib/windows-hook.js

@@ -4,31 +4,33 @@
 // On Windows we can't use Electron's `globalShortcut.register('Super+V')`
 // because Windows Clipboard History owns Win+V at the RegisterHotKey layer
 // and silently rejects our registration. This module installs a
-// WH_KEYBOARD_LL hook on a dedicated worker thread which intercepts Win+V,
-// Win+N (new note, while that is the shortcut) and numpad keys *before*
-// Windows Clipboard History / the notification panel see them.
+// WH_KEYBOARD_LL hook on a dedicated worker thread which intercepts every
+// Win chord BoardClip uses (Win+V, Win+N and any recorded one, see the chord
+// table in lib/windows-hook-policy.js), the numpad slot keys, and the chord a
+// Settings row is recording, *before* Windows' own handlers see them.
 //
 // See lib/windows-hook-worker.js for the hook implementation and the
 // rationale for running it in a worker.
 //
-// Shared state (popup visible, which numpad slots are assigned, Win+N on;
-// layout = STATE in lib/windows-hook-policy.js) is passed via a
+// Shared state (popup visible, which numpad slots are assigned, recording,
+// the chord table; layout = STATE in lib/windows-hook-policy.js) is passed via a
 // SharedArrayBuffer because the worker is synchronously blocked in
 // GetMessageW and can't process postMessage events from its JS event loop.
 
 const { Worker } = require('worker_threads');
 const path = require('path');
-const { STATE } = require('./windows-hook-policy');
+const { STATE, writeChords } = require('./windows-hook-policy');
 
 let currentHook = null;
 
-function install({ onShowPopup, onNumpadPaste, onNewNote }) {
+function install({ onShowPopup, onNumpadPaste, onQuickPaste, onNewNote, onRecordKey }) {
   if (process.platform !== 'win32') {
     // Non-Windows platforms use Electron's globalShortcut; no-op API here.
     return {
       setPopupVisible() {},
       setSlotAssignments() {},
-      setNewNoteHotkey() {},
+      setChords() { return true; },
+      setRecording() {},
       uninstall() {},
     };
   }
@@ -49,8 +51,14 @@ function install({ onShowPopup, onNumpadPaste, onNewNote }) {
       case 'numpad':
         try { onNumpadPaste(msg.slot); } catch (e) { console.error('[windows-hook] onNumpadPaste:', e); }
         break;
+      case 'quick-paste':
+        try { onQuickPaste(msg.slot); } catch (e) { console.error('[windows-hook] onQuickPaste:', e); }
+        break;
       case 'new-note':
-        try { if (onNewNote) onNewNote(); } catch (e) { console.error('[windows-hook] onNewNote:', e); }
+        try { onNewNote(); } catch (e) { console.error('[windows-hook] onNewNote:', e); }
+        break;
+      case 'record':
+        try { onRecordKey(msg.vk, msg.mods); } catch (e) { console.error('[windows-hook] onRecordKey:', e); }
         break;
       case 'ready':
         // Hook installed successfully — no action needed.
@@ -81,10 +89,14 @@ function install({ onShowPopup, onNumpadPaste, onNewNote }) {
         sharedState[STATE.SLOT_FIRST + n - 1] = assignedSet && assignedSet.has(n) ? 1 : 0;
       }
     },
-    // Win+N opens a new note only while it is the new-note shortcut (not
-    // while it is off or another chord is recorded, nor during a recording).
-    setNewNoteHotkey(enabled) {
-      sharedState[STATE.NEW_NOTE_HOTKEY] = enabled ? 1 : 0;
+    // The Win chords the hook claims: [{ vk, mods, type, slot? }] (main's
+    // registerShortcuts; empty while a recording runs). False = some did not fit.
+    setChords(chords) {
+      return writeChords(sharedState, chords);
+    },
+    // A Settings row is recording: every Win/Ctrl/Alt press goes to it.
+    setRecording(on) {
+      sharedState[STATE.RECORDING] = on ? 1 : 0;
     },
     uninstall() {
       if (!currentHook) return;

package/main.js

@@ -50,6 +50,7 @@ const conflictModel = require('./lib/conflict-model');
 const { ControlServer } = require('./lib/control-server');
 const windowsConsole = require('./lib/windows-console');
 const windowsDwm = require('./lib/windows-dwm');
+const hookPolicy = require('./lib/windows-hook-policy');
 const appearance = require('./lib/appearance');
 const { createNotifier } = require('./lib/notifications');
 
@@ -676,9 +677,9 @@ function effectiveQuickPasteShortcut() {
   return settings.quick_paste_shortcut || defaultQuickPasteShortcut();
 }
 
-// Windows: Win+N, taken by the keyboard hook like Win+V (it is Windows' own
-// notification panel chord, which RegisterHotKey cannot win). Elsewhere none
-// until one is recorded.
+// Windows: Win+N, taken by the keyboard hook like every Win chord (it is
+// Windows' own notification panel chord, which RegisterHotKey cannot win).
+// Elsewhere none until one is recorded.
 function defaultNewNoteShortcut() {
   return process.platform === 'win32' ? 'Super+N' : '';
 }
@@ -687,22 +688,11 @@ function defaultNewNoteShortcut() {
 // (Windows: Win+N goes back to Windows' notification panel). '' = the default.
 const SHORTCUT_OFF = 'none';
 
-// The chord the user recorded ('' for the default or off).
-function recordedNewNoteShortcut() {
-  const value = settings.new_note_shortcut || '';
-  return value === SHORTCUT_OFF ? '' : value;
-}
-
 function effectiveNewNoteShortcut() {
   if (settings.new_note_shortcut === SHORTCUT_OFF) return '';
   return settings.new_note_shortcut || defaultNewNoteShortcut();
 }
 
-function globalShowShortcut() {
-  if (process.platform === 'darwin' && shortcutUsesFn(settings.show_shortcut)) return '';
-  return settings.show_shortcut || (process.platform === 'win32' ? '' : DEFAULT_SHOW_SHORTCUT);
-}
-
 function globalQuickPasteShortcut() {
   const shortcut = effectiveQuickPasteShortcut();
   if (shortcutUsesFn(shortcut)) return '';
@@ -761,7 +751,8 @@ function quickPasteShortcutForSlot(shortcut, slot) {
   if (!parts.length) return '';
   const keyIndex = parts.length - 1;
   if (quickPasteSlotFromShortcut(parts[keyIndex]) == null) return '';
-  parts[keyIndex] = String(slot);
+  // A numpad digit stays a numpad digit (Ctrl+Alt+num1 is Ctrl+Alt+num1..num9).
+  parts[keyIndex] = (/^num/i.test(parts[keyIndex]) ? 'num' : '') + slot;
   return parts.join('+');
 }
 
@@ -8022,15 +8013,45 @@ function commitShortcutSetting(key, next, registeredFlag, error) {
 }
 
 function registerShortcuts() {
-  // What each shortcut needs: an OS registration (globalShortcut / Carbon), the
-  // Windows hook, or nothing. A recorded new-note chord is an ordinary global
-  // shortcut; Windows' default (Win+N) is the hook's; off is neither.
-  const macosShowKey = process.platform === 'darwin' ? effectiveShowShortcut() : '';
-  const showKey = process.platform === 'darwin' ? '' : globalShowShortcut();
-  const quickPasteKey = globalQuickPasteShortcut();
-  const recordedNewNote = recordedNewNoteShortcut();
-  const newNoteKey = shortcutUsesFn(recordedNewNote) ? '' : recordedNewNote;
-  const newNoteHookKey = process.platform === 'win32' && !settings.new_note_shortcut;
+  // Where each shortcut lives: macOS's popup hotkey (Carbon, Globe-capable),
+  // the Windows keyboard hook, a globalShortcut, or nowhere (off). On Windows
+  // EVERY Win chord is the hook's (hookPolicy.isWinChord: the shell holds most
+  // of them, Win+V / Win+N / Win+1-9 included, where a globalShortcut silently
+  // loses); the defaults Win+V and Win+N are Win chords like a recorded one.
+  const viaHook = (shortcut) => process.platform === 'win32' && hookPolicy.isWinChord(shortcut);
+  const showShortcut = effectiveShowShortcut();
+  const macosShowKey = process.platform === 'darwin' ? showShortcut : '';
+  const showHook = viaHook(showShortcut);
+  const showKey = macosShowKey || showHook ? '' : showShortcut;
+  const quickPasteShortcut = globalQuickPasteShortcut();
+  const quickPasteHook = viaHook(quickPasteShortcut);
+  const quickPasteKey = quickPasteHook ? '' : quickPasteShortcut;
+  const newNoteShortcut = shortcutUsesFn(effectiveNewNoteShortcut()) ? '' : effectiveNewNoteShortcut();
+  const newNoteHook = viaHook(newNoteShortcut);
+  const newNoteKey = newNoteHook ? '' : newNoteShortcut;
+
+  // The hook's chord table, first come first served like globalShortcut: a
+  // chord two shortcuts share, or a key the hook has no code for, fails the
+  // later one the way an already-registered globalShortcut does.
+  const hookChords = [];
+  const addHookChord = (shortcut, type, slot) => {
+    const chord = hookPolicy.chordFromAccelerator(shortcut);
+    if (!chord || hookChords.some(c => c.vk === chord.vk && c.mods === chord.mods)) return false;
+    hookChords.push({ ...chord, type, slot });
+    return true;
+  };
+  const showHookOk = !showHook || addHookChord(showShortcut, 'show');
+  const quickPasteRegistrations = [];
+  let quickPasteHookOk = true;
+  if (quickPasteHook) {
+    for (let n = 1; n <= 9; n++) {
+      const key = quickPasteShortcutForSlot(quickPasteShortcut, n);
+      const registered = !!key && addHookChord(key, 'quick-paste', n);
+      quickPasteRegistrations.push({ slot: n, key, registered, backend: 'hook' });
+      if (!registered) quickPasteHookOk = false;
+    }
+  }
+  const newNoteHookOk = !newNoteHook || addHookChord(newNoteShortcut, 'new-note');
 
   // A throwaway QA instance (BOARDCLIP_ISOLATED=1) never takes the keyboard: its
   // low-level hook would sit in front of the real app's, so Win+V would open the
@@ -8040,11 +8061,11 @@ function registerShortcuts() {
   // live, as it does for real (it cannot fail), so its row can be saved in QA.
   if (process.env.BOARDCLIP_ISOLATED === '1') {
     const isolated = {
-      showShortcutRegistered: !(macosShowKey || showKey),
+      showShortcutRegistered: showHookOk && !(macosShowKey || showKey),
       showShortcut: effectiveShowShortcut(),
-      quickPasteRegistered: !quickPasteKey,
+      quickPasteRegistered: quickPasteHookOk && !quickPasteKey,
       quickPasteShortcut: effectiveQuickPasteShortcut(),
-      newNoteRegistered: !newNoteKey,
+      newNoteRegistered: newNoteHookOk && !newNoteKey,
       newNoteShortcut: effectiveNewNoteShortcut(),
     };
     diagnostics.record('shortcut.register', { platform: process.platform, isolated: true, show_registered: isolated.showShortcutRegistered, quick_paste_registered: isolated.quickPasteRegistered, new_note_registered: isolated.newNoteRegistered });
@@ -8062,22 +8083,26 @@ function registerShortcuts() {
   }
   globalShortcut.unregisterAll();
 
-  let showShortcutRegistered = true;
-  let quickPasteRegistered = true;
-  let newNoteRegistered = true;
+  let showShortcutRegistered = showHookOk;
+  let quickPasteRegistered = quickPasteHookOk;
+  let newNoteRegistered = newNoteHookOk;
 
   if (process.platform === 'win32') {
-    // Windows Clipboard History owns Win+V and Win+Numpad1-9, so we can't use
-    // Electron's globalShortcut (RegisterHotKey) here — it silently fails.
-    // Instead, install a WH_KEYBOARD_LL hook on a dedicated worker thread that
-    // intercepts these keys *before* Windows Clipboard History sees them.
+    // The WH_KEYBOARD_LL hook on its own worker thread (lib/windows-hook.js):
+    // it takes the chord table, the numpad slot keys and a recording before
+    // Windows' own handlers see them.
     const { install } = require('./lib/windows-hook');
     windowsHook = install({
       onShowPopup: showPopup,
       onNumpadPaste: handleNumpad,
+      onQuickPaste: (slot) => handleQuickPaste(slot).catch(error => {
+        diagnostics.record('shortcut.quick_paste_error', { slot, source: 'hook', error: error && error.message }, { forceFile: true });
+      }),
       onNewNote: handleNewNoteShortcut,
+      onRecordKey: handleHookRecordedKey,
     });
-    windowsHook.setNewNoteHotkey(newNoteHookKey);
+    windowsHook.setRecording(false);
+    windowsHook.setChords(hookChords);
     // Seed the shared state with current history so plain numpad keys
     // immediately intercept for already-assigned slots.
     syncHookState();
@@ -8099,7 +8124,6 @@ function registerShortcuts() {
     if (!showShortcutRegistered) logSafe(`Warning: Could not register popup shortcut ${showKey}`);
   }
 
-  const quickPasteRegistrations = [];
   if (quickPasteKey) {
     if (process.platform === 'darwin') {
       const hook = getMacosHotkey();
@@ -8148,15 +8172,15 @@ function registerShortcuts() {
   }
   diagnostics.record('shortcut.register', {
     platform: process.platform,
-    show_key: macosShowKey || showKey,
+    show_key: showShortcut,
     show_registered: showShortcutRegistered,
-    show_backend: macosShowKey ? 'carbon' : (showKey ? 'electron' : ''),
-    quick_paste_key: quickPasteKey,
+    show_backend: macosShowKey ? 'carbon' : (showHook ? 'hook' : 'electron'),
+    quick_paste_key: quickPasteShortcut,
     quick_paste_registered: quickPasteRegistered,
     quick_paste_registrations: quickPasteRegistrations,
-    new_note_key: newNoteKey || (newNoteHookKey ? defaultNewNoteShortcut() : ''),
+    new_note_key: newNoteShortcut,
     new_note_registered: newNoteRegistered,
-    new_note_backend: newNoteKey ? 'electron' : (newNoteHookKey ? 'hook' : ''),
+    new_note_backend: newNoteHook ? 'hook' : (newNoteKey ? 'electron' : ''),
   }, { forceFile: true });
 
   return {
@@ -8172,8 +8196,14 @@ function registerShortcuts() {
 function suspendShortcutsForRecording() {
   shortcutsSuspended = true;
   globalShortcut.unregisterAll();
-  // The hook's Win+N too: a recording never opens a note (resume re-arms it).
-  if (windowsHook) windowsHook.setNewNoteHotkey(false);
+  // The hook's chords too, and every Win/Ctrl/Alt press now goes to the
+  // recorder instead of its app (resume re-arms them). Without this Windows
+  // acted on a Win chord first: Win+1 switched to a taskbar app, the popup
+  // lost focus and hid mid-recording, nothing was saved.
+  if (windowsHook) {
+    windowsHook.setChords([]);
+    windowsHook.setRecording(true);
+  }
   if (macosHotkey) {
     macosHotkey.clearRuntimeShortcut();
     macosHotkey.clearQuickPasteShortcuts();
@@ -8182,6 +8212,15 @@ function suspendShortcutsForRecording() {
   return { ok: true };
 }
 
+// A chord the hook took while a Settings row records (Windows): handed to the
+// popup's recorder as the chord its own keydown would have been.
+function handleHookRecordedKey(vk, mods) {
+  if (!shortcutsSuspended || !win || win.isDestroyed()) return;
+  const chord = hookPolicy.recordedChord(vk, mods);
+  diagnostics.record('shortcut.record_key', { vk, mods, shortcut: chord.shortcut }, { forceFile: diagnostics.isEnabled() });
+  win.webContents.send('shortcut-recorded', chord);
+}
+
 function resumeShortcutsAfterRecording() {
   shortcutsSuspended = false;
   const result = registerShortcuts();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tobq/boardclip",
   "productName": "BoardClip",
-  "version": "2.1.114",
+  "version": "2.1.115",
   "description": "Cross-platform clipboard history tray app with numpad quick-paste and native cloud sync",
   "keywords": [
     "clipboard",

package/preload.js

@@ -35,6 +35,13 @@ contextBridge.exposeInMainWorld('api', {
   suspendShortcuts: () => ipcRenderer.invoke('suspend-shortcuts'),
   resumeShortcuts: () => ipcRenderer.invoke('resume-shortcuts'),
   resolveShowShortcut: (shortcut) => ipcRenderer.invoke('resolve-show-shortcut', shortcut),
+  // Windows: the chord the keyboard hook took while a row records ({ shortcut, key },
+  // what the page recorder makes of a keydown); the page never sees those keys.
+  onShortcutRecorded: (callback) => {
+    const listener = (_, chord) => callback(chord);
+    ipcRenderer.on('shortcut-recorded', listener);
+    return () => ipcRenderer.removeListener('shortcut-recorded', listener);
+  },
   groupCreate: (text) => ipcRenderer.invoke('group-create', text), // -> the tag names ("a, b" = two), or false
   groupDelete: (name) => ipcRenderer.invoke('group-delete', name), // -> { ok, name, ids, shared }, or false
   groupRestore: (payload) => ipcRenderer.invoke('group-restore', payload), // the delete's Undo