cursedbelt 5.79.4 → 5.80.0

package/src/react/code-editor/keys.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test';
+import { EditorSelection, EditorState, type Transaction } from '@codemirror/state';
+import type { KeyBinding } from '@codemirror/view';
+import { editorKeyBindings } from './keys.js';
+import { selectAllOccurrences, selectNextOccurrence } from './occurrences.js';
+
+/** The command the editor runs for `key` on a Mac — the first binding that names it, as `keymap` resolves. */
+function macCommand(key: string): KeyBinding['run'] {
+  const named = (b: KeyBinding) => b.mac === key || (!b.mac && b.key === key.replace('Cmd-', 'Mod-'));
+  return editorKeyBindings.find(named)?.run;
+}
+
+function press(key: string, doc: string, at: number) {
+  let state = EditorState.create({ doc, selection: EditorSelection.cursor(at) });
+  const run = macCommand(key);
+  run?.({ state, dispatch: (tr: Transaction) => { state = tr.state; } } as never);
+  return { doc: state.doc.toString(), caret: state.selection.main.head };
+}
+
+describe('CodeEditor keys — VS Code on a Mac (forge task 3182)', () => {
+  test('⌘↑ / ⌘↓ jump to the top or bottom and leave the line where it is', () => {
+    expect(press('Cmd-ArrowUp', 'one\ntwo\nthree', 6)).toEqual({ doc: 'one\ntwo\nthree', caret: 0 });
+    expect(press('Cmd-ArrowDown', 'one\ntwo\nthree', 1)).toEqual({ doc: 'one\ntwo\nthree', caret: 13 });
+  });
+
+  test('⌥↑ / ⌥↓ move the line', () => {
+    expect(press('Alt-ArrowUp', 'one\ntwo', 5)).toEqual({ doc: 'two\none', caret: 1 });
+    expect(press('Alt-ArrowDown', 'one\ntwo', 1)).toEqual({ doc: 'two\none', caret: 5 });
+  });
+});
+
+describe('⌘D and ⇧⌘L — several cursors on the same word', () => {
+  const multi = EditorState.allowMultipleSelections.of(true);
+  function run(command: typeof selectNextOccurrence, state: EditorState): EditorState {
+    let next = state;
+    command({ state, dispatch: (tr: Transaction) => { next = tr.state; } });
+    return next;
+  }
+  const spans = (state: EditorState) => state.selection.ranges.map((r) => [r.from, r.to]);
+
+  test('⌘D takes the word under the caret, then each next match, wrapping, then stops', () => {
+    let state = EditorState.create({ doc: 'ab x ab y ab', selection: EditorSelection.cursor(6), extensions: multi });
+    state = run(selectNextOccurrence, state);
+    expect(spans(state)).toEqual([[5, 7]]);
+    state = run(selectNextOccurrence, state);
+    expect(spans(state)).toEqual([[5, 7], [10, 12]]);
+    state = run(selectNextOccurrence, state);
+    expect(spans(state)).toEqual([[0, 2], [5, 7], [10, 12]]);
+    expect(selectNextOccurrence({ state, dispatch: () => {} })).toBe(false);
+  });
+
+  test('⇧⌘L selects every match at once', () => {
+    const state = run(selectAllOccurrences, EditorState.create({ doc: 'ab x ab', selection: EditorSelection.cursor(1), extensions: multi }));
+    expect(spans(state)).toEqual([[0, 2], [5, 7]]);
+  });
+
+  test('they sit in front of defaultKeymap, on VS Code\'s keys', () => {
+    expect(macCommand('Cmd-d')).toBe(selectNextOccurrence);
+    expect(macCommand('Shift-Cmd-l')).toBe(selectAllOccurrences);
+  });
+});

package/src/react/code-editor/keys.ts

