latex-stickies 1.2.0 → 1.3.1

package/README.md

@@ -1,9 +1,16 @@
 # LaTeX Stickies
 
-Sticky notes for your desktop that render LaTeX and Markdown.
+[![npm](https://img.shields.io/npm/v/latex-stickies)](https://www.npmjs.com/package/latex-stickies)
+[![CI](https://github.com/kev-nj/latex-stickies/actions/workflows/ci.yml/badge.svg)](https://github.com/kev-nj/latex-stickies/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/latex-stickies)](LICENSE)
 
-Write `$e^{i\pi} + 1 = 0$` in a note and it renders as soon as you click away.
-Notes stay where you put them, in the color you chose, across restarts.
+Sticky notes for your desktop that render LaTeX and Markdown as you type.
+macOS, Windows and Linux.
+
+Write `$e^{i\pi} + 1 = 0$` and it becomes the equation. Click into it and the
+source comes back. There is no edit mode and no preview mode.
+
+<img src="https://raw.githubusercontent.com/kev-nj/latex-stickies/main/assets/demo.gif" alt="Typing maths, a table, a code block and an autocompleted equation into a note" width="420">
 
 ```
 npx latex-stickies
@@ -16,41 +23,63 @@ npm install -g latex-stickies
 latex-stickies
 ```
 
-Requires Node 22.12 or newer. The first run downloads the Electron runtime (~230 MB), so
-give it a minute; later launches are instant.
+Requires Node 22.12 or newer. The first run downloads the Electron runtime
+(~230 MB), so give it a minute; later launches are instant. On a Mac you can
+download a `.dmg` from [Releases](https://github.com/kev-nj/latex-stickies/releases)
+instead and skip Node entirely.
 
 ## Writing in a note
 
-Everything renders as you type. Click into a line to see the markdown behind
-it; move away and it renders again.
+Everything renders while you write. Put the caret in an element to see the
+markdown behind it; move away and it renders again.
+
+**Maths** — `$…$` inline, `$$…$$` on its own line. Delimiters have to hug their
+content, so prose like `costs $5 and $6` stays text rather than turning into a
+formula. Broken TeX shows the source underlined in red with the parse error on
+hover, instead of blanking the note.
+
+**Markdown** — headings, `**bold**`, `*italic*`, `` `code` ``, `~~struck~~`,
+quotes, lists, and links that open in your browser. Tables render as tables,
+and their cells render maths. Task list checkboxes are clickable: tick one and
+`[ ]` becomes `[x]` in the file.
+
+**Code** — fenced blocks are highlighted across eleven languages, labelled with
+the language, and each has a copy button.
+
+Inside a fence the editor behaves like a code editor: Enter keeps your
+indentation and adds a level after `:` or `{`, Tab and Shift+Tab indent and
+dedent, and brackets and quotes auto-close. Outside one it behaves like a notes
+field — lists continue on Enter, and quotes are left alone so `don't` types
+normally.
+
+**Images of your maths** — right-click a rendered equation for *Copy as Image*
+or *Copy LaTeX*. `Cmd+Shift+C` copies the whole note as an image, however long
+it is. Both go straight to the clipboard, ready to paste into Slack or an email.
 
-**Math** — `$…$` inline, `$$…$$` on its own line. Delimiters have to hug their
-content, so ordinary prose like `costs $5 and $6` stays text rather than turning
-into a formula. Broken TeX shows the source underlined in red with the parse
-error on hover, instead of blanking the note.
+## Autocomplete (optional, local)
 
-**Markdown** — headings, `**bold**`, `*italic*`, `~~strikethrough~~`, lists,
-task lists, tables, blockquotes, and links (which open in your browser).
+A grey suggestion appears after a pause in typing; **Tab** accepts it, **Esc**
+dismisses it. It runs entirely on your machine through
+[Ollama](https://ollama.com) — nothing is sent anywhere — and is **off by
+default**. Turn it on under **Note → Autocomplete**.
 
-**Code** — fenced blocks are highlighted in 20 languages, with the language
-labelled and a copy button on hover:
+Pull a small model. This fires on every pause, so speed matters far more than
+size:
 
-````
-```python
-def gaussian(x, mu, sigma):
-    return exp(-((x - mu) ** 2) / (2 * sigma ** 2))
 ```
-````
+ollama pull qwen2.5-coder:1.5b
+```
 
-Aliases work as you would expect: `sh`, `shell` and `zsh` all mean bash, `py`
-means python, and `tex` means latex. A fence with no language stays plain --
-guessing on a two-line snippet is wrong often enough to be worse than nothing.
+Measured on a MacBook: **0.06–0.5s** with that model, against 0.4–3.5s for a
+14B — and the small one wrote better prose. Choose yours under **Note →
+Autocomplete Model**; installed models are listed with their sizes.
 
-Inside a fence the editor behaves like a code editor: Enter keeps your
-indentation and adds a level after `:` or `{`, Tab and Shift+Tab indent and
-dedent (including a whole selection), and brackets and quotes auto-close.
-Outside a fence it behaves like a notes field instead -- lists continue on
-Enter, and quotes are left alone so `don't` types normally.
+It knows what this app is for. `$$\int_0^1 x^2 dx = ` suggests `\frac{1}{3}$$`,
+and `The derivative of $x^2$ is ` suggests `$2x$.`
+
+**`Cmd+Shift+M`** turns a description into LaTeX: select *"integral of e to the
+minus x squared from 0 to infinity"* and it becomes
+`$\int_{0}^{\infty} e^{-x^2}\,dx$`.
 
 ## Keyboard
 
@@ -59,58 +88,82 @@ Use `Ctrl` in place of `Cmd` on Windows and Linux.
 | | |
 |---|---|
 | `Cmd+N` | New note |
-| `Cmd+W` | Close note |
-| `Cmd+Backspace` | Delete note |
-| `Cmd+E` | Toggle edit / preview |
-| `Cmd+T` | Keep on top |
-| `Cmd+±` | Text size |
+| `Cmd+W` | Close note (it reopens next launch) |
+| `Cmd+Shift+Backspace` | Delete note, permanently |
 | `Cmd+B` / `Cmd+I` / `Cmd+E` | Bold / italic / code |
 | `Cmd+K` | Link |
-| `Cmd+Shift+C` | Copy note as image |
-| `Esc` | Leave edit mode |
+| `Cmd+F` | Find in note |
+| `Cmd+Shift+M` | Maths from a description |
+| `Cmd+Shift+C` | Copy note as an image |
+| `Cmd+Shift+O` | Open the notes folder |
+| `Cmd+T` | Keep on top |
+| `Cmd+±` | Text size |
+
+On Windows and Linux the note windows have no menu bar, so the **☰** button
+in a note's toolbar opens the same menu. Every command is there.
+
+The **All Notes** menu lists every note you have. A tick means it is on screen;
+click to open a note, or click a ticked one to close it. So a note you closed
+is one click away rather than lost until the next launch.
 
 ## Where notes live
 
-| | |
-|---|---|
-| macOS | `~/Library/Application Support/latex-stickies/notes.json` |
-| Windows | `%APPDATA%\latex-stickies\notes.json` |
-| Linux | `~/.config/latex-stickies/notes.json` |
+One Markdown file per note, in a folder you can open:
+
+```
+~/Documents/LaTeX Stickies/
+  shopping-list.md
+  lecture-3.md
+  .stickies.json      # colours, positions, pinned state
+```
 
-Saves are atomic -- written to a temp file, flushed, then renamed over the
-target -- so a crash, a force quit, or pulling the power leaves the previous
-good file intact rather than a truncated one. Only one instance runs at a time,
-because two copies would hold divergent notes in memory and the last to quit
-would silently overwrite the other.
+They are ordinary files: grep them, keep the folder in git, sync it through
+Dropbox, or edit a note in another editor — the open note follows the change.
+`Cmd+Shift+O` opens the folder.
+
+Files are named from the note's first line, and renamed if you retitle it. A
+file you rename yourself keeps its name. Dropping a `.tex` or `.txt` file into
+the folder makes it a note too, and it keeps that extension.
+
+Metadata lives in the sidecar index rather than in frontmatter, so the note
+files stay clean — a `.tex` file with YAML at the top would not compile.
+
+Saves are atomic: written to a temp file, flushed, then renamed over the
+target, so a crash or force quit leaves the previous file intact rather than a
+truncated one. Only one instance runs at a time, because two copies would hold
+divergent notes and the last to quit would overwrite the other.
+
+An existing `notes.json` from an older version is migrated the first time and
+then left in place.
 
 ## Development
 
 ```
 npm install
 npm start        # run from source
-npm test         # 4 suites, 62 assertions
-npm run vendor   # regenerate the bundled Prism
+npm test         # unit suites
+npm run vendor   # rebuild the bundled libraries
 npm run icon     # rebuild the app icon from assets/icon-master.png
+npm run demo     # re-record assets/demo.gif from the real app (needs ffmpeg)
+npm run dist     # build a macOS .app and .dmg
 ```
 
-Artwork lives in `assets/`: `logo.jpeg` is the original, and `icon-master.png`
-is the prepared 1024px master the icon is generated from -- transparent ground,
-art filling 824 of the canvas, which is the macOS convention that keeps an icon
-at the same visual weight as the rest of the Dock.
-
-The renderer loads over `file://` under a strict content-security policy, so
-KaTeX, marked, DOMPurify and Prism are vendored into `src/renderer/vendor/`
-rather than pulled from a CDN. Note text is sanitized before it reaches the
-page, and the renderer talks to disk only through a six-function preload bridge.
-
-To build a macOS `.app` and `.dmg`:
+Beyond the unit tests, several checks drive the real app and run in CI on
+macOS, Windows and Linux:
 
 ```
-npm run dist
+node scripts/smoke.js             # boots, and stays up
+node scripts/smoke.js --lifecycle # closing every note behaves per platform
+node scripts/render-check.js      # the first-run note renders correctly
+node scripts/ghost-check.js       # autocomplete suggests, and Tab accepts
+node scripts/snapshot-check.js    # a long note is captured whole
 ```
 
-The build is unsigned, so macOS will warn on other machines unless you sign it
-with an Apple Developer ID.
+The renderer loads over `file://` under a strict content-security policy, so
+CodeMirror and KaTeX are bundled into `src/renderer/vendor/` rather than pulled
+from a CDN. Note text is never parsed as HTML, and the renderer reaches the
+filesystem and the network only through a narrow preload bridge — Ollama is
+called from the main process, so the page keeps `default-src 'none'`.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "latex-stickies",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Sticky notes for your desktop that render LaTeX and Markdown.",
   "main": "src/main.js",
   "scripts": {
@@ -8,6 +8,7 @@
     "test": "node scripts/test.js",
     "vendor": "node scripts/vendor.js",
     "icon": "node scripts/make-icon.js",
+    "demo": "node scripts/make-demo.js",
     "dist": "node scripts/build-dmg.js",
     "install-app": "npm run dist && rm -rf \"/Applications/LaTeX Stickies.app\" && cp -R \"dist/mac-arm64/LaTeX Stickies.app\" /Applications/ && xattr -dr com.apple.quarantine \"/Applications/LaTeX Stickies.app\"",
     "prepublishOnly": "npm test",
@@ -45,6 +46,7 @@
     "@codemirror/lang-sql": "^6.10.0",
     "@codemirror/lang-yaml": "^6.1.3",
     "@codemirror/language": "^6.12.4",
+    "@codemirror/search": "^6.7.2",
     "@codemirror/state": "^6.7.2",
     "@codemirror/view": "^6.43.10",
     "@lezer/highlight": "^1.2.3",

package/src/ai.js

@@ -168,4 +168,50 @@ async function complete({ prefix, suffix, model }) {
   }
 }
 
-module.exports = { status, complete, pickDefault, trimOverlap, tidy, HOST };
+/**
+ * Turns a description of some maths into LaTeX.
+ *
+ * Unlike autocomplete this is a real instruction, so it goes through the chat
+ * template rather than fill-in-the-middle -- the model is being asked a
+ * question, not continuing a sentence.
+ */
+async function toLatex({ text, model }) {
+  if (!text || !text.trim()) return '';
+
+  const prompt = 'Write the LaTeX for the following, and reply with the LaTeX '
+    + 'only -- no explanation, no dollar signs, no code fences.\n\n'
+    + `${text.trim()}\n`;
+
+  try {
+    const res = await withTimeout(`${HOST}/api/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        prompt,
+        stream: false,
+        options: { num_predict: 120, temperature: 0.1 },
+      }),
+    }, 20000);
+    if (!res.ok) return '';
+    const data = await res.json();
+
+    // Models wrap the answer in fences, dollars or \[ \] however firmly you
+    // ask them not to. The caller supplies its own delimiters.
+    return String(data.response || '')
+      .replace(/```[a-z]*\n?/gi, '')
+      .replace(/```/g, '')
+      .trim()
+      .replace(/^\\\[|\\\]$/g, '')
+      .replace(/^\\\(|\\\)$/g, '')
+      .trim()
+      .replace(/^\$+|\$+$/g, '')
+      .trim();
+  } catch (_) {
+    return '';
+  }
+}
+
+module.exports = {
+  status, complete, toLatex, pickDefault, trimOverlap, tidy, HOST,
+};

package/src/editor/entry.js

@@ -23,6 +23,9 @@ import {
   LanguageDescription,
 } from '@codemirror/language';
 import { tags } from '@lezer/highlight';
+import {
+  search, searchKeymap, highlightSelectionMatches, openSearchPanel,
+} from '@codemirror/search';
 
 import { python } from '@codemirror/lang-python';
 import { javascript } from '@codemirror/lang-javascript';
@@ -66,4 +69,5 @@ window.CM = {
   markdown, markdownLanguage,
   syntaxTree, HighlightStyle, syntaxHighlighting, defaultHighlightStyle,
   tags, codeLanguages,
+  search, searchKeymap, highlightSelectionMatches, openSearchPanel,
 };

package/src/main.js

@@ -43,6 +43,48 @@ function randomId() {
   return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
 }
 
+/** What to call a note in a menu: its first non-empty line. */
+function titleOf(note) {
+  const first = (note.body || '').split('\n').find((l) => l.trim());
+  if (!first) return 'Untitled note';
+  const clean = first.replace(/^#+\s*/, '').trim();
+  return clean.length > 40 ? `${clean.slice(0, 40)}...` : clean;
+}
+
+/**
+ * Deletes the focused note, asking first.
+ *
+ * The confirmation is a native dialog rather than window.confirm(). These
+ * windows are frameless, transparent and often on top, and a web confirm can
+ * end up behind the note or invisible -- the delete then blocks on a prompt
+ * nobody can see, which looks exactly like the shortcut doing nothing.
+ */
+async function deleteFocusedNote() {
+  const win = BrowserWindow.getFocusedWindow();
+  if (!win) return;
+  const entry = [...windows.entries()].find(([, w]) => w === win);
+  if (!entry) return;
+  const [id] = entry;
+
+  const note = store.get(id);
+  if (note && note.body.trim()) {
+    const { response } = await dialog.showMessageBox(win, {
+      type: 'warning',
+      buttons: ['Delete', 'Cancel'],
+      defaultId: 1,
+      cancelId: 1,
+      message: 'Delete this note?',
+      detail: `"${titleOf(note)}" will be removed from your notes folder. `
+        + 'This cannot be undone.',
+    });
+    if (response !== 0) return;
+  }
+
+  store.remove(id);
+  if (!win.isDestroyed()) win.destroy();
+  buildMenu();
+}
+
 function cascadeBounds() {
   const area = screen.getPrimaryDisplay().workArea;
   const n = windows.size;
@@ -115,6 +157,19 @@ function openNote(note) {
   win.on('closed', () => {
     windows.delete(note.id);
     smokeLog(`windows=${windows.size}`);
+
+    // macOS apps outlive their windows; the Dock icon is the way back.
+    // Elsewhere there is no way back, so an app with no windows is just an
+    // invisible process -- and the next launch hands off to it and appears to
+    // do nothing. Leave, rather than trusting the quit lifecycle to unwind an
+    // event loop that open handles can keep alive.
+    if (windows.size === 0 && process.platform !== 'darwin') {
+      prepareToExit();
+      process.exit(0);
+      return;
+    }
+
+    buildMenu(); // the tick beside this note in the All Notes menu
   });
 
   // Links inside a note open in the real browser, never inside the sticky.
@@ -180,6 +235,22 @@ async function buildMenu() {
     },
   }));
 
+  // Every saved note, so a closed one is not lost until the next launch --
+  // until now nothing in the interface said it still existed.
+  const noteItems = store.all().map((note) => ({
+    label: titleOf(note),
+    type: 'checkbox',
+    // The tick means "on screen". Since it looks like a checkbox it has to
+    // behave like one: clicking a ticked note closes it, rather than the tick
+    // being decoration you cannot affect.
+    checked: windows.has(note.id),
+    click: () => {
+      const open = windows.get(note.id);
+      if (open && !open.isDestroyed()) open.close();
+      else openNote(store.get(note.id) || note);
+    },
+  }));
+
   const template = [
     {
       label: app.name,
@@ -204,11 +275,12 @@ async function buildMenu() {
         { type: 'separator' },
         {
           label: 'Delete Note',
-          accelerator: 'CmdOrCtrl+Backspace',
-          click: () => {
-            const win = BrowserWindow.getFocusedWindow();
-            if (win) win.webContents.send('request-delete');
-          },
+          // Not Cmd+Backspace: that is "delete to start of line" in every
+          // macOS text field, and CodeMirror binds it too -- so the editor ate
+          // the key, and had it not, reaching for a normal editing shortcut
+          // would have destroyed a note with no undo.
+          accelerator: 'CmdOrCtrl+Shift+Backspace',
+          click: () => deleteFocusedNote(),
         },
       ],
     },
@@ -217,10 +289,24 @@ async function buildMenu() {
       label: 'Note',
       submenu: [
         {
-          label: 'Toggle Edit / Preview',
-          accelerator: 'CmdOrCtrl+E',
-          click: () => BrowserWindow.getFocusedWindow()?.webContents.send('toggle-edit'),
+          label: 'Maths from Description...',
+          accelerator: 'CmdOrCtrl+Shift+M',
+          click: () => BrowserWindow.getFocusedWindow()?.webContents.send('describe-latex'),
         },
+        { type: 'separator' },
+        {
+          label: 'Find in Note',
+          accelerator: 'CmdOrCtrl+F',
+          // The editor owns the panel; this entry is for discoverability.
+          click: () => BrowserWindow.getFocusedWindow()?.webContents.send('find-in-note'),
+        },
+        { type: 'separator' },
+        {
+          label: 'Open Notes Folder',
+          accelerator: 'CmdOrCtrl+Shift+O',
+          click: () => shell.openPath(store.DIR),
+        },
+        { type: 'separator' },
         {
           label: 'Autocomplete (Ollama)',
           type: 'checkbox',
@@ -292,6 +378,15 @@ async function buildMenu() {
         },
       ],
     },
+    {
+      // "All Notes", not "Notes": it sits beside the "Note" menu, and two
+      // near-identical names for the current note and the list of every note
+      // is a coin toss every time you reach for one.
+      label: 'All Notes',
+      submenu: noteItems.length
+        ? noteItems
+        : [{ label: 'No notes yet', enabled: false }],
+    },
     {
       label: 'Window',
       submenu: [
@@ -341,6 +436,38 @@ function surfaceNotes() {
 
 app.on('second-instance', surfaceNotes);
 
+/**
+ * Follows edits made to the note files by anything else -- another editor,
+ * Dropbox, a git checkout. The open window updates in place rather than
+ * quietly overwriting what was changed on disk.
+ */
+let stopWatchingNotes = null;
+
+/**
+ * Everything that must happen before the process goes away.
+ *
+ * Synchronous on purpose: it runs immediately before process.exit(), which
+ * gives nothing asynchronous a chance to finish. The watcher is closed first
+ * because its handle is what keeps the event loop -- and so the invisible
+ * process -- alive after the last window has gone.
+ */
+function prepareToExit() {
+  if (stopWatchingNotes) {
+    stopWatchingNotes();
+    stopWatchingNotes = null;
+  }
+  store.saveNow();
+}
+
+function watchNotesFolder() {
+  stopWatchingNotes = store.watch((changed) => {
+    for (const note of changed) {
+      const win = windows.get(note.id);
+      if (win && !win.isDestroyed()) win.webContents.send('note-changed', note.body);
+    }
+  });
+}
+
 app.whenReady().then(async () => {
   // Run from npm there is no .app bundle to carry the icon, so macOS would show
   // the generic Electron atom in the Dock. Set it explicitly.
@@ -358,6 +485,7 @@ app.whenReady().then(async () => {
 
   await buildMenu();
   restoreNotes();
+  watchNotesFolder();
 
   if (SMOKE_CLOSE_MS) {
     setTimeout(() => {
@@ -374,13 +502,35 @@ app.whenReady().then(async () => {
 // process lingered invisibly with no way to reach it, and the next launch
 // handed off to it and appeared to do nothing. Quit there instead. The notes
 // are already on disk and come back on the next launch.
+// Belt and braces: the window 'closed' handler above normally gets there
+// first, but this catches any window torn down by another route.
 app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') app.quit();
+  if (process.platform !== 'darwin') {
+    prepareToExit();
+    process.exit(0);
+  }
 });
-app.on('before-quit', () => store.saveNow());
+app.on('before-quit', prepareToExit);
 
 ipcMain.handle('note:get', (_e, id) => store.get(id));
-ipcMain.handle('note:update', (_e, patch) => store.upsert(patch));
+let titleTimer = null;
+let lastTitles = '';
+
+/** Rebuilds the Notes menu when a title changes, at a human pace. */
+function refreshNoteTitles() {
+  clearTimeout(titleTimer);
+  titleTimer = setTimeout(() => {
+    const titles = store.all().map(titleOf).join('\u0000');
+    if (titles === lastTitles) return;
+    lastTitles = titles;
+    buildMenu();
+  }, 800);
+}
+
+ipcMain.handle('note:update', (_e, patch) => {
+  store.upsert(patch);
+  if (patch && patch.body !== undefined) refreshNoteTitles();
+});
 
 // A closing note flushes its last edit here. Write straight through rather than
 // joining the debounce: the window is already going away.
@@ -391,12 +541,17 @@ ipcMain.on('note:flush', (e, patch) => {
   }
   e.returnValue = true;
 });
-ipcMain.handle('note:new', () => createNote().id);
+ipcMain.handle('note:new', () => {
+  const id = createNote().id;
+  buildMenu();
+  return id;
+});
 
 ipcMain.handle('note:delete', (_e, id) => {
   store.remove(id);
   const win = windows.get(id);
   if (win && !win.isDestroyed()) win.destroy();
+  buildMenu();
 });
 
 ipcMain.handle('note:setAlwaysOnTop', (e, value) => {
@@ -466,6 +621,19 @@ ipcMain.handle('note:mathMenu', (e, { rect, tex } = {}) => {
 
 ipcMain.handle('note:openExternal', (_e, url) => openExternal(url));
 
+/**
+ * Pops the application menu open at the toolbar button.
+ *
+ * frame: false means Windows and Linux draw no menu bar, so every command
+ * behind it was reachable only by a shortcut someone had to already know.
+ * The same menu, so accelerators and this stay in step by construction.
+ */
+ipcMain.on('app:show-menu', (event) => {
+  const win = BrowserWindow.fromWebContents(event.sender);
+  const menu = Menu.getApplicationMenu();
+  if (win && menu) menu.popup({ window: win, x: 8, y: 26 });
+});
+
 ipcMain.handle('note:copyText', (_e, text) => clipboard.writeText(String(text)));
 
 /**
@@ -492,6 +660,15 @@ ipcMain.handle('ai:settings', async () => {
 
 ipcMain.handle('ai:complete', (_e, payload) => ai.complete(payload || {}));
 
+ipcMain.handle('ai:toLatex', async (_e, { text } = {}) => {
+  const saved = store.settings();
+  const { available, models } = await ai.status();
+  if (!available || !models.length) return { error: 'ollama-unreachable' };
+  const names = models.map((m) => m.name);
+  const model = names.includes(saved.aiModel) ? saved.aiModel : ai.pickDefault(models);
+  return { latex: await ai.toLatex({ text, model }) };
+});
+
 /**
  * Puts a PNG on the clipboard.
  *

package/src/preload.js

@@ -29,17 +29,21 @@ contextBridge.exposeInMainWorld('sticky', {
   flush: (body) => ipcRenderer.sendSync('note:flush', { id: noteId, body }),
   mathMenu: (payload) => ipcRenderer.invoke('note:mathMenu', payload),
   copyNote: (payload) => ipcRenderer.invoke('note:copyNote', payload),
+  // These windows are frameless, so on Windows and Linux there is no menu
+  // bar at all. This is the way in.
+  openAppMenu: () => ipcRenderer.send('app:show-menu'),
 
   // Optional, local-only autocomplete. Requests are made in the main process:
   // this page cannot reach the network, and should not be able to.
   ai: {
     settings: () => ipcRenderer.invoke('ai:settings'),
     complete: (payload) => ipcRenderer.invoke('ai:complete', payload),
+    toLatex: (payload) => ipcRenderer.invoke('ai:toLatex', payload),
   },
   on: (channel, fn) => {
     const allowed = [
-      'toggle-edit', 'request-delete', 'font-size', 'always-on-top-changed',
-      'copy-note-image', 'ai-settings-changed',
+      'font-size', 'always-on-top-changed',
+      'copy-note-image', 'ai-settings-changed', 'note-changed', 'find-in-note', 'describe-latex',
     ];
     if (!allowed.includes(channel)) return;
     ipcRenderer.on(channel, (_e, payload) => fn(payload));