Merge branch 'master' into fix/buffer-copy-and-reflow-wrap

* fix(addon-search): advance highlight scan by buffer match size

_highlightAllMatches() stepped to the next find() using term.length
and col + 1 when staying on the same row. Search results expose size
in buffer columns (wide glyphs, wrapped matches), which select() and
decorations already use.

Advance with col + size and wrap row/col when crossing the terminal
width so highlight-all does not skip, duplicate, or stop early on
non-ASCII matches.

Co-authored-by: Cursor <cursoragent@cursor.com>

* test(addon-search): regression for highlight-all wide char advance by size

Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>

* test(addon-search): move highlight-all regression to integration tests

Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Daniel Imms <Tyriar@users.noreply.github.com>

addons/addon-search/src/SearchAddon.ts

@@ -142,12 +142,14 @@ export class SearchAddon extends Disposable implements ITerminalAddon, ISearchAp
       }
       prevResult = result;
       results.push(prevResult);
-      result = this._engine.find(
-        term,
-        prevResult.col + prevResult.term.length >= this._terminal.cols ? prevResult.row + 1 : prevResult.row,
-        prevResult.col + prevResult.term.length >= this._terminal.cols ? 0 : prevResult.col + 1,
-        searchOptions
-      );
+      const cols = this._terminal.cols;
+      let nextCol = prevResult.col + prevResult.size;
+      let nextRow = prevResult.row;
+      if (nextCol >= cols) {
+        nextRow += Math.floor(nextCol / cols);
+        nextCol = nextCol % cols;
+      }
+      result = this._engine.find(term, nextRow, nextCol, searchOptions);
     }
 
     this._resultTracker.updateResults(results, this._highlightLimit);

addons/addon-search/test/SearchAddon.test.ts

@@ -414,6 +414,20 @@ test.describe('Search Tests', () => {
   });
 
   test.describe('Regression tests', () => {
+    test('should advance highlight-all scan by buffer match size for wide characters', async () => {
+      await ctx.page.evaluate(`
+        window.calls = [];
+        window.search.onDidChangeResults(e => window.calls.push(e));
+      `);
+      await ctx.proxy.resize(3, 5);
+      await ctx.proxy.write('𝄞𝄞𝄞');
+      strictEqual(await ctx.page.evaluate(`window.search.findNext('𝄞', { decorations: { activeMatchColorOverviewRuler: '#ff0000', matchOverviewRuler: '#ffff00' } })`), true);
+      deepStrictEqual(await ctx.page.evaluate('window.calls'), [
+        { resultCount: 3, resultIndex: 0 }
+      ]);
+      await ctx.proxy.resize(80, 24);
+    });
+
     test.describe('#2444 wrapped line content not being found', () => {
       let fixture: string;
       test.beforeAll(async () => {

src/common/buffer/BufferLine.test.ts

@@ -495,6 +495,21 @@ describe('BufferLine', function(): void {
       assert.deepEqual(columns, [0]);
     });
   });
+  describe('copyCellsFrom', () => {
+    it('should only move combined data within the copied range', () => {
+      const src = new TestBufferLine(10, NULL_CELL_DATA, false);
+      src.setCell(1, createCellData(1, 'a', 1));
+      src.addCodepointToCell(1, '\u0301'.charCodeAt(0), 0);
+      src.setCell(5, createCellData(1, 'z', 1));
+      src.addCodepointToCell(5, '\u0301'.charCodeAt(0), 0);
+
+      const dest = new TestBufferLine(10, NULL_CELL_DATA, false);
+      dest.copyCellsFrom(src, 0, 0, 2, false);
+
+      assert.property(dest.combined, '1');
+      assert.notProperty(dest.combined, '5');
+    });
+  });
   describe('addCharToCell', () => {
     it('should set width to 1 for empty cell', () => {
       const line = new TestBufferLine(3, NULL_CELL_DATA, false);

src/common/buffer/BufferLine.ts

@@ -609,9 +609,13 @@ export class BufferLine implements IBufferLine {
     const srcStart = srcCol * Constants.CELL_INDICIES;
     if (src._data[srcStart + Cell.CONTENT] & Content.IS_COMBINED_MASK) {
       this._combined[destCol] = src._combined[srcCol];
+    } else {
+      delete this._combined[destCol];
     }
     if (src._data[srcStart + Cell.BG] & BgFlags.HAS_EXTENDED) {
       this._extendedAttrs[destCol] = src._extendedAttrs[srcCol];
+    } else {
+      delete this._extendedAttrs[destCol];
     }
   }
 

src/common/buffer/BufferReflow.test.ts

@@ -10,6 +10,7 @@ import { CellData } from './CellData';
 import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE } from './Constants';
 import { reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths } from './BufferReflow';
 import { IBufferLine } from './Types';
+import { createCellData, NULL_CELL_DATA } from '../TestUtils.test';
 
 const TEST_STRING_CACHE = new BufferLineStringCache();
 
@@ -122,5 +123,27 @@ describe('BufferReflow', () => {
       const lines = createWrappedLines('abcde');
       assert.notDeepEqual(reflowLargerGetLinesToRemove(lines, 1, 5, 10, nullCell, false), []);
     });
+
+    it('should clear isWrapped on the last retained row after unwrap', () => {
+      const lines = new CircularList<BufferLine>(10);
+      const set2 = (line: BufferLine, s: string) => {
+        for (let i = 0; i < s.length; i++) {
+          line.setCell(i, createCellData(0, s[i], 1));
+        }
+      };
+      const l0 = new BufferLine(TEST_STRING_CACHE, 2);
+      set2(l0, 'ab');
+      const l1 = new BufferLine(TEST_STRING_CACHE, 2, undefined, true);
+      set2(l1, 'cd');
+      const l2 = new BufferLine(TEST_STRING_CACHE, 2, undefined, true);
+      set2(l2, 'ef');
+      lines.push(l0);
+      lines.push(l1);
+      lines.push(l2);
+
+      reflowLargerGetLinesToRemove(lines, 2, 6, 99, NULL_CELL_DATA, false);
+
+      assert.equal(l1.isWrapped, false);
+    });
   });
 });

src/common/buffer/BufferReflow.ts

@@ -99,6 +99,11 @@ export function reflowLargerGetLinesToRemove(lines: CircularList<IBufferLine>, o
     }
 
     if (countToRemove > 0) {
+      wrappedLines[destLineIndex].isWrapped = false;
+      const lineAfterGroup = lines.get(y + wrappedLines.length);
+      if (lineAfterGroup) {
+        lineAfterGroup.isWrapped = false;
+      }
       toRemove.push(y + wrappedLines.length - countToRemove); // index
       toRemove.push(countToRemove);
     }