@@ -0,0 +1,17 @@
+import { defaultKeymap, historyKeymap, indentWithTab } from '@codemirror/commands';
+import type { KeyBinding } from '@codemirror/view';
+import { lineKeyBindings } from './lineAbove.js';
+import { occurrenceBindings } from './occurrences.js';
+
+/**
+ * Every key `CodeEditor` answers, first match wins: cb's VS Code additions IN FRONT of
+ * CodeMirror's `defaultKeymap`, which is already VS Code's for the rest. Nothing here may shadow
+ * a `defaultKeymap` key VS Code means the same way — `keys.spec.ts` holds ⌘↑ / ⌘↓ to the jump.
+ */
+export const editorKeyBindings: readonly KeyBinding[] = [
+  ...lineKeyBindings,
+  ...occurrenceBindings,
+  ...defaultKeymap,
+  ...historyKeymap,
+  indentWithTab,
+];

package/src/react/code-editor/languages.ts

@@ -9,6 +9,7 @@
 // and a snippet shown WITHOUT highlighting is the plain <pre> this component
 // exists to replace.
 import type { Extension } from '@codemirror/state';
+import { markdownRules } from './markdownRules.js';
 
 /** Supported language identifiers. `text` (the default) means no highlighting. */
 export type CodeLanguage =
@@ -397,10 +398,11 @@ export async function loadLanguageExtension(language: CodeLanguage): Promise<Ext
     case 'diff':
       return stream((await import('@codemirror/legacy-modes/mode/diff')).diff);
     // The one Lezer grammar past the first six: a markdown fence highlights its own
-    // code, and `#`, `**` and `[](…)` read as structure rather than as punctuation.
+    // code, and `#`, `**` and `[](…)` read as structure rather than as punctuation. A `---`
+    // rule is drawn as one while the caret is off its line (`markdownRules`).
     case 'markdown': {
       const { markdown } = await import('@codemirror/lang-markdown');
-      return markdown();
+      return [markdown(), markdownRules];
     }
     case 'scala':
       return stream((await import('@codemirror/legacy-modes/mode/clike')).scala);

package/src/react/code-editor/lineAbove.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test';
 import { EditorSelection, EditorState, type Transaction } from '@codemirror/state';
-import { insertBlankLineAbove, lineKeyBindings } from './lineAbove.js';
+import { insertBlankLineAbove } from './lineAbove.js';
 
 function run(doc: string, at: number): { doc: string; caret: number } {
   let state = EditorState.create({ doc, selection: EditorSelection.cursor(at) });
@@ -19,18 +19,3 @@ describe('insertBlankLineAbove — ⇧⌘↵ in CodeEditor', () => {
     expect(insertBlankLineAbove({ state, dispatch: () => {} })).toBe(false);
   });
 });
-
-describe('lineKeyBindings — ⌘↑ / ⌘↓ in CodeEditor', () => {
-  function press(key: string, doc: string, at: number): { doc: string; caret: number } {
-    let state = EditorState.create({ doc, selection: EditorSelection.cursor(at) });
-    const binding = lineKeyBindings.find((b) => b.key === key);
-    // moveLineUp/Down are StateCommands at heart; they read only `state` and `dispatch`.
-    binding?.run?.({ state, dispatch: (tr: Transaction) => { state = tr.state; } } as never);
-    return { doc: state.doc.toString(), caret: state.selection.main.head };
-  }
-
-  test('⌘↑ moves the line up and ⌘↓ moves it down, the caret riding with it', () => {
-    expect(press('Mod-ArrowUp', 'one\ntwo', 5)).toEqual({ doc: 'two\none', caret: 1 });
-    expect(press('Mod-ArrowDown', 'one\ntwo', 1)).toEqual({ doc: 'two\none', caret: 5 });
-  });
-});

package/src/react/code-editor/lineAbove.ts

@@ -1,4 +1,3 @@
-import { moveLineDown, moveLineUp } from '@codemirror/commands';
 import { EditorSelection, type StateCommand } from '@codemirror/state';
 import type { KeyBinding } from '@codemirror/view';
 
