Reset maxAtlasPages after tests that lower it

setMaxAtlasPages mutates a static that lives for the page's lifetime, so a lowered cap silently leaked into every renderer built by later tests in the same file (their GL texture and shader sampler arrays were sized at the tiny cap, making tests order-dependent). Add resetMaxAtlasPages and call it in afterEach wherever the cap is lowered on a shared page.
Fix atlas page overflow: merge same-size pairs, evict as last resort
2026-07-04 13:04:11 -07:00 · 2026-07-04 13:01:13 -07:00 · 2026-07-04 12:58:33 -07:00 · 2026-07-04 12:54:34 -07:00 · 2026-07-04 12:48:26 -07:00 · 2026-07-04 12:46:27 -07:00
79 changed files with 2538 additions and 2191 deletions
@@ -6,19 +6,14 @@ on:
  pull_request:
    branches: [ "master" ]

-permissions:
-  contents: read 
-
 jobs:
  build:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
-    - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@v5
    - name: Use Node.js 22.x
-      uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+      uses: actions/setup-node@v5
      with:
        node-version: 22.x
        cache: 'npm'
@@ -74,7 +69,7 @@ jobs:
          ./addons/addon-webgl/out/* \
          ./addons/addon-webgl/out-*st/*
    - name: Upload artifacts
-      uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6
+      uses: actions/upload-artifact@v6
      with:
        name: build-artifacts
        path: compressed-build.zip
@@ -84,11 +79,9 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
-    - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@v5
    - name: Use Node.js 22.x
-      uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+      uses: actions/setup-node@v5
      with:
        node-version: 22.x
        cache: 'npm'
@@ -107,18 +100,16 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    steps:
-    - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@v5
    - name: Use Node.js 22.x
-      uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+      uses: actions/setup-node@v5
      with:
        node-version: 22.x
        cache: 'npm'
    - name: Install dependencies
      run: |
        npm ci
-    - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
+    - uses: actions/download-artifact@v7
      with:
        name: build-artifacts
    - name: Unzip artifacts
@@ -146,18 +137,16 @@ jobs:
        runs-on: [ubuntu, macos, windows]
    runs-on: ${{ matrix.runs-on }}-latest
    steps:
-    - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@v5
    - name: Use Node.js ${{ matrix.node-version }}.x
-      uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+      uses: actions/setup-node@v5
      with:
        node-version: ${{ matrix.node-version }}.x
        cache: 'npm'
    - name: Install dependencies
      run: |
        npm ci
-    - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
+    - uses: actions/download-artifact@v7
      with:
        name: build-artifacts
    - name: Unzip artifacts
@@ -182,11 +171,9 @@ jobs:
        browser: [chromium, firefox, webkit]
    runs-on: ${{ matrix.runs-on }}
    steps:
-    - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@v5
    - name: Use Node.js ${{ matrix.node-version }}.x
-      uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+      uses: actions/setup-node@v5
      with:
        node-version: ${{ matrix.node-version }}.x
        cache: 'npm'
@@ -195,7 +182,7 @@ jobs:
        npm ci
    - name: Install playwright
      run: npx playwright install --with-deps ${{ matrix.browser }}
-    - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
+    - uses: actions/download-artifact@v7
      with:
        name: build-artifacts
    - name: Unzip artifacts
@@ -245,11 +232,9 @@ jobs:
      matrix:
        node-version: [22]
    steps:
-    - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@v5
    - name: Use Node.js ${{ matrix.node-version }}.x
-      uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+      uses: actions/setup-node@v5
      with:
        node-version: ${{ matrix.node-version }}.x
        cache: 'npm'
@@ -258,7 +243,7 @@ jobs:
        npm ci
    - name: Install playwright
      run: npx playwright install
-    - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7
+    - uses: actions/download-artifact@v7
      with:
        name: build-artifacts
    - name: Unzip artifacts
@@ -8,11 +8,6 @@ on:
  schedule:
    - cron: '41 17 * * 0'

-permissions:
-  actions: read          
-  contents: read          
-  security-events: write 
-
 jobs:
  analyze:
    name: Analyze
@@ -29,14 +24,12 @@ jobs:

    steps:
    - name: Checkout repository
-      uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+      uses: actions/checkout@v5
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+      uses: github/codeql-action/init@v4
      with:
        languages: ${{ matrix.language }}
    - name: Autobuild
-      uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+      uses: github/codeql-action/autobuild@v4
    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+      uses: github/codeql-action/analyze@v4
@@ -9,9 +9,6 @@ on:
    paths:
      - .github/workflows/copilot-setup-steps.yml

-permissions:
-  contents: read
-
 jobs:
  copilot-setup-steps:
    runs-on: ubuntu-latest
@@ -21,11 +18,9 @@ jobs:

    steps:
      - name: Checkout code
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          persist-credentials: false
+        uses: actions/checkout@v5
      - name: Use Node.js 22.x
-        uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+        uses: actions/setup-node@v5
        with:
          node-version: 22.x
          cache: 'npm'
@@ -6,18 +6,13 @@ on:
    # without running tests to save time to publish
    branches: [ "master" ]

-permissions:
-  contents: read
-
 jobs:
  release:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@v5
    - name: Use Node.js 22.x
-      uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5
+      uses: actions/setup-node@v5
      with:
        node-version: 22.x
        cache: 'npm'
@@ -255,12 +255,6 @@ Xterm.js is used in many world-class applications to provide great terminal expe
 - [**Orca**](https://github.com/stablyai/orca): Agentic development environment for 100x builders.
 - [**4bit**](https://ciembor.github.io/4bit): Terminal Color Scheme Designer.
 - [**Cate**](https://github.com/0-AI-UG/cate): Open source desktop IDE on an infinite zoomable canvas. Editor, browser, and terminal panels float in spatial space; the terminals are xterm.js with the WebGL addon, backed by node-pty.
- [**OmnyShell PWA**](https://github.com/OmnyGrid/omnyshell_web): Web client for [**OmnyShell**](https://github.com/OmnyGrid/omnyshell), featuring remote terminals, a built-in IDE, AI-assisted workflows, and detachable/resumable sessions for seamless browser-based access to nodes.
- [**kmux**](https://github.com/kkd927/kmux): A keyboard-centric terminal workspace for running parallel AI coding agents side by side on macOS and Linux.
- [**LynxHub**](https://github.com/KindaBrazy/LynxHub): Cross-platform, extensible terminal and browser for AI management.
- [**Codeman**](https://github.com/Ark0N/Codeman): Self-hosted mission control for AI coding agents, streaming live tmux sessions to browser and phone.
- [**JSVIsion**](https://github.com/blendsdk/jsvision): A Turbo Vision-Style TUI SDK for TypeScript. We use xterm.js in our docs to show live JSVision examples running in a web terminal.
- [**BitFun**](https://github.com/GCWing/BitFun): Open-source desktop AI agent whose integrated terminals and read-only terminal output views use xterm.js with the Fit, Web Links, and WebGL addons.
 - [And much more...](https://github.com/xtermjs/xterm.js/network/dependents?package_id=UGFja2FnZS0xNjYzMjc4OQ%3D%3D)

 Do you use xterm.js in your application as well? Please [open a Pull Request](https://github.com/sourcelair/xterm.js/pulls) to include it here. We would love to have it on our list. Please add any new contributions to the end of the list.
@@ -98,7 +98,7 @@ terminal.loadAddon(imageAddon);
  Set by default, change it with `{iipSupport: true}`.

  The IIP implementation has the following features / restrictions (sequence will silently fail for unmet conditions):
-  - Supported formats: PNG, JPEG, GIF, QOI, WEBP and AVIF
+  - Supported formats: PNG, JPEG, GIF and QOI
  - No animation support.
  - Image type hinting is not supported (always deducted from data header).
  - File download is not supported.
@@ -112,13 +112,6 @@ terminal.loadAddon(imageAddon);
  - ReportCellSize sequence is supported.
  - Hi-res display support is currently limited (image gets blurred).

- **Note on IIP image format support**  
-  For all image formats except QOI the addon only does the dimension extraction and leaves
-  the image decoding to the underlying browser engine. Note that some formats are implemented
-  and enabled with different constraints by browser vendors, especially newer formats
-  (e.g. under Firefox you might need to change the setting _image.avif.compliance_strictness_ to 0
-  to get broader AVIF support).
-
 - **Kitty Graphics Support (TGP)**  
  Set by default, change it with `{kittySupport: true}`.

@@ -3,13 +3,13 @@
 * @license MIT
 */
 import { IImageAddonOptions, IOscHandler, IResetHandler, ITerminalExt } from './Types';
+import { ImageRenderer } from './ImageRenderer';
 import { IIPImageStorage } from './IIPImageStorage';
 import { CELL_SIZE_DEFAULT } from './ImageStorage';
 import Base64Decoder from 'xterm-wasm-parts/lib/base64/Base64Decoder.wasm';
 import QoiDecoder from 'xterm-wasm-parts/lib/qoi/QoiDecoder.wasm';
 import { HeaderParser, IHeaderFields, HeaderState, SequenceType } from './IIPHeaderParser';
