ep_vim 0.9.3 → 0.10.1

package/README.md

@@ -10,15 +10,16 @@ A vim-mode plugin for [Etherpad](https://etherpad.org/). Adds modal editing with
 
 ## Features
 
-- **Modal editing** — normal, insert, and visual (char + line) modes
+- **Modal editing** — normal, insert, and visual (char + line) modes; visual selections support all operators (`d`, `c`, `y`)
 - **Motions** — `h` `j` `k` `l`, `w` `b` `e`, `0` `$` `^`, `gg` `G`, `f`/`F`/`t`/`T` char search, `{` `}` paragraph forward/backward, `H` `M` `L` viewport (top/middle/bottom)
 - **Char search** — `f`/`F`/`t`/`T` find, `;` repeat last search, `,` reverse direction
 - **Bracket matching** — `%` jump to matching bracket
 - **Text objects** — `iw`/`aw` (word), `i"`/`a"` and `i'`/`a'` (quotes), `i{`/`a{` etc. (brackets), `ip`/`ap` (paragraph), `is`/`as` (sentence)
 - **Operators** — `d`, `c`, `y` with motion and text object combinations (`dw`, `ce`, `y$`, `ciw`, `da"`, `yi(`, etc.)
 - **Line operations** — `dd`, `cc`, `yy`, `J` (join), `Y` (yank line)
+- **Registers** — `"a`–`"z` named registers for yank/delete/put, `"_` blackhole register
 - **Put** — `p` / `P` with linewise and characterwise register handling
-- **Editing** — `x`, `r`, `s`, `S`, `C`, `o`, `O`, `~` (toggle case)
+- **Editing** — `i` `a` `A` `I` (insert/append), `x`, `r`, `s`, `S`, `C`, `o`, `O`, `~` (toggle case)
 - **Marks** — `m{a-z}` to set, `'{a-z}` / `` `{a-z} `` to jump
 - **Search** — `/` and `?` forward/backward, `n`/`N` repeat
 - **Repeat** — `.` repeat last command
@@ -26,12 +27,18 @@ A vim-mode plugin for [Etherpad](https://etherpad.org/). Adds modal editing with
 - **Undo** — `u`
 - **Toggle** — toolbar button to enable/disable vim mode, persisted in localStorage
 
+## Differences from vi
+
+- **Ctrl key mapping** — browser shortcuts conflict with common vim bindings (`Ctrl+d`, `Ctrl+u`, `Ctrl+r`, etc.); These will be implemented under a configurable setting.
+- **Clipboard toggle** — the default register writes to the system clipboard. We will add a setting to turn on the default vim behavior.
+- **No command line, macros, or globals** - these are not planned, but PRs welcome.
+
 ## Installation
 
-Clone or symlink into your Etherpad plugins directory, then install:
+From your Etherpad directory run
 
 ```
-pnpm install ep_vim
+pnpm run plugins install ep_vim
 ```
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ep_vim",
-  "version": "0.9.3",
+  "version": "0.10.1",
   "description": "Vim-mode plugin for Etherpad with modal editing, motions, and operators",
   "author": {
     "name": "Seth Rothschild",
@@ -24,14 +24,14 @@
   "peerDependencies": {
     "ep_etherpad-lite": ">=1.8.6"
   },
-  "scripts": {
-    "test": "npm run format && node --test static/js/vim-core.test.js static/js/index.test.js",
-    "format": "prettier -w static/js/*"
-  },
   "engines": {
     "node": ">=20.0.0"
   },
   "dependencies": {
     "prettier": "^3.8.1"
+  },
+  "scripts": {
+    "test": "npm run format && node --test static/js/vim-core.test.js static/js/index.test.js",
+    "format": "prettier -w static/js/*"
   }
-}
+}

package/static/js/index.js

@@ -36,6 +36,9 @@ const state = {
   pendingCount: null,
   countBuffer: "",
   register: null,
+  namedRegisters: {},
+  pendingRegister: null,
+  awaitingRegister: false,
   marks: {},
   lastCharSearch: null,
   visualAnchor: null,
@@ -53,6 +56,14 @@ const state = {
 // --- Editor operations ---
 
 const setRegister = (value) => {
+  if (state.pendingRegister === "_") {
+    return;
+  }
+  if (state.pendingRegister && /^[a-zA-Z]$/.test(state.pendingRegister)) {
+    const name = state.pendingRegister.toLowerCase();
+    state.namedRegisters[name] = value;
+    return;
+  }
   state.register = value;
   const text = Array.isArray(value) ? value.join("\n") + "\n" : value;
   if (navigator.clipboard) {
@@ -60,6 +71,19 @@ const setRegister = (value) => {
   }
 };
 
+const getActiveRegister = () => {
+  if (state.pendingRegister === "_") {
+    return null;
+  }
+  if (state.pendingRegister && /^[a-zA-Z]$/.test(state.pendingRegister)) {
+    const name = state.pendingRegister.toLowerCase();
+    return state.namedRegisters[name] !== undefined
+      ? state.namedRegisters[name]
+      : null;
+  }
+  return state.register;
+};
+
 const moveCursor = (editorInfo, line, char) => {
   const pos = [line, char];
   editorInfo.ace_inCallStackIfNecessary("vim-move", () => {
@@ -833,6 +857,7 @@ parameterized["r"] = (key, { editorInfo, line, char, lineText, count }) => {
 
 commands.normal["Y"] = ({ rep, line }) => {
   setRegister([getLineText(rep, line)]);
+  recordCommand("Y", 1);
 };
 
 commands.normal["x"] = ({ editorInfo, rep, line, char, lineText, count }) => {
@@ -847,14 +872,15 @@ commands.normal["x"] = ({ editorInfo, rep, line, char, lineText, count }) => {
 };
 
 commands.normal["p"] = ({ editorInfo, line, char, lineText, count }) => {
-  if (state.register !== null) {
-    if (typeof state.register === "string") {
+  const reg = getActiveRegister();
+  if (reg !== null) {
+    if (typeof reg === "string") {
       const insertPos = Math.min(char + 1, lineText.length);
-      const repeated = state.register.repeat(count);
+      const repeated = reg.repeat(count);
       replaceRange(editorInfo, [line, insertPos], [line, insertPos], repeated);
-      moveBlockCursor(editorInfo, line, insertPos);
+      moveBlockCursor(editorInfo, line, insertPos + repeated.length - 1);
     } else {
-      const block = state.register.join("\n");
+      const block = reg.join("\n");
       const parts = [];
       for (let i = 0; i < count; i++) parts.push(block);
       const insertText = "\n" + parts.join("\n");
@@ -864,25 +890,26 @@ commands.normal["p"] = ({ editorInfo, line, char, lineText, count }) => {
         [line, lineText.length],
         insertText,
       );
-      moveBlockCursor(editorInfo, line + 1, 0);
+      moveBlockCursor(editorInfo, line + 1, firstNonBlank(reg[0]));
     }
     recordCommand("p", count);
   }
 };
 
 commands.normal["P"] = ({ editorInfo, line, char, count }) => {
-  if (state.register !== null) {
-    if (typeof state.register === "string") {
-      const repeated = state.register.repeat(count);
+  const reg = getActiveRegister();
+  if (reg !== null) {
+    if (typeof reg === "string") {
+      const repeated = reg.repeat(count);
       replaceRange(editorInfo, [line, char], [line, char], repeated);
-      moveBlockCursor(editorInfo, line, char);
+      moveBlockCursor(editorInfo, line, char + repeated.length - 1);
     } else {
-      const block = state.register.join("\n");
+      const block = reg.join("\n");
       const parts = [];
       for (let i = 0; i < count; i++) parts.push(block);
       const insertText = parts.join("\n") + "\n";
       replaceRange(editorInfo, [line, 0], [line, 0], insertText);
-      moveBlockCursor(editorInfo, line, 0);
+      moveBlockCursor(editorInfo, line, firstNonBlank(reg[0]));
     }
     recordCommand("P", count);
   }
@@ -944,7 +971,7 @@ commands.normal["C"] = ({ editorInfo, line, char, lineText }) => {
 
 commands.normal["s"] = ({ editorInfo, rep, line, char, lineText, count }) => {
   clearEmptyLineCursor();
-  setRegister(lineText.slice(char, char + 1));
+  setRegister(lineText.slice(char, Math.min(char + count, lineText.length)));
   replaceRange(
     editorInfo,
     [line, char],
@@ -958,7 +985,7 @@ commands.normal["s"] = ({ editorInfo, rep, line, char, lineText, count }) => {
 
 commands.normal["S"] = ({ editorInfo, line, lineText }) => {
   clearEmptyLineCursor();
-  setRegister(lineText);
+  setRegister([lineText]);
   replaceRange(editorInfo, [line, 0], [line, lineText.length], "");
   moveCursor(editorInfo, line, 0);
   state.mode = "insert";
@@ -995,9 +1022,50 @@ commands.normal["N"] = (ctx) => {
   if (pos) moveBlockCursor(ctx.editorInfo, pos[0], pos[1]);
 };
 
+const getWordAt = (text, char) => {
+  if (char >= text.length || !/\w/.test(text[char])) return null;
+  let start = char;
+  while (start > 0 && /\w/.test(text[start - 1])) start--;
+  let end = char;
+  while (end < text.length && /\w/.test(text[end])) end++;
+  return text.slice(start, end);
+};
+
+commands.normal["*"] = (ctx) => {
+  const word = getWordAt(ctx.lineText, ctx.char);
+  if (!word) return;
+  state.lastSearch = { pattern: word, direction: "/" };
+  const pos = searchForward(ctx.rep, ctx.line, ctx.char + 1, word, ctx.count);
+  if (pos) moveBlockCursor(ctx.editorInfo, pos[0], pos[1]);
+};
+
+commands.normal["#"] = (ctx) => {
+  const word = getWordAt(ctx.lineText, ctx.char);
+  if (!word) return;
+  state.lastSearch = { pattern: word, direction: "?" };
+  const pos = searchBackward(ctx.rep, ctx.line, ctx.char, word, ctx.count);
+  if (pos) moveBlockCursor(ctx.editorInfo, pos[0], pos[1]);
+};
+
+commands.normal["zz"] = ({ line }) => {
+  if (!state.editorDoc) return;
+  const lineDiv = state.editorDoc.body.querySelectorAll("div")[line];
+  if (lineDiv) lineDiv.scrollIntoView({ block: "center" });
+};
+
 // --- Dispatch ---
 
 const handleKey = (key, ctx) => {
+  if (state.awaitingRegister) {
+    state.pendingRegister = key;
+    state.awaitingRegister = false;
+    return true;
+  }
+  if (key === '"' && state.mode === "normal") {
+    state.awaitingRegister = true;
+    return true;
+  }
+
   if (key >= "1" && key <= "9") {
     state.countBuffer += key;
     return true;
@@ -1019,6 +1087,7 @@ const handleKey = (key, ctx) => {
     state.pendingKey = null;
     handler(key, ctx);
     state.pendingCount = null;
+    state.pendingRegister = null;
     return true;
   }
 
@@ -1028,7 +1097,10 @@ const handleKey = (key, ctx) => {
   if (map[seq]) {
     state.pendingKey = null;
     map[seq](ctx);
-    if (state.pendingKey === null) state.pendingCount = null;
+    if (state.pendingKey === null) {
+      state.pendingCount = null;
+      state.pendingRegister = null;
+    }
     return true;
   }
 
@@ -1073,6 +1145,7 @@ const handleKey = (key, ctx) => {
 
   state.pendingKey = null;
   state.pendingCount = null;
+  state.pendingRegister = null;
   return true;
 };
 

package/static/js/index.test.js

@@ -2007,6 +2007,9 @@ const resetState = () => {
   state.pendingCount = null;
   state.countBuffer = "";
   state.register = null;
+  state.namedRegisters = {};
+  state.pendingRegister = null;
+  state.awaitingRegister = false;
   state.marks = {};
   state.lastCharSearch = null;
   state.visualAnchor = null;
@@ -3079,3 +3082,651 @@ describe("edge cases: df and dt (operator + char motion)", () => {
     );
   });
 });
+
+// --- Register bugs ---
+
+describe("register bug: s ignores count", () => {
+  beforeEach(resetState);
+
+  it("s with count=3 saves 3 chars to register", () => {
+    const rep = makeRep(["abcdef"]);
+    const { editorInfo } = makeMockEditorInfo();
+
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 1,
+      lineText: "abcdef",
+      count: 3,
+    };
+    commands.normal["s"](ctx);
+
+    assert.equal(state.register, "bcd", "3s should save 3 chars, not 1");
+  });
+
+  it("s with count=1 saves 1 char to register", () => {
+    const rep = makeRep(["abcdef"]);
+    const { editorInfo } = makeMockEditorInfo();
+
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 2,
+      lineText: "abcdef",
+      count: 1,
+    };
+    commands.normal["s"](ctx);
+
+    assert.equal(state.register, "c");
+  });
+
+  it("s with count exceeding line saves up to end of line", () => {
+    const rep = makeRep(["abc"]);
+    const { editorInfo } = makeMockEditorInfo();
+
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 1,
+      lineText: "abc",
+      count: 10,
+    };
+    commands.normal["s"](ctx);
+
+    assert.equal(
+      state.register,
+      "bc",
+      "s with large count should save remaining chars",
+    );
+  });
+});
+
+describe("register bug: S uses char-wise register instead of line-wise", () => {
+  beforeEach(resetState);
+
+  it("S saves register as array (line-wise)", () => {
+    const rep = makeRep(["hello world"]);
+    const { editorInfo } = makeMockEditorInfo();
+
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello world",
+      count: 1,
+    };
+    commands.normal["S"](ctx);
+
+    assert.ok(
+      Array.isArray(state.register),
+      "S should store register as array (line-wise), not string",
+    );
+    assert.deepEqual(state.register, ["hello world"]);
+  });
+
+  it("S register is line-wise so p pastes on new line", () => {
+    const rep = makeRep(["hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+    };
+    commands.normal["S"](ctx);
+
+    assert.ok(
+      Array.isArray(state.register),
+      "register should be line-wise after S",
+    );
+
+    const replaces = calls.filter((c) => c.type === "replace");
+    assert.ok(replaces.length > 0);
+    assert.equal(replaces[0].newText, "", "S should clear the line");
+  });
+});
+
+describe("register bug: p cursor at start of paste instead of end", () => {
+  beforeEach(resetState);
+
+  it("p char-wise: cursor lands at last char of pasted text", () => {
+    const rep = makeRep(["hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    state.register = "abc";
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+    };
+    commands.normal["p"](ctx);
+
+    const selects = calls.filter((c) => c.type === "select");
+    const lastSelect = selects[selects.length - 1];
+    assert.deepEqual(
+      lastSelect.start,
+      [0, 3],
+      "cursor after p should be at last char of pasted text (insertPos + length - 1 = 1+3-1 = 3)",
+    );
+  });
+
+  it("p char-wise with count: cursor lands at last char of all pasted text", () => {
+    const rep = makeRep(["hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    state.register = "ab";
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 3,
+    };
+    commands.normal["p"](ctx);
+
+    const selects = calls.filter((c) => c.type === "select");
+    const lastSelect = selects[selects.length - 1];
+    assert.deepEqual(
+      lastSelect.start,
+      [0, 6],
+      "cursor after 3p 'ab': insertPos=1, repeated='ababab' length=6, cursor=1+6-1=6",
+    );
+  });
+});
+
+describe("register bug: P cursor at start of paste instead of end", () => {
+  beforeEach(resetState);
+
+  it("P char-wise: cursor lands at last char of pasted text", () => {
+    const rep = makeRep(["hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    state.register = "abc";
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 2,
+      lineText: "hello",
+      count: 1,
+    };
+    commands.normal["P"](ctx);
+
+    const selects = calls.filter((c) => c.type === "select");
+    const lastSelect = selects[selects.length - 1];
+    assert.deepEqual(
+      lastSelect.start,
+      [0, 4],
+      "cursor after P should be at last char of pasted text (char + length - 1 = 2+3-1 = 4)",
+    );
+  });
+
+  it("P char-wise with count: cursor lands at last char of all pasted text", () => {
+    const rep = makeRep(["hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    state.register = "ab";
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 1,
+      lineText: "hello",
+      count: 2,
+    };
+    commands.normal["P"](ctx);
+
+    const selects = calls.filter((c) => c.type === "select");
+    const lastSelect = selects[selects.length - 1];
+    assert.deepEqual(
+      lastSelect.start,
+      [0, 4],
+      "cursor after 2P 'ab' should be at char + 4 - 1 = 1+4-1 = 4",
+    );
+  });
+});
+
+describe("register bug: line-wise p cursor at col 0 instead of first non-blank", () => {
+  beforeEach(resetState);
+
+  it("p line-wise: cursor lands on first non-blank of pasted line", () => {
+    const rep = makeRep(["hello", "world"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    state.register = ["  indented"];
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+    };
+    commands.normal["p"](ctx);
+
+    const selects = calls.filter((c) => c.type === "select");
+    const lastSelect = selects[selects.length - 1];
+    assert.deepEqual(
+      lastSelect.start,
+      [1, 2],
+      "p line-wise cursor should be at first non-blank (col 2) of pasted line",
+    );
+  });
+
+  it("p line-wise with unindented content: cursor at col 0", () => {
+    const rep = makeRep(["hello", "world"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    state.register = ["noindent"];
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+    };
+    commands.normal["p"](ctx);
+
+    const selects = calls.filter((c) => c.type === "select");
+    const lastSelect = selects[selects.length - 1];
+    assert.deepEqual(lastSelect.start, [1, 0]);
+  });
+});
+
+describe("register bug: line-wise P cursor at col 0 instead of first non-blank", () => {
+  beforeEach(resetState);
+
+  it("P line-wise: cursor lands on first non-blank of pasted line", () => {
+    const rep = makeRep(["hello", "world"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+
+    state.register = ["  indented"];
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 1,
+      char: 0,
+      lineText: "world",
+      count: 1,
+    };
+    commands.normal["P"](ctx);
+
+    const selects = calls.filter((c) => c.type === "select");
+    const lastSelect = selects[selects.length - 1];
+    assert.deepEqual(
+      lastSelect.start,
+      [1, 2],
+      "P line-wise cursor should be at first non-blank (col 2) of pasted line",
+    );
+  });
+});
+
+describe("register bug: Y missing recordCommand", () => {
+  beforeEach(resetState);
+
+  it("Y sets lastCommand so dot can repeat it", () => {
+    const rep = makeRep(["hello"]);
+    const { editorInfo } = makeMockEditorInfo();
+
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+    };
+    commands.normal["Y"](ctx);
+
+    assert.notEqual(
+      state.lastCommand,
+      null,
+      "Y should record command for dot-repeat",
+    );
+    assert.equal(state.lastCommand.key, "Y");
+  });
+
+  it("Y does not corrupt lastCommand of a prior operation", () => {
+    const rep = makeRep(["hello"]);
+    const { editorInfo } = makeMockEditorInfo();
+
+    state.lastCommand = { key: "dd", count: 1, param: null };
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+    };
+    commands.normal["Y"](ctx);
+
+    assert.equal(
+      state.lastCommand.key,
+      "Y",
+      "Y should overwrite lastCommand with its own entry",
+    );
+  });
+});
+
+describe("missing feature: named registers", () => {
+  beforeEach(resetState);
+
+  it('"ayy yanks into named register a', () => {
+    // In vim, "a followed by yy copies the line into register 'a'.
+    // This requires parsing the " prefix in handleKey and routing
+    // setRegister calls to the named register slot.
+    const rep = makeRep(["hello"]);
+    const { editorInfo } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    // Simulate: " -> a -> yy
+    handleKey('"', ctx);
+    handleKey("a", ctx);
+    handleKey("y", ctx);
+    handleKey("y", ctx);
+
+    assert.ok(
+      state.namedRegisters && state.namedRegisters["a"],
+      "register a should be set",
+    );
+    assert.deepEqual(state.namedRegisters["a"], ["hello"]);
+  });
+
+  it('"ap pastes from named register a', () => {
+    state.namedRegisters = { a: ["yanked line"] };
+    const rep = makeRep(["hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    // Simulate: " -> a -> p
+    handleKey('"', ctx);
+    handleKey("a", ctx);
+    handleKey("p", ctx);
+
+    const replaces = calls.filter((c) => c.type === "replace");
+    assert.ok(replaces.length > 0, "should paste from named register");
+  });
+
+  it('"add deletes line into named register a', () => {
+    const rep = makeRep(["hello", "world"]);
+    const { editorInfo } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    handleKey('"', ctx);
+    handleKey("a", ctx);
+    handleKey("d", ctx);
+    handleKey("d", ctx);
+
+    assert.ok(
+      state.namedRegisters && state.namedRegisters["a"],
+      "register a should be set after delete",
+    );
+    assert.deepEqual(state.namedRegisters["a"], ["hello"]);
+    assert.equal(state.register, null, "anonymous register should not be set");
+  });
+
+  it('"ayw yanks word into named register a', () => {
+    const rep = makeRep(["hello world"]);
+    const { editorInfo } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello world",
+      count: 1,
+      hasCount: false,
+    };
+
+    handleKey('"', ctx);
+    handleKey("a", ctx);
+    handleKey("y", ctx);
+    handleKey("w", ctx);
+
+    assert.deepEqual(state.namedRegisters["a"], "hello ");
+  });
+
+  it("named registers are independent", () => {
+    const rep = makeRep(["first", "second"]);
+    const { editorInfo } = makeMockEditorInfo();
+
+    const ctx0 = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "first",
+      count: 1,
+      hasCount: false,
+    };
+    handleKey('"', ctx0);
+    handleKey("a", ctx0);
+    handleKey("y", ctx0);
+    handleKey("y", ctx0);
+
+    const ctx1 = {
+      rep,
+      editorInfo,
+      line: 1,
+      char: 0,
+      lineText: "second",
+      count: 1,
+      hasCount: false,
+    };
+    handleKey('"', ctx1);
+    handleKey("b", ctx1);
+    handleKey("y", ctx1);
+    handleKey("y", ctx1);
+
+    assert.deepEqual(state.namedRegisters["a"], ["first"]);
+    assert.deepEqual(state.namedRegisters["b"], ["second"]);
+  });
+
+  it('"_yy yank to blackhole does not affect anonymous register', () => {
+    state.register = "preserved";
+    const rep = makeRep(["hello"]);
+    const { editorInfo } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    handleKey('"', ctx);
+    handleKey("_", ctx);
+    handleKey("y", ctx);
+    handleKey("y", ctx);
+
+    assert.equal(state.register, "preserved", "anonymous register unchanged");
+  });
+
+  it('"_p pastes nothing from blackhole register', () => {
+    state.register = "fallback";
+    const rep = makeRep(["hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    handleKey('"', ctx);
+    handleKey("_", ctx);
+    handleKey("p", ctx);
+
+    const replaces = calls.filter((c) => c.type === "replace");
+    assert.equal(replaces.length, 0, "blackhole p should paste nothing");
+  });
+
+  it('"_dd deletes to blackhole register without overwriting anonymous', () => {
+    state.register = "preserved";
+    const rep = makeRep(["hello", "world"]);
+    const { editorInfo } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    // Simulate: " -> _ -> dd
+    handleKey('"', ctx);
+    handleKey("_", ctx);
+    handleKey("d", ctx);
+    handleKey("d", ctx);
+
+    assert.equal(
+      state.register,
+      "preserved",
+      "blackhole register should not overwrite anonymous register",
+    );
+  });
+});
+
+describe("missing feature: * and # word search", () => {
+  beforeEach(resetState);
+
+  it("* searches forward for word under cursor", () => {
+    const rep = makeRep(["hello world hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello world hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    commands.normal["*"](ctx);
+
+    assert.equal(calls.length, 1, "should move cursor to next match");
+    assert.deepEqual(state.lastSearch, { pattern: "hello", direction: "/" });
+  });
+
+  it("* on non-word char does nothing", () => {
+    const rep = makeRep(["hello world"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 5,
+      lineText: "hello world",
+      count: 1,
+      hasCount: false,
+    };
+
+    commands.normal["*"](ctx);
+
+    assert.equal(calls.length, 0, "should not move cursor");
+    assert.equal(state.lastSearch, null);
+  });
+
+  it("# searches backward for word under cursor", () => {
+    const rep = makeRep(["hello world hello"]);
+    const { editorInfo, calls } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 12,
+      lineText: "hello world hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    commands.normal["#"](ctx);
+
+    assert.equal(calls.length, 1, "should move cursor to previous match");
+    assert.deepEqual(state.lastSearch, { pattern: "hello", direction: "?" });
+  });
+
+  it("* sets lastSearch so n repeats the search", () => {
+    const rep = makeRep(["foo bar foo bar"]);
+    const { editorInfo } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "foo bar foo bar",
+      count: 1,
+      hasCount: false,
+    };
+
+    commands.normal["*"](ctx);
+
+    assert.deepEqual(state.lastSearch, { pattern: "foo", direction: "/" });
+  });
+});
+
+describe("missing feature: zz center screen", () => {
+  beforeEach(resetState);
+
+  it("zz does nothing when editorDoc is null", () => {
+    state.editorDoc = null;
+    const rep = makeRep(["hello"]);
+    const { editorInfo } = makeMockEditorInfo();
+    const ctx = {
+      rep,
+      editorInfo,
+      line: 0,
+      char: 0,
+      lineText: "hello",
+      count: 1,
+      hasCount: false,
+    };
+
+    assert.doesNotThrow(() => commands.normal["zz"](ctx));
+  });
+});