@@ -23,13 +22,10 @@ export const insertBlankLineAbove: StateCommand = ({ state, dispatch }) => {
 };
 
 /**
- * The line keys `CodeEditor` adds IN FRONT of `defaultKeymap`: ⇧⌘↵ above, and ⌘↑ / ⌘↓ moving the
- * line — the owner's chord (2026-10-05), which in `defaultKeymap` is the Mac's jump to the top or
- * bottom. ⌥↑ / ⌥↓, VS Code's own move, is already in `defaultKeymap`, and so is ⇧⌘↑ (select to
- * the top), which stays. The same keys in a `<textarea>` are `cursedbelt/react/line-keys`.
+ * The line keys `CodeEditor` adds IN FRONT of `defaultKeymap`: ⇧⌘↵ above. Everything else VS Code
+ * binds for lines `defaultKeymap` already has — ⌥↑ / ⌥↓ move, ⇧⌥↑ / ⇧⌥↓ copy, ⌘↑ / ⌘↓ the jump to
+ * the top or bottom with the line left where it is. ⌘↑ / ⌘↓ moved the line here from 2026-10-05
+ * until the owner asked for VS Code's meaning back (2026-10-14, forge task 3182); the same keys
+ * in a `<textarea>` are `cursedbelt/react/line-keys`.
  */
-export const lineKeyBindings: readonly KeyBinding[] = [
-  { key: 'Shift-Mod-Enter', run: insertBlankLineAbove },
-  { key: 'Mod-ArrowUp', run: moveLineUp },
-  { key: 'Mod-ArrowDown', run: moveLineDown },
-];
+export const lineKeyBindings: readonly KeyBinding[] = [{ key: 'Shift-Mod-Enter', run: insertBlankLineAbove }];

package/src/react/code-editor/markdownRules.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from 'bun:test';
+import { markdown } from '@codemirror/lang-markdown';
+import { ensureSyntaxTree } from '@codemirror/language';
+import { EditorSelection, EditorState } from '@codemirror/state';
+import { ruleLines } from './markdownRules.js';
+
+function rules(doc: string, caret: number): number[] {
+  const state = EditorState.create({ doc, selection: EditorSelection.cursor(caret), extensions: markdown() });
+  ensureSyntaxTree(state, state.doc.length, 5000);
+  return ruleLines(state, [{ from: 0, to: state.doc.length }]);
+}
+
+describe('markdownRules — `---` drawn as a rule while writing (forge task 3184)', () => {
+  test('a rule line is drawn, the caret elsewhere', () => {
+    expect(rules('one\n\n---\n\ntwo', 0)).toEqual([5]);
+    expect(rules('***\n\n___', 0)).toEqual([5]);
+  });
+
+  test('with the caret on it, the dashes show', () => {
+    expect(rules('one\n\n---\n\ntwo', 7)).toEqual([]);
+  });
+
+  test('`---` under text is that text\'s heading underline, not a rule — as the preview reads it', () => {
+    expect(rules('Title\n---\n', 0)).toEqual([]);
+  });
+});

package/src/react/code-editor/markdownRules.ts

@@ -0,0 +1,73 @@
+import { syntaxTree } from '@codemirror/language';
+import type { EditorState, Extension, Range } from '@codemirror/state';
+import { Decoration, type DecorationSet, EditorView, ViewPlugin, type ViewUpdate } from '@codemirror/view';
+
+/**
+ * A markdown rule (`---`, `***`, `___`) drawn as a rule while you write, the dashes coming back
+ * when the caret is on its line — Obsidian's live preview of the same thing. The owner, 2026-10-14
+ * (forge task 3184): "it should show as a solid line in editing and in view". Only a rule the
+ * grammar agrees is one: `---` under a line of text is that line's heading underline, and the
+ * preview reads it the same way.
+ */
+const rule = Decoration.line({ class: 'cb-md-rule' });
+
+/** The line starts of every rule in the visible ranges, less any line a selection touches. */
+export function ruleLines(state: EditorState, ranges: readonly { from: number; to: number }[]): number[] {
+  const starts: number[] = [];
+  const tree = syntaxTree(state);
+  for (const { from, to } of ranges) {
+    tree.iterate({
+      from,
+      to,
+      enter: (node) => {
+        if (node.name !== 'HorizontalRule') return;
+        const line = state.doc.lineAt(node.from);
+        const touched = state.selection.ranges.some((r) => r.from <= line.to && r.to >= line.from);
+        if (!touched && starts.at(-1) !== line.from) starts.push(line.from);
+      },
+    });
+  }
+  return starts;
+}
+
+function build(view: EditorView): DecorationSet {
+  const marks: Range<Decoration>[] = ruleLines(view.state, view.visibleRanges).map((at) => rule.range(at));
+  return Decoration.set(marks);
+}
+
+const rulePlugin = ViewPlugin.fromClass(
+  class {
+    decorations: DecorationSet;
+    constructor(view: EditorView) {
+      this.decorations = build(view);
+    }
+    update(update: ViewUpdate) {
+      if (
+        update.docChanged ||
+        update.selectionSet ||
+        update.viewportChanged ||
+        syntaxTree(update.startState) !== syntaxTree(update.state)
+      )
+        this.decorations = build(update.view);
+    }
+  },
+  { decorations: (plugin) => plugin.decorations },
+);
+
+const ruleTheme = EditorView.baseTheme({
+  // The rule is the line's background, centred, the width of the text column; the dashes stay
+  // in the document (and under the caret's click), just not painted.
+  '.cb-md-rule': {
+    backgroundImage: 'linear-gradient(var(--border), var(--border))',
+    backgroundSize: '100% 1px',
+    backgroundPosition: 'center',
+    backgroundRepeat: 'no-repeat',
+    backgroundOrigin: 'content-box',
+    backgroundClip: 'content-box',
+  },
+  '.cb-md-rule, .cb-md-rule *': {
+    color: 'transparent !important',
+  },
+});
+
+export const markdownRules: Extension = [rulePlugin, ruleTheme];