-import { imageType, UNSUPPORTED_TYPE } from './Metrics';
-import { Drawable } from './Primitives';
+import { imageType, UNSUPPORTED_TYPE } from './IIPMetrics';

 // Local const enum mirror - esbuild can't inline const enums from external packages
 const enum DecoderConst {
@@ -39,11 +39,13 @@ export class IIPHandler implements IOscHandler, IResetHandler {
  private _header: IHeaderFields = DEFAULT_HEADER;
  private _dec: Base64Decoder;
  private _qoiDec: QoiDecoder;
+  private _metrics = UNSUPPORTED_TYPE;
  private _isMultipart = false;
  private _abortMulti = false;

  constructor(
    private readonly _opts: IImageAddonOptions,
+    private readonly _renderer: ImageRenderer,
    private readonly _storage: IIPImageStorage,
    private readonly _coreTerminal: ITerminalExt
  ) {
@@ -61,6 +63,7 @@ export class IIPHandler implements IOscHandler, IResetHandler {

  public start(): void {
    this._aborted = false;
+    this._metrics  = UNSUPPORTED_TYPE;
    this._hp.reset();
  }

@@ -117,16 +120,14 @@ export class IIPHandler implements IOscHandler, IResetHandler {

    if (seqType === SequenceType.REPORTCELLSIZE) {
      // OSC 1337 ; ReportCellSize=[height];[width];[scale] ST
-      // IMPORTANT: ReportCellSize uses logical points (CSS pixels)
-      let w = CELL_SIZE_DEFAULT.width;
-      let h = CELL_SIZE_DEFAULT.height;
-      const dimensions = this._coreTerminal.dimensions;
-      if (dimensions) {
-        w = dimensions.css.canvas.width / this._coreTerminal.cols;
-        h = dimensions.css.canvas.height / this._coreTerminal.rows;
+      let width = CELL_SIZE_DEFAULT.width;
+      let height = CELL_SIZE_DEFAULT.height;
+      if (this._renderer.dimensions) {
+        width = this._renderer.dimensions.css.canvas.width / this._coreTerminal.cols;
+        height = this._renderer.dimensions.css.canvas.height / this._coreTerminal.rows;
      }
      const scale = this._coreTerminal._core._coreBrowserService?.dpr ?? 1;
-      const report = `\x1b]1337;ReportCellSize=${h.toFixed(3)};${w.toFixed(3)};${scale.toFixed(3)}\x1b\\`;
+      const report = `\x1b]1337;ReportCellSize=${height.toFixed(3)};${width.toFixed(3)};${scale.toFixed(3)}\x1b\\`;
      this._coreTerminal.input(report, false);
      return true;
    }
@@ -148,21 +149,22 @@ export class IIPHandler implements IOscHandler, IResetHandler {

    // fallthrough for SequenceType.FILE & SequenceType.FILEEND

+    let w = 0;
+    let h = 0;
+
    // early exit condition chain
    let cond: number | boolean;
-    let metrics = UNSUPPORTED_TYPE;
    if (cond = success) {
      if (cond = !this._dec.end()) {
-        metrics = imageType(this._dec.data8);
-        if (cond = metrics.mime !== 'unsupported') {
-          if (!(cond = metrics.width && metrics.height && metrics.width * metrics.height < this._opts.pixelLimit)) {
-            console.warn(`IIP: image dimension issue ${metrics.width}x${metrics.height}`);
+        this._metrics = imageType(this._dec.data8);
+        if (cond = this._metrics.mime !== 'unsupported') {
+          w = this._metrics.width;
+          h = this._metrics.height;
+          if (cond = w && h && w * h < this._opts.pixelLimit) {
+            [w, h] = this._resize(w, h).map(Math.floor);
+            cond = w && h && w * h < this._opts.pixelLimit;
          }
-        } else {
-          console.warn('IIP: unsupported image type');
        }
-      } else {
-        console.warn('IIP: error during BASE64 decoding');
      }
    }
    if (!cond) {
@@ -170,52 +172,42 @@ export class IIPHandler implements IOscHandler, IResetHandler {
      return true;
    }

-    let bmSrc: Blob | ImageData;
-    let imgBlob: Blob;
-    if (metrics.mime === 'image/qoi') {
+    let blob: Blob | ImageData;
+    if (this._metrics.mime === 'image/qoi') {
      const data = this._qoiDec.decode(this._dec.data8);
-      bmSrc = new ImageData(
+      blob = new ImageData(
        new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength),
        this._qoiDec.width,
        this._qoiDec.height
      );
      this._qoiDec.release();
+      if (w === this._qoiDec.width && h === this._qoiDec.height) {
+        // use fast-path if we don't need to rescale
+        this._dec.release();
+        const canvas = ImageRenderer.createCanvas(undefined, this._qoiDec.width, this._qoiDec.height);
+        canvas.getContext('2d')?.putImageData(blob, 0, 0);
+        this._storage.addImage(canvas);
+        return true;
+      }
    } else {
-      imgBlob = bmSrc = new Blob([this._dec.data8], { type: metrics.mime });
+      blob = new Blob([this._dec.data8], { type: this._metrics.mime });
    }
    this._dec.release();
-    return createImageBitmap(bmSrc)
+    return createImageBitmap(blob, { resizeWidth: w, resizeHeight: h })
      .then(bm => {
-        const [w, h] = this._resize(metrics.width, metrics.height);
-        this._storage.addImage(new Drawable(bm), imgBlob, metrics, w / metrics.width, h / metrics.height);
-        return true;
-      })
-      .catch(e => {
-        console.warn(`IIP: decoding error ${metrics.mime} ${metrics.width}x${metrics.height}`, e);
+        this._storage.addImage(bm);
        return true;
      });
  }

  private _resize(w: number, h: number): [number, number] {
-    let cw;
-    let ch;
-    let width;
-    let height;
-    const dimensions = this._coreTerminal.dimensions;
-    if (dimensions) {
-      width = dimensions.device.canvas.width;
-      height = dimensions.device.canvas.height;
-      cw = width / this._coreTerminal.cols;
-      ch = height / this._coreTerminal.rows;
-    } else {
-      cw = CELL_SIZE_DEFAULT.width;
-      ch = CELL_SIZE_DEFAULT.height;
-      width = cw * this._coreTerminal.cols;
-      height = ch * this._coreTerminal.rows;
-    }
+    const cw = this._renderer.dimensions?.css.cell.width || CELL_SIZE_DEFAULT.width;
+    const ch = this._renderer.dimensions?.css.cell.height || CELL_SIZE_DEFAULT.height;
+    const width = this._renderer.dimensions?.css.canvas.width || cw * this._coreTerminal.cols;
+    const height = this._renderer.dimensions?.css.canvas.height || ch * this._coreTerminal.rows;

-    const rw = this._dim(this._header.width ?? '', width, cw);
-    const rh = this._dim(this._header.height ?? '', height, ch);
+    const rw = this._dim(this._header.width!, width, cw);
+    const rh = this._dim(this._header.height!, height, ch);
    if (!rw && !rh) {
      const wf = width / w;         // TODO: should this respect initial cursor offset?
      const hf = (height - ch) / h; // TODO: fix offset issues from float cell height
@@ -3,7 +3,7 @@
 * @license MIT
 */

-import { IAddImageOpts, IDrawable, IMetrics } from './Types';
+import { IAddImageOpts } from './Types';
 import { ImageStorage } from './ImageStorage';

 /**
@@ -22,9 +22,7 @@ export class IIPImageStorage {
   * Add an IIP image to storage.
   * Always uses scrolling mode — cursor advances past the image.
   */
-  public addImage(src: IDrawable, data: Blob | undefined, metrics: IMetrics, prescaleX: number, prescaleY: number): void {
-    this._addImageOpts.prescaleX = prescaleX;
-    this._addImageOpts.prescaleY = prescaleY;
-    this._storage.addImage(src, data, metrics, this._addImageOpts);
+  public addImage(img: HTMLCanvasElement | ImageBitmap): void {
+    this._storage.addImage(img, this._addImageOpts);
  }
 }
@@ -4,8 +4,7 @@
 */

 import { assert } from 'chai';
-import { imageType } from './Metrics';
-import type { IMetrics } from 'Types';
+import { imageType, IMetrics } from './IIPMetrics';

 // fix missing nodejs decl
 declare const require: (s: string) => any;
@@ -33,28 +32,6 @@ const TEST_IMAGES: [string, IMetrics][] = [
  ['agfa-makernotes.jpg', { mime: 'image/jpeg', width: 8, height: 8 }],
  ['sony-alpha-6000.jpg', { mime: 'image/jpeg', width: 6000, height: 4000 }],
  ['dice.qoi', { mime: 'image/qoi', width: 800, height: 600 }],
-  // VP8
-  ['1.webp', { mime: 'image/webp', width: 550, height: 368 }],
-  ['2.webp', { mime: 'image/webp', width: 550, height: 404 }],
-  ['3.webp', { mime: 'image/webp', width: 1280, height: 720 }],
-  ['4.webp', { mime: 'image/webp', width: 1024, height: 772 }],
-  ['5.webp', { mime: 'image/webp', width: 1024, height: 752 }],
-  // VP8X
-  ['1_webp_a.webp', { mime: 'image/webp', width: 400, height: 301 }],
-  ['2_webp_a.webp', { mime: 'image/webp', width: 386, height: 395 }],
-  ['3_webp_a.webp', { mime: 'image/webp', width: 800, height: 600 }],
-  ['4_webp_a.webp', { mime: 'image/webp', width: 421, height: 163 }],
-  ['5_webp_a.webp', { mime: 'image/webp', width: 300, height: 300 }],
-  // VP8L
-  ['1_webp_ll.webp', { mime: 'image/webp', width: 400, height: 301 }],
-  ['2_webp_ll.webp', { mime: 'image/webp', width: 386, height: 395 }],
-  ['3_webp_ll.webp', { mime: 'image/webp', width: 800, height: 600 }],
-  ['4_webp_ll.webp', { mime: 'image/webp', width: 421, height: 163 }],
-  ['5_webp_ll.webp', { mime: 'image/webp', width: 300, height: 300 }],
-  // some AVIF test images
-  ['fox.profile2.12bpc.yuv444.odd-width.odd-height.avif', { mime: 'image/avif', width: 1203, height: 799 }],
-  ['hato.profile0.8bpc.yuv420.avif', { mime: 'image/avif', width: 3082, height: 2048 }],
-  ['kimono.crop.avif', { mime: 'image/avif', width: 722, height: 1024 }],
 ];


@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2023 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+
+export type ImageType = 'image/png' | 'image/jpeg' | 'image/gif' | 'image/qoi' | 'unsupported' | '';
+
+export interface IMetrics {
+  mime: ImageType;
+  width: number;
+  height: number;
+}
+
+export const UNSUPPORTED_TYPE: IMetrics = {
+  mime: 'unsupported',
+  width: 0,
+  height: 0
+};
+
+export function imageType(d: Uint8Array): IMetrics {
+  if (d.length < 24) {
+    return UNSUPPORTED_TYPE;
+  }
+  const d32 = new Uint32Array(d.buffer, d.byteOffset, 6);
+  // PNG: 89 50 4E 47 0D 0A 1A 0A (8 first bytes == magic number for PNG)
+  // + first chunk must be IHDR
+  if (d32[0] === 0x474E5089 && d32[1] === 0x0A1A0A0D && d32[3] === 0x52444849) {
+    return {
+      mime: 'image/png',
+      width: d[16] << 24 | d[17] << 16 | d[18] << 8 | d[19],
+      height: d[20] << 24 | d[21] << 16 | d[22] << 8 | d[23]
+    };
+  }
+  // JPEG: FF D8 FF
+  if (d[0] === 0xFF && d[1] === 0xD8 && d[2] === 0xFF) {
+    const [width, height] = jpgSize(d);
+    return { mime: 'image/jpeg', width, height };
+  }
+  // GIF: GIF87a or GIF89a
+  if (d32[0] === 0x38464947 && (d[4] === 0x37 || d[4] === 0x39) && d[5] === 0x61) {
+    return {
+      mime: 'image/gif',
+      width: d[7] << 8 | d[6],
+      height: d[9] << 8 | d[8]
+    };
+  }
+  // QOI: qoif
+  if (d32[0] === 0x66696F71) {
+    return {
+      mime: 'image/qoi',
+      width: d[4] << 24 | d[5] << 16 | d[6] << 8 | d[7],
+      height: d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11]
+    };
+  }
+  return UNSUPPORTED_TYPE;
+}
+
+function jpgSize(d: Uint8Array): [number, number] {
+  const len = d.length;
+  let i = 4;
+  let blockLength = d[i] << 8 | d[i + 1];
+  while (true) {
+    i += blockLength;
+    if (i >= len) {
+      // exhausted without size info
+      return [0, 0];
+    }
+    if (d[i] !== 0xFF) {
+      return [0, 0];
+    }
+    if (d[i + 1] === 0xC0 || d[i + 1] === 0xC2) {
+      if (i + 8 < len) {
+        return [
+          d[i + 7] << 8 | d[i + 8],
+          d[i + 5] << 8 | d[i + 6]
+        ];
+      }
+      return [0, 0];
+    }
+    i += 2;
+    blockLength = d[i] << 8 | d[i + 1];
+  }
+}
@@ -144,9 +144,6 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
      terminal.options.windowOptions = windowOps;
    }

-    // apply placeholder setting
-    this._renderer.showPlaceholder(this._opts.showPlaceholder);
-
    this._disposeLater(
      this._renderer,
      this._storage,
@@ -190,7 +187,7 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
    // iTerm IIP handler
    if (this._opts.iipSupport) {
      const iipStorage = new IIPImageStorage(this._storage!);
-      const iipHandler = new IIPHandler(this._opts, iipStorage, terminal);
+      const iipHandler = new IIPHandler(this._opts, this._renderer!, iipStorage, terminal);
      this._handlers.set('iip', iipHandler);
      this._disposeLater(
        terminal._core._inputHandler._parser.registerOscHandler(1337, iipHandler)
@@ -253,6 +250,10 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
    return this._storage?.getImageAtBufferCell(x, y);
  }

+  public extractTileAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined {
+    return this._storage?.extractTileAtBufferCell(x, y);
+  }
+
  private _report(s: string): void {
    this._terminal?._core.input(s, false);
  }
@@ -343,8 +344,8 @@ export class ImageAddon implements ITerminalAddon, IImageApi {
      switch (params[1]) {
        // we only implement read and read_max here
        case GaAction.READ:
-          let width = this._renderer?.dimensions?.device.canvas.width;
-          let height = this._renderer?.dimensions?.device.canvas.height;
+          let width = this._renderer?.dimensions?.css.canvas.width;
+          let height = this._renderer?.dimensions?.css.canvas.height;
          if (!width || !height) {
            // for some reason we have no working image renderer
            // --> fallback to default cell size
@@ -3,14 +3,19 @@
 * @license MIT
 */

+import { toRGBA8888 } from 'sixel/lib/Colors';
 import { IDisposable } from '@xterm/xterm';
-import type { ICellSize, ImageLayer, ITerminalExt, IImageSpec, IRenderDimensions, IRenderService } from './Types';
+import { ICellSize, ImageLayer, ITerminalExt, IImageSpec, IRenderDimensions, IRenderService } from './Types';
 import { Disposable, MutableDisposable, toDisposable } from 'common/Lifecycle';
-import { createCanvas } from './Primitives';

+const enum Constants {
+  PLACEHOLDER_LENGTH = 4096,
+  PLACEHOLDER_HEIGHT = 24
+}

 /**
 * ImageRenderer - terminal frontend extension:
+ * - provide primitives for canvas, ImageData, Bitmap (static)
 * - add canvas layer to DOM (browser only for now)
 * - draw image tiles onRender
 */
@@ -19,14 +24,51 @@ export class ImageRenderer extends Disposable implements IDisposable {
  public get canvas(): HTMLCanvasElement | undefined { return this._layers.get('top')?.canvas; }
  private _layers = new Map<ImageLayer, CanvasRenderingContext2D>();
  private _placeholder: HTMLCanvasElement | undefined;
+  private _placeholderBitmap: ImageBitmap | undefined;
  private _optionsRefresh = this._register(new MutableDisposable());
  private _oldOpen: ((parent: HTMLElement) => void) | undefined;
  private _renderService: IRenderService | undefined;
  private _oldSetRenderer: ((renderer: any) => void) | undefined;

-  // some local variables for faster access
-  private _dimensions: IRenderDimensions | undefined;
-  private _cellSize: ICellSize | undefined;
+  // drawing primitive - canvas
+  public static createCanvas(localDocument: Document | undefined, width: number, height: number): HTMLCanvasElement {
+    /**
+     * NOTE: We normally dont care, from which document the canvas
+     * gets created, so we can fall back to global document,
+     * if the terminal has no document associated yet.
+     * This way early image loads before calling .open keep working
+     * (still discouraged though, as the metrics will be screwed up).
+     * Only the DOM output canvas should be on the terminal's document,
+     * which gets explicitly checked in `insertLayerToDom`.
+     */
+    const canvas = (localDocument ?? document).createElement('canvas');
+    canvas.width = width | 0;
+    canvas.height = height | 0;
+    return canvas;
+  }
+
+  // drawing primitive - ImageData with optional buffer
+  public static createImageData(ctx: CanvasRenderingContext2D, width: number, height: number, buffer?: ArrayBuffer): ImageData {
+    if (typeof ImageData !== 'function') {
+      const imgData = ctx.createImageData(width, height);
+      if (buffer) {
+        imgData.data.set(new Uint8ClampedArray(buffer, 0, width * height * 4));
+      }
+      return imgData;
+    }
+    return buffer
+      ? new ImageData(new Uint8ClampedArray(buffer, 0, width * height * 4), width, height)
+      : new ImageData(width, height);
+  }
+
+  // drawing primitive - ImageBitmap
+  public static createImageBitmap(img: ImageBitmapSource): Promise<ImageBitmap | undefined> {
+    if (typeof createImageBitmap !== 'function') {
+      return Promise.resolve(undefined);
+    }
+    return createImageBitmap(img);
+  }
+

  constructor(private _terminal: ITerminalExt) {
    super();
@@ -58,6 +100,8 @@ export class ImageRenderer extends Disposable implements IDisposable {
      }
      this._renderService = undefined;
      this._layers.clear();
+      this._placeholderBitmap?.close();
+      this._placeholderBitmap = undefined;
      this._placeholder = undefined;
    }));
  }
@@ -66,7 +110,15 @@ export class ImageRenderer extends Disposable implements IDisposable {
   * Enable the placeholder.
   */
  public showPlaceholder(value: boolean): void {
-    this._placeholder = value ? this._createPlaceHolder() : undefined;
+    if (value) {
+      if (!this._placeholder && this.cellSize.height !== -1) {
+        this._createPlaceHolder(Math.max(this.cellSize.height + 1, Constants.PLACEHOLDER_HEIGHT));
+      }
+    } else {
+      this._placeholderBitmap?.close();
+      this._placeholderBitmap = undefined;
+      this._placeholder = undefined;
+    }
    this._renderService?.refreshRows(0, this._terminal.rows);
  }

@@ -79,27 +131,22 @@ export class ImageRenderer extends Disposable implements IDisposable {
  }

  /**
-   * Current cell size.
+   * Current cell size (float).
   */
-  public getCellSize(dimensions?: IRenderDimensions): ICellSize | undefined {
-    dimensions ??= this._terminal.dimensions;
-    if (dimensions) {
-      return {
-        width: dimensions.device.canvas.width / this._terminal.cols,
-        height: dimensions.device.canvas.height / this._terminal.rows,
-      };
-    }
+  public get cellSize(): ICellSize {
+    return {
+      width: this.dimensions?.css.cell.width || -1,
+      height: this.dimensions?.css.cell.height || -1
+    };
  }

  /**
   * Clear a region of the image layer canvas.
   */
  public clearLines(start: number, end: number, layer?: ImageLayer): void {
-    const deviceGrid = this._cellSize;
-    if (!deviceGrid || !this._dimensions) return;
-    const y = Math.floor(start * deviceGrid.height);
-    const w = this._dimensions.device.canvas.width;
-    const h = Math.ceil((end + 1 - start) * deviceGrid.height);
+    const y = start * (this.dimensions?.css.cell.height || 0);
+    const w = this.dimensions?.css.canvas.width || 0;
+    const h = (end + 1 - start) * (this.dimensions?.css.cell.height || 0);
    if (!layer || layer === 'top') {
      this._layers.get('top')?.clearRect(0, y, w, h);
    }
@@ -127,103 +174,142 @@ export class ImageRenderer extends Disposable implements IDisposable {
   */
  public draw(imgSpec: IImageSpec, tileId: number, col: number, row: number, count: number = 1): void {
    const ctx = this._layers.get(imgSpec.layer);
-    const initialGrid = imgSpec.cellSize;
-    const deviceGrid = this._cellSize;
+    if (!ctx) {
+      return;
+    }
+    const { width, height } = this.cellSize;

-    if (!ctx || !imgSpec.src.native || !deviceGrid) {
+    // Don't try to draw anything, if we cannot get valid renderer metrics.
+    if (width === -1 || height === -1) {
      return;
    }

-    const img = imgSpec.src;
-    const cols = Math.ceil(img.width * imgSpec.prescaleX / initialGrid.width);
+    this._rescaleImage(imgSpec, width, height);
+    const img = imgSpec.actual!;
+    const cols = Math.ceil(img.width / width);

-    const gridWidth = initialGrid.width / imgSpec.prescaleX;
-    const gridHeight = initialGrid.height / imgSpec.prescaleY;
+    const sx = (tileId % cols) * width;
+    const sy = Math.floor(tileId / cols) * height;
+    const dx = col * width;
+    const dy = row * height;

-    // crops are initialGrid px
-    const sx = (tileId % cols) * gridWidth + imgSpec.precropX;
-    const sy = Math.floor(tileId / cols) * gridHeight + imgSpec.precropY;
-    const dx = Math.floor(col * deviceGrid.width + imgSpec.offsetX);
-    const dy = Math.floor(row * deviceGrid.height + imgSpec.offsetY);
-
-    // safari bug: never access image source out of bounds, thus we clamp its dimensions
-    const sWidth = Math.min(count * gridWidth, img.width - sx);
-    const sHeight = Math.min(gridHeight, img.height - sy);
-    const dWidth = Math.ceil(sWidth / gridWidth * deviceGrid.width * imgSpec.scaleX);
-    const dHeight = Math.ceil(sHeight / gridHeight * deviceGrid.height * imgSpec.scaleY);
-
-    if (imgSpec.blendMode === 'overwrite') {
-      ctx.clearRect(dx, dy, dWidth, dHeight);
-    }
+    // safari bug: never access image source out of bounds
+    const finalWidth = count * width + sx > img.width ? img.width - sx : count * width;
+    const finalHeight = sy + height > img.height ? img.height - sy : height;

    // Floor all pixel offsets to get stable tile mapping without any overflows.
    // Note: For not pixel perfect aligned cells like in the DOM renderer
    // this will move a tile slightly to the top/left (subpixel range, thus ignore it).
    // FIX #34: avoid striping on displays with pixelDeviceRatio != 1 by ceiling height and width
    ctx.drawImage(
-      img.native,
-      Math.floor(sx), Math.floor(sy), Math.ceil(sWidth), Math.ceil(sHeight),
-      dx, dy, dWidth, dHeight
+      img,
+      Math.floor(sx), Math.floor(sy), Math.ceil(finalWidth), Math.ceil(finalHeight),
+      Math.floor(dx), Math.floor(dy), Math.ceil(finalWidth), Math.ceil(finalHeight)
    );
  }

+  /**
+   * Extract a single tile from an image.
+   */
+  public extractTile(imgSpec: IImageSpec, tileId: number): HTMLCanvasElement | undefined {
+    const { width, height } = this.cellSize;
+    // Don't try to draw anything, if we cannot get valid renderer metrics.
+    if (width === -1 || height === -1) {
+      return;
+    }
+    this._rescaleImage(imgSpec, width, height);
+    const img = imgSpec.actual!;
+    const cols = Math.ceil(img.width / width);
+    const sx = (tileId % cols) * width;
+    const sy = Math.floor(tileId / cols) * height;
+    const finalWidth = width + sx > img.width ? img.width - sx : width;
+    const finalHeight = sy + height > img.height ? img.height - sy : height;
+
+    const canvas = ImageRenderer.createCanvas(this.document, finalWidth, finalHeight);
+    const ctx = canvas.getContext('2d');
+    if (ctx) {
+      ctx.drawImage(
+        img,
+        Math.floor(sx), Math.floor(sy), Math.floor(finalWidth), Math.floor(finalHeight),
+        0, 0, Math.floor(finalWidth), Math.floor(finalHeight)
+      );
+      return canvas;
+    }
+  }
+
  /**
   * Draw a line with placeholder on the image layer canvas.
   */
  public drawPlaceholder(col: number, row: number, count: number = 1): void {
    const ctx = this._layers.get('top');
-    const deviceGrid = this._cellSize;
-    if (!ctx || !deviceGrid) {
-      return;
+    if (ctx) {
+      const { width, height } = this.cellSize;
+
+      // Don't try to draw anything, if we cannot get valid renderer metrics.
+      if (width === -1 || height === -1) {
+        return;
+      }
+
+      if (!this._placeholder) {
+        this._createPlaceHolder(Math.max(height + 1, Constants.PLACEHOLDER_HEIGHT));
+      } else if (height >= this._placeholder!.height) {
+        this._createPlaceHolder(height + 1);
+      }
+      if (!this._placeholder) return;
+      ctx.drawImage(
+        this._placeholderBitmap ?? this._placeholder!,
+        col * width,
+        (row * height) % 2 ? 0 : 1,  // needs %2 offset correction
+        width * count,
+        height,
+        col * width,
+        row * height,
+        width * count,
+        height
+      );
    }
-    this._placeholder ??= this._createPlaceHolder();
-    if (!this._placeholder) return;
-    ctx.drawImage(
-      this._placeholder,
-      0, 0, 1, 1,
-      col * deviceGrid.width,
-      row * deviceGrid.height,
-      count * deviceGrid.width,
-      deviceGrid.height
-    );
  }

  /**
   * Rescale image layer canvas if needed.
   * Checked once from `ImageStorage.render`.
-   * NOTE: This method updates dimensions on instance properties
-   * for faster access during draw and clear calls.
-   * So make sure to always call this before doing any draws.
   */
-  public rescaleCanvas(force: boolean = false): void {
-    const dimensions = this._terminal.dimensions;
-    if (dimensions) {
-      const cssW = dimensions.css.canvas.width;
-      const cssH = dimensions.css.canvas.height;
-      const devW = dimensions.device.canvas.width;
-      const devH = dimensions.device.canvas.height;
-      let recalc = force;
-      for (const ctx of this._layers.values()) {
-        if (ctx.canvas.width !== devW
-          || ctx.canvas.height !== devH
-          || ctx.canvas.style.width !== `${cssW}px`
-          || ctx.canvas.style.height !== `${cssH}px`
-        ) {
-          ctx.canvas.width = devW;
-          ctx.canvas.height = devH;
-          ctx.canvas.style.width = `${cssW}px`;
-          ctx.canvas.style.height = `${cssH}px`;
-          recalc = true;
-        }
+  public rescaleCanvas(): void {
+    const w = this.dimensions?.css.canvas.width || 0;
+    const h = this.dimensions?.css.canvas.height || 0;
+    for (const ctx of this._layers.values()) {
+      if (ctx.canvas.width !== w || ctx.canvas.height !== h) {
+        ctx.canvas.width = w;
+        ctx.canvas.height = h;
      }
-      if (recalc) {
-        this._dimensions = dimensions;
-        this._cellSize = this.getCellSize(dimensions);
-      }
-    } else {
-      // we were not able to get render dimensions:
-      // set cellsize to undefined so we don't try to draw anything
-      this._cellSize = this.getCellSize();
+    }
+  }
+
+  /**
+   * Rescale image in storage if needed.
+   */
+  private _rescaleImage(spec: IImageSpec, currentWidth: number, currentHeight: number): void {
+    if (currentWidth === spec.actualCellSize.width && currentHeight === spec.actualCellSize.height) {
+      return;
+    }
+    const { width: originalWidth, height: originalHeight } = spec.origCellSize;
+    if (currentWidth === originalWidth && currentHeight === originalHeight) {
+      spec.actual = spec.orig;
+      spec.actualCellSize.width = originalWidth;
+      spec.actualCellSize.height = originalHeight;
+      return;
+    }
+    const canvas = ImageRenderer.createCanvas(
+      this.document,
+      Math.ceil(spec.orig!.width * currentWidth / originalWidth),
+      Math.ceil(spec.orig!.height * currentHeight / originalHeight)
+    );
+    const ctx = canvas.getContext('2d');
+    if (ctx) {
+      ctx.drawImage(spec.orig!, 0, 0, canvas.width, canvas.height);
+      spec.actual = canvas;
+      spec.actualCellSize.width = currentWidth;
+      spec.actualCellSize.height = currentHeight;
    }
  }

@@ -250,12 +336,9 @@ export class ImageRenderer extends Disposable implements IDisposable {
    if (this._layers.has(layer)) {
      return;
    }
-    const canvas = createCanvas(
-      this.document,
-      this.dimensions?.device.canvas.width || 0,
-      this.dimensions?.device.canvas.height || 0,
-      this.dimensions?.css.canvas.width || 0,
-      this.dimensions?.css.canvas.height || 0,
+    const canvas = ImageRenderer.createCanvas(
+      this.document, this.dimensions?.css.canvas.width || 0,
+      this.dimensions?.css.canvas.height || 0
    );
    canvas.classList.add(`xterm-image-layer-${layer}`);
    const screenElement = this._terminal._core.screenElement;
@@ -283,8 +366,6 @@ export class ImageRenderer extends Disposable implements IDisposable {
      return;
    }
    this._layers.set(layer, ctx);
-    // force rescaling to update stored cellSize (maybe not be populated yet)
-    this.rescaleCanvas(true);
    this.clearAll(layer);
  }

@@ -300,17 +381,41 @@ export class ImageRenderer extends Disposable implements IDisposable {
    return this._layers.has(layer);
  }

-  /**
-   * Create a semi-transparent gray 1x1 placeholder
-   */
-  private _createPlaceHolder(): HTMLCanvasElement | undefined {
-    const imgData = new ImageData(1, 1);
-    new Uint32Array(imgData.data.buffer).fill(128 << 24 | 128 << 16 | 128 << 8 | 128);
-    const canvas = createCanvas(this.document, 1, 1);
-    const ctx = canvas.getContext('2d', { alpha: true });
+  private _createPlaceHolder(height: number = Constants.PLACEHOLDER_HEIGHT): void {
+    this._placeholderBitmap?.close();
+    this._placeholderBitmap = undefined;
+
+    // create blueprint to fill placeholder with
+    const bWidth = 32;  // must be 2^n
+    const blueprint = ImageRenderer.createCanvas(this.document, bWidth, height);
+    const ctx = blueprint.getContext('2d', { alpha: false });
    if (!ctx) return;
+    const imgData = ImageRenderer.createImageData(ctx, bWidth, height);
+    const d32 = new Uint32Array(imgData.data.buffer);
+    const black = toRGBA8888(0, 0, 0);
+    const white = toRGBA8888(255, 255, 255);
+    d32.fill(black);
+    for (let y = 0; y < height; ++y) {
+      const shift = y % 2;
+      const offset = y * bWidth;
+      for (let x = 0; x < bWidth; x += 2) {
+        d32[offset + x + shift] = white;
+      }
+    }
    ctx.putImageData(imgData, 0, 0);
-    return canvas;
+
+    // create placeholder line, width aligned to blueprint width
+    const width = (screen.width + bWidth - 1) & ~(bWidth - 1) || Constants.PLACEHOLDER_LENGTH;
+    this._placeholder = ImageRenderer.createCanvas(this.document, width, height);
+    const ctx2 = this._placeholder.getContext('2d', { alpha: false });
+    if (!ctx2) {
+      this._placeholder = undefined;
+      return;
+    }
+    for (let i = 0; i < width; i += bWidth) {
+      ctx2.drawImage(blueprint, i, 0);
+    }
+    ImageRenderer.createImageBitmap(this._placeholder).then(bitmap => this._placeholderBitmap = bitmap);
  }

  public get document(): Document | undefined {
@@ -5,14 +5,12 @@

 import { IDisposable } from '@xterm/xterm';
 import { ImageRenderer } from './ImageRenderer';
-import type {
-  ITerminalExt, IImageAddonOptions, IImageSpec, ICellSize, IAddImageOpts,
-  IDrawable,
-  IMetrics
+import {
+  ITerminalExt, IExtendedAttrsImage, IImageAddonOptions, IImageSpec,
+  IBufferLineExt, BgFlags, Cell, Content, ICellSize, ExtFlags, Attributes,
+  UnderlineStyle, IAddImageOpts
 } from './Types';
-import type { IBufferLine } from 'common/buffer/Types';
-import { CellData } from 'common/buffer/CellData';
-import { createCanvas } from './Primitives';
+

 // fallback default cell size
 export const CELL_SIZE_DEFAULT: ICellSize = {
@@ -20,12 +18,93 @@ export const CELL_SIZE_DEFAULT: ICellSize = {
  height: 14
 };

-class ImageTileInfo {
+/**
+ * Extend extended attribute to also hold image tile information.
+ *
+ * Object definition is copied from base repo to fully mimick its behavior.
+ * Image data is added as additional public properties `imageId` and `tileId`.
+ */
+class ExtendedAttrsImage implements IExtendedAttrsImage {
+  private _ext: number = 0;
+  public get ext(): number {
+    if (this._urlId) {
+      return (
+        (this._ext & ~ExtFlags.UNDERLINE_STYLE) |
+        (this.underlineStyle << 26)
+      );
+    }
+    return this._ext;
+  }
+  public set ext(value: number) { this._ext = value; }
+
+  public get underlineStyle(): UnderlineStyle {
+    // Always return the URL style if it has one
+    if (this._urlId) {
+      return UnderlineStyle.DASHED;
+    }
+    return (this._ext & ExtFlags.UNDERLINE_STYLE) >> 26;
+  }
+  public set underlineStyle(value: UnderlineStyle) {
+    this._ext &= ~ExtFlags.UNDERLINE_STYLE;
+    this._ext |= (value << 26) & ExtFlags.UNDERLINE_STYLE;
+  }
+
+  public get underlineColor(): number {
+    return this._ext & (Attributes.CM_MASK | Attributes.RGB_MASK);
+  }
+  public set underlineColor(value: number) {
+    this._ext &= ~(Attributes.CM_MASK | Attributes.RGB_MASK);
+    this._ext |= value & (Attributes.CM_MASK | Attributes.RGB_MASK);
+  }
+
+  public get underlineVariantOffset(): number {
+    const val = (this._ext & ExtFlags.VARIANT_OFFSET) >> 29;
+    if (val < 0) {
+      return val ^ 0xFFFFFFF8;
+    }
+    return val;
+  }
+  public set underlineVariantOffset(value: number) {
+    this._ext &= ~ExtFlags.VARIANT_OFFSET;
+    this._ext |= (value << 29) & ExtFlags.VARIANT_OFFSET;
+  }
+
+  private _urlId: number = 0;
+  public get urlId(): number {
+    return this._urlId;
+  }
+  public set urlId(value: number) {
+    this._urlId = value;
+  }
+
  constructor(
+    ext: number = 0,
+    urlId: number = 0,
    public imageId = -1,
-    public tileId = -1) {
+    public tileId = -1
+  ) {
+    this._ext = ext;
+    this._urlId = urlId;
+  }
+
+  public clone(): IExtendedAttrsImage {
+    /**
+     * Technically we dont need a clone variant of ExtendedAttrsImage,
+     * as we never clone a cell holding image data.
+     * Note: Clone is only meant to be used by the InputHandler for
+     * sticky attributes, which is never the case for image data.
+     * We still provide a proper clone method to reflect the full ext attr
+     * state in case there are future use cases for clone.
+     */
+    return new ExtendedAttrsImage(this._ext, this._urlId, this.imageId, this.tileId);
+  }
+
+  public isEmpty(): boolean {
+    return this.underlineStyle === UnderlineStyle.NONE && this._urlId === 0 && this.imageId === -1;
  }
 }
+const EMPTY_ATTRS = new ExtendedAttrsImage();
+

 /**
 * ImageStorage - extension of CoreTerminal:
@@ -46,8 +125,7 @@ export class ImageStorage implements IDisposable {
  // whether render should do a full clear
  private _needsFullClear = false;
  // hard limit of stored pixels (fallback limit of 10 MB)
-  private _byteLimit: number = 10000000;
-  private _workCell: CellData = new CellData();
+  private _pixelLimit: number = 2500000;

  private _viewportMetrics: { cols: number, rows: number };
  public onImageAdded: (() => void) | undefined;
@@ -86,54 +164,43 @@ export class ImageStorage implements IDisposable {
    this._renderer.clearAll();
  }

-  /**
-   * FIXME: below we need to introduce separation of:
-   * - RAM usage
-   * - VRAM usage
-   * - Blob unsage
-   */
-
-
  public getLimit(): number {
-    return this._byteLimit / 1000000;
+    return this._pixelLimit * 4 / 1000000;
  }

  public setLimit(value: number): void {
    if (value < 0.5 || value > 1000) {
-      throw RangeError('invalid storageLimit, should be at least 0.5 MB and not exceed 1GB');
+      throw RangeError('invalid storageLimit, should be at least 0.5 MB and not exceed 1G');
    }
-    this._byteLimit = (value * 1000000) >>> 0;
+    this._pixelLimit = (value / 4 * 1000000) >>> 0;
    this._evictOldest(0);
  }

  public getUsage(): number {
-    return this._getVRAMUsage() / 1000000;
+    return this._getStoredPixels() * 4 / 1000000;
  }

-  private _getVRAMUsage(): number {
-    let bytes = 0;
+  private _getStoredPixels(): number {
+    let storedPixels = 0;
    for (const spec of this._images.values()) {
-      bytes += spec.src.bytes;
-    }
-    return bytes;
-  }
-
-  public getBlobUsage(): number {
-    let size = 0;
-    for (const spec of this._images.values()) {
-      if (spec.data instanceof Blob) {
-        size += spec.data.size;
+      if (spec.orig) {
+        storedPixels += spec.orig.width * spec.orig.height;
+        if (spec.actual && spec.actual !== spec.orig) {
+          storedPixels += spec.actual.width * spec.actual.height;
+        }
      }
    }
-    return size;
+    return storedPixels;
  }

  private _delImg(id: number): void {
    const spec = this._images.get(id);
    if (!spec) return;
    this._images.delete(id);
-    spec.src.close();
-    spec.data = undefined;
+    // FIXME: really ugly workaround to get bitmaps deallocated :(
+    if (window.ImageBitmap && spec.orig instanceof ImageBitmap) {
+      spec.orig.close();
+    }
    this.onImageDeleted?.(id);
  }

@@ -170,10 +237,8 @@ export class ImageStorage implements IDisposable {
  }

  /**
-   * Method to add an drawable to the storage.
-   * @param src - The drawable to add.
-   * @param data - Blob or Uint8Array of the original image data.
-   * @param metrics - IMetrics of the original image.
+   * Method to add an image to the storage.
+   * @param img - The image to add (canvas or bitmap).
   * @param opts - Options for addImage:
   *   - scrolling:  When true, cursor advances with the image.
   *                 When false, image is placed at ORIGIN and cursor does not move.
@@ -182,16 +247,17 @@ export class ImageStorage implements IDisposable {
   *   - cursorPos:  'vt340' for bottom-left, 'iip' for bottom.right.
   * @returns The internal image ID assigned to the stored image.
   */
-  public addImage(src: IDrawable, data: Blob | undefined, metrics: IMetrics, opts: IAddImageOpts): number {
+  public addImage(img: HTMLCanvasElement | ImageBitmap, opts: IAddImageOpts): number {
    // never allow storage to exceed memory limit
-    this._evictOldest(src.bytes);
+    this._evictOldest(img.width * img.height);

    // calc rows x cols needed to display the image
-    const prescaleX = opts.prescaleX ?? 1.0;
-    const prescaleY = opts.prescaleY ?? 1.0;
-    const cellSize = this._renderer.getCellSize() ?? CELL_SIZE_DEFAULT;
-    const cols = Math.ceil(src.width * prescaleX / cellSize.width);
-    const rows = Math.ceil(src.height * prescaleY / cellSize.height);
+    let cellSize = this._renderer.cellSize;
+    if (cellSize.width === -1 || cellSize.height === -1) {
+      cellSize = CELL_SIZE_DEFAULT;
+    }
+    const cols = Math.ceil(img.width / cellSize.width);
+    const rows = Math.ceil(img.height / cellSize.height);

    const imageId = ++this._lastId;

@@ -211,10 +277,10 @@ export class ImageStorage implements IDisposable {

    this._terminal._core._inputHandler._dirtyRowTracker.markDirty(buffer.y);
    for (let row = 0; row < rows; ++row) {
-      const line = buffer.lines.get(buffer.y + buffer.ybase)!;
+      const line = buffer.lines.get(buffer.y + buffer.ybase);
      for (let col = 0; col < cols; ++col) {
        if (offset + col >= termCols) break;
-        this._writeToCell(line, offset + col, imageId, row * cols + col);
+        this._writeToCell(line as IBufferLineExt, offset + col, imageId, row * cols + col);
        tileCount++;
      }
      if (opts.scrolling) {
@@ -268,24 +334,15 @@ export class ImageStorage implements IDisposable {

    // create storage entry
    const imgSpec: IImageSpec = {
-      src,
-      data,
-      metrics,
-      cellSize,
+      orig: img,
+      origCellSize: cellSize,
+      actual: img,
+      actualCellSize: { ...cellSize },  // clone needed, since later modified
      marker: endMarker || undefined,
      tileCount,
      bufferType: this._terminal.buffer.active.type,
      layer: opts.layer,
-      zIndex: opts.zIndex,
-      prescaleX,
-      prescaleY,
-      precropX: 0,
-      precropY: 0,
-      scaleX: 1.0,
-      scaleY: 1.0,
-      offsetX: 0,
-      offsetY: 0,
-      blendMode: 'alpha'
+      zIndex: opts.zIndex
    };

    // finally add the image
@@ -370,42 +427,55 @@ export class ImageStorage implements IDisposable {
    const placeholderCalls: { col: number, row: number, count: number }[] = [];

    // walk all cells in viewport and collect tiles found
+    // Note: We check _extendedAttrs directly (not just HAS_EXTENDED flag)
+    // because text writes clear the BG flag but leave image tile data intact.
+    // This lets top-layer images survive text overwrites (kitty C=1 behavior).
    for (let row = start; row <= end; ++row) {
-      const line = buffer.lines.get(row + buffer.ydisp);
+      const line = buffer.lines.get(row + buffer.ydisp) as IBufferLineExt;
      if (!line) return;
      for (let col = 0; col < cols; ++col) {
-        const e = line.getExtended(col)?.payload;
-        if (e instanceof ImageTileInfo) {
-          const imageId = e.imageId;
-          if (imageId === undefined || imageId === -1) {
+        let e: IExtendedAttrsImage;
+        if (line.getBg(col) & BgFlags.HAS_EXTENDED) {
+          e = line._extendedAttrs[col] ?? EMPTY_ATTRS;
+        } else {
+          const maybeImg = line._extendedAttrs[col] as IExtendedAttrsImage | undefined;
+          if (!maybeImg || maybeImg.imageId === undefined || maybeImg.imageId === -1) {
            continue;
          }
-          const imgSpec = this._images.get(imageId);
-          if (e.tileId !== -1) {
-            const startTile = e.tileId;
-            const startCol = col;
-            let count = 1;
-            /**
-             * merge tiles to the right into a single draw call, if:
-             * - not at end of line
-             * - cell has same image id
-             * - cell has consecutive tile id
-             */
-            while (++col < cols) {
-              const nextE = line.getExtended(col)?.payload;
-              if (!(nextE instanceof ImageTileInfo) || nextE.imageId !== imageId || nextE.tileId !== startTile + count) {
-                break;
-              }
-              count++;
+          e = maybeImg;
+        }
+        const imageId = e.imageId;
+        if (imageId === undefined || imageId === -1) {
+          continue;
+        }
+        const imgSpec = this._images.get(imageId);
+        if (e.tileId !== -1) {
+          const startTile = e.tileId;
+          const startCol = col;
+          let count = 1;
+          /**
+           * merge tiles to the right into a single draw call, if:
+           * - not at end of line
+           * - cell has same image id
+           * - cell has consecutive tile id
+           * Also check _extendedAttrs directly for cells where text cleared HAS_EXTENDED.
+           */
+          while (++col < cols) {
+            const nextE = line._extendedAttrs[col] as IExtendedAttrsImage | undefined;
+            if (!nextE || nextE.imageId !== imageId || nextE.tileId !== startTile + count) {
+              break;
            }
-            col--;
-            if (imgSpec) {
-              drawCalls.push({ imgSpec, tileId: startTile, col: startCol, row, count });
-            } else if (this._opts.showPlaceholder) {
-              placeholderCalls.push({ col: startCol, row, count });
-            }
-            this._fullyCleared = false;
+            count++;
          }
+          col--;
+          if (imgSpec) {
+            if (imgSpec.actual) {
+              drawCalls.push({ imgSpec, tileId: startTile, col: startCol, row, count });
+            }
+          } else if (this._opts.showPlaceholder) {
+            placeholderCalls.push({ col: startCol, row, count });
+          }
+          this._fullyCleared = false;
        }
      }
    }
@@ -443,9 +513,9 @@ export class ImageStorage implements IDisposable {
    const rows = buffer.lines.length;
    const oldCol = this._viewportMetrics.cols - 1;
    for (let row = 0; row < rows; ++row) {
-      const line = buffer.lines.get(row)!;
-      const e = line.getExtended(oldCol)?.payload;
-      if (e instanceof ImageTileInfo) {
+      const line = buffer.lines.get(row) as IBufferLineExt;
+      if (line.getBg(oldCol) & BgFlags.HAS_EXTENDED) {
+        const e: IExtendedAttrsImage = line._extendedAttrs[oldCol] ?? EMPTY_ATTRS;
        const imageId = e.imageId;
        if (imageId === undefined || imageId === -1) {
          continue;
@@ -455,14 +525,14 @@ export class ImageStorage implements IDisposable {
          continue;
        }
        // found an image tile at oldCol, check if it qualifies for right exapansion
-        const tilesPerRow = Math.ceil(imgSpec.src.width * imgSpec.prescaleX / imgSpec.cellSize.width);
+        const tilesPerRow = Math.ceil((imgSpec.actual?.width || 0) / imgSpec.actualCellSize.width);
        if ((e.tileId % tilesPerRow) + 1 >= tilesPerRow) {
          continue;
        }
        // expand only if right side is empty (nothing got wrapped from below)
        let hasData = false;
        for (let rightCol = oldCol + 1; rightCol > metrics.cols; ++rightCol) {
-          if (line.hasContent(rightCol)) {
+          if (line._data[rightCol * Cell.SIZE + Cell.CONTENT] & Content.HAS_CONTENT_MASK) {
            hasData = true;
            break;
          }
@@ -474,7 +544,7 @@ export class ImageStorage implements IDisposable {
        const end = Math.min(metrics.cols, tilesPerRow - (e.tileId % tilesPerRow) + oldCol);
        let lastTile = e.tileId;
        for (let expandCol = oldCol + 1; expandCol < end; ++expandCol) {
-          this._writeToCell(line, expandCol, imageId, ++lastTile);
+          this._writeToCell(line as IBufferLineExt, expandCol, imageId, ++lastTile);
          imgSpec.tileCount++;
        }
      }
@@ -488,17 +558,34 @@ export class ImageStorage implements IDisposable {
   */
  public getImageAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined {
    const buffer = this._terminal._core.buffer;
-    const line = buffer.lines.get(y);
-    if (line) {
-      const e = line.getExtended(x)?.payload;
-      if (e instanceof ImageTileInfo && e.imageId && e.imageId !== -1) {
-        const src = this._images.get(e.imageId)?.src;
-        if (src?.native instanceof ImageBitmap || src?.native instanceof VideoFrame) {
-          const canvas = createCanvas(window.document, src.width, src.height);
-          canvas.getContext('2d')?.drawImage(src.native, 0, 0, src.width, src.height);
+    const line = buffer.lines.get(y) as IBufferLineExt;
+    if (line && line.getBg(x) & BgFlags.HAS_EXTENDED) {
+      const e: IExtendedAttrsImage = line._extendedAttrs[x] ?? EMPTY_ATTRS;
+      if (e.imageId && e.imageId !== -1) {
+        const orig = this._images.get(e.imageId)?.orig;
+        if (window.ImageBitmap && orig instanceof ImageBitmap) {
+          const canvas = ImageRenderer.createCanvas(window.document, orig.width, orig.height);
+          canvas.getContext('2d')?.drawImage(orig, 0, 0, orig.width, orig.height);
          return canvas;
        }
-        return src?.native;
+        return orig as HTMLCanvasElement;
+      }
+    }
+  }
+
+  /**
+   * Extract active single tile at buffer position.
+   */
+  public extractTileAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined {
+    const buffer = this._terminal._core.buffer;
+    const line = buffer.lines.get(y) as IBufferLineExt;
+    if (line && line.getBg(x) & BgFlags.HAS_EXTENDED) {
+      const e: IExtendedAttrsImage = line._extendedAttrs[x] ?? EMPTY_ATTRS;
+      if (e.imageId && e.imageId !== -1 && e.tileId !== -1) {
+        const spec = this._images.get(e.imageId);
+        if (spec) {
+          return this._renderer.extractTile(spec, e.tileId);
+        }
      }
    }
  }
@@ -506,12 +593,15 @@ export class ImageStorage implements IDisposable {
  // TODO: Do we need some blob offloading tricks here to avoid early eviction?
  // also see https://stackoverflow.com/questions/28307789/is-there-any-limitation-on-javascript-max-blob-size
  private _evictOldest(room: number): number {
-    const used = this._getVRAMUsage();
+    const used = this._getStoredPixels();
    let current = used;
-    while (this._byteLimit < current + room && this._images.size) {
+    while (this._pixelLimit < current + room && this._images.size) {
      const spec = this._images.get(++this._lowestId);
-      if (spec) {
-        current -= spec.src.bytes;
+      if (spec && spec.orig) {
+        current -= spec.orig.width * spec.orig.height;
+        if (spec.actual && spec.orig !== spec.actual) {
+          current -= spec.actual.width * spec.actual.height;
+        }
        spec.marker?.dispose();
        this._delImg(this._lowestId);
      }
@@ -519,31 +609,31 @@ export class ImageStorage implements IDisposable {
    return used - current;
  }

-  private _writeToCell(line: IBufferLine, x: number, imageId: number, tileId: number): void {
-    const workCell = this._workCell;
-    line.loadCell(x, workCell);
-    if (this._workCell.hasExtendedAttrs()) {
-      const old = workCell.extended.payload;
-      if (old instanceof ImageTileInfo) {
-        // found an old ExtendedAttrsImage, since we know that
-        // they are always isolated instances (single cell usage),
-        // we can re-use it and just update their id entries
-        const oldSpec = this._images.get(old.imageId);
-        if (oldSpec) {
-          // early eviction for in-viewport overwrites
-          oldSpec.tileCount--;
+  private _writeToCell(line: IBufferLineExt, x: number, imageId: number, tileId: number): void {
+    if (line._data[x * Cell.SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) {
+      const old = line._extendedAttrs[x];
+      if (old) {
+        if (old.imageId !== undefined) {
+          // found an old ExtendedAttrsImage, since we know that
+          // they are always isolated instances (single cell usage),
+          // we can re-use it and just update their id entries
+          const oldSpec = this._images.get(old.imageId);
+          if (oldSpec) {
+            // early eviction for in-viewport overwrites
+            oldSpec.tileCount--;
+          }
+          old.imageId = imageId;
+          old.tileId = tileId;
+          return;
        }
-        old.imageId = imageId;
-        old.tileId = tileId;
+        // found a plain ExtendedAttrs instance, clone it to new entry
+        line._extendedAttrs[x] = new ExtendedAttrsImage(old.ext, old.urlId, imageId, tileId);
        return;
      }
    }
-    // fall-through: always create new ExtendedAttrs entry
-    const extattr = workCell.extended.clone();
-    extattr.payload = new ImageTileInfo(imageId, tileId);
-    workCell.extended = extattr;
-    workCell.updateExtended();
-    line.setCell(x, workCell);
+    // fall-through: always create new ExtendedAttrsImage entry
+    line._data[x * Cell.SIZE + Cell.BG] |= BgFlags.HAS_EXTENDED;
+    line._extendedAttrs[x] = new ExtendedAttrsImage(0, 0, imageId, tileId);
  }

  private _evictOnAlternate(): void {
@@ -556,16 +646,18 @@ export class ImageStorage implements IDisposable {
    // re-count tiles on whole buffer
    const buffer = this._terminal._core.buffer;
    for (let y = 0; y < this._terminal.rows; ++y) {
-      const line = buffer.lines.get(y);
+      const line = buffer.lines.get(y) as IBufferLineExt;
      if (!line) {
        continue;
      }
      for (let x = 0; x < this._terminal.cols; ++x) {
-        const payload = line.getExtended(x)?.payload;
-        if (payload instanceof ImageTileInfo) {
-          const spec = this._images.get(payload.imageId);
-          if (spec) {
-            spec.tileCount++;
+        if (line._data[x * Cell.SIZE + Cell.BG] & BgFlags.HAS_EXTENDED) {
+          const imgId = line._extendedAttrs[x]?.imageId;
+          if (imgId) {
+            const spec = this._images.get(imgId);
+            if (spec) {
+              spec.tileCount++;
+            }
          }
        }
      }
@@ -1,137 +0,0 @@
-/**
- * Copyright (c) 2023 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IMetrics } from './Types';
-
-
-
-export const UNSUPPORTED_TYPE: IMetrics = {
-  mime: 'unsupported',
-  width: 0,
-  height: 0
-};
-
-export function imageType(d: Uint8Array): IMetrics {
-  if (d.length < 32) {
-    return UNSUPPORTED_TYPE;
-  }
-  const d32 = new Uint32Array(d.buffer, d.byteOffset, 8);
-  // PNG: 89 50 4E 47 0D 0A 1A 0A (8 first bytes == magic number for PNG)
-  // + first chunk must be IHDR
-  if (d32[0] === 0x474E5089 && d32[1] === 0x0A1A0A0D && d32[3] === 0x52444849) {
-    return {
-      mime: 'image/png',
-      width:  d[16] << 24 | d[17] << 16 | d[18] << 8 | d[19],
-      height: d[20] << 24 | d[21] << 16 | d[22] << 8 | d[23]
-    };
-  }
-  // JPEG: FF D8 FF
-  if (d[0] === 0xFF && d[1] === 0xD8 && d[2] === 0xFF) {
-    const [width, height] = jpgSize(d);
-    return { mime: 'image/jpeg', width, height };
-  }
-  // GIF: GIF87a or GIF89a
-  if (d32[0] === 0x38464947 && (d[4] === 0x37 || d[4] === 0x39) && d[5] === 0x61) {
-    return {
-      mime: 'image/gif',
-      width:  d[7] << 8 | d[6],
-      height: d[9] << 8 | d[8]
-    };
-  }
-  // QOI: qoif
-  if (d32[0] === 0x66696F71) {
-    return {
-      mime: 'image/qoi',
-      width:  d[4] << 24 | d[5] << 16 | d[6] << 8 | d[7],
-      height: d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11]
-    };
-  }
-  // WEBP: RIFF | xxxx | WEBP | VP8x
-  if (d32[0] === 0x46464952 && d32[2] === 0x50424557 && (d32[3] & 0xFFFFFF) === 0x385056) {
-    switch (d[15]) {
-      case 0x58:  // Extended WebP VP8X --> "X"
-        return {
-          mime: 'image/webp',
-          width:  (d[24] | d[25] << 8 | d[26] << 16) + 1,
-          height: (d[27] | d[28] << 8 | d[29] << 16) + 1
-        };
-      case 0x4C:  // Lossless WebP VP8L --> "L"
-        if (d[20] !== 0x2f) return UNSUPPORTED_TYPE;
-        const dim = d[21] | d[22] << 8 | d[23] << 16 | d[24] << 24;
-        return {
-          mime: 'image/webp',
-          width:  (dim        & 0x3FFF) + 1,
-          height: (dim >>> 14 & 0x3FFF) + 1
-        };
-      case 0x20:  // Lossy WebP VP8  --> " "
-        if (d[23] !== 0x9d || d[24] !== 0x01 || d[25] !== 0x2a) return UNSUPPORTED_TYPE;
-        return {
-          mime: 'image/webp',
-          width:  (d[26] | d[27] << 8) & 0x3FFF,
-          height: (d[28] | d[29] << 8) & 0x3FFF
-        };
-    }
-    return UNSUPPORTED_TYPE;
-  }
-  // AVIF: Box size | ftyp | avif/avis
-  if (d32[1] === 0x70797466 && (d32[2] === 0x66697661 || d32[2] === 0x73697661)) {
-    let pos = -1;
-    // search for ispe box within first 1024 bytes
-    const limit = Math.min(d.length - 16, 1024);
-    for (let i = 8; i < limit; i++) {
-      // scan for ispe
-      if (d[i] === 0x69 && d[i + 1] === 0x73 && d[i + 2] === 0x70 && d[i + 3] === 0x65) {
-        pos = i;
-        break;
-      }
-    }
-    if (pos !== -1) {
-      // dimensions are in BE at +8 (width) at +12 (height)
-      const width =
-        d[pos +  8] << 24 |
-        d[pos +  9] << 16 |
-        d[pos + 10] <<  8 |
-        d[pos + 11];
-      const height =
-        d[pos + 12] << 24 |
-        d[pos + 13] << 16 |
-        d[pos + 14] <<  8 |
-        d[pos + 15];
-      if (width > 0 && height > 0) {
-        return { mime: 'image/avif', width, height };
-      }
-    }
-    return UNSUPPORTED_TYPE;
-  }
-  return UNSUPPORTED_TYPE;
-}
-
-
-function jpgSize(d: Uint8Array): [number, number] {
-  const len = d.length;
-  let i = 4;
-  let blockLength = d[i] << 8 | d[i + 1];
-  while (true) {
-    i += blockLength;
-    if (i >= len) {
-      // exhausted without size info
-      return [0, 0];
-    }
-    if (d[i] !== 0xFF) {
-      return [0, 0];
-    }
-    if (d[i + 1] === 0xC0 || d[i + 1] === 0xC2) {
-      if (i + 8 < len) {
-        return [
-          d[i + 7] << 8 | d[i + 8],
-          d[i + 5] << 8 | d[i + 6]
-        ];
-      }
-      return [0, 0];
-    }
-    i += 2;
-    blockLength = d[i] << 8 | d[i + 1];
-  }
-}
@@ -1,68 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { IDrawable } from './Types';
-
-export function createCanvas(
-  localDocument: Document | undefined,
-  width: number,
-  height: number,
-  cssWidth?: number,
-  cssHeight?: number
-): HTMLCanvasElement {
-  /**
-   * NOTE: We normally dont care, from which document the canvas
-   * gets created, so we can fall back to global document,
-   * if the terminal has no document associated yet.
-   * This way early image loads before calling .open keep working
-   * (still discouraged though, as the metrics will be screwed up).
-   * Only the DOM output canvas should be on the terminal's document,
-   * which gets explicitly checked in `insertLayerToDom`.
-   */
-  const canvas = (localDocument ?? document).createElement('canvas');
-  canvas.width = width | 0;
-  canvas.height = height | 0;
-  canvas.style.width = `${(cssWidth ?? width) | 0}px`;
-  canvas.style.height = `${(cssHeight ?? height) | 0}px`;
-  return canvas;
-}
-
-
-/**
- * Drawable is a resource the ImageRenderer knows to draw on the screen.
- */
-export class Drawable implements IDrawable {
-  public readonly width: number;
-  public readonly height: number;
-  // @readonly: only for memory tracking
-  public bytes: number;
-
-  constructor(public native: ImageBitmap | VideoFrame | HTMLCanvasElement) {
-    if (native instanceof VideoFrame) {
-      this.width = native.displayWidth;
-      this.height = native.displayHeight;
-      // NOTE: native.allocationSize() is too expensive
-      this.bytes = native.codedWidth * native.codedHeight * 4;
-    } else {
-      this.width = native.width;
-      this.height = native.height;
-      this.bytes = native.width * native.height * 4;
-    }
-  }
-
-  public close(): void {
-    if (this.bytes === 0) return;
-    this.bytes = 0;
-    try {
-      if (this.native instanceof HTMLCanvasElement) {
-        this.native.width = 0;
-        this.native.height = 0;
-      } else {
-        this.native.close?.();
-      }
-    } catch {}
-    this.native = null!;
-  }
-}
@@ -7,9 +7,9 @@ import { SixelImageStorage } from './SixelImageStorage';
 import { IDcsHandler, IParams, IImageAddonOptions, ITerminalExt, AttributeData, IResetHandler, ReadonlyColorSet } from './Types';
 import { toRGBA8888, BIG_ENDIAN, PALETTE_ANSI_256, PALETTE_VT340_COLOR } from 'sixel/lib/Colors';
 import { RGBA8888 } from 'sixel/lib/Types';
+import { ImageRenderer } from './ImageRenderer';

 import { DecoderAsync, Decoder } from 'sixel/lib/Decoder';
-import { createCanvas, Drawable } from './Primitives';

 // always free decoder ressources after decoding if it exceeds this limit
 const MEM_PERMA_LIMIT = 4194304; // 1024 pixels * 1024 pixels * 4 channels = 4MB
@@ -98,12 +98,12 @@ export class SixelHandler implements IDcsHandler, IResetHandler {
      return true;
    }

-    const canvas = createCanvas(undefined, width, height);
+    const canvas = ImageRenderer.createCanvas(undefined, width, height);
    canvas.getContext('2d')?.putImageData(new ImageData(this._dec.data8 as Uint8ClampedArray<ArrayBuffer>, width, height), 0, 0);
    if (this._dec.memoryUsage > MEM_PERMA_LIMIT) {
      this._dec.release();
    }
-    this._storage.addImage(new Drawable(canvas), undefined, { width, height, mime: 'image/sixel' });
+    this._storage.addImage(canvas);
    return true;
  }
 }
@@ -4,7 +4,7 @@
 */

 import { ImageStorage, CELL_SIZE_DEFAULT } from './ImageStorage';
-import { IImageAddonOptions, ITerminalExt, IAddImageOpts, IDrawable, IMetrics } from './Types';
+import { IImageAddonOptions, ITerminalExt, IAddImageOpts } from './Types';
 import { ImageRenderer } from './ImageRenderer';

 /**
@@ -27,9 +27,9 @@ export class SixelImageStorage {
   * Add a sixel image to storage.
   * Cursor behavior depends on the sixelScrolling option (DECSET 80).
   */
-  public addImage(src: IDrawable, data: Blob | undefined, metrics: IMetrics): void {
+  public addImage(img: HTMLCanvasElement | ImageBitmap): void {
    this._addImageOpts.scrolling = this._opts.sixelScrolling;
-    this._storage.addImage(src, data, metrics, this._addImageOpts);
+    this._storage.addImage(img, this._addImageOpts);
  }

  /**
@@ -39,7 +39,10 @@ export class SixelImageStorage {
   */
  public advanceCursor(height: number): void {
    if (this._opts.sixelScrolling) {
-      const cellSize = this._renderer.getCellSize() ?? CELL_SIZE_DEFAULT;
+      let cellSize = this._renderer.cellSize;
+      if (cellSize.width === -1 || cellSize.height === -1) {
+        cellSize = CELL_SIZE_DEFAULT;
+      }
      const rows = Math.ceil(height / cellSize.height);
      for (let i = 1; i < rows; ++i) {
        this._terminal._core._inputHandler.lineFeed();
@@ -10,6 +10,7 @@ import { Attributes, BgFlags, Content, ExtFlags, UnderlineStyle } from 'common/b
 import type { AttributeData } from 'common/buffer/AttributeData';
 import type { IParams, IDcsHandler, IOscHandler, IApcHandler, IEscapeSequenceParser } from 'common/parser/Types';
 import type { IInputHandler } from 'common/Types';
+import type { IBufferLine, IExtendedAttrs } from 'common/buffer/Types';
 import type { ITerminal, ReadonlyColorSet } from 'browser/Types';
 import type { IRenderDimensions } from 'browser/renderer/shared/Types';
 import type { ICoreBrowserService, IRenderService, IThemeService } from 'browser/services/Services';
@@ -47,7 +48,6 @@ export interface IResetHandler {
  reset(): void;
 }

-/* eslint-disable */
 /**
 * Stub into private interfaces.
 * This should be kept in line with common libs.
@@ -55,6 +55,19 @@ export interface IResetHandler {
 * have a somewhat reliable testing against code changes in the core repo.
 */

+// overloaded IExtendedAttrs to hold image refs
+export interface IExtendedAttrsImage extends IExtendedAttrs {
+  imageId: number;
+  tileId: number;
+  clone(): IExtendedAttrsImage;
+}
+
+/* eslint-disable */
+export interface IBufferLineExt extends IBufferLine {
+  _extendedAttrs: {[index: number]: IExtendedAttrsImage | undefined};
+  _data: Uint32Array;
+}
+
 interface IInputHandlerExt extends IInputHandler {
  _parser: IEscapeSequenceParser;
  _curAttrData: AttributeData;
@@ -65,7 +78,6 @@ interface IInputHandlerExt extends IInputHandler {
  };
  onRequestReset(handler: () => void): IDisposable;
 }
-/* eslint-enable */

 export interface ICoreTerminalExt extends ITerminal {
  _themeService: IThemeService | undefined;
@@ -77,6 +89,8 @@ export interface ICoreTerminalExt extends ITerminal {
 export interface ITerminalExt extends Terminal {
  _core: ICoreTerminalExt;
 }
+/* eslint-enable */
+

 /**
 * Some storage definitions.
@@ -94,70 +108,16 @@ export interface IAddImageOpts {
  layer: ImageLayer;
  zIndex: number;
  cursorPos: CursorPos;
-  prescaleX?: number;
-  prescaleY?: number;
-}
-
-export interface IDrawable {
-  native: ImageBitmap | VideoFrame | HTMLCanvasElement;
-  width: number;
-  height: number;
-  close(): void;
-  readonly bytes: number;
-}
-
-export type ImageType = 'unsupported'
-  | 'image/png'
-  | 'image/jpeg'
-  | 'image/gif'
-  | 'image/qoi'
-  | 'image/webp'
-  | 'image/avif'
-  // sixel
-  | 'image/sixel'
-  // rgb|a blobs for kitty
-  | 'image/rgb'
-  | 'image/rgba';
-
-export interface IMetrics {
-  mime: ImageType;
-  width: number;
-  height: number;
 }

 export interface IImageSpec {
-  /** entries for a later IImageSource type */
-  /** drawable for screen rendering */
-  src: IDrawable;
-  /** image bytes as blob */
-  data: Blob | undefined;
-  /** metrics about image like mime and dimensions */
-  metrics: IMetrics;
-
-  /** entries for a later IPlacement type */
-  /** cell size at time of insert */
-  cellSize: ICellSize;
-  /** eviction marker */
+  orig: HTMLCanvasElement | ImageBitmap | undefined;
+  origCellSize: ICellSize;
+  actual: HTMLCanvasElement | ImageBitmap | undefined;
+  actualCellSize: ICellSize;
  marker: IMarker | undefined;
-  /** used tiles as eviction hint */
  tileCount: number;
-  /** buffer it was placed on */
  bufferType: 'alternate' | 'normal';
-  /** layer it was placed on */
  layer: ImageLayer;
  zIndex: number;
-  /** scaling factor on source dimensions, default = 1.0 */
-  prescaleX: number;
-  prescaleY: number;
-  /** crop offset into source, default = 0 (currently unused) */
-  precropX: number;
-  precropY: number;
-  /** output scaling, default = 1.0 (currently unused) */
-  scaleX: number;
-  scaleY: number;
-  /** output offset, default = 0 (currently unused) */
-  offsetX: number;
-  offsetY: number;
-  /** compositing mode on output, default = 'alpha' (currently unused) */
-  blendMode: 'overwrite' | 'alpha';
 }
@@ -19,7 +19,6 @@ import {
  KittyPixelConstants,
  parseKittyCommand
 } from './KittyGraphicsTypes';
-import { createCanvas } from '../Primitives';

 const enum Constants {
  // Memory limit for base64 decoder (4MB, same as IIPHandler)
@@ -574,8 +573,8 @@ export class KittyGraphicsHandler implements IApcHandler, IResetHandler, IDispos
        bitmap = cropped;
      }

-      const cw = this._renderer.dimensions?.device.cell.width || CELL_SIZE_DEFAULT.width;
-      const ch = this._renderer.dimensions?.device.cell.height || CELL_SIZE_DEFAULT.height;
+      const cw = this._renderer.dimensions?.css.cell.width || CELL_SIZE_DEFAULT.width;
+      const ch = this._renderer.dimensions?.css.cell.height || CELL_SIZE_DEFAULT.height;

      // Per spec: c/r default to image's natural cell dimensions.
      // If only one of c/r is specified, compute the other from image aspect ratio.
@@ -637,7 +636,7 @@ export class KittyGraphicsHandler implements IApcHandler, IResetHandler, IDispos
        // the natural cell dimensions.
        const canvasW = (cmd.columns !== undefined) ? Math.round(imgCols * cw) : bitmap.width + xOffset;
        const canvasH = (cmd.rows !== undefined) ? Math.round(imgRows * ch) : bitmap.height + yOffset;
-        const offsetCanvas = createCanvas(window.document, canvasW, canvasH);
+        const offsetCanvas = ImageRenderer.createCanvas(window.document, canvasW, canvasH);
        const offsetCtx = offsetCanvas.getContext('2d');
        if (!offsetCtx) {
          throw new Error('Failed to create offset canvas context');
@@ -701,7 +700,7 @@ export class KittyGraphicsHandler implements IApcHandler, IResetHandler, IDispos
        return new Promise<ImageBitmap>((resolve, reject) => {
          img.addEventListener('load', () => {
            URL.revokeObjectURL(url);
-            const canvas = createCanvas(window.document, img.width, img.height);
+            const canvas = ImageRenderer.createCanvas(window.document, img.width, img.height);
            canvas.getContext('2d')?.drawImage(img, 0, 0);
            createImageBitmap(canvas).then(resolve).catch(reject);
          });
@@ -7,8 +7,6 @@ import { IDisposable } from '@xterm/xterm';
 import { ImageStorage } from '../ImageStorage';
 import { ImageLayer, IAddImageOpts } from '../Types';
 import { IKittyImageData } from './KittyGraphicsTypes';
-import { Drawable } from '../Primitives';
-import { UNSUPPORTED_TYPE } from '../Metrics';

 // Kitty-specific image storage controller.
 //
@@ -104,8 +102,7 @@ export class KittyImageStorage implements IDisposable {
    this._addImageOpts.scrolling = scrolling;
    this._addImageOpts.layer = layer;
    this._addImageOpts.zIndex = zIndex;
-    // FIXME: store image data in blob, fill metrics correctly
-    const storageId = this._storage.addImage(new Drawable(image), undefined, UNSUPPORTED_TYPE, this._addImageOpts);
+    const storageId = this._storage.addImage(image, this._addImageOpts);
    this._kittyIdToStorageId.set(kittyId, storageId);
    this._storageIdToKittyId.set(storageId, kittyId);
  }
@@ -294,10 +294,10 @@ test.describe('ImageAddon', () => {
    test('size params is optional/informative', async () => {
      // too small size param
      await ctx.proxy.write(`\x1b]1337;File=inline=1;size=5:${PALETTE_PNG_BASE64}\x07`);
-      deepStrictEqual(await getImageSize(1), [640, 80]);
+      deepStrictEqual(await getOrigSize(1), [640, 80]);
      // no size aparm at all
      await ctx.proxy.write(`\x1b[10H\x1b]1337;File=inline=1:${PALETTE_QOI_BASE64}\x07`);
-      deepStrictEqual(await getImageSize(2), [640, 80]);
+      deepStrictEqual(await getOrigSize(2), [640, 80]);
    });
    test.skip('FilePart support - bytewise', async () => {
      // opener
@@ -308,7 +308,7 @@ test.describe('ImageAddon', () => {
      }
      // finalizer
      await ctx.proxy.write(`\x1b]1337;FileEnd\x07`);
-      deepStrictEqual(await getImageSize(1), [640, 80]);
+      deepStrictEqual(await getOrigSize(1), [640, 80]);
    });
    test('FilePart support - chunks', async () => {
      // opener
@@ -319,7 +319,7 @@ test.describe('ImageAddon', () => {
      }
      // finalizer
      await ctx.proxy.write(`\x1b]1337;FileEnd\x07`);
-      deepStrictEqual(await getImageSize(1), [640, 80]);
+      deepStrictEqual(await getOrigSize(1), [640, 80]);
    });
    test('FilePart support - edgecases', async () => {
      // multiple opener do not harm
@@ -347,39 +347,39 @@ test.describe('ImageAddon', () => {
      // finalizer skipped
      // write spinfox.png
      await ctx.proxy.write(TESTDATA_IIP[1][0]);
-      deepStrictEqual(await getImageSize(1), TESTDATA_IIP[1][1]);
+      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[1][1]);
    });
  });

  test.describe('IIP support - testimages', () => {
    test('palette.png', async () => {
      await ctx.proxy.write(TESTDATA_IIP[0][0]);
-      deepStrictEqual(await getImageSize(1), TESTDATA_IIP[0][1]);
+      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[0][1]);
    });
    test('spinfox.png', async () => {
      await ctx.proxy.write(TESTDATA_IIP[1][0]);
-      deepStrictEqual(await getImageSize(1), TESTDATA_IIP[1][1]);
+      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[1][1]);
    });
    test('w3c gif', async () => {
      await ctx.proxy.write(TESTDATA_IIP[2][0]);
-      deepStrictEqual(await getImageSize(1), TESTDATA_IIP[2][1]);
+      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[2][1]);
    });
    test('w3c jpeg', async () => {
      await ctx.proxy.write(TESTDATA_IIP[3][0]);
-      deepStrictEqual(await getImageSize(1), TESTDATA_IIP[3][1]);
+      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[3][1]);
    });
    test('w3c png', async () => {
      await ctx.proxy.write(TESTDATA_IIP[4][0]);
-      deepStrictEqual(await getImageSize(1), TESTDATA_IIP[4][1]);
+      deepStrictEqual(await getOrigSize(1), TESTDATA_IIP[4][1]);
    });
  });

  test.describe('IIP - QOI support', () => {
    test('palette should yield same bytes from PNG and QOI', async () => {
      await ctx.proxy.write(`\x1b]1337;File=inline=1;size=525:${PALETTE_PNG_BASE64}\x07`);
-      deepStrictEqual(await getImageSize(1), [640, 80]);
+      deepStrictEqual(await getOrigSize(1), [640, 80]);
      await ctx.proxy.write(`\x1b[10H\x1b]1337;File=inline=1;size=${qoiData.length}:${PALETTE_QOI_BASE64}\x07`);
-      deepStrictEqual(await getImageSize(2), [640, 80]);
+      deepStrictEqual(await getOrigSize(2), [640, 80]);
      const pngScrape = await getImageAtBufferCell(0, 0);
      const qoiScrape = await getImageAtBufferCell(0, 11);
      deepStrictEqual(qoiScrape, pngScrape);
@@ -406,20 +406,20 @@ test.describe('ImageAddon', () => {
        const header = 'width=20;height=5;preserveAspectRatio=0';
        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
        const dim = await getDimensions();
-        deepStrictEqual(await getImageSize(1), [dim.cellWidth * 20, dim.cellHeight * 5]);
+        deepStrictEqual(await getOrigSize(1), [dim.cellWidth * 20, dim.cellHeight * 5]);
      });
      test(name + ': Npx --> width=320px height=160px preserveAspectRatio=0', async () => {
        // pixel based resize
        const header = 'width=320px;height=160px;preserveAspectRatio=0';
        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
-        deepStrictEqual(await getImageSize(1), [320, 160]);
+        deepStrictEqual(await getOrigSize(1), [320, 160]);
      });
      test(name + ': N% --> width=50% height=30% preserveAspectRatio=0', async () => {
        // % of viewport resize
        const header = 'width=50%;height=30%;preserveAspectRatio=0';
        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
        const dim = await getDimensions();
-        deepStrictEqual(await getImageSize(1), [Math.floor(dim.width * 0.5), Math.floor(dim.height * 0.3)]);
+        deepStrictEqual(await getOrigSize(1), [Math.floor(dim.width * 0.5), Math.floor(dim.height * 0.3)]);
      });
      test(name + ': ommitted dimension assumes preserveAspectRatio=1', async () => {
        // width provided in percent
@@ -427,23 +427,14 @@ test.describe('ImageAddon', () => {
        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header}:${payload}\x07`);
        const dim = await getDimensions();
        const width = Math.floor(dim.width * 0.5);
-        deepStrictEqual(await getImageSize(1), [width, Math.floor(width * 80 / 640)]);
+        deepStrictEqual(await getOrigSize(1), [width, Math.floor(width * 80 / 640)]);
        // height provided in pixel
        const header2 = 'height=200px';
        await ctx.proxy.write(`\x1b]1337;File=inline=1;size=${size};${header2}:${payload}\x07`);
-        deepStrictEqual(await getImageSize(2), [Math.floor(200 * 640 / 80), 200]);
+        deepStrictEqual(await getOrigSize(2), [Math.floor(200 * 640 / 80), 200]);
      });
    }
  });
-
-  test.describe('text overwrite removes tiles', () => {
-    test('sixel', async () => {
-      await assertTextClearsTiles(SIXEL_SEQ_0);
-    });
-    test('iip', async () => {
-      await assertTextClearsTiles(TESTDATA_IIP[0][0]);
-    });
-  });
 });

 /**
@@ -452,10 +443,10 @@ test.describe('ImageAddon', () => {
 async function getDimensions(): Promise<IDimensions> {
  const dimensions: any = await ctx.page.evaluate(`term.dimensions`);
  return {
-    cellWidth: Math.round(dimensions.device.cell.width),
-    cellHeight: Math.round(dimensions.device.cell.height),
-    width: Math.round(dimensions.device.canvas.width),
-    height: Math.round(dimensions.device.canvas.height)
+    cellWidth: Math.round(dimensions.css.cell.width),
+    cellHeight: Math.round(dimensions.css.cell.height),
+    width: Math.round(dimensions.css.canvas.width),
+    height: Math.round(dimensions.css.canvas.height)
  };
 }

@@ -471,30 +462,13 @@ async function getScrollbackPlusRows(): Promise<number> {
  return ctx.page.evaluate('window.term.options.scrollback + window.term.rows');
 }

-async function getImageSize(id: number): Promise<[number, number]> {
+async function getOrigSize(id: number): Promise<[number, number]> {
  return ctx.page.evaluate<any>(`[
-    window.imageAddon._storage._images.get(${id}).src.width * window.imageAddon._storage._images.get(${id}).prescaleX,
-    window.imageAddon._storage._images.get(${id}).src.height * window.imageAddon._storage._images.get(${id}).prescaleY
-  ]`).then(r => r.map(Math.floor));
+    window.imageAddon._storage._images.get(${id}).orig.width,
+    window.imageAddon._storage._images.get(${id}).orig.height
+  ]`);
 }

 async function getImageAtBufferCell(x: number, y: number): Promise<string | undefined> {
  return ctx.page.evaluate<any>(`window.imageAddon.getImageAtBufferCell(${x}, ${y})?.toDataURL('image/png')`);
 }
-
-async function hasTileAtBufferCell(x: number, y: number): Promise<boolean> {
-  return ctx.page.evaluate(`!!window.imageAddon.getImageAtBufferCell(${x}, ${y})`);
-}
-
-async function assertTextClearsTiles(imageSeq: string): Promise<void> {
-  await ctx.proxy.write('\x1b[H' + imageSeq);
-  await pollFor(ctx.page, '!!window.imageAddon.getImageAtBufferCell(5, 1)', true);
-  ok(await hasTileAtBufferCell(0, 1));
-  await ctx.proxy.write('\x1b[2;6H#######');
-  for (let x = 5; x < 12; x++) {
-    strictEqual(await hasTileAtBufferCell(x, 1), false);
-  }
-  ok(await hasTileAtBufferCell(0, 1));
-  ok(await hasTileAtBufferCell(13, 1));
-  ok(((await ctx.page.evaluate('window.term.buffer.active.getLine(1).translateToString(true)')) as string).includes('#######'));
-}
@@ -123,7 +123,7 @@ test.describe('Kitty Graphics Protocol', () => {
      await ctx.proxy.write(seq);
      await timeout(100);
      strictEqual(await getImageStorageLength(), 1);
-      deepStrictEqual(await getImageSize(1), [1, 1]);
+      deepStrictEqual(await getOrigSize(1), [1, 1]);
    });

    test('stores 3x1 RGB PNG with a=T', async () => {
@@ -131,7 +131,7 @@ test.describe('Kitty Graphics Protocol', () => {
      await ctx.proxy.write(seq);
      await timeout(100);
      strictEqual(await getImageStorageLength(), 1);
-      deepStrictEqual(await getImageSize(1), [3, 1]);
+      deepStrictEqual(await getOrigSize(1), [3, 1]);
    });

    test('transmit only (a=t) does not display but stores in handler', async () => {
@@ -1107,7 +1107,7 @@ test.describe('Kitty Graphics Protocol', () => {
      await timeout(200);

      strictEqual(await getImageStorageLength(), 1);
-      deepStrictEqual(await getImageSize(1), [20, 50]);
+      deepStrictEqual(await getOrigSize(1), [20, 50]);
      deepStrictEqual(await getPixel(0, 0, 0, 0), [255, 128, 0, 255]);
    });

@@ -1283,7 +1283,7 @@ test.describe('Kitty Graphics Protocol', () => {

      const cursor = await getCursor();
      const cellDims: number[] = await ctx.page.evaluate(() => {
-        const d = (window as any).term._core._renderService.dimensions.device.cell;
+        const d = (window as any).term._core._renderService.dimensions.css.cell;
        return [d.width, d.height];
      });
      const expectedR = Math.ceil((100 / 200) * 10 * cellDims[0] / cellDims[1]);
@@ -1301,7 +1301,7 @@ test.describe('Kitty Graphics Protocol', () => {

      const cursor = await getCursor();
      const cellDims: number[] = await ctx.page.evaluate(() => {
-        const d = (window as any).term._core._renderService.dimensions.device.cell;
+        const d = (window as any).term._core._renderService.dimensions.css.cell;
        return [d.width, d.height];
      });
      const expectedC = Math.ceil((200 / 100) * 5 * cellDims[1] / cellDims[0]);
@@ -1535,7 +1535,7 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=100;${KITTY_MULTICOLOR_200X100_BASE64}\x1b\\`);
        await timeout(200);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [200, 100]);
+        deepStrictEqual(await getOrigSize(1), [200, 100]);
      });

      test('transmit only (a=t) stores 200x100 image without display', async () => {
@@ -1564,7 +1564,7 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=100,i=500;${part2}\x1b\\`);
        await timeout(200);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [200, 100]);
+        deepStrictEqual(await getOrigSize(1), [200, 100]);
      });

      test('handles 3-chunk transmission', async () => {
@@ -1580,7 +1580,7 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=100,i=501;${p3}\x1b\\`);
        await timeout(200);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [200, 100]);
+        deepStrictEqual(await getOrigSize(1), [200, 100]);
      });

      test('verifies chunked data assembles correctly', async () => {
@@ -1713,7 +1713,7 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=100,x=20,y=0,w=20,h=50;${KITTY_MULTICOLOR_200X100_BASE64}\x1b\\`);
        await timeout(200);

-        deepStrictEqual(await getImageSize(1), [20, 50]);
+        deepStrictEqual(await getOrigSize(1), [20, 50]);
        deepStrictEqual(await getPixel(0, 0, 0, 0), [255, 128, 0, 255]);
        deepStrictEqual(await getPixel(0, 0, 19, 49), [255, 128, 0, 255]);
      });
@@ -1747,7 +1747,7 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=100,w=0;${KITTY_MULTICOLOR_200X100_BASE64}\x1b\\`);
        await timeout(200);

-        deepStrictEqual(await getImageSize(1), [200, 100]);
+        deepStrictEqual(await getOrigSize(1), [200, 100]);
        deepStrictEqual(await getPixel(0, 0, 0, 0), [255, 0, 0, 255]);
        deepStrictEqual(await getPixel(0, 0, 199, 99), [255, 255, 255, 255]);
      });
@@ -1756,7 +1756,7 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=100,h=0;${KITTY_MULTICOLOR_200X100_BASE64}\x1b\\`);
        await timeout(200);

-        deepStrictEqual(await getImageSize(1), [200, 100]);
+        deepStrictEqual(await getOrigSize(1), [200, 100]);
        deepStrictEqual(await getPixel(0, 0, 0, 0), [255, 0, 0, 255]);
        deepStrictEqual(await getPixel(0, 0, 0, 50), [255, 192, 203, 255]);
      });
@@ -1772,7 +1772,7 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=100,x=-10,y=-10;${KITTY_MULTICOLOR_200X100_BASE64}\x1b\\`);
        await timeout(200);

-        deepStrictEqual(await getImageSize(1), [200, 100]);
+        deepStrictEqual(await getOrigSize(1), [200, 100]);
        deepStrictEqual(await getPixel(0, 0, 0, 0), [255, 0, 0, 255]);
      });

@@ -1893,28 +1893,28 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=24,s=3,v=1;${RAW_RGB_3X1}\x1b\\`);
        await timeout(100);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [3, 1]);
+        deepStrictEqual(await getOrigSize(1), [3, 1]);
      });

      test('stores image with correct original dimensions (2x2)', async () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=24,s=2,v=2;${RAW_RGB_2X2}\x1b\\`);
        await timeout(100);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [2, 2]);
+        deepStrictEqual(await getOrigSize(1), [2, 2]);
      });

      test('stores image with correct original dimensions (5x1)', async () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=24,s=5,v=1;${RAW_RGB_5X1}\x1b\\`);
        await timeout(100);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [5, 1]);
+        deepStrictEqual(await getOrigSize(1), [5, 1]);
      });

      test('stores image with correct original dimensions (4x2)', async () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=24,s=4,v=2;${RAW_RGB_4X2}\x1b\\`);
        await timeout(100);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [4, 2]);
+        deepStrictEqual(await getOrigSize(1), [4, 2]);
      });
    });

@@ -2034,21 +2034,21 @@ test.describe('Kitty Graphics Protocol', () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=32,s=3,v=1;${RAW_RGBA_3X1}\x1b\\`);
        await timeout(100);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [3, 1]);
+        deepStrictEqual(await getOrigSize(1), [3, 1]);
      });

      test('stores image with correct original dimensions (2x2)', async () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=32,s=2,v=2;${RAW_RGBA_2X2}\x1b\\`);
        await timeout(100);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [2, 2]);
+        deepStrictEqual(await getOrigSize(1), [2, 2]);
      });

      test('stores image with correct original dimensions (5x1)', async () => {
        await ctx.proxy.write(`\x1b_Ga=T,f=32,s=5,v=1;${RAW_RGBA_5X1}\x1b\\`);
        await timeout(100);
        strictEqual(await getImageStorageLength(), 1);
-        deepStrictEqual(await getImageSize(1), [5, 1]);
+        deepStrictEqual(await getOrigSize(1), [5, 1]);
      });
    });

@@ -2213,21 +2213,6 @@ test.describe('Kitty Graphics Protocol', () => {
      await pollFor(ctx.page, 'window._imageAddedCount', 2);
    });
  });
-
-  test.describe('text overwrite removes tiles', () => {
-    test('a=T placement', async () => {
-      await ctx.proxy.write(`\x1b[H\x1b_Ga=T,f=100;${KITTY_MULTICOLOR_200X100_BASE64}\x1b\\`);
-      await pollFor(ctx.page, '!!window.imageAddon.getImageAtBufferCell(5, 1)', true);
-      ok(await hasTileAtBufferCell(0, 1));
-      await ctx.proxy.write('\x1b[2;6H#######');
-      for (let x = 5; x < 12; x++) {
-        strictEqual(await hasTileAtBufferCell(x, 1), false);
-      }
-      ok(await hasTileAtBufferCell(0, 1));
-      ok(await hasTileAtBufferCell(13, 1));
-      ok(((await ctx.page.evaluate('window.term.buffer.active.getLine(1).translateToString(true)')) as string).includes('#######'));
-    });
-  });
 });

 /**
@@ -2236,10 +2221,10 @@ test.describe('Kitty Graphics Protocol', () => {
 async function getDimensions(): Promise<IDimensions> {
  const dimensions: any = await ctx.page.evaluate(`term.dimensions`);
  return {
-    cellWidth: Math.round(dimensions.device.cell.width),
-    cellHeight: Math.round(dimensions.device.cell.height),
-    width: Math.round(dimensions.device.canvas.width),
-    height: Math.round(dimensions.device.canvas.height)
+    cellWidth: Math.round(dimensions.css.cell.width),
+    cellHeight: Math.round(dimensions.css.cell.height),
+    width: Math.round(dimensions.css.canvas.width),
+    height: Math.round(dimensions.css.canvas.height)
  };
 }

@@ -2251,10 +2236,10 @@ async function getImageStorageLength(): Promise<number> {
  return ctx.page.evaluate('window.imageAddon._storage._images.size');
 }

-async function getImageSize(id: number): Promise<[number, number]> {
+async function getOrigSize(id: number): Promise<[number, number]> {
  return ctx.page.evaluate<any>(`[
-    window.imageAddon._storage._images.get(${id}).src.width,
-    window.imageAddon._storage._images.get(${id}).src.height
+    window.imageAddon._storage._images.get(${id}).orig.width,
+    window.imageAddon._storage._images.get(${id}).orig.height
  ]`);
 }

@@ -2277,7 +2262,3 @@ async function getPixels(col: number, row: number, x: number, y: number, w: numb
    return Array.from(ctx2d.getImageData(x, y, w, h).data);
  }, [col, row, x, y, w, h]);
 }
-
-async function hasTileAtBufferCell(x: number, y: number): Promise<boolean> {
-  return ctx.page.evaluate(`!!window.imageAddon.getImageAtBufferCell(${x}, ${y})`);
-}
@@ -125,5 +125,10 @@ declare module '@xterm/addon-image' {
     * Get original image canvas at buffer position.
     */
    public getImageAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined;
+
+    /**
+     * Extract single tile canvas at buffer position.
+     */
+    public extractTileAtBufferCell(x: number, y: number): HTMLCanvasElement | undefined;
  }
 }
@@ -100,7 +100,7 @@ export class GlyphRenderer extends Disposable {
  private readonly _attributesBuffer: WebGLBuffer;

  private _atlas: ITextureAtlas | undefined;
-  private _lastSeenPageLayoutVersion: number = -1;
+  private _lastAtlasPagesVersion: number = -1;
  private _pageOverflowWarned: boolean = false;
  private _activeBuffer: number = 0;
  private readonly _vertices: IVertices = {
@@ -216,15 +216,17 @@ export class GlyphRenderer extends Disposable {
  }

  /**
-   * Call when a frame is being drawn. Returns whether the full model must be rebuilt before
-   * rendering this frame because the atlas page layout changed since this renderer last drew.
+   * Returns whether the full model must be rebuilt before rendering this frame.
+   * This is tracked per renderer (not on the shared atlas) so that every
+   * terminal sharing the atlas rebuilds its model after a page merge, not just
+   * the first one to render (vscode#322756).
   */
  public beginFrame(): boolean {
    if (!this._atlas) {
      return true;
    }
-    if (this._atlas.pageLayoutVersion !== this._lastSeenPageLayoutVersion) {
-      this._lastSeenPageLayoutVersion = this._atlas.pageLayoutVersion;
+    if (this._atlas.pagesVersion !== this._lastAtlasPagesVersion) {
+      this._lastAtlasPagesVersion = this._atlas.pagesVersion;
      return true;
    }
    return false;
@@ -375,8 +377,9 @@ export class GlyphRenderer extends Disposable {

    // Bind the atlas page texture if they have changed. AtlasPage.version is globally
    // monotonic, so a page object swap at the same index (which happens after a page merge)
-    // is detected by the same comparison.
-    // Clamp defensively in case the atlas unexpectedly exceeds texture capacity.
+    // is detected by the same comparison. The page count is clamped to the fixed texture
+    // array size so an atlas page overflow degrades (untextured glyphs) instead of throwing
+    // mid-frame; the atlas is responsible for never exceeding maxAtlasPages.
    const pageCount = Math.min(this._atlas.pages.length, this._atlasTextures.length);
    if (this._atlas.pages.length > this._atlasTextures.length && !this._pageOverflowWarned) {
      this._pageOverflowWarned = true;
@@ -394,7 +397,9 @@ export class GlyphRenderer extends Disposable {

  public setAtlas(atlas: ITextureAtlas): void {
    this._atlas = atlas;
-    this._lastSeenPageLayoutVersion = -1;
+    // Force a model rebuild on the next frame as glyph coordinates from a
+    // previous atlas are meaningless in the new one.
+    this._lastAtlasPagesVersion = -1;
    this.invalidateAtlasTextures();
  }

@@ -132,8 +132,16 @@ export class TextureAtlas implements ITextureAtlas {
    }
  }

-  private _pageLayoutVersion = 0;
-  public get pageLayoutVersion(): number { return this._pageLayoutVersion; }
+  /**
+   * Incremented whenever the structure of the pages array changes in a way that
+   * invalidates texture page indexes/coordinates cached outside the atlas (page
+   * merges, overflow page creation). Renderers compare this against their own
+   * last-seen value to decide when to rebuild their models; the atlas is shared
+   * across terminals, so a consume-once flag would only repair the first
+   * renderer to draw (see the shared-atlas garble in vscode#322756).
+   */
+  private _pagesVersion = 0;
+  public get pagesVersion(): number { return this._pagesVersion; }

  public clearTexture(): void {
    if (this._pages[0].currentRow.x === 0 && this._pages[0].currentRow.y === 0) {
@@ -145,11 +153,6 @@ export class TextureAtlas implements ITextureAtlas {
    this._cacheMap.clear();
    this._cacheMapCombined.clear();
    this._didWarmUp = false;
-
-    // Invalidate renderer models so all texture pages are refreshed. The atlas may be shared, in
-    // which case the clearing renderer has cleared only its own model and every other owner still
-    // holds texture coords into the rows just wiped.
-    this._pageLayoutVersion++;
  }

  private _createNewPage(): AtlasPage {
@@ -158,7 +161,7 @@ export class TextureAtlas implements ITextureAtlas {
    // animation frame which would result in blank rendered areas. This is actually not that
    // expensive relative to drawing the glyphs, so there is no need to wait for an idle callback.
    if (TextureAtlas.maxAtlasPages && this._pages.length >= Math.max(4, TextureAtlas.maxAtlasPages)) {
-      // Find the set of the largest 4 images, below the maximum size, with the highest
+      // Find the set of the largest images, below the maximum size, with the highest
      // percentages used
      const pagesBySize = this._pages.filter(e => {
        return e.canvas.width * 2 <= (TextureAtlas.maxTextureSize || Constants.FORCED_MAX_TEXTURE_SIZE);
@@ -168,50 +171,55 @@ export class TextureAtlas implements ITextureAtlas {
        }
        return b.percentageUsed - a.percentageUsed;
      });
-      let sameSizeI = -1;
-      let size = 0;
-      for (let i = 0; i < pagesBySize.length; i++) {
-        if (pagesBySize[i].canvas.width !== size) {
-          sameSizeI = i;
-          size = pagesBySize[i].canvas.width;
-        } else if (i - sameSizeI === 3) {
-          break;
+
+      // Find the largest group (up to 4) of same-sized pages, preferring larger page sizes. A
+      // group of 2 or 3 still reduces (or at worst maintains) the page count net of the new page
+      // pushed below; growing past the cap is never an option as GlyphRenderer's texture and
+      // shader sampler arrays are sized to exactly maxAtlasPages (exceeding them crashes render).
+      let bestGroupStart = -1;
+      let bestGroupSize = 0;
+      let groupStart = 0;
+      for (let i = 1; i <= pagesBySize.length; i++) {
+        if (i === pagesBySize.length || pagesBySize[i].canvas.width !== pagesBySize[groupStart].canvas.width) {
+          const groupSize = Math.min(4, i - groupStart);
+          if (groupSize > bestGroupSize) {
+            bestGroupSize = groupSize;
+            bestGroupStart = groupStart;
+            if (groupSize === 4) {
+              break;
+            }
+          }
+          groupStart = i;
        }
      }

-      // Gather details of the merge
-      const mergingPages = pagesBySize.slice(sameSizeI, sameSizeI + 4);
+      if (bestGroupSize >= 2) {
+        // Gather details of the merge
+        const mergingPages = pagesBySize.slice(bestGroupStart, bestGroupStart + bestGroupSize);
+        const sortedMergingPagesIndexes = mergingPages.map(e => this._pages.indexOf(e)).sort((a, b) => a - b);
+        const mergedPageIndex = this.pages.length - mergingPages.length;

-      // Only proceed with merge if we have exactly 4 same-sized pages. If not, we cannot
-      // effectively reduce page count and merging would cause issues.
-      if (mergingPages.length < 4 || mergingPages.some(p => p.canvas.width !== mergingPages[0].canvas.width)) {
-        // Evict instead of adding a page beyond the renderer's texture capacity.
+        // Merge into the new page
+        const mergedPage = this._mergePages(mergingPages, mergedPageIndex);
+        mergedPage.version = ++AtlasPage.nextVersion;
+
+        // Delete the pages, shifting glyph texture pages as needed
+        for (let i = sortedMergingPagesIndexes.length - 1; i >= 0; i--) {
+          this._deletePage(sortedMergingPagesIndexes[i]);
+        }
+
+        // Add the new merged page to the end
+        this.pages.push(mergedPage);
+
+        // Invalidate models so all texture pages are refreshed.
+        this._pagesVersion++;
+        this._onAddTextureAtlasCanvas.fire(mergedPage.canvas);
+      } else {
+        // No two same-sized pages below the maximum size exist, so merging cannot reduce the
+        // page count. Evict all pages rather than exceed the renderers' fixed texture/sampler
+        // capacity; glyphs re-rasterize on demand and models rebuild via pagesVersion.
        this._evictAllPages();
-        const newPage = new AtlasPage(this._document, this._textureSize);
-        this._pages.push(newPage);
-        this._activePages.push(newPage);
-        this._onAddTextureAtlasCanvas.fire(newPage.canvas);
-        return newPage;
      }
-
-      const sortedMergingPagesIndexes = mergingPages.map(e => e.glyphs[0].texturePage).sort((a, b) => a - b);
-      const mergedPageIndex = this.pages.length - mergingPages.length;
-
-      // Merge into the new page
-      const mergedPage = this._mergePages(mergingPages, mergedPageIndex);
-      mergedPage.version = ++AtlasPage.nextVersion;
-
-      // Delete the pages, shifting glyph texture pages as needed
-      for (let i = sortedMergingPagesIndexes.length - 1; i >= 0; i--) {
-        this._deletePage(sortedMergingPagesIndexes[i]);
-      }
-
-      // Add the new merged page to the end
-      this.pages.push(mergedPage);
-
-      // Invalidate renderer models so all texture pages are refreshed.
-      this._pageLayoutVersion++;
-      this._onAddTextureAtlasCanvas.fire(mergedPage.canvas);
    }

    // All new atlas pages are created small as they are highly dynamic
@@ -261,9 +269,14 @@ export class TextureAtlas implements ITextureAtlas {
    }
  }

+  /**
+   * Removes every page and clears the glyph caches. This is the last resort when the page cap is
+   * reached but no same-sized pages exist to merge: the page count must never exceed
+   * maxAtlasPages because renderers size their texture and shader sampler arrays to exactly
+   * that. Glyphs re-rasterize on demand and renderers rebuild their models via
+   * {@link pagesVersion}.
+   */
  private _evictAllPages(): void {
-    const startTime = performance.now();
-    const pageCount = this._pages.length;
    for (const page of this._pages) {
      this._onRemoveTextureAtlasCanvas.fire(page.canvas);
      page.canvas.remove();
@@ -274,8 +287,7 @@ export class TextureAtlas implements ITextureAtlas {
    this._cacheMap.clear();
    this._cacheMapCombined.clear();
    this._didWarmUp = false;
-    this._pageLayoutVersion++;
-    this._logService.debug(`Evicted ${pageCount} WebGL atlas pages in ${(performance.now() - startTime).toFixed(2)}ms`);
+    this._pagesVersion++;
  }

  public getRasterizedGlyphCombinedChar(chars: string, bg: number, fg: number, ext: number, restrictToCellHeight: boolean, domContainer: HTMLElement | undefined): IRasterizedGlyph {
@@ -835,15 +847,11 @@ export class TextureAtlas implements ITextureAtlas {
      // Create a new page for oversized glyphs as they come up
      if (rasterizedGlyph.size.x > this._textureSize) {
        if (!this._overflowSizePage) {
-          // Make room for the oversized page without exceeding texture capacity.
-          if (TextureAtlas.maxAtlasPages && this._pages.length >= TextureAtlas.maxAtlasPages) {
-            this._evictAllPages();
-          }
          this._overflowSizePage = new AtlasPage(this._document, this._config.deviceMaxTextureSize);
          this.pages.push(this._overflowSizePage);

-          // Invalidate renderer models so all texture pages are refreshed.
-          this._pageLayoutVersion++;
+          // Invalidate models so all texture pages are refreshed.
+          this._pagesVersion++;
          this._onAddTextureAtlasCanvas.fire(this._overflowSizePage.canvas);
        }
        activePage = this._overflowSizePage;
@@ -1123,7 +1131,7 @@ class AtlasPage {
          sourcePages[2]._usedPixels +
          sourcePages[3]._usedPixels;
      } else {
-        // fallback for non quadmerges (should never be used)
+        // 2- and 3-page merges, used when no 4-page same-size set exists at the page cap
        for (let i = 0; i < sourcePages.length; ++i) {
          this._glyphs = this._glyphs.concat(sourcePages[i].glyphs);
          this._usedPixels += sourcePages[i]._usedPixels;
@@ -68,12 +68,13 @@ export interface ITextureAtlas extends IDisposable {
  warmUp(): void;

  /**
-   * Incremented whenever cached glyph texture page mappings may be stale, such as after atlas page
-   * merges or overflow page creation. Renderers compare this against their own last-seen value and
-   * rebuild their model when it changes; a shared atlas can have many renderers, so this must not
-   * be a consume-once flag.
+   * Incremented whenever the pages array changes structurally (page merge,
+   * overflow page creation), invalidating any texture page indexes/coordinates
+   * cached by renderers. Tracked as a version rather than a consumable flag
+   * because the atlas may be shared by multiple renderers, each of which must
+   * notice the change independently.
   */
-  readonly pageLayoutVersion: number;
+  readonly pagesVersion: number;

  /**
   * Clear all glyphs from the texture atlas.
@@ -1,54 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { assert } from 'chai';
-import { createPatternCanvas } from './CustomGlyphRasterizer';
-
-describe('CustomGlyphRasterizer', () => {
-  describe('createPatternCanvas', () => {
-    it('prefers an offscreen canvas without using the DOM canvas factory', () => {
-      const expectedCanvas = {} as OffscreenCanvas;
-      const calls: string[] = [];
-
-      const canvas = createPatternCanvas(
-        2,
-        3,
-        (width, height) => {
-          calls.push(`offscreen:${width}x${height}`);
-          return expectedCanvas;
-        },
-        () => {
-          calls.push('dom');
-          return {} as HTMLCanvasElement;
-        }
-      );
-
-      assert.deepEqual({ canvas, calls }, {
-        canvas: expectedCanvas,
-        calls: ['offscreen:2x3']
-      });
-    });
-
-    it('uses the main-realm DOM canvas factory when OffscreenCanvas is unavailable', () => {
-      const expectedCanvas = {} as HTMLCanvasElement;
-      const calls: string[] = [];
-
-      const canvas = createPatternCanvas(
-        4,
-        5,
-        undefined,
-        (width, height) => {
-          calls.push(`dom:${width}x${height}`);
-          return expectedCanvas;
-        }
-      );
-
-      assert.deepEqual({ canvas, calls }, {
-        canvas: expectedCanvas,
-        calls: ['dom:4x5']
-      });
-    });
-  });
-});
@@ -8,29 +8,6 @@ import type { ILogService } from 'common/services/Services';
 import { customGlyphDefinitions } from './CustomGlyphDefinitions';
 import { CustomGlyphDefinitionType, CustomGlyphScaleType, CustomGlyphVectorType, type CustomGlyphDefinitionPart, type CustomGlyphPathDrawFunctionDefinition, type CustomGlyphPatternDefinition, type ICustomGlyphSolidOctantBlockVector, type ICustomGlyphVectorShape } from './Types';

-type PatternCanvas = HTMLCanvasElement | OffscreenCanvas;
-type PatternCanvasFactory = (width: number, height: number) => PatternCanvas;
-
-const createOffscreenPatternCanvas: PatternCanvasFactory | undefined = typeof OffscreenCanvas === 'undefined'
-  ? undefined
-  : (width, height) => new OffscreenCanvas(width, height);
-
-const createDomPatternCanvas: PatternCanvasFactory = (width, height) => {
-  const canvas = document.createElement('canvas');
-  canvas.width = width;
-  canvas.height = height;
-  return canvas;
-};
-
-export function createPatternCanvas(
-  width: number,
-  height: number,
-  offscreenCanvasFactory: PatternCanvasFactory | undefined = createOffscreenPatternCanvas,
-  domCanvasFactory: PatternCanvasFactory = createDomPatternCanvas
-): PatternCanvas {
-  return offscreenCanvasFactory?.(width, height) ?? domCanvasFactory(width, height);
-}
-
 /**
 * Try drawing a custom block element or box drawing character, returning whether it was
 * successfully drawn.
@@ -481,9 +458,9 @@ function drawPatternChar(
  if (!pattern) {
    const width = charDefinition[0].length;
    const height = charDefinition.length;
-    // The atlas canvas can be adopted into another document, so temporary resources must not use
-    // its mutable ownerDocument.
-    const tmpCanvas = createPatternCanvas(width, height);
+    const tmpCanvas = ctx.canvas.ownerDocument.createElement('canvas');
+    tmpCanvas.width = width;
+    tmpCanvas.height = height;
    const tmpCtx = throwIfFalsy(tmpCanvas.getContext('2d'));
    const imageData = new ImageData(width, height);

@@ -1,480 +1,103 @@
 /**
 * Copyright (c) 2025 The xterm.js authors. All rights reserved.
 * @license MIT
+ *
+ * Reproduces the single-terminal WebGL crash/garble when the texture atlas
+ * page count overflows TextureAtlas.maxAtlasPages (vscode#322756 class).
+ *
+ * GlyphRenderer sizes its GL texture array and fragment-shader sampler array
+ * to exactly maxAtlasPages at construction time, but TextureAtlas._createNewPage
+ * pushes past that cap whenever a 4-page same-size merge is impossible (e.g. a
+ * heterogeneous mix like 1024+512+512+512). The next GlyphRenderer.render then
+ * throws "Cannot read properties of undefined (reading 'version')" and cells
+ * reference sampler indexes the shader does not have, freezing/garbling the
+ * terminal. Long heavy-CLI sessions hit this in production; the test makes it
+ * fast by building the renderer with a small cap (the same code path as the
+ * production 8/16/32 values).
+ *
+ * Chromium only (additive scope; Firefox/WebKit WebGL broken in CI, xtermjs#5854).
 */
-
-import { IImage32, decodePng } from '@lunapaint/png-codec';
 import test, { expect } from '@playwright/test';
-import type { Terminal, ITerminalInitOnlyOptions, ITerminalOptions } from '@xterm/xterm';
-import type { IWebglAddonOptions, WebglAddon } from '@xterm/addon-webgl';
 import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
+import {
+  captureRowSignatures,
+  expectSignatureMatches,
+  loadWebglStrict,
+  resetMaxAtlasPages,
+  setMaxAtlasPages,
+  writeAndWaitForRender
+} from '../../../test/playwright/RendererTestUtils';
+import { generateUniqueGlyphFlood } from '../../../test/playwright/SyntheticTui';

-type CellSignature = number[];
-type TestTerminalConstructor = new (options?: ITerminalOptions & ITerminalInitOnlyOptions) => ITestTerminal;
-type TestWebglAddonConstructor = new (options?: IWebglAddonOptions) => ITestWebglAddon;
+const HEADER = ' OVERFLOW_REF_0123456789';
+const HEADER_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

-interface ITestTextureAtlasConstructor {
-  maxAtlasPages: number | undefined;
-  maxTextureSize: number | undefined;
-}
-
-interface ITestAtlasPage {
-  canvas: HTMLCanvasElement;
-}
-
-interface ITestTextureAtlas {
-  constructor: ITestTextureAtlasConstructor;
-  pages: ITestAtlasPage[];
-  pageLayoutVersion: number;
-  _overflowSizePage?: ITestAtlasPage;
-  _textureSize: number;
-}
-
-interface ITestGlyphRenderer {
-  _atlasTextures: unknown[];
-}
-
-interface ITestRenderer {
-  _charAtlas?: ITestTextureAtlas;
-  _glyphRenderer?: {
-    value?: ITestGlyphRenderer;
-  };
-  dimensions: {
-    device: {
-      cell: {
-        width: number;
-      };
-    };
-  };
-}
-
-interface ITestRenderService {
-  _renderer?: {
-    value?: ITestRenderer;
-  };
-}
-
-interface ITestTerminal extends Terminal {
-  _core?: {
-    _renderService?: ITestRenderService;
-  };
-}
-
-interface ITestWebglAddon extends WebglAddon {
-  _renderer?: ITestRenderer;
-}
-
-interface IAtlasEventStats {
-  removals: number;
-  maxPages: number;
-}
-
-interface ITestWindow extends Window {
-  Terminal: TestTerminalConstructor;
-  WebglAddon: TestWebglAddonConstructor;
-  term: ITestTerminal;
-  termB?: ITestTerminal;
-  addon?: ITestWebglAddon;
-  addonB?: ITestWebglAddon;
-  atlasEventStats?: IAtlasEventStats;
-}
-
-interface IAtlasLimits {
-  maxAtlasPages: number;
-  maxTextureSize: number;
-}
-
-interface IAtlasState {
-  pages: number;
-  atlasTextures: number;
-  pageLayoutVersion: number;
-  overflowPageCreated: boolean;
-  removals: number;
-  maxPages: number;
-}
-
-const NORMAL_HEADER = ' NORMAL_REF_0123456789';
-const POST_EVICTION_TEXT = ' AFTER_EVICTION_0123456789';
-const NORMAL_HEADER_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-const POST_EVICTION_COLS = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-const TERM_B_SELECTOR = '#terminal-container-b .xterm-screen';
-const TERM_SELECTOR = '#terminal-container .xterm-screen';
-
-async function loadWebglStrict(ctx: ITestContext): Promise<void> {
-  await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    w.addon = new w.WebglAddon({ preserveDrawingBuffer: true });
-    w.term.loadAddon(w.addon);
-  });
-  const isWebglRenderer = await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    return !!w.addon && w.term._core?._renderService?._renderer?.value === w.addon._renderer;
-  });
-  expect(isWebglRenderer, 'WebGL renderer must be active').toBe(true);
-}
-
-async function createTerminalB(ctx: ITestContext, cols: number): Promise<void> {
-  await ctx.page.evaluate(columnCount => {
-    const w = window as unknown as ITestWindow;
-    w.termB?.dispose();
-    document.getElementById('terminal-container-b')?.remove();
-    const element = document.createElement('div');
-    element.id = 'terminal-container-b';
-    document.body.appendChild(element);
-    w.termB = new w.Terminal({ cols: columnCount, rows: 24, allowProposedApi: true });
-    w.termB.open(element);
-    w.addonB = new w.WebglAddon({ preserveDrawingBuffer: true });
-    w.termB.loadAddon(w.addonB);
-  }, cols);
-}
-
-async function writeToBAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
-  await ctx.page.evaluate(value => new Promise<void>(resolve => {
-    const w = window as unknown as ITestWindow;
-    if (!w.termB) {
-      throw new Error('Terminal B must be created before writing to it');
-    }
-    const disposable = w.termB.onRender(() => {
-      disposable.dispose();
-      resolve();
-    });
-    w.termB.write(value);
-  }), data);
-}
-
-async function writeAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
-  const renderPromise = new Promise<void>(resolve => {
-    const disposable = ctx.proxy.onRender(() => {
-      disposable.dispose();
-      resolve();
-    });
-  });
-  await ctx.proxy.write(data);
-  await renderPromise;
-}
-
-async function refreshAndWaitForRender(ctx: ITestContext, terminal: 'term' | 'termB'): Promise<void> {
-  await ctx.page.evaluate(name => new Promise<void>(resolve => {
-    const w = window as unknown as ITestWindow;
-    const term = w[name];
-    if (!term) {
-      throw new Error(`${name} must exist before refreshing it`);
-    }
-    const disposable = term.onRender(() => {
-      disposable.dispose();
-      resolve();
-    });
-    term.refresh(0, term.rows - 1);
-  }), terminal);
-}
-
-async function configureAtlasLimits(ctx: ITestContext): Promise<IAtlasLimits> {
-  const limits = await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    const atlas = w.term._core?._renderService?._renderer?.value?._charAtlas;
-    if (!atlas || atlas.constructor.maxAtlasPages === undefined || atlas.constructor.maxTextureSize === undefined) {
-      return undefined;
-    }
-    const result = {
-      maxAtlasPages: atlas.constructor.maxAtlasPages,
-      maxTextureSize: atlas.constructor.maxTextureSize
-    };
-    atlas.constructor.maxAtlasPages = 4;
-    atlas.constructor.maxTextureSize = 512;
-    return result;
-  });
-  expect(limits, 'TextureAtlas limits must be initialized').toBeDefined();
-  return limits!;
-}
-
-async function restoreAtlasLimits(ctx: ITestContext, limits: IAtlasLimits | undefined): Promise<void> {
-  if (!limits) {
-    return;
-  }
-  await ctx.page.evaluate(original => {
-    const w = window as unknown as ITestWindow;
-    const atlas = w.term._core?._renderService?._renderer?.value?._charAtlas;
-    if (atlas) {
-      atlas.constructor.maxAtlasPages = original.maxAtlasPages;
-      atlas.constructor.maxTextureSize = original.maxTextureSize;
-    }
-  }, limits);
-}
-
-async function installAtlasEventStats(ctx: ITestContext): Promise<void> {
-  const installed = await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    const atlas = w.term._core?._renderService?._renderer?.value?._charAtlas;
-    if (!atlas || !w.addon) {
-      return false;
-    }
-    const stats: IAtlasEventStats = {
-      removals: 0,
-      maxPages: atlas.pages.length
-    };
-    w.atlasEventStats = stats;
-    w.addon.onAddTextureAtlasCanvas(() => {
-      stats.maxPages = Math.max(stats.maxPages, atlas.pages.length);
-    });
-    w.addon.onRemoveTextureAtlasCanvas(() => stats.removals++);
-    return true;
-  });
-  expect(installed, 'atlas event tracking must be installed').toBe(true);
-}
-
-async function getAtlasState(ctx: ITestContext): Promise<IAtlasState> {
-  const state = await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    const renderer = w.term._core?._renderService?._renderer?.value;
-    const atlas = renderer?._charAtlas;
-    const glyphRenderer = renderer?._glyphRenderer?.value;
-    const stats = w.atlasEventStats;
-    if (!atlas || !glyphRenderer || !stats) {
-      return undefined;
-    }
-    return {
-      pages: atlas.pages.length,
-      atlasTextures: glyphRenderer._atlasTextures.length,
-      pageLayoutVersion: atlas.pageLayoutVersion,
-      overflowPageCreated: !!atlas._overflowSizePage,
-      removals: stats.removals,
-      maxPages: stats.maxPages
-    };
-  });
-  expect(state, 'atlas state must be available').toBeDefined();
-  return state!;
-}
-
-function generateUniqueGlyphFlood(count: number, cols: number, offset: number): string {
-  const base = 0x4E00;
-  const range = 0x9FFF - base;
-  const perRow = Math.max(1, Math.floor(cols / 2));
-  let result = '';
-  for (let i = 0; i < count; i++) {
-    result += String.fromCodePoint(base + ((offset + i) % range));
-    if ((i + 1) % perRow === 0 && i + 1 < count) {
-      result += '\r\n';
-    }
-  }
-  return result;
-}
-
-async function captureRowSignatures(ctx: ITestContext, selector: string, cols: number, row: number, sampleCols: number[], debugName: string): Promise<CellSignature[]> {
-  const screenshotOptions = process.env.DEBUG ? { path: `out-esbuild-test/playwright/${debugName}.png` } : undefined;
-  const buffer = await ctx.page.locator(selector).screenshot(screenshotOptions);
-  const frame = {
-    cols,
-    rows: 24,
-    decoded: (await decodePng(new Uint8Array(buffer), { force32: true })).image
-  };
-  return sampleCols.map(col => cellSignature(frame, col, row));
-}
-
-function cellSignature(frame: { cols: number, rows: number, decoded: IImage32 }, col: number, row: number): CellSignature {
-  const grid = 4;
-  const data = frame.decoded.data;
-  const imageWidth = frame.decoded.width;
-  const cellWidth = frame.decoded.width / frame.cols;
-  const cellHeight = frame.decoded.height / frame.rows;
-  const x0 = (col - 1) * cellWidth;
-  const y0 = (row - 1) * cellHeight;
-  const sums = new Array<number>(grid * grid * 4).fill(0);
-  const counts = new Array<number>(grid * grid).fill(0);
-  const startX = Math.max(0, Math.floor(x0));
-  const startY = Math.max(0, Math.floor(y0));
-  const endX = Math.min(frame.decoded.width, Math.ceil(x0 + cellWidth));
-  const endY = Math.min(frame.decoded.height, Math.ceil(y0 + cellHeight));
-
-  for (let y = startY; y < endY; y++) {
-    const gy = Math.min(grid - 1, Math.max(0, Math.floor(((y - y0) / cellHeight) * grid)));
-    for (let x = startX; x < endX; x++) {
-      const gx = Math.min(grid - 1, Math.max(0, Math.floor(((x - x0) / cellWidth) * grid)));
-      const sub = gy * grid + gx;
-      const i = (y * imageWidth + x) * 4;
-      sums[sub * 4] += data[i];
-      sums[sub * 4 + 1] += data[i + 1];
-      sums[sub * 4 + 2] += data[i + 2];
-      sums[sub * 4 + 3] += data[i + 3];
-      counts[sub]++;
-    }
-  }
-
-  const signature = new Array<number>(grid * grid * 4).fill(0);
-  for (let sub = 0; sub < counts.length; sub++) {
-    if (counts[sub] > 0) {
-      signature[sub * 4] = sums[sub * 4] / counts[sub];
-      signature[sub * 4 + 1] = sums[sub * 4 + 1] / counts[sub];
-      signature[sub * 4 + 2] = sums[sub * 4 + 2] / counts[sub];
-      signature[sub * 4 + 3] = sums[sub * 4 + 3] / counts[sub];
-    }
-  }
-  return signature;
-}
-
-function signatureDiff(actual: CellSignature, reference: CellSignature): number {
-  let diff = 0;
-  for (let i = 0; i < actual.length; i++) {
-    diff = Math.max(diff, Math.abs(actual[i] - reference[i]));
-  }
-  return diff;
-}
-
-function expectSignatureMatches(actual: CellSignature, reference: CellSignature, message: string): void {
-  const diff = signatureDiff(actual, reference);
-  expect(diff, `${message}; max channel diff ${diff}`).toBeLessThanOrEqual(14);
-}
-
-test.describe('atlas page overflow (#6038)', () => {
+test.describe('atlas page overflow (#322756 class)', () => {
  test.skip(({ browserName }) => browserName !== 'chromium');
-  test.describe.configure({ timeout: 90000 });
+  test.describe.configure({ timeout: 60000 });

-  test('evicts normal pages when the page cap cannot be reduced by merging', async ({ browser }) => {
-    const ctx = await createTestContext(browser);
+  test('renderer survives the atlas exceeding maxAtlasPages-sized textures', async ({ browser }) => {
+    const ctx: ITestContext = await createTestContext(browser);
    const errors: string[] = [];
-    const onError = (error: Error): void => { errors.push(error.message); };
-    let limits: IAtlasLimits | undefined;
+    const onError = (e: Error): void => { errors.push(e.message); };
    ctx.page.on('pageerror', onError);
    try {
+      // Bootstrap: create a throwaway WebGL terminal so the TextureAtlas class
+      // statics exist, then lower the page cap. openTerminal() disposes the old
+      // terminal (and its atlas), so the next WebGL renderer is CONSTRUCTED
+      // with the small cap: its GL texture array and fragment-shader sampler
+      // array have exactly 4 entries, faithfully mirroring production where
+      // they always equal maxAtlasPages.
      await openTerminal(ctx, { cols: 80, rows: 24 });
      await loadWebglStrict(ctx);
-      limits = await configureAtlasLimits(ctx);
-
+      await setMaxAtlasPages(ctx, 4);
      await openTerminal(ctx, { cols: 80, rows: 24 });
      await loadWebglStrict(ctx);
-      await createTerminalB(ctx, 80);
-      await installAtlasEventStats(ctx);

-      const atlasShared = await ctx.page.evaluate(() => {
-        const w = window as unknown as ITestWindow;
-        return w.term._core?._renderService?._renderer?.value?._charAtlas === w.termB?._core?._renderService?._renderer?.value?._charAtlas;
-      });
-      expect(atlasShared, 'terminals with equal configs should share one texture atlas').toBe(true);
+      const atlasTexturesLength = await ctx.page.evaluate(() =>
+        (window as any).term._core._renderService._renderer.value._glyphRenderer.value._atlasTextures.length);
+      expect(atlasTexturesLength, 'renderer must be built with the lowered page cap').toBe(4);

-      await writeToBAndWaitForRender(ctx, `\x1b[H${NORMAL_HEADER}\x1b[2;1H${POST_EVICTION_TEXT}`);
-      const headerReference = await captureRowSignatures(ctx, TERM_B_SELECTOR, 80, 1, NORMAL_HEADER_COLS, 'atlas-overflow-header-reference');
-      const postReference = await captureRowSignatures(ctx, TERM_B_SELECTOR, 80, 2, POST_EVICTION_COLS, 'atlas-overflow-post-reference');
-      await writeToBAndWaitForRender(ctx, '\x1b[2;1H\x1b[2K');
+      // Pinned header in the alt buffer; body churns distinct CJK glyphs below
+      // (cursor-positioned, no trailing linefeed on the bottom row -> no scroll).
+      await writeAndWaitForRender(ctx, `\x1b[?1049h\x1b[H${HEADER}`);
+      const reference = await captureRowSignatures(ctx, 1, HEADER_COLS);
+      await ctx.page.locator('#terminal-container .xterm-screen').screenshot({ path: 'out-esbuild-test/playwright/overflow-before.png' });

-      const initialState = await getAtlasState(ctx);
      const glyphsPerChunk = 23 * 40 - 1;
-      for (let chunk = 0; chunk < 24; chunk++) {
-        await ctx.proxy.write('\x1b[H\x1b[2J' + generateUniqueGlyphFlood(glyphsPerChunk, 80, chunk * glyphsPerChunk));
+      for (let c = 0; c < 16; c++) {
+        // Plain write + short wait instead of waiting for a render event: once
+        // the overflow crash fires, render events stop arriving and a render
+        // wait would hang the test instead of failing it.
+        await ctx.proxy.write('\x1b[2;1H' + generateUniqueGlyphFlood(glyphsPerChunk, 80, c * glyphsPerChunk));
        await ctx.page.waitForTimeout(50);
-        const state = await getAtlasState(ctx);
-        if (state.removals > 0 || state.pages > state.atlasTextures || errors.length > 0) {
-          break;
-        }
      }
+      await ctx.page.waitForTimeout(300);
+      await ctx.page.locator('#terminal-container .xterm-screen').screenshot({ path: 'out-esbuild-test/playwright/overflow-after.png' });

-      const evictionState = await getAtlasState(ctx);
-      expect(evictionState.removals, 'normal atlas pages must be evicted at the page cap').toBeGreaterThan(0);
-      expect(evictionState.pageLayoutVersion, 'eviction must invalidate renderer models').toBeGreaterThan(initialState.pageLayoutVersion);
-      expect(evictionState.maxPages, 'atlas pages must stay within renderer texture capacity').toBeLessThanOrEqual(evictionState.atlasTextures);
-      expect(errors, `renderer must not throw during atlas eviction: ${errors[0] ?? ''}`).toEqual([]);
-
-      await writeToBAndWaitForRender(ctx, `\x1b[2;1H${POST_EVICTION_TEXT}`);
-      const termBHeader = await ctx.page.evaluate(() => {
-        const w = window as unknown as ITestWindow;
-        return w.termB?.buffer.active.getLine(0)?.translateToString(true);
+      const state = await ctx.page.evaluate(() => {
+        const renderer = (window as any).term._core._renderService._renderer.value;
+        return {
+          pages: renderer._charAtlas.pages.length,
+          atlasTextures: renderer._glyphRenderer.value._atlasTextures.length
+        };
      });
-      expect(termBHeader, 'terminal B buffer must still contain the header').toBe(NORMAL_HEADER);
+      console.error('[overflow] pages=', state.pages, 'atlasTextures=', state.atlasTextures, 'pageErrors=', errors.length, errors[0] ?? '');

-      const headerAfter = await captureRowSignatures(ctx, TERM_B_SELECTOR, 80, 1, NORMAL_HEADER_COLS, 'atlas-overflow-header-after');
-      const postAfter = await captureRowSignatures(ctx, TERM_B_SELECTOR, 80, 2, POST_EVICTION_COLS, 'atlas-overflow-post-after');
-      for (let i = 0; i < NORMAL_HEADER_COLS.length; i++) {
-        expectSignatureMatches(headerAfter[i], headerReference[i], `existing header col ${NORMAL_HEADER_COLS[i]} changed after eviction`);
-      }
-      for (let i = 0; i < POST_EVICTION_COLS.length; i++) {
-        expectSignatureMatches(postAfter[i], postReference[i], `new text col ${POST_EVICTION_COLS[i]} changed after eviction`);
-      }
+      // Contract: the page count must never exceed the renderer's texture and
+      // sampler capacity, and rendering must never throw.
+      expect(errors, `GlyphRenderer must not crash when the atlas is saturated: ${errors[0] ?? ''}`).toEqual([]);
+      expect(state.pages, 'atlas page count must stay within the renderer texture capacity').toBeLessThanOrEqual(state.atlasTextures);

-      const stableState = await getAtlasState(ctx);
-      await refreshAndWaitForRender(ctx, 'termB');
-      const refreshedState = await getAtlasState(ctx);
-      expect(refreshedState.pageLayoutVersion, 'an unchanged full refresh must not evict again').toBe(stableState.pageLayoutVersion);
-      expect(refreshedState.removals, 'an unchanged full refresh must not remove more pages').toBe(stableState.removals);
-    } finally {
-      ctx.page.off('pageerror', onError);
-      await restoreAtlasLimits(ctx, limits).catch(() => {});
-      await ctx.page.close();
-    }
-  });
-
-  test('evicts before adding an oversized glyph page at the page cap', async ({ browser }) => {
-    const ctx = await createTestContext(browser);
-    const errors: string[] = [];
-    const onError = (error: Error): void => { errors.push(error.message); };
-    let limits: IAtlasLimits | undefined;
-    ctx.page.on('pageerror', onError);
-    try {
-      await openTerminal(ctx, { cols: 160, rows: 24 });
-      await loadWebglStrict(ctx);
-      limits = await configureAtlasLimits(ctx);
-
-      await openTerminal(ctx, { cols: 160, rows: 24 });
-      await loadWebglStrict(ctx);
-      await installAtlasEventStats(ctx);
-
-      let state = await getAtlasState(ctx);
-      let offset = 0;
-      for (let chunk = 0; chunk < 120 && state.pages < state.atlasTextures; chunk++) {
-        const glyphCount = state.pages < state.atlasTextures - 1 ? 200 : 25;
-        await ctx.proxy.write('\x1b[H\x1b[2J' + generateUniqueGlyphFlood(glyphCount, 160, offset));
-        await ctx.page.waitForTimeout(50);
-        offset += glyphCount;
-        state = await getAtlasState(ctx);
-      }
-      expect(state.pages, 'normal atlas pages must reach the texture capacity before the oversized glyph').toBe(state.atlasTextures);
-      expect(state.overflowPageCreated, 'normal glyph filling must not create the oversized page').toBe(false);
-      expect(errors, `renderer must not fail while filling normal pages: ${errors[0] ?? ''}`).toEqual([]);
-
-      await writeAndWaitForRender(ctx, '\x1b[H\x1b[2K\x1b[24;1H');
-      const sampleCols = [1, 8, 16, 24, 32];
-      const blankSignatures = await captureRowSignatures(ctx, TERM_SELECTOR, 160, 1, sampleCols, 'atlas-overflow-wide-blank');
-      const joinedLength = await ctx.page.evaluate(() => {
-        const w = window as unknown as ITestWindow;
-        const renderer = w.term._core?._renderService?._renderer?.value;
-        const atlas = renderer?._charAtlas;
-        if (!renderer || !atlas) {
-          throw new Error('renderer and atlas must exist');
-        }
-        const cellWidth = renderer.dimensions.device.cell.width;
-        const length = Math.min(w.term.cols - 1, Math.ceil(atlas._textureSize / cellWidth) + 32);
-        if (length * cellWidth <= atlas._textureSize) {
-          throw new Error('joined glyph must be wider than a normal atlas page');
-        }
-        const marker = 'W'.repeat(length);
-        w.term.registerCharacterJoiner(text => text.startsWith(marker) ? [[0, length]] : []);
-        return length;
-      });
-
-      const beforeOversized = await getAtlasState(ctx);
-      await ctx.proxy.write(`\x1b[H${'W'.repeat(joinedLength)}`);
-      await ctx.page.waitForTimeout(50);
-      const oversizedState = await getAtlasState(ctx);
-      expect(oversizedState.overflowPageCreated, 'the joined glyph must use the oversized atlas page').toBe(true);
-      expect(oversizedState.removals, 'normal pages must be evicted before adding the oversized page').toBeGreaterThan(beforeOversized.removals);
-      expect(oversizedState.maxPages, 'oversized page creation must stay within renderer texture capacity').toBeLessThanOrEqual(oversizedState.atlasTextures);
-      expect(oversizedState.pageLayoutVersion, 'oversized eviction must invalidate renderer models').toBeGreaterThan(beforeOversized.pageLayoutVersion);
-      expect(errors, `renderer must not throw while adding the oversized page: ${errors[0] ?? ''}`).toEqual([]);
-
-      const wideSignatures = await captureRowSignatures(ctx, TERM_SELECTOR, 160, 1, sampleCols, 'atlas-overflow-wide-after');
-      for (let i = 0; i < sampleCols.length; i++) {
-        expect(signatureDiff(wideSignatures[i], blankSignatures[i]), `wide glyph col ${sampleCols[i]} must render visible pixels`).toBeGreaterThan(14);
-      }
-
-      const stableState = await getAtlasState(ctx);
-      await refreshAndWaitForRender(ctx, 'term');
-      const refreshedState = await getAtlasState(ctx);
-      expect(refreshedState.pageLayoutVersion, 'oversized glyph refresh must settle without another eviction').toBe(stableState.pageLayoutVersion);
-      expect(refreshedState.removals, 'oversized glyph refresh must not remove more pages').toBe(stableState.removals);
-      const wideAfterRefresh = await captureRowSignatures(ctx, TERM_SELECTOR, 160, 1, sampleCols, 'atlas-overflow-wide-refreshed');
-      for (let i = 0; i < sampleCols.length; i++) {
-        expectSignatureMatches(wideAfterRefresh[i], wideSignatures[i], `wide glyph col ${sampleCols[i]} changed after refresh`);
+      // The untouched header must still render correctly after the churn.
+      const after = await captureRowSignatures(ctx, 1, HEADER_COLS);
+      for (let i = 0; i < HEADER_COLS.length; i++) {
+        expectSignatureMatches(after[i], reference[i], 14, `header col ${HEADER_COLS[i]} corrupted after atlas saturation`);
      }
    } finally {
      ctx.page.off('pageerror', onError);
-      await restoreAtlasLimits(ctx, limits).catch(() => {});
+      // Restore the default so a lowered cap can never leak into other tests.
+      await resetMaxAtlasPages(ctx).catch(() => { /* page may already be unusable after a crash */ });
      await ctx.page.close();
    }
  });
@@ -1,288 +0,0 @@
-/**
- * Copyright (c) 2025 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import { decodePng, type IImage32 } from '@lunapaint/png-codec';
-import test, { expect } from '@playwright/test';
-import type { Terminal, ITerminalInitOnlyOptions, ITerminalOptions } from '@xterm/xterm';
-import type { IWebglAddonOptions, WebglAddon } from '@xterm/addon-webgl';
-import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
-
-type CellSignature = number[];
-type TestTerminalConstructor = new (options?: ITerminalOptions & ITerminalInitOnlyOptions) => ITestTerminal;
-type TestWebglAddonConstructor = new (options?: IWebglAddonOptions) => ITestWebglAddon;
-
-interface ITestTextureAtlas {
-  readonly pages: ReadonlyArray<{ readonly canvas: HTMLCanvasElement }>;
-}
-
-interface ITestGlyphRenderer {
-  readonly _atlasTextures: ReadonlyArray<unknown>;
-}
-
-interface ITestRenderer {
-  _charAtlas?: ITestTextureAtlas;
-  _glyphRenderer?: {
-    value?: ITestGlyphRenderer;
-  };
-}
-
-interface ITestRenderService {
-  _renderer?: {
-    value?: ITestRenderer;
-  };
-}
-
-interface ITestTerminal extends Terminal {
-  _core?: {
-    _renderService?: ITestRenderService;
-  };
-}
-
-interface ITestWebglAddon extends WebglAddon {
-  _renderer?: ITestRenderer;
-}
-
-interface IAtlasEventStats {
-  additions: number;
-  maxPages: number;
-}
-
-interface ITestWindow {
-  WebglAddon: TestWebglAddonConstructor;
-  term: ITestTerminal;
-  addon?: ITestWebglAddon;
-  atlasEventStats?: IAtlasEventStats;
-}
-
-interface IAtlasState {
-  additions: number;
-  atlasTextures: number;
-  maxPages: number;
-}
-
-const REFERENCE_LINE = 'Ref0123456789ABCDEF';
-const REFERENCE_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19];
-const TERM_SELECTOR = '#terminal-container .xterm-screen';
-
-async function loadWebglStrict(ctx: ITestContext): Promise<void> {
-  await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    w.addon = new w.WebglAddon({ preserveDrawingBuffer: true });
-    w.term.loadAddon(w.addon);
-  });
-  const isWebglRenderer = await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    return !!w.addon && w.term._core?._renderService?._renderer?.value === w.addon._renderer;
-  });
-  expect(isWebglRenderer, 'WebGL renderer must be active').toBe(true);
-}
-
-async function installAtlasEventStats(ctx: ITestContext): Promise<void> {
-  const installed = await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    const atlas = w.term._core?._renderService?._renderer?.value?._charAtlas;
-    if (!atlas || !w.addon) {
-      return false;
-    }
-    const stats: IAtlasEventStats = {
-      additions: 0,
-      maxPages: atlas.pages.length
-    };
-    w.atlasEventStats = stats;
-    w.addon.onAddTextureAtlasCanvas(() => {
-      stats.additions++;
-      stats.maxPages = Math.max(stats.maxPages, atlas.pages.length);
-    });
-    return true;
-  });
-  expect(installed, 'atlas event tracking must be installed').toBe(true);
-}
-
-async function getAtlasState(ctx: ITestContext): Promise<IAtlasState> {
-  const state = await ctx.page.evaluate(() => {
-    const w = window as unknown as ITestWindow;
-    const renderer = w.term._core?._renderService?._renderer?.value;
-    const glyphRenderer = renderer?._glyphRenderer?.value;
-    const stats = w.atlasEventStats;
-    if (!glyphRenderer || !stats) {
-      return undefined;
-    }
-    return {
-      additions: stats.additions,
-      atlasTextures: glyphRenderer._atlasTextures.length,
-      maxPages: stats.maxPages
-    };
-  });
-  expect(state, 'atlas state must be available').toBeDefined();
-  return state!;
-}
-
-async function writeAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
-  const renderPromise = new Promise<void>(resolve => {
-    const disposable = ctx.proxy.onRender(() => {
-      disposable.dispose();
-      resolve();
-    });
-  });
-  await ctx.proxy.write(data);
-  await renderPromise;
-}
-
-async function refreshAndWaitForRender(ctx: ITestContext): Promise<void> {
-  const renderPromise = new Promise<void>(resolve => {
-    const disposable = ctx.proxy.onRender(() => {
-      disposable.dispose();
-      resolve();
-    });
-  });
-  await ctx.proxy.refresh(0, (await ctx.proxy.rows) - 1);
-  await renderPromise;
-}
-
-function generateSyntheticTuiFrames(frameCount: number, cols: number, rows: number): string[] {
-  const spinner = ['|', '/', '-', '\\'];
-  const words = ['reading', 'rendering', 'atlas', 'terminal', 'buffer', 'tokens', 'diff', 'patch'];
-  const frames: string[] = [];
-  for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {
-    const lines = [
-      `+${'-'.repeat(cols - 2)}+`,
-      `|${(` ${spinner[frameIndex % spinner.length]} Copilot is working`).padEnd(cols - 2).slice(0, cols - 2)}|`,
-      `+${'-'.repeat(cols - 2)}+`
-    ];
-    for (let row = 3; row < rows - 1; row++) {
-      const foreground = 31 + ((frameIndex + row) % 6);
-      const text = `${words[(frameIndex + row) % words.length]} ${frameIndex}:${row}`;
-      lines.push(`\x1b[${foreground}m${text}\x1b[0m`);
-    }
-    lines.push(`\x1b[2mtokens ${1000 + frameIndex * 37}\x1b[0m`);
-    frames.push(`\x1b[2J\x1b[H${lines.join('\r\n')}`);
-  }
-  return frames;
-}
-
-function generateUniqueGlyphFlood(count: number, cols: number, offset: number): string {
-  const base = 0x4E00;
-  const range = 0x9FFF - base;
-  const perRow = Math.max(1, Math.floor(cols / 2));
-  let result = '';
-  for (let i = 0; i < count; i++) {
-    result += String.fromCodePoint(base + ((offset + i) % range));
-    if ((i + 1) % perRow === 0 && i + 1 < count) {
-      result += '\r\n';
-    }
-  }
-  return result;
-}
-
-async function captureRowSignatures(ctx: ITestContext, row: number, cols: number[], debugName: string): Promise<CellSignature[]> {
-  const screenshotOptions = process.env.DEBUG ? { path: `out-esbuild-test/playwright/${debugName}.png` } : undefined;
-  const buffer = await ctx.page.locator(TERM_SELECTOR).screenshot(screenshotOptions);
-  const frame = {
-    cols: await ctx.proxy.cols,
-    rows: await ctx.proxy.rows,
-    decoded: (await decodePng(new Uint8Array(buffer), { force32: true })).image
-  };
-  return cols.map(col => cellSignature(frame, col, row));
-}
-
-function cellSignature(frame: { cols: number, rows: number, decoded: IImage32 }, col: number, row: number): CellSignature {
-  const grid = 4;
-  const data = frame.decoded.data;
-  const imageWidth = frame.decoded.width;
-  const cellWidth = frame.decoded.width / frame.cols;
-  const cellHeight = frame.decoded.height / frame.rows;
-  const x0 = (col - 1) * cellWidth;
-  const y0 = (row - 1) * cellHeight;
-  const sums = new Array<number>(grid * grid * 4).fill(0);
-  const counts = new Array<number>(grid * grid).fill(0);
-  const startX = Math.max(0, Math.floor(x0));
-  const startY = Math.max(0, Math.floor(y0));
-  const endX = Math.min(frame.decoded.width, Math.ceil(x0 + cellWidth));
-  const endY = Math.min(frame.decoded.height, Math.ceil(y0 + cellHeight));
-
-  for (let y = startY; y < endY; y++) {
-    const gy = Math.min(grid - 1, Math.max(0, Math.floor(((y - y0) / cellHeight) * grid)));
-    for (let x = startX; x < endX; x++) {
-      const gx = Math.min(grid - 1, Math.max(0, Math.floor(((x - x0) / cellWidth) * grid)));
-      const sub = gy * grid + gx;
-      const i = (y * imageWidth + x) * 4;
-      sums[sub * 4] += data[i];
-      sums[sub * 4 + 1] += data[i + 1];
-      sums[sub * 4 + 2] += data[i + 2];
-      sums[sub * 4 + 3] += data[i + 3];
-      counts[sub]++;
-    }
-  }
-
-  const signature = new Array<number>(grid * grid * 4).fill(0);
-  for (let sub = 0; sub < counts.length; sub++) {
-    if (counts[sub] > 0) {
-      signature[sub * 4] = sums[sub * 4] / counts[sub];
-      signature[sub * 4 + 1] = sums[sub * 4 + 1] / counts[sub];
-      signature[sub * 4 + 2] = sums[sub * 4 + 2] / counts[sub];
-      signature[sub * 4 + 3] = sums[sub * 4 + 3] / counts[sub];
-    }
-  }
-  return signature;
-}
-
-function expectSignatureMatches(actual: CellSignature, reference: CellSignature, message: string): void {
-  let diff = 0;
-  for (let i = 0; i < actual.length; i++) {
-    diff = Math.max(diff, Math.abs(actual[i] - reference[i]));
-  }
-  expect(diff, `${message}; max channel diff ${diff}`).toBeLessThanOrEqual(14);
-}
-
-test.describe('WebGL atlas TUI stress (#6038)', () => {
-  test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
-  test.describe.configure({ timeout: 90000 });
-
-  test('primary-buffer glyphs survive alternate-buffer redraws and atlas page churn', async ({ browser }) => {
-    const ctx = await createTestContext(browser);
-    const errors: string[] = [];
-    const onError = (error: Error): void => { errors.push(error.message); };
-    ctx.page.on('pageerror', onError);
-    try {
-      await openTerminal(ctx, { cols: 80, rows: 24, scrollback: 5000 });
-      await loadWebglStrict(ctx);
-      await installAtlasEventStats(ctx);
-
-      await writeAndWaitForRender(ctx, REFERENCE_LINE);
-      const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS, 'atlas-stress-reference');
-
-      await writeAndWaitForRender(ctx, '\x1b[?1049h');
-      for (const frame of generateSyntheticTuiFrames(30, 80, 24)) {
-        await writeAndWaitForRender(ctx, frame);
-      }
-      const glyphsPerViewport = 23 * 40 - 1;
-      for (let chunk = 0; chunk < 4; chunk++) {
-        await writeAndWaitForRender(ctx, `\x1b[2J\x1b[H${generateUniqueGlyphFlood(glyphsPerViewport, 80, chunk * glyphsPerViewport)}`);
-      }
-      await writeAndWaitForRender(ctx, '\x1b[?1049l');
-      await refreshAndWaitForRender(ctx);
-
-      const state = await getAtlasState(ctx);
-      expect(state.additions, 'stress workload must add atlas pages').toBeGreaterThan(0);
-      expect(state.maxPages, 'stress workload must exercise multiple atlas pages').toBeGreaterThan(1);
-      expect(state.maxPages, 'atlas pages must remain within renderer texture capacity').toBeLessThanOrEqual(state.atlasTextures);
-      expect(errors, `renderer must not throw during TUI stress: ${errors[0] ?? ''}`).toEqual([]);
-
-      const primaryText = await ctx.page.evaluate(() => {
-        const w = window as unknown as ITestWindow;
-        return w.term.buffer.active.getLine(0)?.translateToString(true);
-      });
-      expect(primaryText, 'primary buffer must still contain the reference line').toBe(REFERENCE_LINE);
-
-      const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS, 'atlas-stress-after');
-      for (let i = 0; i < REFERENCE_COLS.length; i++) {
-        expectSignatureMatches(after[i], reference[i], `primary-buffer glyph at col ${REFERENCE_COLS[i]} changed after TUI stress`);
-      }
-    } finally {
-      ctx.page.off('pageerror', onError);
-      await ctx.page.close();
-    }
-  });
-});
@@ -1,77 +0,0 @@
-/**
- * Copyright (c) 2026 The xterm.js authors. All rights reserved.
- * @license MIT
- */
-
-import test, { expect } from '@playwright/test';
-import { platform } from 'os';
-import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
-
-interface ITestRendererWithAtlasCanvas {
-  readonly _charAtlas?: {
-    readonly _tmpCanvas?: HTMLCanvasElement;
-  };
-}
-
-async function writeAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
-  const renderPromise = new Promise<void>(resolve => {
-    const disposable = ctx.proxy.onRender(() => {
-      disposable.dispose();
-      resolve();
-    });
-  });
-  await ctx.proxy.write(data);
-  await renderPromise;
-}
-
-test.describe('WebGL custom glyphs', () => {
-  if (platform() === 'linux') {
-    test.skip(({ browserName }) => browserName === 'firefox' || browserName === 'webkit');
-  }
-
-  test('pattern glyphs render after the terminal is adopted into another document', async ({ browser }) => {
-    const ctx = await createTestContext(browser);
-    const errors: string[] = [];
-    const onError = (error: Error): void => { errors.push(error.message); };
-    ctx.page.on('pageerror', onError);
-    try {
-      await openTerminal(ctx);
-      await ctx.page.evaluate(`
-        window.addon = new window.WebglAddon({ customGlyphs: true });
-        window.term.loadAddon(window.addon);
-      `);
-      await ctx.page.evaluate(() => {
-        const frame = document.createElement('iframe');
-        document.body.appendChild(frame);
-        const auxiliaryDocument = frame.contentDocument;
-        if (!auxiliaryDocument?.body || !window.term.element) {
-          throw new Error('Auxiliary document and terminal element must be available');
-        }
-        const renderer = window.term._core?._renderService?._renderer?.value as ITestRendererWithAtlasCanvas | undefined;
-        const atlasCanvas = renderer?._charAtlas?._tmpCanvas;
-        if (!atlasCanvas) {
-          throw new Error('Texture atlas canvas must be available');
-        }
-        // Model the atlas state after an uncached glyph has attached the measurement canvas.
-        window.term.element.appendChild(atlasCanvas);
-        auxiliaryDocument.body.appendChild(window.term.element);
-        if (atlasCanvas.ownerDocument !== auxiliaryDocument) {
-          throw new Error('Texture atlas canvas must be adopted into the auxiliary document');
-        }
-        auxiliaryDocument.createElement = () => {
-          throw new Error('Not allowed to create elements in the auxiliary document');
-        };
-      });
-
-      await writeAndWaitForRender(ctx, '\u2591');
-      await writeAndWaitForRender(ctx, 'X');
-
-      const line = await ctx.page.evaluate(() => window.term.buffer.active.getLine(0)?.translateToString(true));
-      expect(errors, `renderer must not create pattern canvases in the auxiliary document: ${errors[0] ?? ''}`).toEqual([]);
-      expect(line).toBe('\u2591X');
-    } finally {
-      ctx.page.off('pageerror', onError);
-      await ctx.page.close();
-    }
-  });
-});
@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * WebGL device-pixel-ratio (HiDPI) and font-size ("resize") atlas tests.
+ *
+ * A devicePixelRatio > 1 and font-size changes both change the device cell
+ * dimensions, which key the texture atlas cache and force the atlas to be
+ * rebuilt. Historically these paths have produced blank/oversized/garbled glyphs
+ * (e.g. xtermjs#4728, #5915/#5929). These tests assert glyphs render and stay
+ * correct across those transitions.
+ *
+ * Chromium + SwiftShader only (additive scope; Firefox/WebKit WebGL broken in CI
+ * per xtermjs#5854).
+ */
+
+import test, { Browser, expect } from '@playwright/test';
+import { ITestContext, TerminalProxy, openTerminal } from '../../../test/playwright/TestUtils';
+import {
+  assertTextureAtlasPresent,
+  captureRowSignatures,
+  expectSignatureMatches,
+  loadWebglStrict,
+  waitForRender,
+  writeAndWaitForRender
+} from '../../../test/playwright/RendererTestUtils';
+
+const REFERENCE_COLS = [1, 2, 3, 4, 5, 6, 7, 8];
+
+/**
+ * Creates a test context whose page uses a specific devicePixelRatio. The shared
+ * `createTestContext` helper always uses DPR 1 (`browser.newPage()`), so HiDPI
+ * tests build their own context here.
+ */
+async function createDprContext(browser: Browser, deviceScaleFactor: number): Promise<ITestContext> {
+  const context = await browser.newContext({ deviceScaleFactor });
+  const page = await context.newPage();
+  page.on('pageerror', e => console.error(`[dpr ${deviceScaleFactor}]`, e));
+  await page.goto('/test');
+  const proxy = new TerminalProxy(page);
+  proxy.initPage();
+  return {
+    browser,
+    page,
+    termHandle: await page.evaluateHandle('window.term'),
+    proxy
+  };
+}
+
+test.describe('WebGL HiDPI (devicePixelRatio) rendering', () => {
+  test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
+
+  test('initializes the WebGL renderer and scales to device pixels at devicePixelRatio 2', async ({ browser }) => {
+    const ctx = await createDprContext(browser, 2);
+    try {
+      await openTerminal(ctx, { cols: 80, rows: 24 });
+      // GPU must be genuinely active at HiDPI (asserted inside loadWebglStrict).
+      await loadWebglStrict(ctx);
+      await writeAndWaitForRender(ctx, 'A W .');
+      await assertTextureAtlasPresent(ctx);
+
+      // The WebGL renderer must render at the device resolution: device cell
+      // dimensions should be ~2x the CSS cell dimensions. This catches the
+      // DPR-scaling class of bugs (e.g. xtermjs#4728) without relying on
+      // screenshotting a WebGL canvas at a non-1 device scale factor.
+      const dims = await ctx.proxy.core.renderDimensions;
+      expect(dims.device.cell.width).toBeGreaterThan(dims.css.cell.width * 1.8);
+      expect(dims.device.cell.width).toBeLessThan(dims.css.cell.width * 2.2);
+      expect(dims.device.cell.height).toBeGreaterThan(dims.css.cell.height * 1.8);
+      expect(dims.device.cell.height).toBeLessThan(dims.css.cell.height * 2.2);
+    } finally {
+      await ctx.page.context().close();
+    }
+  });
+});
+
+test.describe('WebGL font-size change atlas integrity', () => {
+  let ctx: ITestContext;
+  test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
+
+  test.beforeAll(async ({ browser }) => {
+    ctx = await createDprContext(browser, 1);
+  });
+  test.afterAll(async () => await ctx.page.close());
+
+  test.beforeEach(async () => {
+    await openTerminal(ctx, { cols: 80, rows: 24, fontSize: 15 });
+    await loadWebglStrict(ctx);
+  });
+
+  test('glyphs stay correct after cycling font size (atlas rebuilds)', async () => {
+    await writeAndWaitForRender(ctx, 'FontRef0123456789');
+    const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+
+    // Changing font size changes device cell dimensions -> the atlas is rebuilt.
+    for (const fontSize of [12, 18, 21, 15]) {
+      await ctx.proxy.setOption('fontSize', fontSize);
+      await writeAndWaitForRender(ctx, '\r\nchurn');
+    }
+
+    // Back at the original font size the reference glyphs must be unchanged.
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+    const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+    for (let i = 0; i < REFERENCE_COLS.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 16, `reference glyph at col ${REFERENCE_COLS[i]} corrupted after font-size cycling`);
+    }
+  });
+});
@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * WebGL glyph + texture-atlas integrity tests.
+ *
+ * These tests verify that *glyphs* render correctly (not just that cell colors
+ * are right) under conditions that stress the texture atlas: multiple atlas
+ * pages, page merges and atlas clears. The goal is to catch the "garbled glyph"
+ * corruption class reported in microsoft/vscode#322756.
+ *
+ * Note: CI runs WebGL on Chromium + SwiftShader (software WebGL). That catches
+ * renderer/atlas *logic* corruption (stale texture pages, missing model clears),
+ * but not GPU-driver-specific glitches. These tests target the former.
+ */
+
+import test, { expect } from '@playwright/test';
+import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
+import {
+  assertTextureAtlasPresent,
+  captureRowSignatures,
+  expectSignatureDiffers,
+  expectSignatureMatches,
+  floodDistinctGlyphs,
+  loadWebglStrict,
+  resetMaxAtlasPages,
+  setMaxAtlasPages,
+  waitForRender,
+  writeAndWaitForRender
+} from '../../../test/playwright/RendererTestUtils';
+
+let ctx: ITestContext;
+test.beforeAll(async ({ browser }) => {
+  ctx = await createTestContext(browser);
+});
+test.afterAll(async () => await ctx.page.close());
+
+test.describe('WebGL glyph + atlas integrity', () => {
+  // Additive scope: only run on Chromium (SwiftShader). Firefox/WebKit WebGL
+  // tests are known-broken in CI (xtermjs#5854) and out of scope here.
+  test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
+
+  test.beforeEach(async () => {
+    // Fresh terminal (and therefore a predictable atlas) per test.
+    await openTerminal(ctx, { cols: 80, rows: 24 });
+    await loadWebglStrict(ctx);
+  });
+
+  // A lowered page cap must not leak into renderers built by later tests.
+  test.afterEach(async () => await resetMaxAtlasPages(ctx));
+
+  test('renders distinct, non-blank glyphs', async () => {
+    await writeAndWaitForRender(ctx, 'A W .');
+    await assertTextureAtlasPresent(ctx);
+
+    const [a, w, dot, blank] = await captureRowSignatures(ctx, 1, [1, 3, 5, 40]);
+    // A written cell must differ from an empty cell (glyph actually drawn).
+    expectSignatureDiffers(a, blank, 24, 'glyph "A" should not be blank');
+    expectSignatureDiffers(w, blank, 24, 'glyph "W" should not be blank');
+    // Different glyphs must look different (signature has discriminating power).
+    expectSignatureDiffers(a, w, 24, 'glyphs "A" and "W" should render differently');
+    expectSignatureDiffers(a, dot, 24, 'glyphs "A" and "." should render differently');
+  });
+
+  test('glyphs on the first atlas page stay correct after more pages are allocated', async () => {
+    // Reference: a known row of glyphs that lands on the first atlas page.
+    await writeAndWaitForRender(ctx, 'REFERENCE_LINE_0123456789\r\n');
+    const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    const reference = await captureRowSignatures(ctx, 1, cols);
+
+    // Flood thousands of distinct glyphs (one screenful rendered at a time, so
+    // they actually rasterize) to force multiple atlas pages.
+    const pages = await floodDistinctGlyphs(ctx, 4);
+    expect(pages, 'flooding distinct glyphs should allocate more than one atlas page').toBeGreaterThan(1);
+
+    // Bring the reference line back into view and re-check its glyphs.
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+    const after = await captureRowSignatures(ctx, 1, cols);
+    for (let i = 0; i < cols.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${cols[i]} corrupted after multi-page allocation`);
+    }
+  });
+
+  test('glyphs stay correct after a texture-atlas page merge', async () => {
+    // Force merges to happen almost immediately.
+    await writeAndWaitForRender(ctx, 'MERGE_REF_LINE_0123456789\r\n');
+    await setMaxAtlasPages(ctx, 4);
+
+    const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    const reference = await captureRowSignatures(ctx, 1, cols);
+
+    // Flood distinct glyphs (rendered per screenful) to exceed the tiny page cap
+    // and trigger merges.
+    const pages = await floodDistinctGlyphs(ctx, 12);
+    expect(pages, 'flood should have allocated multiple atlas pages (and merged)').toBeGreaterThan(1);
+
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+    const after = await captureRowSignatures(ctx, 1, cols);
+    for (let i = 0; i < cols.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${cols[i]} corrupted after atlas page merge`);
+    }
+  });
+
+  test('glyphs re-render correctly after clearTextureAtlas() on the same terminal', async () => {
+    await writeAndWaitForRender(ctx, 'CLEAR_REF_LINE_0123456789');
+    const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    const reference = await captureRowSignatures(ctx, 1, cols);
+
+    await ctx.proxy.clearTextureAtlas();
+    // Force a full redraw so glyphs are re-rasterized into the cleared atlas.
+    await ctx.proxy.refresh(0, (await ctx.proxy.rows) - 1);
+    await waitForRender(ctx);
+
+    const after = await captureRowSignatures(ctx, 1, cols);
+    for (let i = 0; i < cols.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 14, `glyph at col ${cols[i]} corrupted after clearTextureAtlas()`);
+    }
+  });
+});
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Single-terminal guard for the vscode#322756 "garbled glyph" class: a pinned
+ * alt-buffer header must render identically while the body churns enough
+ * distinct colored glyphs to force texture-atlas page merges.
+ *
+ * Note this scenario is GREEN on current master: the single-terminal mid-frame
+ * merge race was fixed upstream (merge-retry loop in WebglRenderer.renderRows +
+ * globally monotonic AtlasPage versions). The test asserts the buffer content
+ * first so a content bug (e.g. an accidental scroll from the churn stream) can
+ * never masquerade as renderer corruption.
+ */
+import test, { expect } from '@playwright/test';
+import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
+import { captureRowSignatures, expectSignatureMatches, getAtlasPageCount, loadWebglStrict, resetMaxAtlasPages, setMaxAtlasPages, writeAndWaitForRender } from '../../../test/playwright/RendererTestUtils';
+import { generateColoredAsciiFlood } from '../../../test/playwright/SyntheticTui';
+
+const HEADER = ' HEADER_REF_0123456789';
+
+let ctx: ITestContext;
+test.beforeAll(async ({ browser }) => { ctx = await createTestContext(browser); });
+test.afterAll(async () => await ctx.page.close());
+
+test.describe('single-terminal merge integrity (#322756 class)', () => {
+  test.skip(({ browserName }) => browserName !== 'chromium');
+  test.describe.configure({ timeout: 60000 });
+
+  // A lowered page cap must not leak into renderers built by later tests.
+  test.afterEach(async () => await resetMaxAtlasPages(ctx));
+
+  test('pinned header renders identically across 30 merge-heavy body redraws', async () => {
+    await openTerminal(ctx, { cols: 80, rows: 24 });
+    await loadWebglStrict(ctx);
+    await setMaxAtlasPages(ctx, 4);
+    const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    // Alt-buffer TUI: pinned header on row 1, body churns below (like Copilot CLI).
+    await writeAndWaitForRender(ctx, `\x1b[?1049h\x1b[H${HEADER}`);
+    const ref = await captureRowSignatures(ctx, 1, cols);
+    let maxDiff = 0;
+    for (let c = 0; c < 30; c++) {
+      // Redraw body rows 2..24 with unique glyphs; the header row is never touched.
+      let frame = '\x1b[2;1H';
+      frame += generateColoredAsciiFlood(23 * 78, c * 23 * 78);
+      await writeAndWaitForRender(ctx, frame);
+      const now = await captureRowSignatures(ctx, 1, cols); // forces GPU sync
+      for (let i = 0; i < cols.length; i++) {
+        const d = Math.max(...ref[i].map((v, k) => Math.abs(v - now[i][k])));
+        maxDiff = Math.max(maxDiff, d);
+      }
+    }
+    console.error('[repro] pages=', await getAtlasPageCount(ctx), 'headerMaxDiff=', maxDiff);
+
+    // Guard: the header must still be in the buffer. If this fails the churn
+    // stream scrolled the screen and any pixel diff is meaningless.
+    const row1Text = await ctx.page.evaluate(() => (window as any).term.buffer.active.getLine(0)?.translateToString(true));
+    expect(row1Text, 'churn stream must not scroll the pinned header out of the buffer').toBe(HEADER);
+
+    const after = await captureRowSignatures(ctx, 1, cols);
+    for (let i = 0; i < cols.length; i++) {
+      expectSignatureMatches(after[i], ref[i], 14, `header col ${cols[i]} garbled`);
+    }
+  });
+});
@@ -1,92 +1,66 @@
 /**
 * Copyright (c) 2025 The xterm.js authors. All rights reserved.
 * @license MIT
+ *
+ * Reproduces the vscode#322756 "garbled glyph" corruption across terminals that
+ * SHARE a texture atlas (CharAtlasCache hands the same TextureAtlas to every
+ * terminal with an equal config — in VS Code that is every integrated terminal
+ * using the same font settings, including task/background terminals).
+ *
+ * Mechanism: when the atlas merges pages it raises a consume-once
+ * "clear model" flag (TextureAtlas.beginFrame). Only the FIRST terminal to
+ * render consumes it and rebuilds its vertex model; every other terminal keeps
+ * stale texture-page indexes/coordinates in its vertex buffer and draws wrong
+ * glyphs on its next partial render, even though its buffer content is intact.
+ *
+ * The DOM-renderer control shows the corruption is exclusive to the GPU path
+ * (`terminal.integrated.gpuAcceleration off` cannot reproduce it: the DOM
+ * renderer has no texture atlas).
+ *
+ * Chromium only (additive scope; Firefox/WebKit WebGL broken in CI, xtermjs#5854).
 */
-
-import { IImage32, decodePng } from '@lunapaint/png-codec';
 import test, { expect } from '@playwright/test';
-import type { Terminal, ITerminalInitOnlyOptions, ITerminalOptions } from '@xterm/xterm';
-import type { IWebglAddonOptions, WebglAddon } from '@xterm/addon-webgl';
 import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
-
-type CellSignature = number[];
-type TestTerminalConstructor = new (options?: ITerminalOptions & ITerminalInitOnlyOptions) => ITestTerminal;
-type TestWebglAddonConstructor = new (options?: IWebglAddonOptions) => ITestWebglAddon;
-
-interface ITestTextureAtlasConstructor {
-  maxAtlasPages: number | undefined;
-}
-
-interface ITestTextureAtlas {
-  constructor: ITestTextureAtlasConstructor;
-}
-
-interface ITestRenderer {
-  _charAtlas?: ITestTextureAtlas;
-}
-
-interface ITestRenderService {
-  _renderer?: {
-    value?: ITestRenderer;
-  };
-}
-
-interface ITestTerminal extends Terminal {
-  _core?: {
-    _renderService?: ITestRenderService;
-  };
-}
-
-interface ITestWebglAddon extends WebglAddon {
-  _renderer?: ITestRenderer;
-}
-
-declare global {
-  interface Window { // eslint-disable-line @typescript-eslint/naming-convention
-    Terminal: TestTerminalConstructor;
-    WebglAddon: TestWebglAddonConstructor;
-    term: ITestTerminal;
-    termB?: ITestTerminal;
-    addon?: ITestWebglAddon;
-    addonB?: ITestWebglAddon;
-  }
-}
+import {
+  captureRowSignatures,
+  expectSignatureMatches,
+  getAtlasPageCount,
+  loadWebglStrict,
+  setMaxAtlasPages,
+  writeAndWaitForRender
+} from '../../../test/playwright/RendererTestUtils';
+import { generateColoredAsciiFlood } from '../../../test/playwright/SyntheticTui';

 const HEADER = ' HEADER_REF_0123456789';
 const HEADER_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 const TERM_B_SELECTOR = '#terminal-container-b .xterm-screen';

-async function loadWebglStrict(ctx: ITestContext): Promise<void> {
-  await ctx.page.evaluate(() => {
-    window.addon = new window.WebglAddon({ preserveDrawingBuffer: true });
-    window.term.loadAddon(window.addon);
-  });
-  const isWebglRenderer = await ctx.page.evaluate(() => {
-    return !!window.addon && window.term?._core?._renderService?._renderer?.value === window.addon._renderer;
-  });
-  expect(isWebglRenderer, 'WebGL renderer must be active').toBe(true);
-}
-
-async function createTerminalB(ctx: ITestContext): Promise<void> {
-  await ctx.page.evaluate(() => {
-    window.termB?.dispose();
+/**
+ * Creates a second terminal ("termB") on the test page with the given options
+ * and optionally loads the WebGL addon on it. Identical rendering options mean
+ * CharAtlasCache gives it the same atlas instance as `window.term`.
+ */
+async function createTerminalB(ctx: ITestContext, options: { useWebgl: boolean }): Promise<void> {
+  await ctx.page.evaluate(async (useWebgl) => {
+    const w = window as any;
+    w.termB?.dispose();
    document.getElementById('terminal-container-b')?.remove();
    const el = document.createElement('div');
    el.id = 'terminal-container-b';
    document.body.appendChild(el);
-    window.termB = new window.Terminal({ cols: 80, rows: 24, allowProposedApi: true });
-    window.termB.open(el);
-    window.addonB = new window.WebglAddon({ preserveDrawingBuffer: true });
-    window.termB.loadAddon(window.addonB);
-  });
+    w.termB = new w.Terminal({ cols: 80, rows: 24, allowProposedApi: true });
+    w.termB.open(el);
+    if (useWebgl) {
+      w.addonB = new w.WebglAddon({ preserveDrawingBuffer: true });
+      w.termB.loadAddon(w.addonB);
+    }
+  }, options.useWebgl);
 }

+/** Writes data to termB and resolves after its next render event. */
 async function writeToBAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
  await ctx.page.evaluate(d => new Promise<void>(resolve => {
-    const termB = window.termB;
-    if (!termB) {
-      throw new Error('Terminal B must be created before writing to it');
-    }
+    const termB = (window as any).termB;
    const disposable = termB.onRender(() => {
      disposable.dispose();
      resolve();
@@ -95,185 +69,88 @@ async function writeToBAndWaitForRender(ctx: ITestContext, data: string): Promis
  }), data);
 }

-async function writeAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
-  const renderPromise = new Promise<void>(resolve => {
-    const disposable = ctx.proxy.onRender(() => {
-      disposable.dispose();
-      resolve();
-    });
-  });
-  await ctx.proxy.write(data);
-  await renderPromise;
+async function getTermBRow1Text(ctx: ITestContext): Promise<string | undefined> {
+  return ctx.page.evaluate(() => (window as any).termB.buffer.active.getLine(0)?.translateToString(true));
 }

-async function setMaxAtlasPages(ctx: ITestContext, maxAtlasPages: number): Promise<void> {
-  const applied = await ctx.page.evaluate(max => {
-    const atlas = window.term?._core?._renderService?._renderer?.value?._charAtlas;
-    if (!atlas) {
-      return false;
-    }
-    atlas.constructor.maxAtlasPages = max;
-    return true;
-  }, maxAtlasPages);
-  expect(applied, 'should be able to set TextureAtlas.maxAtlasPages').toBe(true);
-}
-
-async function resetMaxAtlasPages(ctx: ITestContext): Promise<void> {
-  await ctx.page.evaluate(() => {
-    const atlas = window.term?._core?._renderService?._renderer?.value?._charAtlas;
-    if (atlas) {
-      atlas.constructor.maxAtlasPages = undefined;
-    }
-  });
-}
-
-function generateColoredAsciiFlood(cells: number, offset: number = 0): string {
-  const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-  let out = '';
-  for (let i = 0; i < cells; i++) {
-    const ch = letters[(offset + i) % letters.length];
-    const fg = (offset + i) % 256;
-    const bg = (offset + i * 7) % 256;
-    out += `\x1b[38;5;${fg}m\x1b[48;5;${bg}m${ch}`;
-    if ((i + 1) % 78 === 0 && i + 1 < cells) {
-      out += '\x1b[0m\r\n';
-    }
-  }
-  return out + '\x1b[0m';
-}
-
-async function captureRowSignatures(ctx: ITestContext, row: number, cols: number[]): Promise<CellSignature[]> {
-  const screenshotOptions = process.env.DEBUG ? { path: 'out-esbuild-test/playwright/shared-atlas-term-b.png' } : undefined;
-  const buffer = await ctx.page.locator(TERM_B_SELECTOR).screenshot(screenshotOptions);
-  const frame = {
-    cols: 80,
-    rows: 24,
-    decoded: (await decodePng(new Uint8Array(buffer), { force32: true })).image
-  };
-  return cols.map(col => cellSignature(frame, col, row));
-}
-
-function cellSignature(frame: { cols: number, rows: number, decoded: IImage32 }, col: number, row: number): CellSignature {
-  const grid = 4;
-  const data = frame.decoded.data;
-  const imageWidth = frame.decoded.width;
-  const cellWidth = frame.decoded.width / frame.cols;
-  const cellHeight = frame.decoded.height / frame.rows;
-  const x0 = (col - 1) * cellWidth;
-  const y0 = (row - 1) * cellHeight;
-  const sums = new Array<number>(grid * grid * 4).fill(0);
-  const counts = new Array<number>(grid * grid).fill(0);
-  const startX = Math.max(0, Math.floor(x0));
-  const startY = Math.max(0, Math.floor(y0));
-  const endX = Math.min(frame.decoded.width, Math.ceil(x0 + cellWidth));
-  const endY = Math.min(frame.decoded.height, Math.ceil(y0 + cellHeight));
-
-  for (let y = startY; y < endY; y++) {
-    const gy = Math.min(grid - 1, Math.max(0, Math.floor(((y - y0) / cellHeight) * grid)));
-    for (let x = startX; x < endX; x++) {
-      const gx = Math.min(grid - 1, Math.max(0, Math.floor(((x - x0) / cellWidth) * grid)));
-      const sub = gy * grid + gx;
-      const i = (y * imageWidth + x) * 4;
-      sums[sub * 4] += data[i];
-      sums[sub * 4 + 1] += data[i + 1];
-      sums[sub * 4 + 2] += data[i + 2];
-      sums[sub * 4 + 3] += data[i + 3];
-      counts[sub]++;
-    }
-  }
-
-  const signature = new Array<number>(grid * grid * 4).fill(0);
-  for (let sub = 0; sub < counts.length; sub++) {
-    if (counts[sub] > 0) {
-      signature[sub * 4] = sums[sub * 4] / counts[sub];
-      signature[sub * 4 + 1] = sums[sub * 4 + 1] / counts[sub];
-      signature[sub * 4 + 2] = sums[sub * 4 + 2] / counts[sub];
-      signature[sub * 4 + 3] = sums[sub * 4 + 3] / counts[sub];
-    }
-  }
-  return signature;
-}
-
-function expectSignatureMatches(actual: CellSignature, reference: CellSignature, message: string): void {
-  let diff = 0;
-  for (let i = 0; i < actual.length; i++) {
-    diff = Math.max(diff, Math.abs(actual[i] - reference[i]));
-  }
-  expect(diff, `${message}; max channel diff ${diff}`).toBeLessThanOrEqual(14);
-}
-
-test.describe('shared-atlas garble across terminals (#6038)', () => {
+test.describe('shared-atlas garble across terminals (#322756)', () => {
  test.skip(({ browserName }) => browserName !== 'chromium');
  test.describe.configure({ timeout: 60000 });

-  test('keeps a second terminal rendering correctly after shared atlas page merges', async ({ browser }) => {
-    const ctx = await createTestContext(browser);
+  test('terminal B keeps rendering its header correctly while terminal A forces atlas merges', async ({ browser }) => {
+    const ctx: ITestContext = await createTestContext(browser);
    try {
      await openTerminal(ctx, { cols: 80, rows: 24 });
      await loadWebglStrict(ctx);
-      await createTerminalB(ctx);
+      await createTerminalB(ctx, { useWebgl: true });

+      // Both terminals must be using the same atlas instance for this test to
+      // mean anything.
      const atlasShared = await ctx.page.evaluate(() => {
-        return window.term._core?._renderService?._renderer?.value?._charAtlas === window.termB?._core?._renderService?._renderer?.value?._charAtlas;
+        const w = window as any;
+        const atlasA = w.term._core._renderService._renderer.value._charAtlas;
+        const atlasB = w.termB._core._renderService._renderer.value._charAtlas;
+        return !!atlasA && atlasA === atlasB;
      });
      expect(atlasShared, 'terminals with equal configs should share one texture atlas').toBe(true);

+      // Lower the cap AFTER both renderers exist so their shaders/texture
+      // arrays keep the original size (this test targets stale vertex data,
+      // not the page-overflow crash).
      await setMaxAtlasPages(ctx, 4);

+      // Render B's header pre-merge and capture its reference pixels.
      await writeToBAndWaitForRender(ctx, HEADER);
-      const reference = await captureRowSignatures(ctx, 1, HEADER_COLS);
+      await ctx.page.locator(TERM_B_SELECTOR).screenshot({ path: 'out-esbuild-test/playwright/termB-before.png' });
+      const reference = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });

+      // Churn terminal A with distinct colored glyphs to force page merges in
+      // the SHARED atlas. A repairs itself (it consumes the clear-model flag);
+      // B is never told.
      for (let c = 0; c < 10; c++) {
        await writeAndWaitForRender(ctx, '\x1b[2;1H' + generateColoredAsciiFlood(23 * 78, c * 23 * 78));
      }
+      const pages = await getAtlasPageCount(ctx);
+      expect(pages, 'churn should have exercised multiple atlas pages').toBeGreaterThan(1);

+      // A tiny unrelated update to B's LAST row triggers a partial render in B.
+      // B's header row is untouched; with a healthy renderer its pixels must
+      // not change.
      await writeToBAndWaitForRender(ctx, '\x1b[24;1Hx');
-      const termBHeader = await ctx.page.evaluate(() => window.termB?.buffer.active.getLine(0)?.translateToString(true));
-      expect(termBHeader, 'terminal B buffer must still contain the header').toBe(HEADER);
+      await ctx.page.locator(TERM_B_SELECTOR).screenshot({ path: 'out-esbuild-test/playwright/termB-after.png' });

-      const after = await captureRowSignatures(ctx, 1, HEADER_COLS);
+      // Guard: B's buffer content is intact, so any pixel change is renderer
+      // corruption by construction.
+      expect(await getTermBRow1Text(ctx), 'terminal B buffer must still contain the header').toBe(HEADER);
+
+      const after = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });
      for (let i = 0; i < HEADER_COLS.length; i++) {
-        expectSignatureMatches(after[i], reference[i], `terminal B header col ${HEADER_COLS[i]} garbled by terminal A's atlas merges`);
+        expectSignatureMatches(after[i], reference[i], 14, `terminal B header col ${HEADER_COLS[i]} garbled by terminal A's atlas merges`);
      }
    } finally {
-      await resetMaxAtlasPages(ctx).catch(() => {});
      await ctx.page.close();
    }
  });

-  test('keeps a second terminal rendering correctly after terminal A clears the shared atlas', async ({ browser }) => {
-    const ctx = await createTestContext(browser);
+  test('DOM renderer control: same workload cannot garble terminal B (no atlas without GPU acceleration)', async ({ browser }) => {
+    const ctx: ITestContext = await createTestContext(browser);
    try {
+      // No WebGL addon on either terminal -> DOM renderer -> no texture atlas.
      await openTerminal(ctx, { cols: 80, rows: 24 });
-      await loadWebglStrict(ctx);
-      await createTerminalB(ctx);
-
-      const atlasShared = await ctx.page.evaluate(() => {
-        return window.term._core?._renderService?._renderer?.value?._charAtlas === window.termB?._core?._renderService?._renderer?.value?._charAtlas;
-      });
-      expect(atlasShared, 'terminals with equal configs should share one texture atlas').toBe(true);
+      await createTerminalB(ctx, { useWebgl: false });

      await writeToBAndWaitForRender(ctx, HEADER);
-      const reference = await captureRowSignatures(ctx, 1, HEADER_COLS);
+      const reference = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });

-      // Terminal A alone clears the shared atlas, as embedders do to force a redraw (VS Code calls
-      // this for every terminal on OS resume). This wipes the pages that terminal B's model still
-      // holds texture coords into.
-      await ctx.proxy.clearTextureAtlas();
-
-      // Terminal A repopulates the cleared pages with a different glyph set, so B's stale coords now
-      // resolve to whatever A rasterized into those slots.
-      await writeAndWaitForRender(ctx, '\x1b[2;1H' + generateColoredAsciiFlood(23 * 78));
-
-      // Nudge B into a render that does not touch row 1, mirroring a terminal that is idle but
-      // visible. Row 1 must still be drawn from a model B rebuilt against the current atlas.
+      for (let c = 0; c < 10; c++) {
+        await writeAndWaitForRender(ctx, '\x1b[2;1H' + generateColoredAsciiFlood(23 * 78, c * 23 * 78));
+      }
      await writeToBAndWaitForRender(ctx, '\x1b[24;1Hx');
-      const termBHeader = await ctx.page.evaluate(() => window.termB?.buffer.active.getLine(0)?.translateToString(true));
-      expect(termBHeader, 'terminal B buffer must still contain the header').toBe(HEADER);

-      const after = await captureRowSignatures(ctx, 1, HEADER_COLS);
+      expect(await getTermBRow1Text(ctx), 'terminal B buffer must still contain the header').toBe(HEADER);
+      const after = await captureRowSignatures(ctx, 1, HEADER_COLS, { selector: TERM_B_SELECTOR, termGlobal: 'termB' });
      for (let i = 0; i < HEADER_COLS.length; i++) {
-        expectSignatureMatches(after[i], reference[i], `terminal B header col ${HEADER_COLS[i]} garbled by terminal A's atlas clear`);
+        expectSignatureMatches(after[i], reference[i], 14, `DOM-rendered terminal B header col ${HEADER_COLS[i]} unexpectedly changed`);
      }
    } finally {
      await ctx.page.close();
@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Single-terminal WebGL atlas stress: try to reproduce the "garbled glyph"
+ * corruption from microsoft/vscode#322756 in ONE terminal (no shared atlas),
+ * via heavy unique-glyph churn that forces atlas page merges, both with content
+ * pinned on screen (TUI-style) and mid-scroll. Chromium/SwiftShader only.
+ */
+
+import test, { expect } from '@playwright/test';
+import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
+import {
+  captureRowSignatures,
+  expectSignatureMatches,
+  floodDistinctGlyphs,
+  getAtlasPageCount,
+  loadWebglStrict,
+  resetMaxAtlasPages,
+  setMaxAtlasPages,
+  waitForRender,
+  writeAndWaitForRender
+} from '../../../test/playwright/RendererTestUtils';
+import { generateUniqueGlyphFlood } from '../../../test/playwright/SyntheticTui';
+
+let ctx: ITestContext;
+test.beforeAll(async ({ browser }) => {
+  ctx = await createTestContext(browser);
+});
+test.afterAll(async () => await ctx.page.close());
+
+test.describe('WebGL single-terminal heavy render + merge', () => {
+  test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL atlas tests run on Chromium/SwiftShader only');
+  test.describe.configure({ timeout: 30000 });
+
+  test.beforeEach(async () => {
+    await openTerminal(ctx, { cols: 80, rows: 24, scrollback: 5000 });
+    await loadWebglStrict(ctx);
+  });
+
+  // A lowered page cap must not leak into renderers built by later tests.
+  test.afterEach(async () => await resetMaxAtlasPages(ctx));
+
+  test('heavy merge churn must not crash the GlyphRenderer (vscode#322756)', async () => {
+    // Guard: heavy merges must not throw from GlyphRenderer.render. Note the
+    // page cap here is lowered AFTER the renderer was built, so _atlasTextures
+    // keeps its original (large) length and this test cannot hit the
+    // page-overflow crash; that scenario needs the cap lowered BEFORE loading
+    // the addon and is covered separately (WebglAtlasOverflow.test.ts).
+    const errors: string[] = [];
+    const onError = (e: Error): void => { errors.push(e.message); };
+    ctx.page.on('pageerror', onError);
+    try {
+      await setMaxAtlasPages(ctx, 4);
+      await floodDistinctGlyphs(ctx, 10);
+      // Force a GPU read (screenshot) mid-churn so a render lands during/after a
+      // merge, then churn more — this reliably exposes the version crash.
+      await captureRowSignatures(ctx, 1, [1, 2, 3]);
+      const pages = await floodDistinctGlyphs(ctx, 10);
+      expect(pages, 'should have allocated/merged pages').toBeGreaterThan(1);
+      await ctx.page.waitForTimeout(300);
+      expect(errors, `renderer crashed during atlas merges: ${errors[0] ?? ''}`).toEqual([]);
+    } finally {
+      ctx.page.off('pageerror', onError);
+    }
+  });
+
+  test('pinned header stays correct while body churns many pages', async () => {
+    const cols = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    await writeAndWaitForRender(ctx, 'HEADER_REF_0123456789');
+    const reference = await captureRowSignatures(ctx, 1, cols);
+
+    // Body churns unique glyphs (forces merges) while header line stays on screen.
+    const pages = await floodDistinctGlyphs(ctx, 8);
+    expect(pages, 'should have allocated/merged pages').toBeGreaterThan(1);
+
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+    const after = await captureRowSignatures(ctx, 1, cols);
+    for (let i = 0; i < cols.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 14, `header glyph col ${cols[i]} corrupted by single-terminal merges`);
+    }
+  });
+
+  test('visible rows match content while scrolling (no merge)', async () => {
+    // Big scrollback of distinct glyphs across multiple pages (no tiny page cap,
+    // so no merge), then scroll up/down repeatedly.
+    for (let c = 0; c < 8; c++) {
+      await writeAndWaitForRender(ctx, generateUniqueGlyphFlood(24 * 40, 80, c * 24 * 40));
+    }
+    expect(await getAtlasPageCount(ctx)).toBeGreaterThan(1);
+
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+    const top = await captureRowSignatures(ctx, 1, [1, 2, 3, 4, 5]);
+    await ctx.proxy.scrollToBottom();
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+    const topAgain = await captureRowSignatures(ctx, 1, [1, 2, 3, 4, 5]);
+    for (let i = 0; i < top.length; i++) {
+      expectSignatureMatches(topAgain[i], top[i], 14, `row1 col${i + 1} changed after scroll round-trip`);
+    }
+  });
+});
@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * WebGL "heavy TUI" stress tests: large scrollback + scrolling, alternate-buffer
+ * full-screen redraws (like an agent CLI animating output), high-volume
+ * rendering and replay of recorded real-world TUI sessions (vim, colored ls).
+ *
+ * The shared invariant: a known reference row of glyphs, captured in a fresh
+ * atlas, must still render identically after the stress workload. If the WebGL
+ * texture atlas is corrupted by the workload the reference glyphs change and the
+ * test fails. See microsoft/vscode#322756.
+ *
+ * Chromium + SwiftShader only (additive scope; Firefox/WebKit WebGL are broken
+ * in CI per xtermjs#5854).
+ */
+
+import { readFileSync } from 'fs';
+import test, { expect } from '@playwright/test';
+import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
+import {
+  assertTextureAtlasPresent,
+  captureRowSignatures,
+  expectSignatureMatches,
+  loadWebglStrict,
+  waitForRender,
+  writeAndWaitForRender
+} from '../../../test/playwright/RendererTestUtils';
+import { generateMixedGlyphBlock, generateSyntheticTuiFrames, generateUniqueGlyphFlood } from '../../../test/playwright/SyntheticTui';
+
+const REFERENCE_COLS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+const REFERENCE_LINE = 'Ref0123456789ABCDEF';
+
+let ctx: ITestContext;
+test.beforeAll(async ({ browser }) => {
+  ctx = await createTestContext(browser);
+});
+test.afterAll(async () => await ctx.page.close());
+
+test.describe('WebGL heavy TUI / scrolling stress', () => {
+  test.skip(({ browserName }) => browserName !== 'chromium', 'WebGL stress tests run on Chromium/SwiftShader only');
+
+  test.beforeEach(async () => {
+    await openTerminal(ctx, { cols: 80, rows: 24, scrollback: 5000 });
+    await loadWebglStrict(ctx);
+  });
+
+  test('reference glyphs survive heavy scrolling through large scrollback', async () => {
+    await writeAndWaitForRender(ctx, `${REFERENCE_LINE}\r\n`);
+    const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+
+    // Push the reference far up into scrollback with thousands of varied glyphs.
+    for (let i = 0; i < 20; i++) {
+      await ctx.proxy.write(generateMixedGlyphBlock(i + 1, 30, 70));
+    }
+    await waitForRender(ctx);
+
+    // Scroll around, then back to the very top where the reference lives.
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+    await ctx.proxy.scrollPages(3);
+    await waitForRender(ctx);
+    await ctx.proxy.scrollToTop();
+    await waitForRender(ctx);
+
+    const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+    for (let i = 0; i < REFERENCE_COLS.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${REFERENCE_COLS[i]} corrupted after heavy scrolling`);
+    }
+  });
+
+  test('alternate-buffer TUI redraws do not corrupt the restored primary buffer', async () => {
+    // Reference content lives in the PRIMARY buffer.
+    await writeAndWaitForRender(ctx, `${REFERENCE_LINE}`);
+    const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+
+    // Animate a synthetic agent TUI in the alternate buffer.
+    const frames = generateSyntheticTuiFrames({ seed: 7, frames: 30, cols: 80, rows: 24, useAltBuffer: true });
+    for (const frame of frames) {
+      await ctx.proxy.write(frame);
+    }
+    await waitForRender(ctx);
+    await assertTextureAtlasPresent(ctx);
+
+    // Back in the primary buffer the reference glyphs must be intact.
+    await ctx.proxy.refresh(0, (await ctx.proxy.rows) - 1);
+    await waitForRender(ctx);
+    const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+    for (let i = 0; i < REFERENCE_COLS.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 14, `primary-buffer glyph at col ${REFERENCE_COLS[i]} corrupted by alt-buffer TUI redraws`);
+    }
+  });
+
+  test('reference glyphs survive a heavy mixed render + unique-glyph churn', async () => {
+    // Capture the reference rendering of a known line in a fresh atlas.
+    await writeAndWaitForRender(ctx, `${REFERENCE_LINE}`);
+    const reference = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+
+    // High-volume rendering: synthetic TUI frames (which clear/redraw the screen)
+    // plus a large unique-glyph flood to churn the atlas, mimicking a long agent
+    // CLI session.
+    const frames = generateSyntheticTuiFrames({ seed: 3, frames: 40, cols: 80, rows: 24 });
+    for (const frame of frames) {
+      await ctx.proxy.write(frame);
+    }
+    await ctx.proxy.write(generateUniqueGlyphFlood(3000, 80));
+    await waitForRender(ctx);
+
+    // The synthetic frames erase the screen, so re-render the reference line and
+    // assert the (heavily churned) atlas still draws those glyphs correctly.
+    await writeAndWaitForRender(ctx, `\x1b[2J\x1b[H${REFERENCE_LINE}`);
+    const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+    for (let i = 0; i < REFERENCE_COLS.length; i++) {
+      expectSignatureMatches(after[i], reference[i], 14, `reference glyph at col ${REFERENCE_COLS[i]} corrupted after heavy render`);
+    }
+  });
+
+  test('replaying recorded TUI sessions renders without errors or atlas corruption', async () => {
+    const pageErrors: string[] = [];
+    const onError = (err: Error): void => {
+      pageErrors.push(err.message);
+    };
+    ctx.page.on('pageerror', onError);
+    try {
+      const fixtures = [
+        './test/fixtures/escape_sequence_files/t0090-alt_screen.in',
+        './test/fixtures/escape_sequence_files/t0502-bash_ls_color.in',
+        './test/fixtures/escape_sequence_files/t0500-bash_long_line.in',
+        './test/fixtures/escape_sequence_files/t0504-vim.in'
+      ];
+      for (const fixture of fixtures) {
+        const data = readFileSync(fixture, { encoding: 'latin1' });
+        await ctx.proxy.write(data);
+      }
+      await waitForRender(ctx);
+      await assertTextureAtlasPresent(ctx);
+
+      // Re-rendering the final frame must be idempotent (self-consistent): if the
+      // atlas were corrupted, a forced redraw would differ from what's shown.
+      const before = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+      await ctx.proxy.refresh(0, (await ctx.proxy.rows) - 1);
+      await waitForRender(ctx);
+      const after = await captureRowSignatures(ctx, 1, REFERENCE_COLS);
+      for (let i = 0; i < REFERENCE_COLS.length; i++) {
+        expectSignatureMatches(after[i], before[i], 14, `fixture replay frame not self-consistent at col ${REFERENCE_COLS[i]}`);
+      }
+      expect(pageErrors, `no page errors during fixture replay, got: ${pageErrors.join(', ')}`).toEqual([]);
+    } finally {
+      ctx.page.off('pageerror', onError);
+    }
+  });
+});
@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ * Produces BEFORE/AFTER screenshots of a single terminal under merge-heavy
+ * churn for manual inspection (before.png / after.png, mono-*.png). On current
+ * master the single-terminal merge path is healthy, so the pinned header lines
+ * are expected to remain readable in the "after" images; a corrupted header in
+ * these captures indicates a renderer regression. Note the mono "after" body is
+ * SUPPOSED to look like glyph soup — that is the mixed box-drawing/braille
+ * payload rendered faithfully, not corruption.
+ */
+import test from '@playwright/test';
+import { ITestContext, createTestContext, openTerminal } from '../../../test/playwright/TestUtils';
+import { loadWebglStrict, setMaxAtlasPages, writeAndWaitForRender } from '../../../test/playwright/RendererTestUtils';
+import { generateColoredAsciiFlood, generateMixedGlyphBlock } from '../../../test/playwright/SyntheticTui';
+
+test.describe('visual #322756', () => {
+  test.skip(({ browserName }) => browserName !== 'chromium');
+  test.describe.configure({ timeout: 60000 });
+
+  test('capture before/after pinned header under merge churn', async ({ browser }) => {
+    const ctx: ITestContext = await createTestContext(browser);
+    await openTerminal(ctx, { cols: 80, rows: 24 });
+    await loadWebglStrict(ctx);
+    await setMaxAtlasPages(ctx, 4);
+    const screen = ctx.page.locator('#terminal-container .xterm-screen');
+    // Header + readable sentences pinned at top; body region churns below.
+    await writeAndWaitForRender(ctx, '\x1b[?1049h\x1b[H\x1b[97mHEADER: THE QUICK BROWN FOX 0123456789\r\nSTATUS: this line should stay readable\r\n');
+    await screen.screenshot({ path: 'out-esbuild-test/playwright/before.png' });
+    for (let c = 0; c < 30; c++) {
+      await writeAndWaitForRender(ctx, '\x1b[5;1H' + generateColoredAsciiFlood(20 * 78, c * 20 * 78));
+    }
+    await screen.screenshot({ path: 'out-esbuild-test/playwright/after.png' });
+    await ctx.page.close();
+  });
+
+  // Issue-like framing: prefill realistic CLI text, force merges with a mixed
+  // glyph payload, then rewrite the top lines clean. The rewritten header lines
+  // must stay readable in mono-after.png.
+  test('capture mono before/after (issue-like)', async ({ browser }) => {
+    const ctx: ITestContext = await createTestContext(browser);
+    await openTerminal(ctx, { cols: 80, rows: 24 });
+    await loadWebglStrict(ctx);
+    await setMaxAtlasPages(ctx, 4);
+    const screen = ctx.page.locator('#terminal-container .xterm-screen');
+    // Prefill a screenful of normal-looking CLI output (all rendered fine).
+    await writeAndWaitForRender(ctx, '\x1b[?1049h\x1b[2J\x1b[H');
+    let pre = '';
+    for (let r = 0; r < 22; r++) {
+      pre += ` $ Shell inspect bundled MCP JSON schema for type enum values ${r} lines\r\n`;
+    }
+    await writeAndWaitForRender(ctx, pre);
+    await screen.screenshot({ path: 'out-esbuild-test/playwright/mono-before.png' });
+    // Overflow the atlas (cap=4) so pages MERGE while most rows keep their cells,
+    // then rewrite a few lines clean (like scroll/redraw).
+    for (let c = 0; c < 12; c++) {
+      let frame = '\x1b[3;1H';
+      frame += generateMixedGlyphBlock(c + 1, 18, 78);
+      await writeAndWaitForRender(ctx, frame);
+    }
+    await writeAndWaitForRender(ctx, '\x1b[1;1H\x1b[2K $ Shell grep installed Copilot CLI binary - 53 lines\r\n\x1b[2K Thought for 1s');
+    await screen.screenshot({ path: 'out-esbuild-test/playwright/mono-after.png' });
+    await ctx.page.close();
+  });
+});
@@ -67,8 +67,6 @@ export class AddonImageWindow extends BaseWindow implements IControlWindow {
    dlIip.appendChild(dtIip);
    this._addDdWithButton(dlIip, 'image-demo3', 'palette (png File)');
    this._addDdWithButton(dlIip, 'image-demo4', 'dice (qoi MultipartFile)');
-    this._addDdWithButton(dlIip, 'image-demo5', 'rose (webp File)');
-    this._addDdWithButton(dlIip, 'image-demo6', 'kimono (avif MultipartFile)');
    container.appendChild(dlIip);

    // Kitty demos
@@ -175,15 +173,11 @@ export class AddonImageWindow extends BaseWindow implements IControlWindow {
    document.getElementById('image-demo2')!.addEventListener('click',
      sixelDemo('https://raw.githubusercontent.com/jerch/node-sixel/master/testfiles/test2.sixel'));
    document.getElementById('image-demo3')!.addEventListener('click',
-      iipDemo('https://raw.githubusercontent.com/xtermjs/xterm.js/master/addons/addon-image/fixture/palette.png'));
+      iipDemo('https://raw.githubusercontent.com/jerch/node-sixel/master/palette.png'));
    document.getElementById('image-demo4')!.addEventListener('click',
-      iipDemoMulti('https://raw.githubusercontent.com/xtermjs/xterm.js/master/addons/addon-image/fixture/testimages/dice.qoi'));
-    document.getElementById('image-demo5')!.addEventListener('click',
-      iipDemo('https://raw.githubusercontent.com/xtermjs/xterm.js/master/addons/addon-image/fixture/testimages/1_webp_a.webp'));
-    document.getElementById('image-demo6')!.addEventListener('click',
-      iipDemoMulti('https://raw.githubusercontent.com/xtermjs/xterm.js/master/addons/addon-image/fixture/testimages/kimono.crop.avif'));
+      iipDemoMulti('https://raw.githubusercontent.com/jerch/xterm-wasm-parts/master/fixtures/qoi/dice.qoi'));
    document.getElementById('image-demo-kitty1')!.addEventListener('click',
-      kittyDemo('https://raw.githubusercontent.com/xtermjs/xterm.js/master/addons/addon-image/fixture/palette.png'));
+      kittyDemo('https://raw.githubusercontent.com/jerch/node-sixel/master/palette.png'));

    // demo for image retrieval API
    this._terminal.element!.addEventListener('click', (ev: MouseEvent) => {
@@ -203,8 +197,11 @@ export class AddonImageWindow extends BaseWindow implements IControlWindow {
      const pos = (this._terminal as any)._core._mouseCoordsService!.getCoords(ev, (this._terminal as any)._core.screenElement!, this._terminal.cols, this._terminal.rows);
      const x = pos[0] - 1;
      const y = pos[1] - 1;
-      // ctrl+click: get original image
-      const canvas = imageAddon.getImageAtBufferCell(x, this._terminal.buffer.active.viewportY + y);
+      const canvas = ev.shiftKey
+        // ctrl+shift+click: get single tile
+        ? imageAddon.extractTileAtBufferCell(x, this._terminal.buffer.active.viewportY + y)
+        // ctrl+click: get original image
+        : imageAddon.getImageAtBufferCell(x, this._terminal.buffer.active.viewportY + y);
      canvas?.toBlob(data => data && window.open(URL.createObjectURL(data), '_blank'));
    });
  }
@@ -12,33 +12,31 @@ export class WebglWindow extends BaseWindow implements IControlWindow {

  private _textureAtlasContainer!: HTMLElement;
  private _stressRunning = false;
-  private _scrollOutput: HTMLInputElement | undefined;
+  private _stressScrolling: HTMLInputElement | undefined;

  public build(container: HTMLElement): void {
-    const stressButtons = document.createElement('div');
+    const stressDiv = document.createElement('div');
    const stressStart = document.createElement('button');
    stressStart.id = 'stress-start';
    stressStart.textContent = 'atlas stress start';
    stressStart.addEventListener('click', () => this._stress());
-    stressButtons.appendChild(stressStart);
+    stressDiv.appendChild(stressStart);

    const stressStop = document.createElement('button');
    stressStop.id = 'stress-stop';
    stressStop.textContent = 'atlas stress stop';
    stressStop.addEventListener('click', () => this._stressRunning = false);
-    stressButtons.appendChild(stressStop);
-    container.appendChild(stressButtons);
+    stressDiv.appendChild(stressStop);

-    const stressOptions = document.createElement('div');
-    this._scrollOutput = document.createElement('input');
-    this._scrollOutput.type = 'checkbox';
-    this._scrollOutput.id = 'scroll-output';
-    stressOptions.appendChild(this._scrollOutput);
-    const scrollOutputLabel = document.createElement('label');
-    scrollOutputLabel.htmlFor = 'scroll-output';
-    scrollOutputLabel.textContent = 'Scroll output';
-    stressOptions.appendChild(scrollOutputLabel);
-    container.appendChild(stressOptions);
+    this._stressScrolling = document.createElement('input');
+    this._stressScrolling.type = 'checkbox';
+    this._stressScrolling.id = 'stress-scrolling';
+    stressDiv.appendChild(this._stressScrolling);
+    const stressScrollingLabel = document.createElement('label');
+    stressScrollingLabel.htmlFor = 'stress-scrolling';
+    stressScrollingLabel.textContent = 'stress scrolling';
+    stressDiv.appendChild(stressScrollingLabel);
+    container.appendChild(stressDiv);

    const zoomCheckbox = document.createElement('input');
    zoomCheckbox.type = 'checkbox';
@@ -82,7 +80,7 @@ export class WebglWindow extends BaseWindow implements IControlWindow {
      return;
    }
    this._stressRunning = true;
-    const scrollOutput = !!(this._scrollOutput?.checked);
+    const scrolling = !!(this._stressScrolling?.checked);
    for (let r = 0; r < 256; r += 2) {
      for (let g = 0; g < 256; g += 2) {
        let s: string[] = [];
@@ -93,7 +91,7 @@ export class WebglWindow extends BaseWindow implements IControlWindow {
          const rbg = `RGB: ${[r, g, b]}`;
          s.push(`\r\x1b[38;2;${r};${g};${b}m${rbg.padEnd(18, ' ')}${TEXT}`);
          if (s.length >= 16) {
-            if (scrollOutput) {
+            if (scrolling) {
              await new Promise<void>(r => this._terminal.write(s.join('\r\n') + '\r\n', r));
            } else {
              await new Promise<void>(r => this._terminal.write('\x1b[H' + s.join('\r\n'), r));
@@ -3061,16 +3061,16 @@
      }
    },
    "node_modules/brace-expansion": {
-      "version": "5.0.9",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
-      "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "balanced-match": "^4.0.2"
      },
      "engines": {
-        "node": "20 || >=22"
+        "node": "18 || 20 || >=22"
      }
    },
    "node_modules/braces": {
@@ -3519,15 +3519,15 @@
      }
    },
    "node_modules/concurrently": {
-      "version": "9.2.4",
-      "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-9.2.4.tgz",
-      "integrity": "sha512-TZ0CEhyzvFjgtAvHTusDMgj7wNdihCh7LLLrzdUOXIhdlnL2JBBGA9eJxR24rtqgmdjh3OA3hrN1rCHj6HM8qA==",
+      "version": "9.2.1",
+      "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-9.2.1.tgz",
+      "integrity": "sha512-fsfrO0MxV64Znoy8/l1vVIjjHa29SZyyqPgQBwhiDcaW8wJc2W3XWVOGx4M3oJBnv/zdUZIIp1gDeS98GzP8Ng==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "chalk": "4.1.2",
        "rxjs": "7.8.2",
-        "shell-quote": "1.9.0",
+        "shell-quote": "1.8.3",
        "supports-color": "8.1.1",
        "tree-kill": "1.2.2",
        "yargs": "17.7.2"
@@ -4308,9 +4308,9 @@
      }
    },
    "node_modules/express-ws/node_modules/ws": {
-      "version": "7.5.13",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.13.tgz",
-      "integrity": "sha512-rsKI6xDBFVf4r/x8XyChGK04QR/XHroxs/jUcoWvtEZM8TPU/X/uIY9B1CsSzYws9ZJb/6bbBu7dPhFW00CAoA==",
+      "version": "7.5.10",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.10.tgz",
+      "integrity": "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
@@ -4351,9 +4351,9 @@
      "license": "MIT"
    },
    "node_modules/fast-uri": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.5.tgz",
-      "integrity": "sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
+      "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==",
      "dev": true,
      "funding": [
        {
@@ -4749,9 +4749,9 @@
      "license": "MIT"
    },
    "node_modules/glob/node_modules/brace-expansion": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.4.tgz",
-      "integrity": "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg==",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
+      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -5795,9 +5795,9 @@
      "license": "MIT"
    },
    "node_modules/mocha/node_modules/brace-expansion": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.4.tgz",
-      "integrity": "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg==",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
+      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
@@ -7127,9 +7127,9 @@
      }
    },
    "node_modules/shell-quote": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.9.0.tgz",
-      "integrity": "sha512-Iov+JwFv/2HcTpcwNMKd8+IWNb8tboQJNQTkAY/LLVK7gGH9jy+LGkVqPxfekHl+yMmiqXszdGWXgkfml7hjqA==",
+      "version": "1.8.3",
+      "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz",
+      "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==",
      "dev": true,
      "license": "MIT",
      "engines": {
@@ -7975,9 +7975,9 @@
      }
    },
    "node_modules/undici": {
-      "version": "7.29.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.0.tgz",
-      "integrity": "sha512-IDxfleLmmbSskfWSUATiN1nfn2rDuvnMOqb5CWR92iIfojA0Ud+ulOAAEQ57LPr9rWmsreUyf5lwyao+7GNNVw==",
+      "version": "7.25.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.25.0.tgz",
+      "integrity": "sha512-xXnp4kTyor2Zq+J1FfPI6Eq3ew5h6Vl0F/8d9XU5zZQf1tX9s2Su1/3PiMmUANFULpmksxkClamIZcaUqryHsQ==",
      "dev": true,
      "license": "MIT",
      "engines": {
@@ -8452,9 +8452,9 @@
      "license": "ISC"
    },
    "node_modules/ws": {
-      "version": "8.21.3",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.3.tgz",
-      "integrity": "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==",
+      "version": "8.20.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.1.tgz",
+      "integrity": "sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==",
      "dev": true,
      "license": "MIT",
      "engines": {
@@ -492,7 +492,6 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {
      // https://issuetracker.google.com/issues/260170397
      this.textarea.setAttribute('aria-multiline', 'false');
    }
-    this.textarea.setAttribute('autocomplete', 'off');
    this.textarea.setAttribute('autocorrect', 'off');
    this.textarea.setAttribute('autocapitalize', 'off');
    this.textarea.setAttribute('spellcheck', 'false');
@@ -1137,13 +1136,13 @@ export class CoreBrowserTerminal extends CoreTerminal implements ITerminal {

    switch (type) {
      case WindowsOptionsReportType.GET_WIN_SIZE_PIXELS:
-        const canvasWidth = this._renderService.dimensions.device.canvas.width.toFixed(0);
-        const canvasHeight = this._renderService.dimensions.device.canvas.height.toFixed(0);
+        const canvasWidth = this._renderService.dimensions.css.canvas.width.toFixed(0);
+        const canvasHeight = this._renderService.dimensions.css.canvas.height.toFixed(0);
        this.coreService.triggerDataEvent(`${C0.ESC}[4;${canvasHeight};${canvasWidth}t`);
        break;
      case WindowsOptionsReportType.GET_CELL_SIZE_PIXELS:
-        const cellWidth = this._renderService.dimensions.device.cell.width.toFixed(0);
-        const cellHeight = this._renderService.dimensions.device.cell.height.toFixed(0);
+        const cellWidth = this._renderService.dimensions.css.cell.width.toFixed(0);
+        const cellHeight = this._renderService.dimensions.css.cell.height.toFixed(0);
        this.coreService.triggerDataEvent(`${C0.ESC}[6;${cellHeight};${cellWidth}t`);
        break;
    }
@@ -6,14 +6,16 @@
 import jsdom = require('jsdom');
 import { assert } from 'chai';
 import { DomRendererRowFactory } from './DomRendererRowFactory';
-import { DEFAULT_ATTR, FgFlags, BgFlags, Attributes, UnderlineStyle } from '../../../common/buffer/Constants';
+import { NULL_CELL_CODE, NULL_CELL_WIDTH, NULL_CELL_CHAR, DEFAULT_ATTR, FgFlags, BgFlags, Attributes, UnderlineStyle } from '../../../common/buffer/Constants';
 import { BufferLine, DEFAULT_ATTR_DATA } from '../../../common/buffer/BufferLine';
+import { BufferLineStringCache } from '../../../common/buffer/BufferLineStringCache';
 import { IBufferLine } from '../../../common/buffer/Types';
 import { CellData } from '../../../common/buffer/CellData';
 import { MockCoreService, MockDecorationService, MockOptionsService, createCellData, NULL_CELL_DATA } from '../../../common/TestUtils.test';
 import { MockCharacterJoinerService, MockCoreBrowserService, MockThemeService } from '../../TestUtils.test';
 import { TestWidthCache } from './WidthCache.test';

+const TEST_STRING_CACHE = new BufferLineStringCache();

 describe('DomRendererRowFactory', () => {
  let dom: jsdom.JSDOM;
@@ -515,7 +517,7 @@ describe('DomRendererRowFactory', () => {
  }

  function createEmptyLineData(cols: number): IBufferLine {
-    const lineData = new BufferLine(cols);
+    const lineData = new BufferLine(TEST_STRING_CACHE, cols);
    for (let i = 0; i < cols; i++) {
      lineData.setCell(i, NULL_CELL_DATA);
    }
@@ -7,10 +7,12 @@ import { assert } from 'chai';
 import { ICharacterJoinerService } from './Services';
 import { CharacterJoinerService } from './CharacterJoinerService';
 import { BufferLine } from '../../common/buffer/BufferLine';
+import { BufferLineStringCache } from '../../common/buffer/BufferLineStringCache';
 import { IBufferLine } from '../../common/buffer/Types';
 import { CellData } from '../../common/buffer/CellData';
 import { MockBufferService, createCellData } from '../../common/TestUtils.test';

+const TEST_STRING_CACHE = new BufferLineStringCache();

 describe('CharacterJoinerService', () => {
  let service: ICharacterJoinerService;
@@ -23,7 +25,7 @@ describe('CharacterJoinerService', () => {
    lines.set(2, lineData([['a -> b -', 0xFFFFFFFF], ['> c -> d', 0]]));

    lines.set(3, lineData([['no joined ranges']]));
-    lines.set(4, new BufferLine(0));
+    lines.set(4, new BufferLine(TEST_STRING_CACHE, 0));
    lines.set(5, lineData([['a', 0x11111111], [' -> b -> c -> '], ['d', 0x22222222]]));
    const line6 = lineData([['wi']]);
    line6.resize(line6.length + 1, createCellData(0, '￥', 2));
@@ -268,7 +270,7 @@ describe('CharacterJoinerService', () => {
 type IPartialLineData = ([string] | [string, number]);

 function lineData(data: IPartialLineData[]): IBufferLine {
-  const tline = new BufferLine(0);
+  const tline = new BufferLine(TEST_STRING_CACHE, 0);
  for (let i = 0; i < data.length; ++i) {
    const line = data[i][0];
    const attr = (data[i][1] || 0) as number;
@@ -9,11 +9,13 @@ import { SelectionModel } from '../selection/SelectionModel';
 import { IBuffer, IBufferLine } from '../../common/buffer/Types';
 import { MockBufferService, MockOptionsService, MockCoreService, MockMouseStateService, createCellData } from '../../common/TestUtils.test';
 import { BufferLine } from '../../common/buffer/BufferLine';
+import { BufferLineStringCache } from '../../common/buffer/BufferLineStringCache';
 import { IBufferService, IOptionsService } from '../../common/services/Services';
 import { MockCoreBrowserService, MockMouseService, MockRenderService } from '../TestUtils.test';
 import { CellData } from '../../common/buffer/CellData';
 import { IRenderService } from './Services';

+const TEST_STRING_CACHE = new BufferLineStringCache();

 class TestSelectionService extends SelectionService {
  constructor(
@@ -58,7 +60,7 @@ describe('SelectionService', () => {
  });

  function stringToRow(text: string): IBufferLine {
-    const result = new BufferLine(text.length);
+    const result = new BufferLine(TEST_STRING_CACHE, text.length);
    for (let i = 0; i < text.length; i++) {
      result.setCell(i, createCellData(0, text.charAt(i), 1));
    }
@@ -66,7 +68,7 @@ describe('SelectionService', () => {
  }

  function stringArrayToRow(chars: string[]): IBufferLine {
-    const line = new BufferLine(chars.length);
+    const line = new BufferLine(TEST_STRING_CACHE, chars.length);
    chars.map((c, idx) => line.setCell(idx, createCellData(0, c, 1)));
    return line;
  }
@@ -121,7 +123,7 @@ describe('SelectionService', () => {
        [0, 'o', 1, 'o'.charCodeAt(0)],
        [0, 'o', 1, 'o'.charCodeAt(0)]
      ];
-      const line = new BufferLine(data.length);
+      const line = new BufferLine(TEST_STRING_CACHE, data.length);
      for (let i = 0; i < data.length; ++i) line.setCell(i, CellData.fromCharData(data[i]));
      buffer.lines.set(0, line);
      // Ensure wide characters take up 2 columns
@@ -27,13 +27,11 @@ export class Emitter<T> {
      }

      const entry = { fn: listener, thisArgs };
-      this._listeners = this._listeners.slice();
      this._listeners.push(entry);

      const result = toDisposable(() => {
        const idx = this._listeners.indexOf(entry);
        if (idx !== -1) {
-          this._listeners = this._listeners.slice();
          this._listeners.splice(idx, 1);
        }
      });
@@ -52,16 +50,23 @@ export class Emitter<T> {
  }

  public fire(event: T): void {
-    if (this._disposed || !this._listeners.length) {
+    if (this._disposed) {
      return;
    }
-    if (this._listeners.length === 1) {
-      this._listeners[0].fn.call(this._listeners[0].thisArgs, event);
-      return;
-    }
-    const listeners = this._listeners;
-    for (let i = 0, len = listeners.length; i < len; ++i) {
-      listeners[i].fn.call(listeners[i].thisArgs, event);
+    switch (this._listeners.length) {
+      case 0: return;
+      case 1: {
+        const { fn, thisArgs } = this._listeners[0];
+        fn.call(thisArgs, event);
+        return;
+      }
+      default: {
+        // Snapshot listeners to allow modifications during iteration (2+ listeners)
+        const listeners = this._listeners.slice();
+        for (const { fn, thisArgs } of listeners) {
+          fn.call(thisArgs, event);
+        }
+      }
    }
  }

@@ -2394,54 +2394,6 @@ describe('InputHandler', () => {
    });
  });

-  describe('ED3 - erase saved lines', () => {
-    beforeEach(() => {
-      bufferService.resize(10, 5);
-    });
-    it('should stop locking the viewport when the scrollback the user scrolled into is erased', async () => {
-      for (let i = 0; i < 20; ++i) {
-        await inputHandler.parseP(`old ${i}\r\n`);
-      }
-      bufferService.scrollLines(-5);
-      assert.strictEqual(bufferService.isUserScrolling, true);
-
-      await inputHandler.parseP('\x1b[3J');
-
-      assert.strictEqual(bufferService.isUserScrolling, false);
-      assert.strictEqual(bufferService.buffer.ybase, 0);
-      assert.strictEqual(bufferService.buffer.ydisp, 0);
-
-      for (let i = 0; i < 20; ++i) {
-        await inputHandler.parseP(`new ${i}\r\n`);
-      }
-
-      assert.strictEqual(bufferService.buffer.ydisp, bufferService.buffer.ybase);
-    });
-    it('should not reset the scroll position when erasing scrollback on a resized alt buffer', async () => {
-      bufferService.resize(10, 50);
-      bufferService.resize(10, 5);
-      for (let i = 0; i < 20; ++i) {
-        await inputHandler.parseP(`old ${i}\r\n`);
-      }
-      bufferService.scrollLines(-5);
-      const ydisp = bufferService.buffer.ydisp;
-
-      await inputHandler.parseP('\x1b[?1049h');
-      for (let i = 0; i < 20; ++i) {
-        await inputHandler.parseP(`new ${i}\r\n`);
-      }
-      await inputHandler.parseP('\x1b[3J\x1b[?1049l');
-
-      assert.strictEqual(bufferService.isUserScrolling, true);
-      assert.strictEqual(bufferService.buffer.ydisp, ydisp);
-
-      await inputHandler.parseP('more\r\n');
-
-      assert.strictEqual(bufferService.isUserScrolling, true);
-      assert.strictEqual(bufferService.buffer.ydisp, ydisp);
-    });
-  });
-
  describe('DECSCA and DECSED/DECSEL', () => {
    it('default is unprotected', async () => {
      await inputHandler.parseP('some text');
@@ -1286,11 +1286,6 @@ export class InputHandler extends Disposable implements IInputHandler {
          this._activeBuffer.lines.trimStart(scrollBackSize);
          this._activeBuffer.ybase = Math.max(this._activeBuffer.ybase - scrollBackSize, 0);
          this._activeBuffer.ydisp = Math.max(this._activeBuffer.ydisp - scrollBackSize, 0);
-          // isUserScrolling tracks the normal buffer's viewport, so ED3 on the alt
-          // screen must not touch it
-          if (this._activeBuffer === this._bufferService.buffers.normal) {
-            this._bufferService.isUserScrolling = false;
-          }
          // Force a scroll event to refresh viewport
          this._onScroll.fire(0);
        }
@@ -139,7 +139,6 @@ export class AttributeData implements IAttributeData {
 */
 export class ExtendedAttrs implements IExtendedAttrs {
  private _ext: number = 0;
-  public payload: Object | undefined;
  public get ext(): number {
    if (this._urlId) {
      return (
@@ -208,6 +207,6 @@ export class ExtendedAttrs implements IExtendedAttrs {
   * that needs to be persistant in the buffer.
   */
  public isEmpty(): boolean {
-    return this.underlineStyle === UnderlineStyle.NONE && this._urlId === 0 && this.payload === undefined;
+    return this.underlineStyle === UnderlineStyle.NONE && this._urlId === 0;
  }
 }
@@ -8,14 +8,24 @@ import { Buffer } from './Buffer';
 import { CircularList } from '../CircularList';
 import { MockOptionsService, MockBufferService, MockLogService, createCellData } from '../TestUtils.test';
 import { BufferLine, DEFAULT_ATTR_DATA } from './BufferLine';
+import { BufferLineStringCache } from './BufferLineStringCache';
 import { CellData } from './CellData';
-
+import { ExtendedAttrs } from './AttributeData';

 const INIT_COLS = 80;
 const INIT_ROWS = 24;
 const INIT_SCROLLBACK = 1000;
+const TEST_STRING_CACHE = new BufferLineStringCache();

-class TestBuffer extends Buffer {}
+class TestBuffer extends Buffer {
+  public getStringCache(): BufferLineStringCache {
+    return (this as unknown as { _stringCache: BufferLineStringCache })._stringCache;
+  }
+
+  public getStringCacheClearTimeout(): unknown {
+    return (this.getStringCache() as unknown as { _clearTimeout: { value: unknown } })._clearTimeout.value;
+  }
+}

 describe('Buffer', () => {
  let optionsService: MockOptionsService;
@@ -1192,7 +1202,7 @@ describe('Buffer', () => {

  describe ('translateBufferLineToString', () => {
    it('should handle selecting a section of ascii text', () => {
-      const line = new BufferLine(4);
+      const line = new BufferLine(TEST_STRING_CACHE, 4);
      line.setCell(0, createCellData(0, 'a', 1));
      line.setCell(1, createCellData(0, 'b', 1));
      line.setCell(2, createCellData(0, 'c', 1));
@@ -1204,7 +1214,7 @@ describe('Buffer', () => {
    });

    it('should handle a cut-off double width character by including it', () => {
-      const line = new BufferLine(3);
+      const line = new BufferLine(TEST_STRING_CACHE, 3);
      line.setCell(0, createCellData(0, '語', 2));
      line.setCell(1, createCellData(0, '', 0));
      line.setCell(2, createCellData(0, 'a', 1));
@@ -1215,7 +1225,7 @@ describe('Buffer', () => {
    });

    it('should handle a zero width character in the middle of the string by not including it', () => {
-      const line = new BufferLine(3);
+      const line = new BufferLine(TEST_STRING_CACHE, 3);
      line.setCell(0, createCellData(0, '語', 2));
      line.setCell(1, createCellData(0, '', 0));
      line.setCell(2, createCellData(0, 'a', 1));
@@ -1232,7 +1242,7 @@ describe('Buffer', () => {
    });

    it('should handle single width emojis', () => {
-      const line = new BufferLine(2);
+      const line = new BufferLine(TEST_STRING_CACHE, 2);
      line.setCell(0, createCellData(0, '😁', 1));
      line.setCell(1, createCellData(0, 'a', 1));
      buffer.lines.set(0, line);
@@ -1245,7 +1255,7 @@ describe('Buffer', () => {
    });

    it('should handle double width emojis', () => {
-      const line = new BufferLine(2);
+      const line = new BufferLine(TEST_STRING_CACHE, 2);
      line.setCell(0, createCellData(0, '😁', 2));
      line.setCell(1, createCellData(0, '', 0));
      buffer.lines.set(0, line);
@@ -1256,7 +1266,7 @@ describe('Buffer', () => {
      const str2 = buffer.translateBufferLineToString(0, true, 0, 2);
      assert.equal(str2, '😁');

-      const line2 = new BufferLine(3);
+      const line2 = new BufferLine(TEST_STRING_CACHE, 3);
      line2.setCell(0, createCellData(0, '😁', 2));
      line2.setCell(1, createCellData(0, '', 0));
      line2.setCell(2, createCellData(0, 'a', 1));
@@ -1267,6 +1277,99 @@ describe('Buffer', () => {
    });
  });

+  describe('line string cache cleanup', () => {
+    it('should clear shared cache entries with a single timer', () => {
+      const originalSetTimeout = globalThis.setTimeout;
+      const originalClearTimeout = globalThis.clearTimeout;
+      const originalDateNow = Date.now;
+      let timeoutId = 0;
+      let now = 0;
+      const clearedTimeouts: number[] = [];
+      const scheduledTimeouts = new Map<number, { delay: number, fire: () => void }>();
+      (globalThis as any).setTimeout = ((handler: (...args: any[]) => void, timeout?: number) => {
+        const id = ++timeoutId;
+        scheduledTimeouts.set(id, {
+          delay: timeout ?? 0,
+          fire: () => {
+            scheduledTimeouts.delete(id);
+            handler();
+          }
+        });
+        return id as ReturnType<typeof setTimeout>;
+      }) as typeof setTimeout;
+      (globalThis as any).clearTimeout = ((id: ReturnType<typeof setTimeout>) => {
+        const numericId = id as unknown as number;
+        clearedTimeouts.push(numericId);
+        scheduledTimeouts.delete(numericId);
+      }) as typeof clearTimeout;
+      Date.now = () => now;
+      try {
+        buffer.fillViewportRows();
+        buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+        buffer.lines.get(1)!.setCell(0, createCellData(0, 'b', 1));
+
+        assert.equal(buffer.translateBufferLineToString(0, false), `a${' '.repeat(INIT_COLS - 1)}`);
+        assert.equal(buffer.translateBufferLineToString(1, false), `b${' '.repeat(INIT_COLS - 1)}`);
+
+        const cache = buffer.getStringCache();
+        assert.equal(cache.entries.size, 2);
+        assert.ok(buffer.getStringCacheClearTimeout() !== undefined);
+        assert.equal(scheduledTimeouts.size, 1);
+        assert.equal([...scheduledTimeouts.values()][0].delay, 15000);
+        const initialTimerCreationCount = timeoutId;
+
+        now = 5000;
+        assert.equal(buffer.translateBufferLineToString(0, false), `a${' '.repeat(INIT_COLS - 1)}`);
+        assert.equal(timeoutId, initialTimerCreationCount);
+        assert.equal(scheduledTimeouts.size, 1);
+        assert.deepEqual(clearedTimeouts, []);
+
+        now = 15000;
+        [...scheduledTimeouts.values()][0].fire();
+        assert.equal(timeoutId, initialTimerCreationCount + 1);
+        assert.ok(buffer.getStringCacheClearTimeout() !== undefined);
+        assert.equal(scheduledTimeouts.size, 1);
+        assert.equal([...scheduledTimeouts.values()][0].delay, 5000);
+
+        now = 20000;
+        [...scheduledTimeouts.values()][0].fire();
+
+        assert.equal(cache.entries.size, 0);
+        assert.equal(buffer.getStringCacheClearTimeout(), undefined);
+
+        assert.equal(buffer.translateBufferLineToString(0, false), `a${' '.repeat(INIT_COLS - 1)}`);
+        assert.equal(cache.entries.size, 1);
+      } finally {
+        Date.now = originalDateNow;
+        globalThis.setTimeout = originalSetTimeout;
+        globalThis.clearTimeout = originalClearTimeout;
+      }
+    });
+
+    it('should reset line string cache state on clear and resize', () => {
+      buffer.fillViewportRows();
+      buffer.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+      buffer.translateBufferLineToString(0, false);
+
+      const cache = buffer.getStringCache();
+      assert.equal(cache.entries.size, 1);
+      assert.ok(buffer.getStringCacheClearTimeout() !== undefined);
+
+      buffer.clear();
+      assert.equal(cache.entries.size, 0);
+      assert.equal(buffer.getStringCacheClearTimeout(), undefined);
+
+      buffer.fillViewportRows();
+      buffer.lines.get(0)!.setCell(0, createCellData(0, 'b', 1));
+      buffer.translateBufferLineToString(0, false);
+      assert.equal(cache.entries.size, 1);
+
+      buffer.resize(INIT_COLS - 1, INIT_ROWS);
+      assert.equal(cache.entries.size, 0);
+      assert.equal(buffer.getStringCacheClearTimeout(), undefined);
+    });
+  });
+
  describe('memory cleanup after shrinking', () => {
    it('should realign memory from idle task execution', async () => {
      buffer.fillViewportRows();
@@ -10,6 +10,7 @@ import { ICharset } from '../Types';
 import { IAttributeData, IBuffer, IBufferLine, ICellData } from './Types';
 import { ExtendedAttrs } from './AttributeData';
 import { BufferLine, DEFAULT_ATTR_DATA } from './BufferLine';
+import { BufferLineStringCache } from './BufferLineStringCache';
 import { getWrappedLineTrimmedLength, reflowLargerApplyNewLayout, reflowLargerCreateNewLayout, reflowLargerGetLinesToRemove, reflowSmallerGetNewLineLengths } from './BufferReflow';
 import { CellData } from './CellData';
 import { NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR, WHITESPACE_CELL_CODE, WHITESPACE_CELL_WIDTH } from './Constants';
@@ -51,6 +52,7 @@ export class Buffer extends Disposable implements IBuffer {
  private _isClearing: boolean = false;
  private _memoryCleanupQueue: InstanceType<typeof IdleTaskQueue>;
  private _memoryCleanupPosition = 0;
+  private readonly _stringCache: BufferLineStringCache;

  constructor(
    private _hasScrollback: boolean,
@@ -68,6 +70,7 @@ export class Buffer extends Disposable implements IBuffer {
    this._memoryCleanupQueue = new IdleTaskQueue(this._logService);
    this._register(toDisposable(() => this._memoryCleanupQueue.clear()));
    this._register(toDisposable(() => this.clearAllMarkers()));
+    this._stringCache = this._register(new BufferLineStringCache());
  }

  public getNullCell(attr?: IAttributeData): ICellData {
@@ -97,7 +100,7 @@ export class Buffer extends Disposable implements IBuffer {
  }

  public getBlankLine(attr: IAttributeData, isWrapped?: boolean): IBufferLine {
-    return new BufferLine(this._bufferService.cols, this.getNullCell(attr), isWrapped);
+    return new BufferLine(this._stringCache, this._bufferService.cols, this.getNullCell(attr), isWrapped);
  }

  public get hasScrollback(): boolean {
@@ -142,6 +145,7 @@ export class Buffer extends Disposable implements IBuffer {
   * Clears the buffer to its initial state, discarding all previous data.
   */
  public clear(): void {
+    this._stringCache.clear();
    this.ydisp = 0;
    this.ybase = 0;
    this.y = 0;
@@ -160,6 +164,7 @@ export class Buffer extends Disposable implements IBuffer {
  public resize(newCols: number, newRows: number): void {
    // store reference to null cell with default attrs
    const nullCell = this.getNullCell(DEFAULT_ATTR_DATA);
+    this._stringCache.clear();

    // count bufferlines with overly big memory to be cleaned afterwards
    let dirtyMemoryLines = 0;
@@ -194,7 +199,7 @@ export class Buffer extends Disposable implements IBuffer {
            if (this._optionsService.rawOptions.windowsPty.backend !== undefined || this._optionsService.rawOptions.windowsPty.buildNumber !== undefined) {
              // Just add the new missing rows on Windows as conpty reprints the screen with its
              // view of the world. Once a line enters scrollback for conpty it remains there
-              this.lines.push(new BufferLine(newCols, nullCell, false));
+              this.lines.push(new BufferLine(this._stringCache, newCols, nullCell, false));
            } else {
              if (this.ybase > 0 && this.lines.length <= this.ybase + this.y + addToY + 1) {
                // There is room above the buffer and there are no empty elements below the line,
@@ -208,7 +213,7 @@ export class Buffer extends Disposable implements IBuffer {
              } else {
                // Add a blank line if there is no buffer left at the top to scroll to, or if there
                // are blank lines after the cursor
-                this.lines.push(new BufferLine(newCols, nullCell, false));
+                this.lines.push(new BufferLine(this._stringCache, newCols, nullCell, false));
              }
            }
          }
@@ -349,7 +354,7 @@ export class Buffer extends Disposable implements IBuffer {
        }
        if (this.lines.length < newRows) {
          // Add an extra row at the bottom of the viewport
-          this.lines.push(new BufferLine(newCols, nullCell, false));
+          this.lines.push(new BufferLine(this._stringCache, newCols, nullCell, false));
        }
      } else {
        if (this.ydisp === this.ybase) {
@@ -4,16 +4,19 @@
 */
 import { NULL_CELL_CHAR, NULL_CELL_WIDTH, NULL_CELL_CODE, DEFAULT_ATTR, Content, UnderlineStyle, BgFlags, Attributes, FgFlags } from './Constants';
 import { BufferLine } from './BufferLine';
+import { BufferLineStringCache } from './BufferLineStringCache';
 import { CellData } from './CellData';
 import { CharData, IBufferLine, ICellData } from './Types';
 import { assert } from 'chai';
 import { AttributeData } from './AttributeData';
 import { createCellData, NULL_CELL_DATA, extendedAttributes } from '../TestUtils.test';

+const TEST_STRING_CACHE = new BufferLineStringCache();
+

 class TestBufferLine extends BufferLine {
  constructor(cols: number, fillCellData?: ICellData, isWrapped: boolean = false) {
-    super(cols, fillCellData, isWrapped);
+    super(TEST_STRING_CACHE, cols, fillCellData, isWrapped);
  }

  public get combined(): {[index: number]: string} {
@@ -21,19 +24,19 @@ class TestBufferLine extends BufferLine {
  }

  public get cachedString(): string | undefined {
-    return this._cacheValid ? this._cache : undefined;
+    return this._getStringCacheEntry(false)?.value;
  }

  public set cachedString(value: string | undefined) {
-    this._cache = value ?? '';
+    this._getStringCacheEntry(true)!.value = value;
  }

  public get isCachedStringTrimmed(): boolean {
-    return this._cacheTrimmed;
+    return this._getStringCacheEntry(false)?.isTrimmed ?? false;
  }

  public set isCachedStringTrimmed(value: boolean) {
-    this._cacheTrimmed = value;
+    this._getStringCacheEntry(true)!.isTrimmed = value;
  }

  public toArray(): CharData[] {
@@ -8,6 +8,7 @@ import { AttributeData } from './AttributeData';
 import { CellData } from './CellData';
 import { Attributes, BgFlags, CHAR_DATA_ATTR_INDEX, CHAR_DATA_CHAR_INDEX, CHAR_DATA_WIDTH_INDEX, Content, NULL_CELL_CHAR, NULL_CELL_CODE, NULL_CELL_WIDTH, WHITESPACE_CELL_CHAR } from './Constants';
 import { stringFromCodePoint } from '../input/TextDecoder';
+import { StringBuilder } from '../StringBuilder';

 // Buffer memory layout:
 //
@@ -36,20 +37,24 @@ const enum Cell {
  BG = 2  // currently unused
 }

-
-interface IExtendedAttrsExt extends IExtendedAttrs {
-  _ext: number;
-  _urlId: number;
-}
-
-
 export const DEFAULT_ATTR_DATA = Object.freeze(new AttributeData());

 // Work variables to avoid garbage collection
 let $startIndex = 0;
 const $workCell = new CellData();
-const $extended = DEFAULT_ATTR_DATA.extended.clone() as IExtendedAttrsExt;
+const $translateToStringBuilder = new StringBuilder();

+export interface IBufferLineStringCacheEntry {
+  value: string | undefined;
+  isTrimmed: boolean;
+  generation: number;
+}
+
+export interface IBufferLineStringCache {
+  generation: number;
+  allocateEntry(): IBufferLineStringCacheEntry;
+  touch?(): void;
+}

 /**
 * Typed array based bufferline implementation.
@@ -72,14 +77,11 @@ export class BufferLine implements IBufferLine {
  protected _combined: {[index: number]: string} = {};
  /** Sparse cache; only read when `HAS_EXTENDED` is set in `_data`. */
  protected _extendedAttrs: {[index: number]: IExtendedAttrs | undefined} = {};
+  protected _stringCacheEntryRef: WeakRef<IBufferLineStringCacheEntry> | undefined;
  public length: number;

-  /** line text cache */
-  protected _cacheValid = false;
-  protected _cache: string = '';
-  protected _cacheTrimmed = false;
-
  constructor(
+    protected readonly _stringCache: IBufferLineStringCache,
    cols: number,
    fillCellData?: ICellData,
    public isWrapped: boolean = false
@@ -116,7 +118,7 @@ export class BufferLine implements IBufferLine {
   * @deprecated
   */
  public set(index: number, value: CharData): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    this._data[index * Constants.CELL_INDICIES + Cell.FG] = value[CHAR_DATA_ATTR_INDEX];
    if (value[CHAR_DATA_CHAR_INDEX].length > 1) {
      this._combined[index] = value[1];
@@ -208,30 +210,21 @@ export class BufferLine implements IBufferLine {
    } else {
      cell.combinedData = '';
    }
-    cell.extended = this.getExtended(index);
-    return cell;
-  }
-
-  public getExtended(index: number): IExtendedAttrs {
-    $startIndex = index * Constants.CELL_INDICIES;
-    if (this._data[$startIndex + Cell.BG] & BgFlags.HAS_EXTENDED) {
-      return this._extendedAttrs[index]!;
+    if (cell.bg & BgFlags.HAS_EXTENDED) {
+      cell.extended = this._extendedAttrs[index]!;
+    } else {
+      // Do not mutate cell.extended in place: it may still reference this line's map entry from a
+      // prior loadCell into a reused CellData (e.g. $workCell during insert/delete).
+      cell.extended = DEFAULT_ATTR_DATA.extended.clone();
    }
-    // Do not mutate cell.extended in place: it may still reference this line's map entry from a
-    // prior loadCell into a reused CellData (e.g. $workCell during insert/delete).
-    // We use $extended as blueprint and reset the internals
-    // mimicking the ctor to avoid a new allocation.
-    $extended._ext = 0;
-    $extended._urlId = 0;
-    $extended.payload = undefined;
-    return $extended;
+    return cell;
  }

  /**
   * Set data at `index` to `cell`.
   */
  public setCell(index: number, cell: ICellData): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    if (cell.content & Content.IS_COMBINED_MASK) {
      this._combined[index] = cell.combinedData;
    }
@@ -249,14 +242,13 @@ export class BufferLine implements IBufferLine {
   * it gets an optimized access method.
   */
  public setCellFromCodepoint(index: number, codePoint: number, width: number, attrs: IAttributeData): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    if (attrs.bg & BgFlags.HAS_EXTENDED) {
      this._extendedAttrs[index] = attrs.extended;
    }
-    const $idx = index * Constants.CELL_INDICIES;
-    this._data[$idx + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
-    this._data[$idx + Cell.FG] = attrs.fg;
-    this._data[$idx + Cell.BG] = attrs.bg;
+    this._data[index * Constants.CELL_INDICIES + Cell.CONTENT] = codePoint | (width << Content.WIDTH_SHIFT);
+    this._data[index * Constants.CELL_INDICIES + Cell.FG] = attrs.fg;
+    this._data[index * Constants.CELL_INDICIES + Cell.BG] = attrs.bg;
  }

  /**
@@ -266,7 +258,7 @@ export class BufferLine implements IBufferLine {
   * by the previous `setDataFromCodePoint` call, we can omit it here.
   */
  public addCodepointToCell(index: number, codePoint: number, width: number): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    let content = this._data[index * Constants.CELL_INDICIES + Cell.CONTENT];
    if (content & Content.IS_COMBINED_MASK) {
      // we already have a combined string, simply add
@@ -293,7 +285,7 @@ export class BufferLine implements IBufferLine {
  }

  public insertCells(pos: number, n: number, fillCellData: ICellData): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    pos %= this.length;

    // handle fullwidth at pos: reset cell one to the left if pos is second cell of a wide char
@@ -321,7 +313,7 @@ export class BufferLine implements IBufferLine {
  }

  public deleteCells(pos: number, n: number, fillCellData: ICellData): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    pos %= this.length;
    if (n < this.length - pos) {
      for (let i = 0; i < this.length - pos - n; ++i) {
@@ -348,7 +340,7 @@ export class BufferLine implements IBufferLine {
  }

  public replaceCells(start: number, end: number, fillCellData: ICellData, respectProtect: boolean = false): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    // full branching on respectProtect==true, hopefully getting fast JIT for standard case
    if (respectProtect) {
      if (start && this.getWidth(start - 1) === 2 && !this.isProtected(start - 1)) {
@@ -388,7 +380,7 @@ export class BufferLine implements IBufferLine {
   * excess memory (true after shrinking > Constants.CLEANUP_THRESHOLD).
   */
  public resize(cols: number, fillCellData: ICellData): boolean {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    if (cols === this.length) {
      return this._data.length * 4 * Constants.CLEANUP_THRESHOLD < this._data.buffer.byteLength;
    }
@@ -448,7 +440,7 @@ export class BufferLine implements IBufferLine {

  /** fill a line with fillCharData */
  public fill(fillCellData: ICellData, respectProtect: boolean = false): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    // full branching on respectProtect==true, hopefully getting fast JIT for standard case
    if (respectProtect) {
      for (let i = 0; i < this.length; ++i) {
@@ -466,7 +458,8 @@ export class BufferLine implements IBufferLine {
  }

  /** alter to a full copy of line  */
-  public copyFrom(line: BufferLine, blank?: boolean): void {
+  public copyFrom(line: BufferLine): void {
+    this._invalidateStringCache();
    if (this.length !== line.length) {
      this._data = new Uint32Array(line._data);
    } else {
@@ -474,29 +467,16 @@ export class BufferLine implements IBufferLine {
      this._data.set(line._data);
    }
    this.length = line.length;
-    if (blank) {
-      // a blank line may never hold combined or extended attrs,
-      // thus we can skip handling them
-      this._combined = {};
-      this._extendedAttrs = {};
-    } else {
-      this._copySparseMapsFrom(line);
-    }
-    this._cache = '';
-    this._cacheValid = false;
+    this._copySparseMapsFrom(line);
    this.isWrapped = line.isWrapped;
  }

  /** create a new clone */
-  public clone(blank?: boolean): IBufferLine {
-    const newLine = new BufferLine(0, undefined, false);
+  public clone(): IBufferLine {
+    const newLine = new BufferLine(this._stringCache, 0, undefined, false);
    newLine._data = new Uint32Array(this._data);
    newLine.length = this.length;
-    if (!blank) {
-      // a blank line may never hold combined or extended attrs,
-      // thus we can skip handling them
-      newLine._copySparseMapsFrom(this);
-    }
+    newLine._copySparseMapsFrom(this);
    newLine.isWrapped = this.isWrapped;
    return newLine;
  }
@@ -520,7 +500,7 @@ export class BufferLine implements IBufferLine {
  }

  public copyCellsFrom(src: BufferLine, srcCol: number, destCol: number, length: number, applyInReverse: boolean): void {
-    this._cacheValid = false;
+    this._invalidateStringCache();
    const srcData = src._data;
    if (applyInReverse) {
      for (let cell = length - 1; cell >= 0; cell--) {
@@ -554,13 +534,17 @@ export class BufferLine implements IBufferLine {
   * returned string, the corresponding entries in `outColumns` will have the same column number.
   */
  public translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string {
-    const isCanonical = (startCol === undefined || startCol === 0) && endCol === undefined && outColumns === undefined;
-    if (isCanonical && this._cacheValid) {
+    const isCanonicalRequest = (startCol === undefined || startCol === 0) && endCol === undefined && outColumns === undefined;
+    if (isCanonicalRequest) {
+      this._stringCache.touch?.();
+    }
+    const stringCacheEntry = isCanonicalRequest ? this._getStringCacheEntry(false) : undefined;
+    if (isCanonicalRequest && stringCacheEntry?.value !== undefined) {
      if (trimRight) {
-        return this._cacheTrimmed ? this._cache : this._cache.trimEnd();
+        return stringCacheEntry.isTrimmed ? stringCacheEntry.value : stringCacheEntry.value.trimEnd();
      }
-      if (!this._cacheTrimmed) {
-        return this._cache;
+      if (!stringCacheEntry.isTrimmed) {
+        return stringCacheEntry.value;
      }
    }
    startCol = startCol ?? 0;
@@ -571,12 +555,12 @@ export class BufferLine implements IBufferLine {
    if (outColumns) {
      outColumns.length = 0;
    }
-    const cellContents: string[] = [];
+    $translateToStringBuilder.reset();
    while (startCol < endCol) {
      const content = this._data[startCol * Constants.CELL_INDICIES + Cell.CONTENT];
      const cp = content & Content.CODEPOINT_MASK;
      const chars = (content & Content.IS_COMBINED_MASK) ? this._combined[startCol] : (cp) ? stringFromCodePoint(cp) : WHITESPACE_CELL_CHAR;
-      cellContents.push(chars);
+      $translateToStringBuilder.append(chars);
      if (outColumns) {
        for (let i = 0; i < chars.length; ++i) {
          outColumns.push(startCol);
@@ -587,15 +571,39 @@ export class BufferLine implements IBufferLine {
    if (outColumns) {
      outColumns.push(startCol);
    }
-    const result = cellContents.join('');
-    if (isCanonical) {
-      this._cache = result;
-      this._cacheValid = true;
-      this._cacheTrimmed = !!trimRight;
+    const result = $translateToStringBuilder.toString();
+    $translateToStringBuilder.reset();
+    if (isCanonicalRequest) {
+      const cacheEntry = this._getStringCacheEntry(true)!;
+      cacheEntry.value = result;
+      cacheEntry.isTrimmed = !!trimRight;
    }
    return result;
  }

+  protected _getStringCacheEntry(createIfNeeded: boolean): IBufferLineStringCacheEntry | undefined {
+    const cachedEntry = this._stringCacheEntryRef?.deref();
+    if (cachedEntry) {
+      if (cachedEntry.generation === this._stringCache.generation) {
+        return cachedEntry;
+      }
+    }
+    if (!createIfNeeded) {
+      return undefined;
+    }
+    const cacheEntry = this._stringCache.allocateEntry();
+    this._stringCacheEntryRef = new WeakRef(cacheEntry);
+    return cacheEntry;
+  }
+
+  private _invalidateStringCache(): void {
+    const cacheEntry = this._getStringCacheEntry(false);
+    if (cacheEntry) {
+      cacheEntry.value = undefined;
+      cacheEntry.isTrimmed = false;
+    }
+  }
+
  /** Copy sparse map entries for a single cell when `_data` flags require them. */
  private _copyCellMapsFrom(src: BufferLine, srcCol: number, destCol: number): void {
    const srcStart = srcCol * Constants.CELL_INDICIES;
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2026 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import type { IBufferLineStringCache, IBufferLineStringCacheEntry } from './BufferLine';
+import { disposableTimeout } from '../Async';
+import { Disposable, MutableDisposable, toDisposable, type IDisposable } from '../Lifecycle';
+
+const enum Constants {
+  CACHE_TTL_MS = 15000
+}
+
+export class BufferLineStringCache extends Disposable implements IBufferLineStringCache {
+  public generation: number = 0;
+  public readonly entries: Set<IBufferLineStringCacheEntry> = new Set();
+  private readonly _clearTimeout = this._register(new MutableDisposable<IDisposable>());
+  private _lastAccessTimestamp: number = 0;
+
+  constructor() {
+    super();
+    this._register(toDisposable(() => this.entries.clear()));
+  }
+
+  public touch(): void {
+    this._scheduleClear();
+  }
+
+  public allocateEntry(): IBufferLineStringCacheEntry {
+    const entry: IBufferLineStringCacheEntry = {
+      value: undefined,
+      isTrimmed: false,
+      generation: this.generation
+    };
+    this.entries.add(entry);
+    this._scheduleClear();
+    return entry;
+  }
+
+  public clear(): void {
+    this._clearTimeout.clear();
+    this._lastAccessTimestamp = 0;
+    this.generation++;
+    for (const entry of this.entries) {
+      entry.value = undefined;
+      entry.isTrimmed = false;
+    }
+    this.entries.clear();
+  }
+
+  private _scheduleClear(): void {
+    this._lastAccessTimestamp = Date.now();
+    if (this._clearTimeout.value) {
+      return;
+    }
+    this._scheduleClearTimeout(Constants.CACHE_TTL_MS);
+  }
+
+  private _scheduleClearTimeout(timeoutMs: number): void {
+    this._clearTimeout.value = disposableTimeout(() => {
+      const elapsed = Date.now() - this._lastAccessTimestamp;
+      if (elapsed >= Constants.CACHE_TTL_MS) {
+        this.clear();
+        return;
+      }
+      this._scheduleClearTimeout(Constants.CACHE_TTL_MS - elapsed);
+    }, timeoutMs);
+  }
+}
@@ -5,16 +5,18 @@
 import { assert } from 'chai';
 import { CircularList } from '../CircularList';
 import { BufferLine } from './BufferLine';
+import { BufferLineStringCache } from './BufferLineStringCache';
 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';

+const TEST_STRING_CACHE = new BufferLineStringCache();

 describe('BufferReflow', () => {
  describe('reflowSmallerGetNewLineLengths', () => {
    it('should return correct line lengths for a small line with wide characters', () => {
-      const line = new BufferLine(4);
+      const line = new BufferLine(TEST_STRING_CACHE, 4);
      line.set(0, [0, '汉', 2, '汉'.charCodeAt(0)]);
      line.set(1, [0, '', 0, 0]);
      line.set(2, [0, '语', 2, '语'.charCodeAt(0)]);
@@ -24,7 +26,7 @@ describe('BufferReflow', () => {
      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 4, 2), [2, 2], 'line: 汉, 语');
    });
    it('should return correct line lengths for a large line with wide characters', () => {
-      const line = new BufferLine(12);
+      const line = new BufferLine(TEST_STRING_CACHE, 12);
      for (let i = 0; i < 12; i += 4) {
        line.set(i, [0, '汉', 2, '汉'.charCodeAt(0)]);
        line.set(i + 2, [0, '语', 2, '语'.charCodeAt(0)]);
@@ -46,7 +48,7 @@ describe('BufferReflow', () => {
      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 12, 2), [2, 2, 2, 2, 2, 2], 'line: 汉, 语, 汉, 语, 汉, 语');
    });
    it('should return correct line lengths for a string with wide and single characters', () => {
-      const line = new BufferLine(6);
+      const line = new BufferLine(TEST_STRING_CACHE, 6);
      line.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]);
      line.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]);
      line.set(2, [0, '', 0, 0]);
@@ -60,14 +62,14 @@ describe('BufferReflow', () => {
      assert.deepEqual(reflowSmallerGetNewLineLengths([line], 6, 2), [1, 2, 2, 1], 'line: a, 汉, 语, b');
    });
    it('should return correct line lengths for a wrapped line with wide and single characters', () => {
-      const line1 = new BufferLine(6);
+      const line1 = new BufferLine(TEST_STRING_CACHE, 6);
      line1.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]);
      line1.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]);
      line1.set(2, [0, '', 0, 0]);
      line1.set(3, [0, '语', 2, '语'.charCodeAt(0)]);
      line1.set(4, [0, '', 0, 0]);
      line1.set(5, [0, 'b', 1, 'b'.charCodeAt(0)]);
-      const line2 = new BufferLine(6, undefined, true);
+      const line2 = new BufferLine(TEST_STRING_CACHE, 6, undefined, true);
      line2.set(0, [0, 'a', 1, 'a'.charCodeAt(0)]);
      line2.set(1, [0, '汉', 2, '汉'.charCodeAt(0)]);
      line2.set(2, [0, '', 0, 0]);
@@ -82,7 +84,7 @@ describe('BufferReflow', () => {
      assert.deepEqual(reflowSmallerGetNewLineLengths([line1, line2], 6, 2), [1, 2, 2, 2, 2, 2, 1], 'lines: a, 汉, 语, ba, 汉, 语, b');
    });
    it('should work on lines ending in null space', () => {
-      const line = new BufferLine(5);
+      const line = new BufferLine(TEST_STRING_CACHE, 5);
      line.set(0, [0, '汉', 2, '汉'.charCodeAt(0)]);
      line.set(1, [0, '', 0, 0]);
      line.set(2, [0, '语', 2, '语'.charCodeAt(0)]);
@@ -100,7 +102,7 @@ describe('BufferReflow', () => {
    function createWrappedLines(chars: string): CircularList<IBufferLine> {
      const lines = new CircularList<IBufferLine>(chars.length);
      for (let i = 0; i < chars.length; i++) {
-        const line = new BufferLine(1);
+        const line = new BufferLine(TEST_STRING_CACHE, 1);
        line.set(0, [0, chars[i], 1, chars.charCodeAt(i)]);
        line.isWrapped = i > 0;
        lines.push(line);
@@ -82,4 +82,45 @@ describe('BufferSet', () => {
      assert.equal(bufferSet.alt.markers.length, 0);
    });
  });
+
+  describe('lifecycle', () => {
+    it('should dispose previous buffers on reset', () => {
+      const oldNormal = bufferSet.normal as any;
+      oldNormal.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+      oldNormal.translateBufferLineToString(0, false);
+
+      const oldCache = oldNormal._stringCache;
+      assert.equal(oldCache.entries.size, 1);
+      assert.notEqual(oldCache._clearTimeout.value, undefined);
+
+      bufferSet.reset();
+
+      assert.notEqual(bufferSet.normal, oldNormal);
+      assert.equal(oldCache.entries.size, 0);
+      assert.equal(oldCache._clearTimeout.value, undefined);
+    });
+
+    it('should dispose both buffers when disposed', () => {
+      const normal = bufferSet.normal as any;
+      normal.lines.get(0)!.setCell(0, createCellData(0, 'a', 1));
+      normal.translateBufferLineToString(0, false);
+
+      bufferSet.activateAltBuffer();
+      const alt = bufferSet.alt as any;
+      alt.lines.get(0)!.setCell(0, createCellData(0, 'b', 1));
+      alt.translateBufferLineToString(0, false);
+
+      const normalCache = normal._stringCache;
+      const altCache = alt._stringCache;
+      assert.notEqual(normalCache._clearTimeout.value, undefined);
+      assert.notEqual(altCache._clearTimeout.value, undefined);
+
+      bufferSet.dispose();
+
+      assert.equal(normalCache.entries.size, 0);
+      assert.equal(altCache.entries.size, 0);
+      assert.equal(normalCache._clearTimeout.value, undefined);
+      assert.equal(altCache._clearTimeout.value, undefined);
+    });
+  });
 });
@@ -20,7 +20,6 @@ export interface IExtendedAttrs {
  underlineColor: number;
  underlineVariantOffset: number;
  urlId: number;
-  payload: Object | undefined;
  clone(): IExtendedAttrs;
  isEmpty(): boolean;
 }
@@ -132,8 +131,8 @@ export interface IBufferLine {
  resize(cols: number, fill: ICellData): boolean;
  cleanupMemory(): number;
  fill(fillCellData: ICellData, respectProtect?: boolean): void;
-  copyFrom(line: IBufferLine, blank?: boolean): void;
-  clone(blank?: boolean): IBufferLine;
+  copyFrom(line: IBufferLine): void;
+  clone(): IBufferLine;
  getTrimmedLength(): number;
  getNoBgTrimmedLength(): number;
  translateToString(trimRight?: boolean, startCol?: number, endCol?: number, outColumns?: number[]): string;
@@ -147,7 +146,6 @@ export interface IBufferLine {
  getCodePoint(index: number): number;
  isCombined(index: number): number;
  getString(index: number): string;
-  getExtended(index: number): IExtendedAttrs;
 }

 export interface IMarker extends IDisposable {
@@ -86,12 +86,12 @@ export class BufferService extends Disposable implements IBufferService {
      // Insert the line using the fastest method
      if (bottomRow === buffer.lines.length - 1) {
        if (willBufferBeTrimmed) {
-          buffer.lines.recycle().copyFrom(newLine, true);
+          buffer.lines.recycle().copyFrom(newLine);
        } else {
-          buffer.lines.push(newLine.clone(true));
+          buffer.lines.push(newLine.clone());
        }
      } else {
-        buffer.lines.splice(bottomRow + 1, 0, newLine.clone(true));
+        buffer.lines.splice(bottomRow + 1, 0, newLine.clone());
      }

      // Only adjust ybase and ydisp when the buffer is not trimmed
@@ -113,7 +113,7 @@ export class BufferService extends Disposable implements IBufferService {
      // scrollback, instead we can just shift them in-place.
      const scrollRegionHeight = bottomRow - topRow + 1 /* as it's zero-based */;
      buffer.lines.shiftElements(topRow + 1, scrollRegionHeight - 1, -1);
-      buffer.lines.set(bottomRow, newLine.clone(true));
+      buffer.lines.set(bottomRow, newLine.clone());
    }

    // Move the viewport to the bottom of the buffer unless the user is
@@ -214,7 +214,7 @@ export class DecorationLineCache extends Disposable {
  }

  private _handleBufferLinesTrim(amount: number): void {
-    if (amount <= 0 || !this._decorationsByLine.size) {
+    if (amount <= 0) {
      return;
    }
    const newMap = new Map<number, IInternalDecoration[]>();
@@ -0,0 +1,362 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IImage32, decodePng } from '@lunapaint/png-codec';
+import { expect } from '@playwright/test';
+import { ITestContext } from './TestUtils';
+import { generateUniqueGlyphFlood } from './SyntheticTui';
+
+/**
+ * A decoded screenshot of a terminal's render surface together with its grid
+ * dimensions, used to sample per-cell pixels.
+ */
+export interface IRendererFrame {
+  cols: number;
+  rows: number;
+  decoded: IImage32;
+}
+
+/**
+ * A coarse, downsampled fingerprint of a single cell's rendered pixels. It is an
+ * `grid * grid` array of averaged `[r, g, b, a]` sub-cell colors, flattened.
+ *
+ * Averaging makes the signature tolerant to sub-pixel antialiasing differences
+ * (which vary slightly even under SwiftShader) while still changing massively
+ * when a glyph is garbled, blank, or drawn from the wrong texture atlas page.
+ */
+export type CellSignature = number[];
+
+const DEFAULT_GRID = 4;
+const DEFAULT_SCREEN_SELECTOR = '#terminal-container .xterm-screen';
+
+/**
+ * Captures a fresh screenshot of a terminal render surface and decodes it.
+ *
+ * Unlike the cached helper in `SharedRendererTests.ts`, this always takes a new
+ * screenshot and accepts a `selector` so multiple terminals (each in their own
+ * container) can be sampled independently in the same test.
+ * @param ctx The test context.
+ * @param selector CSS selector for the `.xterm-screen` element to capture.
+ * @param termGlobal Name of the `window` terminal global to read grid dimensions
+ * from (default `'term'`); use e.g. `'termB'` for multi-terminal tests.
+ */
+export async function captureFrame(
+  ctx: ITestContext,
+  selector: string = DEFAULT_SCREEN_SELECTOR,
+  termGlobal: string = 'term'
+): Promise<IRendererFrame> {
+  const screenshotOptions = process.env.DEBUG
+    ? { path: `out-esbuild-test/playwright/screenshot-${termGlobal}.png` }
+    : undefined;
+  const buffer = await ctx.page.locator(selector).screenshot(screenshotOptions);
+  const grid = await ctx.page.evaluate((name) => {
+    const term = (window as any)[name];
+    return { cols: term.cols as number, rows: term.rows as number };
+  }, termGlobal);
+  return {
+    cols: grid.cols,
+    rows: grid.rows,
+    decoded: (await decodePng(new Uint8Array(buffer), { force32: true })).image
+  };
+}
+
+/**
+ * Computes the coarse pixel signature of a single 1-based cell from a frame.
+ * @param frame The decoded frame to sample.
+ * @param col The 1-based column.
+ * @param row The 1-based row.
+ * @param grid The sub-cell resolution per axis (default 4 -> 16 sub-cells).
+ */
+export function cellSignature(frame: IRendererFrame, col: number, row: number, grid: number = DEFAULT_GRID): CellSignature {
+  const data = frame.decoded.data;
+  const imageWidth = frame.decoded.width;
+  const cellWidth = frame.decoded.width / frame.cols;
+  const cellHeight = frame.decoded.height / frame.rows;
+  const x0 = (col - 1) * cellWidth;
+  const y0 = (row - 1) * cellHeight;
+
+  const subCount = grid * grid;
+  const sums = new Array<number>(subCount * 4).fill(0);
+  const counts = new Array<number>(subCount).fill(0);
+
+  const startX = Math.max(0, Math.floor(x0));
+  const startY = Math.max(0, Math.floor(y0));
+  const endX = Math.min(frame.decoded.width, Math.ceil(x0 + cellWidth));
+  const endY = Math.min(frame.decoded.height, Math.ceil(y0 + cellHeight));
+
+  for (let y = startY; y < endY; y++) {
+    const gy = Math.min(grid - 1, Math.max(0, Math.floor(((y - y0) / cellHeight) * grid)));
+    for (let x = startX; x < endX; x++) {
+      const gx = Math.min(grid - 1, Math.max(0, Math.floor(((x - x0) / cellWidth) * grid)));
+      const sub = gy * grid + gx;
+      const i = (y * imageWidth + x) * 4;
+      sums[sub * 4] += data[i];
+      sums[sub * 4 + 1] += data[i + 1];
+      sums[sub * 4 + 2] += data[i + 2];
+      sums[sub * 4 + 3] += data[i + 3];
+      counts[sub]++;
+    }
+  }
+
+  const signature = new Array<number>(subCount * 4).fill(0);
+  for (let sub = 0; sub < subCount; sub++) {
+    if (counts[sub] > 0) {
+      signature[sub * 4] = sums[sub * 4] / counts[sub];
+      signature[sub * 4 + 1] = sums[sub * 4 + 1] / counts[sub];
+      signature[sub * 4 + 2] = sums[sub * 4 + 2] / counts[sub];
+      signature[sub * 4 + 3] = sums[sub * 4 + 3] / counts[sub];
+    }
+  }
+  return signature;
+}
+
+/**
+ * Returns the maximum absolute per-channel difference between two signatures.
+ * @param a The first signature.
+ * @param b The second signature.
+ */
+export function signatureMaxChannelDiff(a: CellSignature, b: CellSignature): number {
+  if (a.length !== b.length) {
+    return Number.POSITIVE_INFINITY;
+  }
+  let max = 0;
+  for (let i = 0; i < a.length; i++) {
+    max = Math.max(max, Math.abs(a[i] - b[i]));
+  }
+  return max;
+}
+
+/**
+ * Asserts that two cell signatures are effectively identical (i.e. the glyph
+ * rendered the same), within a tolerance for antialiasing noise. Use this after
+ * a stress action (atlas page merge, atlas clear, scroll, resize) to assert a
+ * reference glyph did not become garbled.
+ * @param actual The signature observed after the stress action.
+ * @param reference The baseline signature captured in a fresh atlas.
+ * @param tolerance Max allowed per-channel difference (default 12 / 255).
+ * @param message Optional assertion message.
+ */
+export function expectSignatureMatches(actual: CellSignature, reference: CellSignature, tolerance: number = 12, message?: string): void {
+  const diff = signatureMaxChannelDiff(actual, reference);
+  expect(diff, message ?? `glyph signature drifted by ${diff} (> ${tolerance}); likely corruption`).toBeLessThanOrEqual(tolerance);
+}
+
+/**
+ * Asserts that two cell signatures are meaningfully different. Useful as a
+ * sanity check that distinct glyphs actually render differently (so the
+ * signature has discriminating power) and that a cell is not blank.
+ * @param a The first signature.
+ * @param b The second signature.
+ * @param minDiff Minimum required per-channel difference (default 24 / 255).
+ * @param message Optional assertion message.
+ */
+export function expectSignatureDiffers(a: CellSignature, b: CellSignature, minDiff: number = 24, message?: string): void {
+  const diff = signatureMaxChannelDiff(a, b);
+  expect(diff, message ?? `signatures unexpectedly similar (${diff} < ${minDiff})`).toBeGreaterThanOrEqual(minDiff);
+}
+
+/**
+ * Convenience: capture a fresh frame and return the signature of one cell.
+ * @param ctx The test context.
+ * @param col The 1-based column.
+ * @param row The 1-based row.
+ * @param options Optional overrides.
+ * @param options.selector CSS selector for the screen element to capture.
+ * @param options.grid Sub-cell resolution per axis.
+ * @param options.termGlobal Window terminal global to read dimensions from.
+ */
+export async function captureCellSignature(
+  ctx: ITestContext,
+  col: number,
+  row: number,
+  options: { selector?: string, grid?: number, termGlobal?: string } = {}
+): Promise<CellSignature> {
+  const frame = await captureFrame(ctx, options.selector ?? DEFAULT_SCREEN_SELECTOR, options.termGlobal ?? 'term');
+  return cellSignature(frame, col, row, options.grid ?? DEFAULT_GRID);
+}
+
+/**
+ * Captures the signatures of a contiguous run of cells on a single row from one
+ * screenshot (cheaper than one screenshot per cell).
+ * @param ctx The test context.
+ * @param row The 1-based row.
+ * @param cols The 1-based columns to sample.
+ * @param options Optional overrides.
+ * @param options.selector CSS selector for the screen element to capture.
+ * @param options.grid Sub-cell resolution per axis.
+ * @param options.termGlobal Window terminal global to read dimensions from.
+ */
+export async function captureRowSignatures(
+  ctx: ITestContext,
+  row: number,
+  cols: number[],
+  options: { selector?: string, grid?: number, termGlobal?: string } = {}
+): Promise<CellSignature[]> {
+  const frame = await captureFrame(ctx, options.selector ?? DEFAULT_SCREEN_SELECTOR, options.termGlobal ?? 'term');
+  return cols.map(col => cellSignature(frame, col, row, options.grid ?? DEFAULT_GRID));
+}
+
+/**
+ * Loads the WebGL addon onto `window.term` and asserts GPU acceleration is
+ * genuinely active.
+ *
+ * This deliberately does NOT wrap loading in try/catch (unlike some existing
+ * tests). If WebGL2 is unavailable the addon throws and the test must fail
+ * loudly, because a silent fallback to the DOM renderer would make GPU
+ * corruption tests pass falsely.
+ * @param ctx The test context.
+ * @param options WebGL addon options.
+ * @param options.customGlyphs Whether to draw custom glyphs (defaults to the addon default).
+ * @param options.preserveDrawingBuffer Whether to preserve the drawing buffer (defaults to true).
+ */
+export async function loadWebglStrict(
+  ctx: ITestContext,
+  options: { customGlyphs?: boolean, preserveDrawingBuffer?: boolean } = {}
+): Promise<void> {
+  await ctx.page.evaluate((opts) => {
+    const w = window as any;
+    w.addon = new w.WebglAddon(opts);
+    w.term.loadAddon(w.addon);
+  }, { preserveDrawingBuffer: true, ...options });
+  await assertWebglActive(ctx);
+}
+
+/**
+ * Asserts that the WebGL renderer (not the DOM renderer) is the active renderer
+ * for `window.term`. Fails loudly on a silent DOM fallback.
+ * @param ctx The test context.
+ */
+export async function assertWebglActive(ctx: ITestContext): Promise<void> {
+  const state = await ctx.page.evaluate(() => {
+    const w = window as any;
+    const term = w.term;
+    const addon = w.addon;
+    const renderer = term?._core?._renderService?._renderer?.value;
+    return {
+      hasAddon: !!addon,
+      // The addon's private renderer must be the one the render service is using.
+      isWebglRenderer: !!addon && !!renderer && renderer === addon._renderer
+    };
+  });
+  expect(state.hasAddon, 'WebglAddon should be loaded on window.term').toBe(true);
+  expect(state.isWebglRenderer, 'WebGL renderer must be the active renderer (no silent DOM fallback)').toBe(true);
+}
+
+/**
+ * Asserts the WebGL texture atlas canvas exists. Call after writing some content
+ * so the atlas has been created. This is an additional public-API proof that the
+ * GPU path actually rendered glyphs.
+ * @param ctx The test context.
+ */
+export async function assertTextureAtlasPresent(ctx: ITestContext): Promise<void> {
+  const hasAtlas = await ctx.page.evaluate(() => {
+    const addon = (window as any).addon;
+    return !!addon && addon.textureAtlas instanceof HTMLCanvasElement;
+  });
+  expect(hasAtlas, 'WebGL texture atlas canvas should exist after rendering').toBe(true);
+}
+
+/**
+ * Reads the current number of pages in the active WebGL renderer's texture
+ * atlas, via internals. Returns -1 if unavailable.
+ * @param ctx The test context.
+ */
+export async function getAtlasPageCount(ctx: ITestContext): Promise<number> {
+  return ctx.page.evaluate(() => {
+    const renderer = (window as any).term?._core?._renderService?._renderer?.value;
+    const atlas = renderer?._charAtlas;
+    return atlas?.pages?.length ?? -1;
+  });
+}
+
+/**
+ * Forces the texture atlas to merge pages much sooner by lowering the static
+ * `maxAtlasPages` knob on the live atlas class (reached via the atlas instance's
+ * constructor). Must be called after the WebGL renderer/atlas exists.
+ * @param ctx The test context.
+ * @param maxAtlasPages The new page cap (the merge path triggers at >= max(4, this)).
+ */
+export async function setMaxAtlasPages(ctx: ITestContext, maxAtlasPages: number): Promise<void> {
+  const applied = await ctx.page.evaluate((max) => {
+    const renderer = (window as any).term?._core?._renderService?._renderer?.value;
+    const atlas = renderer?._charAtlas;
+    if (!atlas) {
+      return false;
+    }
+    // maxAtlasPages is a static on the TextureAtlas class, reached via constructor.
+    (atlas.constructor as any).maxAtlasPages = max;
+    return true;
+  }, maxAtlasPages);
+  expect(applied, 'should be able to reach the texture atlas to set maxAtlasPages').toBe(true);
+}
+
+/**
+ * Resets `maxAtlasPages` to undefined so the next constructed renderer re-derives it from GL
+ * capabilities. Call after any test that used {@link setMaxAtlasPages}: the static lives for
+ * the page's lifetime, so without a reset every terminal opened later in the same file builds
+ * its GL texture and shader sampler arrays at the lowered cap.
+ * @param ctx The test context.
+ */
+export async function resetMaxAtlasPages(ctx: ITestContext): Promise<void> {
+  await ctx.page.evaluate(() => {
+    const renderer = (window as any).term?._core?._renderService?._renderer?.value;
+    const atlas = renderer?._charAtlas;
+    if (atlas) {
+      (atlas.constructor as any).maxAtlasPages = undefined;
+    }
+  });
+}
+
+/**
+ * Writes `chunks` screenfuls of distinct glyphs, rendering after each chunk.
+ *
+ * Only glyphs that are actually visible during a render get rasterized into the
+ * texture atlas, so a single huge write mostly rasterizes the final viewport. To
+ * accumulate enough distinct glyphs to allocate (and merge) multiple atlas pages
+ * we must write a screenful, render it, then write the next distinct screenful.
+ * @param ctx The test context.
+ * @param chunks Number of screenfuls of distinct glyphs to write.
+ * @param options Sizing overrides.
+ * @param options.linesPerChunk Number of lines per screenful chunk.
+ * @param options.cols Columns per line.
+ * @returns The atlas page count after flooding.
+ */
+export async function floodDistinctGlyphs(
+  ctx: ITestContext,
+  chunks: number,
+  options: { linesPerChunk?: number, cols?: number } = {}
+): Promise<number> {
+  const linesPerChunk = options.linesPerChunk ?? 24;
+  const cols = options.cols ?? 80;
+  const glyphsPerChunk = linesPerChunk * Math.max(1, Math.floor(cols / 2));
+  for (let c = 0; c < chunks; c++) {
+    await writeAndWaitForRender(ctx, generateUniqueGlyphFlood(glyphsPerChunk, cols, c * glyphsPerChunk));
+  }
+  return getAtlasPageCount(ctx);
+}
+
+/**
+ * Resolves once the terminal fires its next render event.
+ * @param ctx The test context.
+ */
+export async function waitForRender(ctx: ITestContext): Promise<void> {
+  await new Promise<void>(resolve => {
+    const disposable = ctx.proxy.onRender(() => {
+      disposable.dispose();
+      resolve();
+    });
+  });
+}
+
+/**
+ * Writes data and waits for the terminal to render it.
+ * @param ctx The test context.
+ * @param data The data to write.
+ */
+export async function writeAndWaitForRender(ctx: ITestContext, data: string): Promise<void> {
+  const renderPromise = waitForRender(ctx);
+  await ctx.proxy.write(data);
+  await renderPromise;
+}
@@ -0,0 +1,199 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Deterministic generators that mimic the output of an AI/agent TUI CLI (e.g.
+ * Copilot CLI): boxed panels, braille spinners, streaming colored text, status
+ * lines, full-screen redraws and large unique-glyph floods.
+ *
+ * Everything here is seeded/precomputed and contains NO `Math.random`, `Date`
+ * or other non-determinism, so the produced byte streams are stable across runs
+ * and machines. This lets WebGL/atlas stress tests assert exact render results.
+ */
+
+/** A tiny deterministic PRNG (mulberry32) so "random-looking" output is stable. */
+function mulberry32(seed: number): () => number {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = (a + 0x6D2B79F5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+const BRAILLE_SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SGR_FG = [31, 32, 33, 34, 35, 36, 37, 90, 91, 92, 93, 94, 95, 96];
+const WORDS = [
+  'analyzing', 'repository', 'reading', 'TextureAtlas', 'rendering', 'glyph',
+  'webgl', 'terminal', 'buffer', 'scrollback', 'tokenizing', 'synthesizing',
+  'patch', 'diff', 'commit', 'validate', 'compile', 'searching', 'context'
+];
+
+/** Box-drawing characters (custom-glyph range that stresses the WebGL atlas). */
+const BOX = { tl: '┌', tr: '┐', bl: '└', br: '┘', h: '─', v: '│' };
+
+const CSI = '\x1b[';
+const RESET = `${CSI}0m`;
+const CLEAR_HOME = `${CSI}2J${CSI}H`;
+const ENTER_ALT = `${CSI}?1049h`;
+const EXIT_ALT = `${CSI}?1049l`;
+
+export interface ISyntheticTuiOptions {
+  /** PRNG seed for stable pseudo-random content. */
+  seed?: number;
+  /** Number of full-screen redraw frames to emit. */
+  frames?: number;
+  /** Terminal columns to format for. */
+  cols?: number;
+  /** Terminal rows to format for. */
+  rows?: number;
+  /** Wrap each frame in alternate-buffer enter/exit (TUI app behavior). */
+  useAltBuffer?: boolean;
+}
+
+function pad(text: string, width: number): string {
+  if (text.length >= width) {
+    return text.slice(0, width);
+  }
+  return text + ' '.repeat(width - text.length);
+}
+
+function boxLine(kind: 'top' | 'bottom' | 'mid', content: string, width: number): string {
+  const inner = Math.max(0, width - 2);
+  if (kind === 'top') {
+    return `${BOX.tl}${BOX.h.repeat(inner)}${BOX.tr}`;
+  }
+  if (kind === 'bottom') {
+    return `${BOX.bl}${BOX.h.repeat(inner)}${BOX.br}`;
+  }
+  return `${BOX.v}${pad(content, inner)}${BOX.v}`;
+}
+
+/**
+ * Generates an array of frame chunks that look like an animated agent TUI. Write
+ * each chunk with a render in between to mimic streaming redraws. Each frame
+ * clears the screen, redraws a bordered panel, a spinner, several colored
+ * "assistant" lines and a status footer.
+ * @param options Generation options.
+ */
+export function generateSyntheticTuiFrames(options: ISyntheticTuiOptions = {}): string[] {
+  const seed = options.seed ?? 1;
+  const frameCount = options.frames ?? 24;
+  const cols = options.cols ?? 80;
+  const rows = options.rows ?? 24;
+  const rand = mulberry32(seed);
+
+  const panelWidth = Math.min(cols, 72);
+  const bodyRows = Math.max(3, rows - 6);
+  const frames: string[] = [];
+
+  for (let f = 0; f < frameCount; f++) {
+    let frame = CLEAR_HOME;
+    const spinner = BRAILLE_SPINNER[f % BRAILLE_SPINNER.length];
+    frame += boxLine('top', '', panelWidth) + '\r\n';
+    frame += boxLine('mid', ` ${spinner} Copilot is working...`, panelWidth) + '\r\n';
+    frame += boxLine('bottom', '', panelWidth) + '\r\n';
+
+    for (let r = 0; r < bodyRows; r++) {
+      const fg = SGR_FG[Math.floor(rand() * SGR_FG.length)];
+      const wordCount = 3 + Math.floor(rand() * 6);
+      let line = '';
+      for (let w = 0; w < wordCount; w++) {
+        const word = WORDS[Math.floor(rand() * WORDS.length)];
+        line += `${CSI}${fg}m${word}${RESET} `;
+      }
+      frame += line + '\r\n';
+    }
+
+    frame += `${CSI}2m── tokens ${1000 + f * 37} · ${spinner} streaming ──${RESET}`;
+    frames.push(frame);
+  }
+
+  if (options.useAltBuffer) {
+    frames[0] = ENTER_ALT + frames[0];
+    frames[frames.length - 1] = frames[frames.length - 1] + EXIT_ALT;
+  }
+  return frames;
+}
+
+/**
+ * Generates a single string that writes `count` distinct Unicode glyphs, wrapping
+ * at `cols`. Distinct codepoints each need their own texture-atlas slot, so this
+ * is the primary lever for forcing the atlas to allocate (and, with a low
+ * `maxAtlasPages`, merge) pages.
+ *
+ * Codepoints are drawn deterministically from CJK Unified Ideographs
+ * (U+4E00..U+9FFF), which provides 20,000+ unique, mono-width glyphs.
+ * @param count Number of distinct glyphs to emit.
+ * @param cols Columns to wrap at (CJK glyphs are width-2, so half this many per row).
+ * @param offset Starting offset into the codepoint range, so consecutive chunks
+ * emit non-overlapping distinct glyphs.
+ */
+export function generateUniqueGlyphFlood(count: number, cols: number = 80, offset: number = 0): string {
+  const base = 0x4E00;
+  const range = 0x9FFF - 0x4E00; // 20,991 unique codepoints
+  const perRow = Math.max(1, Math.floor(cols / 2));
+  let out = '';
+  for (let i = 0; i < count; i++) {
+    out += String.fromCodePoint(base + ((offset + i) % range));
+    if ((i + 1) % perRow === 0) {
+      out += '\r\n';
+    }
+  }
+  return out;
+}
+
+/**
+ * Generates a deterministic block of mixed "interesting" glyphs spanning the
+ * ranges most likely to exercise the renderer: ASCII, box drawing, block
+ * elements, braille and powerline symbols. Useful as a stable reference payload.
+ * @param seed PRNG seed.
+ * @param lines Number of lines to emit.
+ * @param cols Approximate columns per line.
+ */
+export function generateMixedGlyphBlock(seed: number = 1, lines: number = 10, cols: number = 60): string {
+  const rand = mulberry32(seed);
+  const ranges: [number, number][] = [
+    [0x21, 0x7E],      // printable ASCII
+    [0x2500, 0x257F],  // box drawing
+    [0x2580, 0x259F],  // block elements
+    [0x2800, 0x28FF],  // braille
+    [0x2190, 0x21FF]   // arrows
+  ];
+  let out = '';
+  for (let l = 0; l < lines; l++) {
+    for (let c = 0; c < cols; c++) {
+      const [lo, hi] = ranges[Math.floor(rand() * ranges.length)];
+      out += String.fromCodePoint(lo + Math.floor(rand() * (hi - lo)));
+    }
+    out += '\r\n';
+  }
+  return out;
+}
+
+/**
+ * Emits ASCII letters/words each in a distinct 256-color foreground+background.
+ * Every (char,color) pair is a unique atlas glyph, so this fills/merges atlas
+ * pages with realistic English text (no CJK). Deterministic.
+ *
+ * No `\r\n` is emitted after the final cell: when the flood's last line lands on
+ * the terminal's bottom row a trailing linefeed would scroll the screen (in the
+ * alt buffer this destroys pinned reference rows and makes glyph-integrity
+ * assertions fail for buffer-content reasons rather than rendering reasons).
+ * @param cells Number of colored cells to emit.
+ * @param offset Color offset so consecutive chunks use new color combos.
+ */
+export function generateColoredAsciiFlood(cells: number, offset: number = 0): string {
+  const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let out = '';
+  for (let i = 0; i < cells; i++) {
+    const ch = letters[(offset + i) % letters.length];
+    const fg = (offset + i) % 256;
+    const bg = (offset + i * 7) % 256;
+    out += `\x1b[38;5;${fg}m\x1b[48;5;${bg}m${ch}`;
+    if ((i + 1) % 78 === 0 && i + 1 < cells) { out += '\x1b[0m\r\n'; }
+  }
+  return out + '\x1b[0m';
+}
Author	SHA1	Message	Date
Anthony Kim	fab7bc3c5a	Reset maxAtlasPages after tests that lower it setMaxAtlasPages mutates a static that lives for the page's lifetime, so a lowered cap silently leaked into every renderer built by later tests in the same file (their GL texture and shader sampler arrays were sized at the tiny cap, making tests order-dependent). Add resetMaxAtlasPages and call it in afterEach wherever the cap is lowered on a shared page.	2026-07-04 13:04:11 -07:00
Anthony Kim	f9b043274d	Fix atlas page overflow: merge same-size pairs, evict as last resort TextureAtlas._createNewPage only merged exactly-4 same-size page sets; with a heterogeneous size mix (e.g. 1024+512+512+512) it pushed past maxAtlasPages instead. GlyphRenderer's GL texture array and fragment-shader sampler array are sized to exactly maxAtlasPages, so the next render threw TypeError: Cannot read properties of undefined (reading 'version') and rendering froze (single-terminal breakage under long heavy-CLI sessions, vscode#322756). - Generalize merge selection to the largest same-size group of 2-4 pages (preferring 4, then larger sizes); AtlasPage already supported non-quad merges. Net page count never exceeds the cap. - Derive merging page indexes via _pages.indexOf instead of glyphs[0] .texturePage, which is empty-page safe. - Last resort when no same-size pair exists below max texture size (only possible when almost all pages are at max size): evict all pages; glyphs re-rasterize on demand and models rebuild via pagesVersion. - Defensive clamp in GlyphRenderer.render so any future overflow renders untextured glyphs and logs a warning instead of throwing mid-frame. WebglAtlasOverflow now passes (was 4x TypeError); full webgl suite 75/75.	2026-07-04 13:01:13 -07:00
Anthony Kim	8481bfd8dd	Add failing repro: atlas page overflow crashes GlyphRenderer.render GlyphRenderer sizes its GL texture array and fragment-shader sampler array to exactly TextureAtlas.maxAtlasPages at construction, but _createNewPage pushes past that cap whenever a 4-page same-size merge is impossible (heterogeneous sizes, e.g. 1024+512+512+512). The next render throws TypeError: Cannot read properties of undefined (reading 'version') and rendering freezes — the single-terminal breakage vector for long heavy-CLI sessions (vscode#322756). The test builds the renderer with maxAtlasPages=4 (same code path as the production 8/16/32 values), churns distinct glyphs, and asserts no pageerror, pages.length <= texture capacity, and an intact pinned header. RED today: 4x TypeError from GlyphRenderer.render.	2026-07-04 12:58:33 -07:00
Anthony Kim	32fdce592b	Fix shared-atlas garble: track page changes per renderer, not consume-once TextureAtlas.beginFrame() returned a consume-once boolean, so after a page merge only the FIRST renderer to draw rebuilt its vertex model. Terminals sharing the atlas via CharAtlasCache kept stale texture-page indexes/coords and drew garbled glyphs on their next partial render (vscode#322756). Replace the flag with a monotonic TextureAtlas.pagesVersion, bumped on page merges and overflow-page creation. Each GlyphRenderer tracks its own last-seen value in beginFrame(), so every terminal sharing the atlas rebuilds its model independently. setAtlas() resets the tracker to force a rebuild when the atlas instance changes. WebglSharedAtlasGarble now passes (was diff ~130/255 vs tolerance 14); full webgl addon suite 74/74 green.	2026-07-04 12:54:34 -07:00
Anthony Kim	3113eaefaa	Add failing repro: shared-atlas garble across terminals (vscode#322756) Two terminals with equal configs share one TextureAtlas (CharAtlasCache). When the atlas merges pages it raises a consume-once clear-model flag (TextureAtlas.beginFrame); only the first terminal to render consumes it and rebuilds its vertex model. Every other terminal keeps stale texture-page indexes/coords and draws wrong glyphs on its next partial render even though its buffer is intact. The test churns terminal A to force merges, then gives terminal B a tiny partial update: B's untouched header row garbles (signature diff ~130/255 vs tolerance 14) while B's buffer still reads HEADER_REF. A DOM-renderer control runs the same workload without GPU acceleration and passes: the corruption is exclusive to the WebGL path. RED on current code by design; the fix lands separately.	2026-07-04 12:48:26 -07:00
Anthony Kim	a56dc02cc7	Fix scroll off-by-one in synthetic flood; guard repro against buffer scroll generateColoredAsciiFlood emitted a trailing \r\n after its final cell, so a flood whose last line lands on the bottom row scrolled the screen. In the alt-buffer repro this destroyed the pinned header row in the BUFFER, making the 255/255 signature diff a content change, not renderer corruption. The single-terminal merge path is actually healthy: with the scroll removed the same 30-chunk merge-heavy workload renders the header with zero drift. - generateColoredAsciiFlood: no linefeed after the final cell - WebglReproExperiment: now a green guard; asserts row-1 buffer text first so a content bug can never masquerade as corruption again - WebglVisual: accurate comments; erase rewritten lines so leftover prefill text doesn't look like corruption - WebglSingleTermStress: replace stale EXPECTED-RED comment (test passes)	2026-07-04 12:46:27 -07:00
Anthony Kim	e3399b1db8	webgl stress + glyph-integrity tests for atlas merges; repro vscode#322756 single-terminal garble	2026-06-28 18:27:37 -07:00