package/src/react/code-editor/occurrences.ts

@@ -0,0 +1,69 @@
+import { EditorSelection, type EditorState, type SelectionRange, type StateCommand } from '@codemirror/state';
+import type { KeyBinding } from '@codemirror/view';
+
+/**
+ * VS Code's ⌘D and ⇧⌘L — the two multi-cursor keys `defaultKeymap` leaves to `@codemirror/search`,
+ * which `CodeEditor` does not load (its find panel would fight the app's own find). Exact text,
+ * case-sensitive; a caret with nothing selected first takes the word it is in, as in VS Code.
+ */
+
+/** The text the commands look for: the main selection, or the word under an empty caret. */
+function queryOf(state: EditorState): { query: string; range: SelectionRange } | null {
+  const main = state.selection.main;
+  const range = main.empty ? state.wordAt(main.head) : main;
+  if (!range || range.empty) return null;
+  return { query: state.sliceDoc(range.from, range.to), range: EditorSelection.range(range.from, range.to) };
+}
+
+/** Where `query` starts in `text`, matches never overlapping. */
+function matchesOf(text: string, query: string): number[] {
+  const starts: number[] = [];
+  for (let at = text.indexOf(query); at !== -1; at = text.indexOf(query, at + query.length)) starts.push(at);
+  return starts;
+}
+
+function isSelected(state: EditorState, from: number, to: number): boolean {
+  return state.selection.ranges.some((r) => r.from === from && r.to === to);
+}
+
+/** ⌘D — select the word under the caret, then add the next match of it, wrapping at the end. */
+export const selectNextOccurrence: StateCommand = ({ state, dispatch }) => {
+  const found = queryOf(state);
+  if (!found) return false;
+  const { query, range } = found;
+  if (state.selection.main.empty) {
+    dispatch(state.update({ selection: state.selection.replaceRange(range), scrollIntoView: true, userEvent: 'select' }));
+    return true;
+  }
+  // Every match, the ones after the selection first, then from the top — the first not yet selected.
+  const starts = matchesOf(state.doc.toString(), query);
+  const at = [...starts.filter((a) => a >= range.to), ...starts.filter((a) => a < range.to)].find(
+    (a) => !isSelected(state, a, a + query.length),
+  );
+  if (at === undefined) return false;
+  dispatch(
+    state.update({
+      selection: state.selection.addRange(EditorSelection.range(at, at + query.length)),
+      scrollIntoView: true,
+      userEvent: 'select',
+    }),
+  );
+  return true;
+};
+
+/** ⇧⌘L — every match of the selection (or the word under the caret) selected at once. */
+export const selectAllOccurrences: StateCommand = ({ state, dispatch }) => {
+  const found = queryOf(state);
+  if (!found) return false;
+  const { query, range } = found;
+  const starts = matchesOf(state.doc.toString(), query);
+  const ranges = starts.map((at) => EditorSelection.range(at, at + query.length));
+  const main = Math.max(0, starts.indexOf(range.from));
+  dispatch(state.update({ selection: EditorSelection.create(ranges, main), userEvent: 'select' }));
+  return true;
+};
+
+export const occurrenceBindings: readonly KeyBinding[] = [
+  { key: 'Mod-d', run: selectNextOccurrence, preventDefault: true },
+  { key: 'Shift-Mod-l', run: selectAllOccurrences, preventDefault: true },
+];

package/src/react/code-editor/plainInput.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'bun:test';
+import { unsmarten } from './plainInput.js';
+
+describe('unsmarten — the OS\'s smart punctuation, put back (forge task 3184)', () => {
+  test('a dash the OS made of typed hyphens is the hyphens again', () => {
+    expect(unsmarten('-', '—')).toBe('--');
+    expect(unsmarten('--', '—')).toBe('---');
+    expect(unsmarten('-', '–')).toBe('--');
+  });
+
+  test('a curly quote where a straight one was pressed is straight', () => {
+    expect(unsmarten('', '“')).toBe('"');
+    expect(unsmarten('', '’')).toBe("'");
+    expect(unsmarten('"', '”')).toBe('"');
+  });
+
+  test('anything else is typing, left alone', () => {
+    expect(unsmarten('', '—')).toBeNull();
+    expect(unsmarten('a', '—')).toBeNull();
+    expect(unsmarten('', '-')).toBeNull();
+    expect(unsmarten('x', '“')).toBeNull();
+  });
+});

package/src/react/code-editor/plainInput.ts

@@ -0,0 +1,35 @@
+import { EditorView } from '@codemirror/view';
+
+/**
+ * What the OS's "smart punctuation" types into a source editor, put back to what the keys said.
+ *
+ * iOS (and a Mac with Edit ▸ Substitutions on) rewrites `--` to `—` and `"` to `“` as you type —
+ * in markdown that eats a rule's dashes and a code span's quotes (the owner, 2026-10-14, forge
+ * task 3184: "when typing three dashes … it shifts and deletes some dashes … please fix all other
+ * syntax errors that may be similar"). `CodeEditor` already asks the browser for no autocorrect;
+ * this is the half that holds where the OS does not listen. VS Code substitutes nothing, either.
+ *
+ * Only a substitution is undone: a dash replacing the `-` (or `--`) the keys just typed, or a
+ * curly quote arriving where a straight one was pressed. A `—` pasted in is a paste, never seen here.
+ */
+const QUOTES: Record<string, string> = { '“': '"', '”': '"', '‘': "'", '’': "'" };
+
+/** The text the keys meant, or null when `text` replacing `replaced` is not a substitution. */
+export function unsmarten(replaced: string, text: string): string | null {
+  if ((text === '—' || text === '–') && /^-{1,2}$/.test(replaced)) return text === '—' && replaced === '-' ? '--' : `${replaced}-`;
+  const quote = QUOTES[text];
+  if (quote !== undefined && (replaced === '' || replaced === quote)) return quote;
+  return null;
+}
+
+export const plainInput = EditorView.inputHandler.of((view, from, to, text) => {
+  const meant = unsmarten(view.state.sliceDoc(from, to), text);
+  if (meant === null) return false;
+  view.dispatch({
+    changes: { from, to, insert: meant },
+    selection: { anchor: from + meant.length },
+    scrollIntoView: true,
+    userEvent: 'input.type',
+  });
+  return true;
+});

package/src/react/code-editor/theme.ts

@@ -21,6 +21,11 @@ export const cbEditorTheme = EditorView.theme({
   '.cm-content': {
     caretColor: 'var(--foreground)',
     padding: '0.5rem 0',
+    // Every character drawn as itself — VS Code's `editor.fontLigatures: false`. A ligature font
+    // (JetBrains Mono, desk's) joins `--` and `---` into one glyph that redraws as each dash
+    // lands, and turns `!=`, `=>` and `<=` into symbols that are not what was typed (forge task 3184).
+    fontVariantLigatures: 'none',
+    fontFeatureSettings: '"calt" 0, "liga" 0',
   },
   // CodeMirror's own recipe for a minimum height: give it to the content AND the gutter, so the
   // line-number rail runs the editor's full height instead of stopping under the last line

package/src/react/line-keys/lineKeys.spec.tsx

@@ -89,9 +89,10 @@ describe('lineCommandOf', () => {
     expect(key('Enter', { metaKey: true, altKey: true })).toBeNull();
   });
 
-  test('⌘↑ / ⌘↓ (the owner\'s chord) and ⌥↑ / ⌥↓ (VS Code\'s) move a line; ⇧ stays a selection key', () => {
-    expect(key('ArrowUp', { metaKey: true })).toBe('up');
-    expect(key('ArrowDown', { ctrlKey: true })).toBe('down');
+  test('⌥↑ / ⌥↓ move a line; ⌘↑ / ⌘↓ stay the jump to the top or bottom (VS Code, forge task 3182); ⇧ stays a selection key', () => {
+    expect(key('ArrowUp', { metaKey: true })).toBeNull();
+    expect(key('ArrowDown', { metaKey: true })).toBeNull();
+    expect(key('ArrowDown', { ctrlKey: true })).toBeNull();
     expect(key('ArrowUp', { altKey: true })).toBe('up');
     expect(key('ArrowDown', { altKey: true })).toBe('down');
     expect(key('ArrowUp')).toBeNull();
@@ -136,23 +137,34 @@ describe('installLineKeys — on a React-controlled textarea', () => {
     expect(box.value).toBe('first\nsecond');
   });
 
-  test('⌘↓ moves a line through React state, the caret riding with it; past the last line it does nothing', () => {
+  test('⌥↓ moves a line through React state, the caret riding with it; past the last line it does nothing', () => {
     off = installLineKeys();
     const view = render(<Box initial={'one\ntwo\nthree'} />);
     const box = view.getByLabelText('box') as HTMLTextAreaElement;
     box.focus();
     box.setSelectionRange(1, 1);
-    fireEvent.keyDown(box, { key: 'ArrowDown', metaKey: true });
+    fireEvent.keyDown(box, { key: 'ArrowDown', altKey: true });
     expect(box.value).toBe('two\none\nthree');
     expect(box.selectionStart).toBe(5);
     fireEvent.keyDown(box, { key: 'ArrowDown', altKey: true });
     expect(box.value).toBe('two\nthree\none');
-    const blocked = fireEvent.keyDown(box, { key: 'ArrowDown', metaKey: true });
+    const blocked = fireEvent.keyDown(box, { key: 'ArrowDown', altKey: true });
     expect(box.value).toBe('two\nthree\none');
-    // Swallowed, so ⌘↓ at the last line does not also jump the caret to the end.
+    // Swallowed, so ⌥↓ at the last line does not also move the caret.
     expect(blocked).toBe(false);
   });
 
+  test('⌘↑ / ⌘↓ leave the line where it is and the key to the browser — its jump to the top or bottom', () => {
+    off = installLineKeys();
+    const view = render(<Box initial={'one\ntwo\nthree'} />);
+    const box = view.getByLabelText('box') as HTMLTextAreaElement;
+    box.focus();
+    box.setSelectionRange(5, 5);
+    expect(fireEvent.keyDown(box, { key: 'ArrowUp', metaKey: true })).toBe(true);
+    expect(fireEvent.keyDown(box, { key: 'ArrowDown', metaKey: true })).toBe(true);
+    expect(box.value).toBe('one\ntwo\nthree');
+  });
+
   test('a box that already answers ⌘↵ keeps it', () => {
     off = installLineKeys();
     const view = render(<Box claims initial="send me" />);

package/src/react/line-keys/lineKeys.ts

@@ -4,14 +4,14 @@
  *   ⌘↵  (Ctrl↵)         a new line BELOW the caret's line, from anywhere on it
  *   ⇧⌘↵ (Ctrl⇧↵)        a new line ABOVE it
  *   ⇧⌘K (Ctrl⇧K)        delete the line (every line the selection touches)
- *   ⌘↑ ⌘↓ (Ctrl↑ Ctrl↓)  move the line (every line the selection touches) up or down one
- *   ⌥↑ ⌥↓ (Alt↑ Alt↓)    the same — VS Code's own binding for it
+ *   ⌥↑ ⌥↓ (Alt↑ Alt↓)    move the line (every line the selection touches) up or down one
  *
  * The owner asked for these by name (2026-10-05, desk's context components first, "in apps with
- * multi line text boxes"; ⌘↑ / ⌘↓ the same day, in his words "like vscode does it"). ⌘↑ / ⌘↓ is
- * the owner's chord, and it costs the box the Mac's jump-to-top/bottom (⌘↑ is still that in a
- * single-line `<input>`, which this never touches); ⌥↑ / ⌥↓ is what VS Code itself binds, so
- * hands trained there find it too. They are one document listener rather than an `onKeyDown` on each
+ * multi line text boxes"). ⌘↑ / ⌘↓ is NOT a line key: it is VS Code's — and the Mac's — jump to the
+ * top or bottom, the line staying where it is (the owner, 2026-10-14, forge task 3182: "holding
+ * command and pushing up should jump to the top of the file … make all commands and keystrokes
+ * work like it does in VS code"). It moved the line from 2026-10-05 to then; the browser has it
+ * back. They are one document listener rather than an `onKeyDown` on each
  * `<textarea>` because desk alone draws a dozen of them by hand: a prop is a thing the next box
  * forgets, an install at boot is not.
  *
@@ -28,7 +28,7 @@
  *
  * CodeMirror boxes (cb's `CodeEditor`) are `contenteditable`, not `<textarea>`, and are left to
  * CodeMirror's own keymap: `Mod-Enter` and `Shift-Mod-k` are already in its `defaultKeymap`, and
- * `CodeEditor` adds the line above and ⌘↑ / ⌘↓ (⌥↑ / ⌥↓ is `defaultKeymap`'s `moveLineUp`/`Down`).
+ * `CodeEditor` adds the line above (⌥↑ / ⌥↓ is `defaultKeymap`'s `moveLineUp`/`Down`).
  */
 
 export type LineCommand = 'below' | 'above' | 'delete' | 'up' | 'down';
@@ -114,11 +114,15 @@ function moveLines(value: string, start: number, end: number, from: number, to:
   return { from, to: nextEnd, text: `${next}\n${block}`, caret: start + shift, end: end + shift };
 }
 
-/** Which command a key event asks for, or null. ⌘ on a Mac, Ctrl elsewhere — either is taken. */
+/**
+ * Which command a key event asks for, or null. ⌘ on a Mac, Ctrl elsewhere — either is taken —
+ * except on an arrow, which moves a line on ⌥ alone: ⌘↑ / ⌘↓ stays the browser's jump to the top
+ * or bottom, as in VS Code.
+ */
 export function lineCommandOf(event: Pick<KeyboardEvent, 'key' | 'metaKey' | 'ctrlKey' | 'shiftKey' | 'altKey'>): LineCommand | null {
   const arrow = event.key === 'ArrowUp' ? 'up' : event.key === 'ArrowDown' ? 'down' : null;
   // ⇧ with an arrow extends a selection, in every one of these chords; that stays the browser's.
-  if (arrow) return event.shiftKey || (event.metaKey || event.ctrlKey) === event.altKey ? null : arrow;
+  if (arrow) return event.altKey && !event.shiftKey && !event.metaKey && !event.ctrlKey ? arrow : null;
   if (!(event.metaKey || event.ctrlKey) || event.altKey) return null;
   if (event.key === 'Enter') return event.shiftKey ? 'above' : 'below';
   if (event.shiftKey && (event.key === 'k' || event.key === 'K')) return 'delete';
@@ -154,7 +158,7 @@ function onKeyDown(event: KeyboardEvent): void {
   if (command === 'delete' && field.value === '') return;
   event.preventDefault();
   // A move past the first or last line does nothing — and still swallows the key, as VS Code
-  // does, rather than letting ⌘↑ jump the caret to the top of the box.
+  // does, rather than letting ⌥↑ jump the caret to the start of the paragraph.
   const edit = lineEdit(field.value, field.selectionStart, field.selectionEnd, command);
   if (edit) applyLineEdit(field, edit);
 }