Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

138 KB
Raw Blame
/**
 * Copyright 2023-present DreamNum Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import type { ICellDataForSheetInterceptor, IDocumentData, IStyleData, IWorkbookData, Workbook } from '@univerjs/core';
import {
    BooleanNumber,
    BorderStyleTypes,
    createSheetGapTestConfig,
    CustomRangeType,
    HorizontalAlign,
    ILogService,
    Injector,
    IUniverInstanceService,
    LocaleType,
    LogLevel,
    ObjectMatrix,
    RANGE_TYPE,
    ThemeService,
    Tools,
    Univer,
    UniverInstanceType,
    VerticalAlign,
    WrapStrategy,
} from '@univerjs/core';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import type { IBoundRectNoAngle, IViewportInfo } from '../../../basics/vector2';
import { setupRenderTestEnv } from '../../../__tests__/render-test-utils';
import { Vector2 } from '../../../basics/vector2';
import { Canvas } from '../../../canvas';
import { Engine } from '../../../engine';
import { MAIN_VIEW_PORT_KEY, Scene } from '../../../scene';
import { DumbCanvasColorService, ICanvasColorService } from '../../../services/canvas-color.service';
import { Viewport } from '../../../viewport';
import { FontCache } from '../../docs/layout/shaping-engine/font-cache';
import { Background } from '../extensions/background';
import { Border } from '../extensions/border';
import { Font } from '../extensions/font';
import { Marker } from '../extensions/marker';
import { SHEET_EXTENSION_TYPE, SheetExtension } from '../extensions/sheet-extension';
import { SHEET_VIEWPORT_KEY } from '../interfaces';
import {
    convertTransformToOffsetX,
    convertTransformToOffsetY,
    getShrinkToFitScale,
    scaleDocumentDataForShrinkToFit,
    SpreadsheetSkeleton,
} from '../sheet.render-skeleton';
import { Spreadsheet } from '../spreadsheet';
import { createDocumentModelWithStyle } from '../util';

const workbookDataFactory = (): IWorkbookData => ({
    id: 'sheet-render-workbook',
    appVersion: '3.0.0-alpha',
    locale: LocaleType.EN_US,
    name: 'sheet-render-workbook',
    sheetOrder: ['sheet-1'],
    styles: {
        'style-bg-border': {
            bg: { rgb: '#f6f6cc' },
            bd: {
                t: { s: BorderStyleTypes.THIN, cl: { rgb: '#334455' } },
                r: { s: BorderStyleTypes.THIN, cl: { rgb: '#334455' } },
                b: { s: BorderStyleTypes.THIN, cl: { rgb: '#334455' } },
                l: { s: BorderStyleTypes.THIN, cl: { rgb: '#334455' } },
            },
            tb: WrapStrategy.WRAP,
            fs: 12,
            ff: 'Arial',
        },
        'style-rotate': {
            tr: { a: 45 },
            fs: 11,
            ff: 'Arial',
            cl: { rgb: '#111111' },
        },
        'style-shrink': {
            stf: BooleanNumber.TRUE,
            fs: 12,
            ff: 'Arial',
        },
    },
    sheets: {
        'sheet-1': {
            id: 'sheet-1',
            name: 'Sheet-1',
            rowCount: 20,
            columnCount: 12,
            defaultColumnWidth: 72,
            defaultRowHeight: 24,
            rowHeader: { width: 46 },
            columnHeader: { height: 28 },
            mergeData: [{ startRow: 2, endRow: 3, startColumn: 2, endColumn: 3, rangeType: RANGE_TYPE.NORMAL }],
            rowData: {
                6: { hd: BooleanNumber.TRUE },
            },
            columnData: {
                5: { hd: BooleanNumber.TRUE },
                1: { w: 48 },
                2: { w: 64 },
            },
            cellData: {
                0: {
                    0: { v: 'A1' },
                    1: { v: 'very-long-text-for-overflow-path', s: 'style-bg-border' },
                    2: { v: 'wrapped line text', s: 'style-bg-border' },
                    3: { v: 'very long text that must shrink to fit', s: 'style-shrink' },
                    4: { s: 'style-bg-border', custom: { key: 'value' } },
                },
                1: {
                    1: { v: 'rotate-text', s: 'style-rotate' },
                    3: { v: '123', f: '=1+2' },
                },
                2: {
                    2: { v: 'merged-main', s: 'style-bg-border' },
                },
            },
        },
    },
});

interface IFixture {
    rootInjector: Injector;
    univer: Univer;
    workbook: Workbook;
    skeleton: SpreadsheetSkeleton;
    engine: Engine;
    scene: Scene;
    viewport: Viewport;
    spreadsheet: Spreadsheet;
    mainCanvas: Canvas;
    cacheCanvas: Canvas;
    restoreEnv: () => void;
    container: HTMLDivElement;
}

function createBound(left: number, top: number, right: number, bottom: number): IBoundRectNoAngle {
    return { left, top, right, bottom };
}

function createViewportInfo(scene: Scene, cacheCanvas: Canvas, overrides?: Partial<IViewportInfo>): IViewportInfo {
    const viewBound = createBound(0, 0, 420, 240);
    const cacheBound = createBound(0, 0, 460, 280);
    const viewPortPosition = createBound(0, 0, 420, 240);

    return {
        viewBound,
        cacheBound,
        viewPortPosition,
        cacheViewPortPosition: viewPortPosition,
        diffBounds: [],
        diffCacheBounds: [],
        diffX: 0,
        diffY: 0,
        viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN,
        isDirty: 1,
        isForceDirty: false,
        allowCache: true,
        shouldCacheUpdate: 1,
        sceneTrans: scene.transform,
        cacheCanvas,
        leftOrigin: 0,
        topOrigin: 0,
        bufferEdgeX: 12,
        bufferEdgeY: 8,
        ...overrides,
    };
}

function createFixture(data: IWorkbookData = workbookDataFactory()): IFixture {
    const renderEnv = setupRenderTestEnv();

    const rootInjector = new Injector([[Univer]]);
    const univer = rootInjector.get(Univer);
    const injector = univer.__getInjector();
    injector.add([ICanvasColorService, { useClass: DumbCanvasColorService }]);
    const get = injector.get.bind(injector);

    const workbook = univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, data);
    get(IUniverInstanceService).focusUnit('sheet-render-workbook');
    get(ILogService).setLogLevel(LogLevel.SILENT);

    const worksheet = workbook.getActiveSheet()!;
    injector.add([SpreadsheetSkeleton, { useFactory: () => injector.createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles()) }]);
    const skeleton = get(SpreadsheetSkeleton);
    skeleton.calculate();

    const container = document.createElement('div');
    container.style.width = '640px';
    container.style.height = '360px';
    document.body.appendChild(container);

    const engine = injector.createInstance(Engine, 'sheet-render-engine', { elementWidth: 620, elementHeight: 340, dpr: 1 });
    engine.mount(container, false);
    const scene = injector.createInstance(Scene, 'sheet-render-scene', engine);
    scene.transformByState({
        width: 1800,
        height: 1200,
        scaleX: 1,
        scaleY: 1,
    });

    const viewport = injector.createInstance(Viewport, MAIN_VIEW_PORT_KEY, scene, {
        left: 0,
        top: 0,
        width: 420,
        height: 240,
        active: true,
        allowCache: true,
        bufferEdgeX: 12,
        bufferEdgeY: 8,
    });
    viewport.scrollToViewportPos({ viewportScrollX: 30, viewportScrollY: 18 });

    skeleton.setScene(scene);
    injector.add([Spreadsheet, { useFactory: () => injector.createInstance(Spreadsheet, 'sheet-component', skeleton, true) }]);
    const spreadsheet = get(Spreadsheet);
    scene.addObject(spreadsheet, 1);

    const mainCanvas = injector.createInstance(Canvas, { width: 640, height: 360, pixelRatio: 1 });
    const cacheCanvas = injector.createInstance(Canvas, { width: 700, height: 420, pixelRatio: 1 });

    return {
        rootInjector,
        univer,
        workbook,
        skeleton,
        engine,
        scene,
        viewport,
        spreadsheet,
        mainCanvas,
        cacheCanvas,
        restoreEnv: renderEnv.restore,
        container,
    };
}

function disposeFixture(fixture: IFixture) {
    fixture.spreadsheet.dispose();
    fixture.viewport.dispose();
    fixture.scene.dispose();
    fixture.engine.dispose();
    fixture.mainCanvas.dispose();
    fixture.cacheCanvas.dispose();
    fixture.rootInjector.dispose();
    fixture.restoreEnv();
    fixture.container.remove();
}

class RenderOrderProbe extends SheetExtension {
    drawCount = 0;

    constructor(key: string, zIndex: number, type: SHEET_EXTENSION_TYPE) {
        super();
        this.uKey = key;
        this.Z_INDEX = zIndex;
        this.type = type;
    }

    override draw() {
        this.drawCount++;
    }
}

describe('spreadsheet integration', () => {
    let fixture: IFixture;

    beforeEach(() => {
        fixture = createFixture();
    });

    afterEach(() => {
        vi.restoreAllMocks();
        disposeFixture(fixture);
        document.body.innerHTML = '';
    });

    it('calculates a shrink scale with a one-point minimum font size', () => {
        expect(getShrinkToFitScale(80, 100, 12)).toBe(1);
        expect(getShrinkToFitScale(200, 100, 12)).toBe(0.5);
        expect(getShrinkToFitScale(2400, 100, 12)).toBeCloseTo(1 / 12);
    });

    it.each([
        { system: 'Linux', scale: 1.5, merges: true, overflow: false, hidden: false, disabled: false, expected: true },
        { system: 'Linux', scale: 1.5, merges: false, overflow: true, hidden: false, disabled: false, expected: true },
        { system: 'Mac', scale: 1.5, merges: true, overflow: true, hidden: false, disabled: false, expected: false },
        { system: 'Linux', scale: 2, merges: true, overflow: true, hidden: false, disabled: false, expected: false },
        { system: 'Linux', scale: 1.5, merges: false, overflow: false, hidden: false, disabled: false, expected: false },
        { system: 'Linux', scale: 1.5, merges: true, overflow: true, hidden: true, disabled: false, expected: false },
        { system: 'Linux', scale: 1.5, merges: true, overflow: true, hidden: false, disabled: true, expected: false },
    ])('uses the native grid fallback only for affected geometry: %j', (scenario) => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        const sheetData = data.sheets['sheet-1'];
        sheetData.cellData = {};
        sheetData.mergeData = scenario.merges ? [{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 1 }] : [];
        sheetData.showGridlines = scenario.hidden ? BooleanNumber.FALSE : BooleanNumber.TRUE;
        fixture = createFixture(data);
        const { spreadsheet, skeleton, mainCanvas, scene, cacheCanvas } = fixture;
        const context = mainCanvas.getContext();
        vi.spyOn(Tools, 'getSystemType').mockReturnValue(scenario.system);
        context.setTransform(scenario.scale, 0, 0, scenario.scale, 0, 0);
        if (scenario.overflow) {
            skeleton.overflowCache.setValue(1, 1, { startRow: 1, endRow: 1, startColumn: 1, endColumn: 4 });
        }
        Reflect.set(spreadsheet, '_forceDisableGridlines', scenario.disabled);
        const viewport = createViewportInfo(scene, cacheCanvas);
        expect(Reflect.get(spreadsheet, '_requiresNativeGridlineRepaint').call(spreadsheet, context, skeleton, viewport, scenario.merges)).toBe(scenario.expected);
    });

    it('ignores historical grid cuts while finding an offscreen horizontal overflow anchor', () => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        Object.assign(data.sheets['sheet-1'], { rowCount: 100, columnCount: 128, cellData: {}, mergeData: [], rowData: {}, columnData: {} });
        fixture = createFixture(data);
        const { spreadsheet, skeleton, mainCanvas, scene, cacheCanvas, workbook } = fixture;
        const context = mainCanvas.getContext();
        vi.spyOn(Tools, 'getSystemType').mockReturnValue('Linux');
        context.setTransform(1.5, 0, 0, 1.5, 0, 0);
        const { overflowCache, columnWidthAccumulation: columns, rowHeightAccumulation: rows } = skeleton;
        overflowCache.setValue(0, 0, { startRow: 0, endRow: 0, startColumn: 0, endColumn: 100 });
        overflowCache.setValue(42, 70, { startRow: 42, endRow: 42, startColumn: 70, endColumn: 75 });
        const getRow = vi.spyOn(overflowCache, 'getRow');
        const getMergedCellRange = vi.spyOn(workbook.getActiveSheet()!, 'getMergedCellRange');
        const cacheBound = {
            left: columns[19] + skeleton.rowHeaderWidthAndMarginLeft + 1,
            right: columns[25] + skeleton.rowHeaderWidthAndMarginLeft - 1,
            top: rows[39] + skeleton.columnHeaderHeightAndMarginTop + 1,
            bottom: rows[44] + skeleton.columnHeaderHeightAndMarginTop - 1,
        };
        const viewport = createViewportInfo(scene, cacheCanvas, { cacheBound });
        expect(skeleton.getRangeByViewBound(cacheBound)).toMatchObject({ startRow: 40, endRow: 44, startColumn: 20, endColumn: 25 });
        const requiresRepaint = Reflect.get(spreadsheet, '_requiresNativeGridlineRepaint').bind(spreadsheet);
        expect(requiresRepaint(context, skeleton, viewport, true)).toBe(false);
        expect(getMergedCellRange).toHaveBeenCalledExactlyOnceWith(40, 20, 44, 25);
        expect(getRow.mock.calls.map(([row]) => row)).toEqual([40, 41, 42, 43, 44]);
        overflowCache.setValue(42, 0, { startRow: 42, endRow: 42, startColumn: 0, endColumn: 20 });
        expect(requiresRepaint(context, skeleton, viewport, false)).toBe(true);
    });

    it.each(['invalidate', 'clear'])('rejects viewport reuse after a font metrics %s without font load events', (action) => {
        const { spreadsheet, mainCanvas, scene, cacheCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas);
        spreadsheet.render(mainCanvas.getContext(), info);
        expect(spreadsheet.canReuseViewportCache()).toBe(true);

        if (action === 'invalidate') {
            FontCache.invalidateMetrics(() => false);
        } else {
            FontCache.clearFontMeasureCache('12px Arial');
        }
        expect(spreadsheet.canReuseViewportCache()).toBe(false);

        spreadsheet.render(mainCanvas.getContext(), info);
        expect(spreadsheet.canReuseViewportCache()).toBe(true);
    });

    it.each([
        { reset: 'range', key: 't', row: 2, col: 3 },
        { reset: 'range', key: 'r', row: 3, col: 3 },
        { reset: 'range', key: 'b', row: 3, col: 2 },
        { reset: 'range', key: 'l', row: 2, col: 2 },
        { reset: 'all', key: 't', row: 2, col: 3 },
        { reset: 'all', key: 'r', row: 3, col: 3 },
        { reset: 'all', key: 'b', row: 3, col: 2 },
        { reset: 'all', key: 'l', row: 2, col: 2 },
    ] as const)('refreshes a cached merged $key edge after $reset invalidation', ({ reset, key, row, col }) => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        for (let r = 2; r <= 3; r++) {
            for (let c = 2; c <= 3; c++) {
                const cells = data.sheets['sheet-1'].cellData!;
                (cells[r] ??= {})[c] = {
                    v: r === 2 && c === 2 ? 'merged title' : undefined,
                    s: {
                        bg: { rgb: '#fef3c7' },
                        bd: Object.fromEntries(['t', 'r', 'b', 'l'].map((side) => [side, {
                            s: BorderStyleTypes.THIN,
                            cl: { rgb: '#334455' },
                        }])),
                    },
                };
            }
        }
        fixture = createFixture(data);
        const { skeleton, scene, cacheCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas);
        skeleton.setStylesCache(info);
        expect(skeleton.stylesCache.border?.getValue(row, col)?.[key]).toEqual(expect.objectContaining({ color: '#334455' }));

        const previous = skeleton.worksheet.getCellRaw(row, col)!;
        const previousStyle = previous.s as IStyleData;
        skeleton.worksheet.getCellMatrix().setValue(row, col, {
            ...previous,
            s: {
                ...previousStyle,
                bd: {
                    ...previousStyle.bd,
                    [key]: {
                        s: BorderStyleTypes.DOUBLE,
                        cl: { rgb: '#be123c' },
                    },
                },
            },
        });
        if (reset === 'range') {
            skeleton.resetRangeCache([{ startRow: row, endRow: row, startColumn: col, endColumn: col }]);
        } else {
            skeleton.resetCache();
        }
        skeleton.setStylesCache({ ...info, isDirty: 0, shouldCacheUpdate: 0, diffX: 0.2 });
        expect(skeleton.stylesCache.border?.getValue(row, col)?.[key]).toEqual(expect.objectContaining({
            style: BorderStyleTypes.DOUBLE,
            color: '#be123c',
        }));
        const opposites = {
            t: { row: 3, col: 3, key: 'b' },
            b: { row: 2, col: 2, key: 't' },
            l: { row: 3, col: 3, key: 'r' },
            r: { row: 2, col: 2, key: 'l' },
        };
        const opposite = opposites[key];
        expect(skeleton.stylesCache.border?.getValue(opposite.row, opposite.col)?.[opposite.key])
            .toEqual(expect.objectContaining({ color: '#334455' }));
    });

    it.each([false, true])('keeps consumer extensions ordered around native background, text and border draws, repair=%s', (repair) => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        expect(spreadsheet.backgroundExtension).toBeInstanceOf(Background);
        expect(spreadsheet.borderExtension).toBeInstanceOf(Border);
        const background = fixture.univer.__getInjector().createInstance(RenderOrderProbe, 'ConsumerBackground', 1, SHEET_EXTENSION_TYPE.BACKGROUND);
        const early = fixture.univer.__getInjector().createInstance(RenderOrderProbe, 'ConsumerBeforeText', 25, SHEET_EXTENSION_TYPE.GRID);
        const late = fixture.univer.__getInjector().createInstance(RenderOrderProbe, 'ConsumerAfterBorder', 70, SHEET_EXTENSION_TYPE.GRID);
        spreadsheet.register(background, early, late);
        const backgroundDraw = vi.spyOn(background, 'draw');
        const earlyDraw = vi.spyOn(early, 'draw');
        const lateDraw = vi.spyOn(late, 'draw');
        const textDraw = vi.spyOn(spreadsheet.fontExtension, 'draw');
        const borderDraw = vi.spyOn(spreadsheet.borderExtension, 'draw');
        const info = createViewportInfo(scene, cacheCanvas);
        skeleton.setStylesCache(info);
        spreadsheet.draw(mainCanvas.getContext(), info, repair);

        expect(backgroundDraw).toHaveBeenCalled();
        expect(earlyDraw).toHaveBeenCalledOnce();
        expect(lateDraw).toHaveBeenCalledOnce();
        expect(backgroundDraw.mock.invocationCallOrder.at(-1)).toBeLessThan(earlyDraw.mock.invocationCallOrder[0]);
        expect(earlyDraw.mock.invocationCallOrder[0]).toBeLessThan(textDraw.mock.invocationCallOrder[0]);
        expect(textDraw.mock.invocationCallOrder[0]).toBeLessThan(borderDraw.mock.invocationCallOrder[0]);
        expect(borderDraw.mock.invocationCallOrder[0]).toBeLessThan(lateDraw.mock.invocationCallOrder[0]);
    });

    it.each(['cache', 'swapped-cache', 'stale-cache', 'main', 'mac', 'printing', 'disabled'])('limits native gridline interior repair to the current Linux cache: %s', (mode) => {
        const { spreadsheet, skeleton, scene, viewport, cacheCanvas, mainCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas);
        skeleton.setStylesCache(info);
        const previousCache = viewport.canvas!;
        if (mode === 'swapped-cache') {
            viewport.swapCacheCanvas(cacheCanvas);
        }
        let canvas = viewport.canvas!;
        if (mode === 'main') {
            canvas = mainCanvas;
        } else if (mode === 'stale-cache') {
            canvas = cacheCanvas;
        }
        const context = canvas.getContext();
        vi.spyOn(context, 'getSystemType').mockReturnValue(mode === 'mac' ? 'Mac' : 'Linux');
        if (mode === 'printing') {
            context.__mode = 'printing';
        }
        if (mode === 'disabled') {
            vi.spyOn(spreadsheet, 'allowCache', 'get').mockReturnValue(false);
        }
        const repair = vi.spyOn(spreadsheet as unknown as {
            _repairGridlineStroke: (...args: unknown[]) => void;
        }, '_repairGridlineStroke');
        try {
            spreadsheet.draw(context, info);
        } finally {
            viewport.swapCacheCanvas(previousCache);
        }
        expect(repair.mock.calls.length > 0).toBe(mode === 'cache' || mode === 'swapped-cache');
    });

    it('updates the mixed screen gridline color after theme changes', () => {
        const { scene, skeleton, viewport } = fixture;
        const themeService = fixture.univer.__getInjector().get(ThemeService);
        const nativeContext = viewport.canvas!.getCanvasEle().getContext('2d') as CanvasRenderingContext2D & {
            __getEvents: () => Array<{ type: string; props: Record<string, unknown> }>;
            __clearEvents: () => void;
        };
        const getStrokeStyles = () => nativeContext.__getEvents()
            .filter((event) => event.type === 'strokeStyle')
            .map((event) => event.props.value);

        nativeContext.__clearEvents();
        skeleton.updateVisibleRange(viewport.calcViewportInfo());
        scene.makeDirty(true);
        scene.render();
        expect(getStrokeStyles()).toContain('#d5d7dc');

        const theme = themeService.getCurrentTheme();
        themeService.setTheme({
            ...theme,
            gray: {
                ...theme.gray,
                200: '#ccddee',
                900: '#112233',
            },
        });

        nativeContext.__clearEvents();
        scene.render();
        expect(getStrokeStyles()).toContain('#bfd0e1');
    });

    it('scales cloned rich-text font sizes without mutating the stored document', () => {
        const document = {
            id: 'rich-text',
            body: {
                dataStream: 'Univer\r\n',
                textRuns: [{ st: 0, ed: 6, ts: { fs: 20 } }],
            },
            documentStyle: { textStyle: { fs: 12 } },
        } as IDocumentData;

        const scaled = scaleDocumentDataForShrinkToFit(document, 0.5, 10);

        expect(scaled).not.toBe(document);
        expect(scaled.documentStyle.textStyle?.fs).toBe(6);
        expect(scaled.body?.textRuns?.[0].ts?.fs).toBe(10);
        expect(document.documentStyle.textStyle?.fs).toBe(12);
        expect(document.body?.textRuns?.[0].ts?.fs).toBe(20);
    });

    it('applies document hyperlink styling to rich-text cells', () => {
        const { skeleton, workbook } = fixture;
        const worksheet = workbook.getActiveSheet()!;
        const document = createDocumentModelWithStyle('Univer', {}).getSnapshot();
        document.body!.customRanges = [{
            startIndex: 0,
            endIndex: 5,
            rangeId: 'sheet-link',
            rangeType: CustomRangeType.HYPERLINK,
        }];
        const cell = { p: document };
        const style = worksheet.getComposedCellStyleByCellData(0, 6, cell)!;

        skeleton._setFontStylesCache(0, 6, cell, style);

        const pages = skeleton.getFont(0, 6)!.documentSkeleton!.getSkeletonData()!.pages;
        const sections = pages.flatMap((page) => page.sections);
        const columns = sections.flatMap((section) => section.columns);
        const lines = columns.flatMap((column) => column.lines);
        const divides = lines.flatMap((line) => line.divides);
        const glyphs = divides.flatMap((divide) => divide.glyphGroup);
        const linkGlyph = glyphs.find((glyph) => glyph.content === 'U');

        expect(linkGlyph?.ts?.cl?.rgb).toBe('blue.600');
        expect(linkGlyph?.ts?.ul?.s).toBe(BooleanNumber.TRUE);
    });

    it('applies shrink to fit while building the font cache', () => {
        const { skeleton, workbook } = fixture;
        const worksheet = workbook.getActiveSheet()!;
        const cell = worksheet.getCell(0, 3)!;
        const style = worksheet.getComposedCellStyleByCellData(0, 3, cell)!;
        vi.spyOn(FontCache, 'getMeasureText').mockReturnValue({ width: 240 } as TextMetrics);

        skeleton._setFontStylesCache(0, 3, cell, style);

        const fontCache = skeleton.getFont(0, 3)!;
        expect(fontCache.shrinkScale).toBeCloseTo(68 / 240);
        expect(fontCache.fontString).toContain(`${12 * 68 / 240}pt`);
        expect(style.fs).toBe(12);
    });

    it('builds sheet skeleton cache through visible viewport and style/layout calculations', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        const vpInfo = createViewportInfo(scene, cacheCanvas);

        expect(skeleton.updateVisibleRange(vpInfo)).toBe(true);
        skeleton.setStylesCache(vpInfo);

        const visibleMain = skeleton.getVisibleRangeByViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN);
        expect(visibleMain).toEqual(expect.objectContaining({
            startRow: expect.any(Number),
            endRow: expect.any(Number),
            startColumn: expect.any(Number),
            endColumn: expect.any(Number),
        }));
        expect(skeleton.rowColumnSegment.endRow).toBeGreaterThanOrEqual(0);
        expect(skeleton.stylesCache.fontMatrix.getSizeOf()).toBeGreaterThan(0);
        expect(skeleton.stylesCache.border?.getValue(0, 4)).toBeTruthy();
        expect(skeleton.stylesCache.fontMatrix.getValue(0, 4)).toBeUndefined();
        expect(skeleton.overflowCache.getValue(0, 4)).toBeUndefined();

        const autoHeights = skeleton.calculateAutoHeightInRange([{ startRow: 0, endRow: 6, startColumn: 0, endColumn: 3, rangeType: RANGE_TYPE.NORMAL }]);
        expect(autoHeights.length).toBeGreaterThan(0);
        expect(autoHeights.some((item) => (item.autoHeight ?? 0) >= 24)).toBe(true);

        const currentCellHeights = new ObjectMatrix<number>();
        currentCellHeights.setValue(0, 0, 6);
        currentCellHeights.setValue(0, 1, 8);
        const autoHeightsWithCurrent = skeleton.calculateAutoHeightInRange([
            { startRow: 0, endRow: 3, startColumn: 0, endColumn: 2, rangeType: RANGE_TYPE.NORMAL },
        ], currentCellHeights);
        expect(autoHeightsWithCurrent.length).toBeGreaterThan(0);

        const autoWidths = skeleton.calculateAutoWidthInRange([{ startRow: 0, endRow: 8, startColumn: 0, endColumn: 4, rangeType: RANGE_TYPE.NORMAL }]);
        expect(autoWidths.length).toBeGreaterThan(0);
        expect(autoWidths.every((item) => (item.width ?? 0) > 0)).toBe(true);

        expect(skeleton.getFont(0, 1)).toBeTruthy();
        expect(skeleton.getColWidth(2)).toBeGreaterThan(0);
        expect(skeleton.getRowHeight(2)).toBeGreaterThan(0);
        expect(skeleton.getDistanceFromTopLeft(2, 2)).toEqual({
            x: expect.any(Number),
            y: expect.any(Number),
        });
        expect(convertTransformToOffsetX(120, 2, { x: 20, y: 0 })).toBe(200);
        expect(convertTransformToOffsetY(80, 1.5, { x: 0, y: 10 })).toBe(105);
        expect(skeleton.getCellWithMergeInfoByIndex(2, 2)).toEqual(expect.objectContaining({
            startRow: 2,
            endRow: 3,
            startColumn: 2,
            endColumn: 3,
        }));

        expect(skeleton.getHiddenRowsInRange({ startRow: 0, endRow: 10 })).toContain(6);
        expect(skeleton.getHiddenColumnsInRange({ startColumn: 0, endColumn: 8 })).toContain(5);

        const overflowRange = skeleton.getOverflowPosition({ width: 260, height: 20 }, 0 as any, 0, 1, 12);
        expect(overflowRange.endColumn).toBeGreaterThanOrEqual(overflowRange.startColumn);

        skeleton.resetRangeCache([{ startRow: 0, endRow: 1, startColumn: 0, endColumn: 2, rangeType: RANGE_TYPE.NORMAL }]);
        skeleton.resetCache();
        expect(skeleton.stylesCache.fontMatrix.getSizeOf()).toBe(0);
    });

    it('skips font cache for sub-four-pixel rows without dropping visible styles or merged text', () => {
        const workbookData = workbookDataFactory();
        workbookData.id = 'sheet-render-short-row-workbook';
        workbookData.name = 'sheet-render-short-row-workbook';
        workbookData.sheets['sheet-1'].rowData = {
            ...workbookData.sheets['sheet-1'].rowData,
            2: { h: 2 },
            3: { h: 2 },
            4: { h: 2 },
        };
        workbookData.sheets['sheet-1'].cellData = {
            ...workbookData.sheets['sheet-1'].cellData,
            4: { 0: { v: 'compressed', s: 'style-bg-border' } },
        };

        const workbook = fixture.univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, workbookData);
        const worksheet = workbook.getActiveSheet()!;
        const skeleton = fixture.univer.__getInjector().createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles()).calculate() as SpreadsheetSkeleton;
        skeleton.setScene(fixture.scene);
        const viewportInfo = createViewportInfo(fixture.scene, fixture.cacheCanvas);

        skeleton.setStylesCache(viewportInfo, { scaleY: 1 });

        expect(skeleton.stylesCache.fontMatrix.getValue(4, 0)).toBeUndefined();
        expect(skeleton.stylesCache.backgroundPositions?.getValue(4, 0)).toBeDefined();
        expect(skeleton.stylesCache.border?.getValue(4, 0)).toBeDefined();
        expect(skeleton.stylesCache.fontMatrix.getValue(2, 2)).toBeDefined();

        skeleton.resetCache();
        skeleton.setStylesCache(viewportInfo, { scaleY: 2 });
        expect(skeleton.stylesCache.fontMatrix.getValue(4, 0)).toBeDefined();

        skeleton.resetCache();
        skeleton.setStylesCache(viewportInfo);
        expect(skeleton.stylesCache.fontMatrix.getValue(4, 0)).toBeDefined();
    });

    it('keeps the last printing row and column when the viewport ends on their exact boundaries', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        const endRow = 3;
        const endColumn = 3;
        const cacheBound = createBound(
            skeleton.rowHeaderWidthAndMarginLeft,
            skeleton.columnHeaderHeightAndMarginTop,
            skeleton.rowHeaderWidthAndMarginLeft + skeleton.columnWidthAccumulation[endColumn],
            skeleton.columnHeaderHeightAndMarginTop + skeleton.rowHeightAccumulation[endRow]
        );
        const vpInfo = createViewportInfo(scene, cacheCanvas, { cacheBound });

        expect(skeleton.getCacheRangeByViewport(vpInfo, true)).toEqual({
            startRow: 0,
            endRow,
            startColumn: 0,
            endColumn,
        });
    });

    it('does not include the next printing row or column for a one-pixel viewport overlap', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        const endRow = 3;
        const endColumn = 3;
        const cacheBound = createBound(
            skeleton.rowHeaderWidthAndMarginLeft,
            skeleton.columnHeaderHeightAndMarginTop,
            skeleton.rowHeaderWidthAndMarginLeft + skeleton.columnWidthAccumulation[endColumn] + 1,
            skeleton.columnHeaderHeightAndMarginTop + skeleton.rowHeightAccumulation[endRow] + 1
        );
        const vpInfo = createViewportInfo(scene, cacheCanvas, { cacheBound });

        expect(skeleton.getCacheRangeByViewport(vpInfo, true)).toEqual({
            startRow: 0,
            endRow,
            startColumn: 0,
            endColumn,
        });
    });

    it('builds border cache for row-wise merged cells on the selection left edge', () => {
        const workbookData = workbookDataFactory();
        workbookData.id = 'sheet-render-border-workbook';
        workbookData.name = 'sheet-render-border-workbook';
        workbookData.styles.leftBorder = {
            bd: {
                l: { s: BorderStyleTypes.THIN, cl: { rgb: '#000000' } },
            },
        };
        workbookData.sheets['sheet-1'].mergeData = [
            { startRow: 3, endRow: 3, startColumn: 2, endColumn: 4, rangeType: RANGE_TYPE.NORMAL },
            { startRow: 4, endRow: 4, startColumn: 2, endColumn: 4, rangeType: RANGE_TYPE.NORMAL },
            { startRow: 5, endRow: 5, startColumn: 2, endColumn: 4, rangeType: RANGE_TYPE.NORMAL },
        ];
        workbookData.sheets['sheet-1'].cellData = {
            3: { 2: { s: 'leftBorder' }, 3: { s: 'leftBorder' }, 4: { s: 'leftBorder' } },
            4: { 2: { s: 'leftBorder' }, 3: { s: 'leftBorder' }, 4: { s: 'leftBorder' } },
            5: { 2: { s: 'leftBorder' }, 3: { s: 'leftBorder' }, 4: { s: 'leftBorder' } },
        };

        const workbook = fixture.univer.createUnit<IWorkbookData, Workbook>(UniverInstanceType.UNIVER_SHEET, workbookData);
        const worksheet = workbook.getActiveSheet()!;
        const skeleton = fixture.univer.__getInjector().createInstance(SpreadsheetSkeleton, worksheet, workbook.getStyles()).calculate() as SpreadsheetSkeleton;
        skeleton.setScene(fixture.scene);
        const borderStyleSpy = vi.spyOn(skeleton, '_setBorderStylesCache');
        skeleton.setStylesCache(createViewportInfo(fixture.scene, fixture.cacheCanvas));

        expect(skeleton.stylesCache.border?.getValue(3, 2)?.l).toEqual(expect.objectContaining({ color: '#000000' }));
        expect(skeleton.stylesCache.border?.getValue(4, 2)?.l).toEqual(expect.objectContaining({ color: '#000000' }));
        expect(skeleton.stylesCache.border?.getValue(5, 2)?.l).toEqual(expect.objectContaining({ color: '#000000' }));
        expect(borderStyleSpy.mock.calls.filter(([, , , options]) => options?.mergeRange)).toHaveLength(3);
    });

    it('renders spreadsheet with cache refresh and scrolling diff paths in scene viewport', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const mainCtx = mainCanvas.getContext();

        const baseVpInfo = createViewportInfo(scene, cacheCanvas, {
            isDirty: 1,
            isForceDirty: false,
        });
        const stylesCacheSpy = vi.spyOn(skeleton, 'setStylesCache');

        spreadsheet.render(mainCtx as any, baseVpInfo);
        expect(stylesCacheSpy).toHaveBeenCalledWith(baseVpInfo, { scaleY: 1 });
        expect(spreadsheet.allowCache).toBe(true);
        expect(spreadsheet.getSelectionBounding(2, 2, 2, 2)).toEqual(expect.objectContaining({
            startRow: 2,
            endRow: 3,
            startColumn: 2,
            endColumn: 3,
        }));

        spreadsheet.makeDirty(false);
        const scrollingVpInfo = createViewportInfo(scene, cacheCanvas, {
            isDirty: 0,
            isForceDirty: false,
            diffBounds: [createBound(120, 72, 220, 142)],
            diffCacheBounds: [createBound(120, 72, 220, 142)],
            diffX: 16,
            diffY: 8,
            shouldCacheUpdate: 1,
        });
        spreadsheet.render(mainCtx as any, scrollingVpInfo);

        spreadsheet.makeForceDirty(true);
        spreadsheet.render(mainCtx as any, createViewportInfo(scene, cacheCanvas, { isDirty: 0, isForceDirty: true }));
        expect(spreadsheet.isForceDirty()).toBe(true);

        spreadsheet.setForceDisableGridlines(true);
        spreadsheet.makeForceDirty(false);
        spreadsheet.render(mainCtx as any, createViewportInfo(scene, cacheCanvas, {
            viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
            isDirty: 1,
        }));

        expect(spreadsheet.getNoMergeCellPositionByIndex(1, 1)).toEqual(expect.objectContaining({
            startX: expect.any(Number),
            endX: expect.any(Number),
            startY: expect.any(Number),
            endY: expect.any(Number),
        }));
        expect(spreadsheet.isHit(Vector2.FromArray([100, 100]))).toBe(true);
        expect(spreadsheet.getScrollXYByRelativeCoords(Vector2.FromArray([20, 20]))).toEqual({
            x: expect.any(Number),
            y: expect.any(Number),
        });

        skeleton.dispose();
    });

    it.each([
        { system: 'Linux', browser: 'Safari', fractional: true, printing: false, corner: true, native: true },
        { system: 'Mac', browser: 'Safari', fractional: true, printing: false, corner: true, native: false },
        { system: 'Unknown system', browser: 'Safari', fractional: true, printing: false, corner: true, native: false },
        { system: 'Linux', browser: 'Chrome', fractional: true, printing: false, corner: true, native: false },
        { system: 'Linux', browser: 'Safari', fractional: false, printing: false, corner: true, native: false },
        { system: 'Linux', browser: 'Safari', fractional: true, printing: true, corner: true, native: false },
        { system: 'Linux', browser: 'Safari', fractional: true, printing: false, corner: false, native: false },
    ])('preserves native frozen-corner coverage without changing other cache paths: %j', (scenario) => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const mainCtx = mainCanvas.getContext();
        vi.spyOn(mainCtx, 'getSystemType').mockReturnValue(scenario.system);
        vi.spyOn(mainCtx, 'getBrowserType').mockReturnValue(scenario.browser);
        mainCtx.__mode = scenario.printing ? 'printing' : 'rendering';
        const drawSpy = vi.spyOn(spreadsheet, 'draw');
        const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const info = createViewportInfo(scene, cacheCanvas, {
            viewportKey: scenario.corner ? SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT_TOP : SHEET_VIEWPORT_KEY.VIEW_MAIN,
            viewPortPosition: createBound(scenario.fractional ? 30.82 : 30, 16, 140, 67),
        });

        spreadsheet.render(mainCtx, info);

        expect(drawSpy.mock.calls.some(([ctx]) => ctx === mainCtx)).toBe(scenario.native);
        expect(refreshSpy).toHaveBeenCalledTimes(scenario.native ? 0 : 1);
        expect(drawSpy.mock.calls.filter(([ctx]) => ctx === mainCtx)).toHaveLength(scenario.native ? 1 : 0);
        expect(drawSpy.mock.calls.some(([ctx]) => ctx === cacheCanvas.getContext())).toBe(!scenario.native);
        skeleton.dispose();
    });

    it('rebuilds the frozen-corner bitmap once after native paints even on a clean return to integral bounds', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const mainCtx = mainCanvas.getContext();
        vi.spyOn(mainCtx, 'getSystemType').mockReturnValue('Linux');
        vi.spyOn(mainCtx, 'getBrowserType').mockReturnValue('Safari');
        const drawSpy = vi.spyOn(spreadsheet, 'draw');
        const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        spreadsheet.render(mainCtx, createViewportInfo(scene, cacheCanvas, {
            viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT_TOP,
            viewPortPosition: createBound(30, 16, 140, 67),
        }));
        expect(refreshSpy).toHaveBeenCalledOnce();
        drawSpy.mockClear();
        refreshSpy.mockClear();
        spreadsheet.makeDirty(false);
        const info = createViewportInfo(scene, cacheCanvas, {
            viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT_TOP,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
            diffBounds: [],
            diffCacheBounds: [],
            viewPortPosition: createBound(30.82, 16, 140, 67),
        });
        spreadsheet.render(mainCtx, info);
        spreadsheet.makeDirty(true);
        spreadsheet.render(mainCtx, info);
        expect(refreshSpy).not.toHaveBeenCalled();
        expect(drawSpy.mock.calls.filter(([ctx]) => ctx === mainCtx)).toHaveLength(2);

        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        drawSpy.mockClear();
        const clean = {
            ...info,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
            diffBounds: [],
            diffCacheBounds: [],
            diffX: 0,
            diffY: 0,
            viewPortPosition: createBound(30, 16, 140, 67),
        };
        spreadsheet.render(mainCtx, clean);
        expect(drawSpy.mock.calls.some(([ctx]) => ctx === mainCtx)).toBe(false);
        expect(refreshSpy).toHaveBeenCalledOnce();
        spreadsheet.makeDirty(false);
        spreadsheet.render(mainCtx, clean);
        expect(refreshSpy).toHaveBeenCalledOnce();
        skeleton.dispose();
    });

    it('renders sheet content from the header plus outline margin origin', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const mainCtx = mainCanvas.getContext() as any;
        const translateSpy = vi.spyOn(mainCtx, 'translateWithPrecision');
        const transformerSpy = vi.spyOn(scene, 'updateTransformerZero');

        skeleton.setMarginLeft(20);
        skeleton.setMarginTop(16);

        spreadsheet.render(mainCtx, createViewportInfo(scene, cacheCanvas, {
            isDirty: 1,
            isForceDirty: false,
        }));

        expect(translateSpy).toHaveBeenCalledWith(66, 44);
        expect(transformerSpy).toHaveBeenCalledWith(66, 44);
        expect(spreadsheet.isHit(Vector2.FromArray([65, 44]))).toBe(false);
        expect(spreadsheet.isHit(Vector2.FromArray([67, 45]))).toBe(true);
    });

    it('covers spreadsheet draw helpers and utility branches', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            diffCacheBounds: [createBound(100, 60, 220, 140)],
            diffX: 4,
            diffY: 3,
            shouldCacheUpdate: 1,
            isDirty: 0,
            isForceDirty: false,
        });

        const extensionDraw = vi.fn();
        vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([{
            uKey: 'MockSheetExtension',
            draw: extensionDraw,
        }]);

        spreadsheet.draw(context, viewportInfo);
        expect(extensionDraw).toHaveBeenCalled();

        (spreadsheet as any)._refreshIncrementalState = true;
        spreadsheet.draw(context, viewportInfo);
        const incrementalDrawInfo = extensionDraw.mock.calls.at(-1)?.[4];
        expect(incrementalDrawInfo.viewRanges).toEqual(
            viewportInfo.diffBounds.map((bound) => skeleton.getRangeByViewBound(bound))
        );

        vi.mocked(spreadsheet.getExtensionsByOrder).mockRestore();
        const fontDraw = vi.spyOn(spreadsheet.fontExtension, 'draw');
        const borderDraw = vi.spyOn(spreadsheet.borderExtension, 'draw');
        spreadsheet.draw(context, viewportInfo);
        const cacheRange = skeleton.getCacheRangeByViewport(viewportInfo);
        const overflowSafeRanges = viewportInfo.diffBounds.map((bound) => ({
            ...skeleton.getRangeByViewBound(bound),
            startColumn: cacheRange.startColumn,
            endColumn: cacheRange.endColumn,
        }));
        expect(fontDraw.mock.calls.at(-1)?.[4].viewRanges).toEqual(overflowSafeRanges);
        const borderRanges = [{ startRow: 1, endRow: 4, startColumn: 0, endColumn: 2 }];
        expect(borderDraw.mock.calls.at(-1)?.[4].viewRanges).toEqual(borderRanges);
        expect(borderDraw.mock.calls.at(-1)?.[3]).toEqual(borderRanges);
        (spreadsheet as any)._refreshIncrementalState = false;

        spreadsheet.paintNewAreaForScrolling(viewportInfo, {
            cacheCanvas,
            cacheCtx: cacheCanvas.getContext() as any,
            mainCtx: context,
            topOrigin: 0,
            leftOrigin: 0,
            bufferEdgeX: 8,
            bufferEdgeY: 6,
            rowHeaderWidthAndMarginLeft: skeleton.rowHeaderWidthAndMarginLeft,
            columnHeaderHeightAndMarginTop: skeleton.columnHeaderHeightAndMarginTop,
            scaleX: 1,
            scaleY: 1,
        } as any);

        spreadsheet.refreshCacheCanvas(viewportInfo, {
            cacheCanvas,
            cacheCtx: cacheCanvas.getContext() as any,
            mainCtx: context,
            topOrigin: 0,
            leftOrigin: 0,
            bufferEdgeX: 8,
            bufferEdgeY: 6,
        });

        (spreadsheet as any)._applyCache(cacheCanvas, null);
        spreadsheet.testShowRuler(cacheCanvas.getContext() as any, viewportInfo);
        const random = spreadsheet.testGetRandomLightColor();
        expect(random).toMatch(/^#[A-F]{6}$/);

        expect(spreadsheet.getDocuments()).toBeDefined();

        const noSkeletonSpreadsheet = fixture.univer.__getInjector().createInstance(Spreadsheet, 'no-skeleton');
        expect(noSkeletonSpreadsheet.draw(context, viewportInfo)).toBeUndefined();
        expect(noSkeletonSpreadsheet.isHit(Vector2.FromArray([10, 10]))).toBe(false);
        expect(noSkeletonSpreadsheet.getNoMergeCellPositionByIndex(0, 0)).toEqual({
            startX: 0,
            startY: 0,
            endX: 0,
            endY: 0,
        });
        noSkeletonSpreadsheet.dispose();
    });

    it('repaints text across the cleared incremental scroll bound', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext();
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(46, 28, 118, 52)],
            diffX: 0,
            diffY: 24,
            isDirty: 0,
            isForceDirty: false,
        });

        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
        const fontExtension = fixture.univer.__getInjector().createInstance(Font);
        spreadsheet.register(fontExtension);
        Reflect.set(spreadsheet, '_fontExtension', fontExtension);
        Reflect.set(skeleton, '_incrementalFontRenderRanges', [{
            startRow: 10,
            endRow: 10,
            startColumn: 0,
            endColumn: 0,
        }]);
        Reflect.set(spreadsheet, '_refreshIncrementalState', true);
        const renderFontSpy = vi.spyOn(
            fontExtension as unknown as { _renderFontEachCell: (...args: unknown[]) => void },
            '_renderFontEachCell'
        );

        spreadsheet.draw(context, viewportInfo);

        expect(renderFontSpy.mock.calls.some(([, row, column]) => row === 0 && column === 0)).toBe(true);
    });

    it('keeps full-row border candidates when a merged diagonal intersects the damaged area', () => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        const style = data.styles['style-bg-border'] as IStyleData;
        style.bd!.tl_br = { s: BorderStyleTypes.THIN, cl: { rgb: '#be123c' } };
        fixture = createFixture(data);
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            isDirty: 0,
            isForceDirty: false,
        });
        skeleton.setStylesCache(info);
        const border = vi.spyOn(spreadsheet.borderExtension, 'draw');
        (spreadsheet as any)._refreshIncrementalState = true;
        spreadsheet.draw(mainCanvas.getContext(), info);
        const cacheRange = skeleton.getCacheRangeByViewport(info);
        const expected = info.diffBounds.map((bound) => ({
            ...skeleton.getRangeByViewBound(bound),
            startColumn: cacheRange.startColumn,
            endColumn: cacheRange.endColumn,
        }));
        expect(border.mock.calls.at(-1)?.[4].viewRanges).toEqual(expected);
    });

    it.each([
        SHEET_VIEWPORT_KEY.VIEW_MAIN,
        SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT,
        SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
    ])('keeps incremental border owners inside the full paint range for %s', (viewportKey) => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas, {
            viewportKey,
            cacheBound: createBound(118, 76, 262, 124),
            diffBounds: [createBound(116, 74, 264, 126)],
            isDirty: 0,
            isForceDirty: false,
        });
        skeleton.setStylesCache(info);
        const border = vi.spyOn(spreadsheet.borderExtension, 'draw');
        spreadsheet.draw(mainCanvas.getContext(), info);
        const fullRanges = border.mock.calls.at(-1)![4].viewRanges;
        Reflect.set(spreadsheet, '_refreshIncrementalState', true);
        spreadsheet.draw(mainCanvas.getContext(), info);
        expect(border.mock.calls.at(-1)![4].viewRanges).toEqual(fullRanges);
        expect(border.mock.calls.at(-1)![3]).toEqual(fullRanges);
    });

    it('does not paint border owners outside the full cache range', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas, {
            cacheBound: createBound(118, 76, 262, 124),
            diffBounds: [createBound(900, 900, 1000, 1000)],
            isDirty: 0,
            isForceDirty: false,
        });
        skeleton.setStylesCache(info);
        const border = vi.spyOn(spreadsheet.borderExtension, 'draw');
        Reflect.set(spreadsheet, '_refreshIncrementalState', true);
        spreadsheet.draw(mainCanvas.getContext(), info);
        expect(border.mock.calls.at(-1)![3]).toEqual([]);
        expect(border.mock.calls.at(-1)![4].viewRanges).toEqual([]);
    });

    it('skips merge gridline cleanup during merge-free drawing', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const extensionDraw = vi.fn();
        vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
        const getMergeRangesSpy = vi.spyOn(skeleton, 'getCurrentRowColumnSegmentMergeData');
        vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([{
            uKey: 'MockSheetExtension',
            draw: extensionDraw,
        }]);

        spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas));

        expect(getMergeRangesSpy).not.toHaveBeenCalled();
        expect(extensionDraw.mock.calls.at(-1)?.[4].hasMergeData).toBe(false);
    });

    it('repaints background extensions after clearing merged cell gridlines', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext();
        const backgroundDraw = vi.fn();
        const gridDraw = vi.fn();
        const clearRectSpy = vi.spyOn(context, 'clearRect');
        const mergedRange = { startRow: 2, endRow: 3, startColumn: 2, endColumn: 3, rangeType: RANGE_TYPE.NORMAL };
        vi.spyOn(skeleton, 'getCurrentRowColumnSegmentMergeData').mockReturnValue([mergedRange]);
        vi.spyOn(skeleton.overflowCache, 'toNativeArray').mockReturnValue([]);
        vi.spyOn(spreadsheet as unknown as { getExtensionsByOrder: () => unknown[] }, 'getExtensionsByOrder').mockReturnValue([
            {
                type: SHEET_EXTENSION_TYPE.BACKGROUND,
                uKey: 'MockBackgroundExtension',
                draw: backgroundDraw,
            },
            {
                type: SHEET_EXTENSION_TYPE.GRID,
                uKey: 'MockGridExtension',
                draw: gridDraw,
            },
        ]);

        const viewportInfo = createViewportInfo(scene, cacheCanvas);
        skeleton.setStylesCache(viewportInfo);
        spreadsheet.draw(context, viewportInfo);

        expect(backgroundDraw).toHaveBeenCalledTimes(2);
        expect(backgroundDraw.mock.calls[1][3]).toEqual(expect.arrayContaining([mergedRange]));
        expect(clearRectSpy.mock.invocationCallOrder[0]).toBeLessThan(backgroundDraw.mock.invocationCallOrder[1]);
        expect(backgroundDraw.mock.invocationCallOrder[1]).toBeLessThan(gridDraw.mock.invocationCallOrder[0]);
    });

    it('clears overflow gridlines at integral physical pixels without changing stroke geometry or caller state', () => {
        const { spreadsheet, mainCanvas } = fixture;
        const context = mainCanvas.getContext();
        context.setTransform(1.5, 0, 0, 1.5, -162.5, 100.5);
        const clear = vi.spyOn(context, 'clearRect');
        const line = vi.spyOn(context, 'moveToByPrecision');
        const save = vi.spyOn(context._context, 'save');
        const restore = vi.spyOn(context._context, 'restore');
        const ranges = [
            { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 },
            { startRow: 1, endRow: 1, startColumn: 1, endColumn: 1 },
        ];
        let repainted = false;
        const repaint = (clearedRanges: typeof ranges) => {
            expect(clearedRanges).toBe(ranges);
            expect(clear).toHaveBeenCalledTimes(2);
            expect(context.getTransform()).toMatchObject({ a: 1.5, d: 1.5, e: -162.5, f: 100.5 });
            repainted = true;
        };
        (spreadsheet as any)._clearRectangle(context, [25, 50], [54, 100], ranges, repaint);

        expect(clear).toHaveBeenNthCalledWith(1, -162, 101, 81, 38);
        expect(clear).toHaveBeenNthCalledWith(2, -81, 139, 69, 37);
        expect(save).toHaveBeenCalledOnce();
        expect(restore).toHaveBeenCalledOnce();
        expect(line).toHaveBeenCalledWith(0, 0);
        expect(line).toHaveBeenCalledWith(54, 25);
        expect(repainted).toBe(true);
        expect(context.getTransform()).toMatchObject({ a: 1.5, d: 1.5, e: -162.5, f: 100.5 });
    });

    it.each(['printing', 'rotation'])('keeps the native gridline clear for %s', (mode) => {
        const { spreadsheet, mainCanvas } = fixture;
        const context = mainCanvas.getContext();
        if (mode === 'printing') {
            context.__mode = 'printing';
        } else {
            context.setTransform(1, 0.2, 0, 1, 0, 0);
        }
        const clear = vi.spyOn(context, 'clearRectByPrecision');
        (spreadsheet as any)._clearRectangle(context, [25], [54], [{ startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 }]);
        expect(clear).toHaveBeenCalledWith(0, 0, 54, 25);
    });

    it.each(['plain', 'shadow', 'filter', 'composite'])('keeps overflow repair ink and unsupported effects: %s', (mode) => {
        const { spreadsheet, mainCanvas } = fixture;
        const context = mainCanvas.getContext();
        context.setTransform(1.5, 0, 0, 1.5, -162.5, 100.5);
        const clear = vi.spyOn(context, 'clearRect');
        const line = vi.spyOn(context, 'moveToByPrecision');
        if (mode === 'shadow') context._context.shadowOffsetX = -100;
        if (mode === 'filter') context._context.filter = 'blur(10px)';
        if (mode === 'composite') context._context.globalCompositeOperation = 'copy';
        const ranges = [0, 1, 2].map((column) => ({ startRow: 0, endRow: 0, startColumn: column, endColumn: column }));
        let repainted: typeof ranges = [];
        const target = spreadsheet as unknown as {
            _clearRectangle(ctx: typeof context, rows: number[], columns: number[], ranges: typeof repainted,
                redraw: (ranges: typeof repainted) => void, repair: boolean, clip: IBoundRectNoAngle): void;
        };
        const redraw = (cleared: typeof ranges) => {
            repainted = cleared;
        };
        target._clearRectangle(context, [25], [54, 100, 150], ranges, redraw, false, { left: -80, top: 101, right: -60, bottom: 139 });
        // The first range's bordering ink can reach the strip; the distant third range cannot.
        expect(clear).toHaveBeenCalledTimes(mode === 'plain' ? 2 : 3);
        expect(repainted).toEqual(mode === 'plain' ? ranges.slice(0, 2) : ranges);
        expect(line).toHaveBeenCalledWith(0, 0);
        expect(line).toHaveBeenCalledWith(54, 0);
        expect(line.mock.calls.some(([left]) => left === 100)).toBe(mode !== 'plain');
        expect(context.getTransform()).toMatchObject({ a: 1.5, d: 1.5, e: -162.5, f: 100.5 });
    });

    it('redraws uncropped text from beyond an adjacent row when its ink enters the damage strip', () => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        const sheet = data.sheets['sheet-1'];
        sheet.mergeData = [];
        sheet.rowData = {};
        sheet.columnData = {};
        sheet.rowCount = 200;
        sheet.defaultRowHeight = 4;
        sheet.defaultColumnWidth = 500;
        sheet.cellData = { 4: {
            0: { v: 'TALL SOURCE', s: { fs: 72, ff: 'Vertical overflow test', tb: WrapStrategy.OVERFLOW } },
            1: { v: 'TALL OTHER', s: { fs: 72, ff: 'Vertical overflow test', tb: WrapStrategy.OVERFLOW } },
        } };
        fixture = createFixture(data);
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        // Canvas in JSDOM cannot measure glyph ink. Keep FontCache real and replace that native boundary only.
        FontCache.getMeasureText('', '12px sans-serif');
        const measurement: CanvasRenderingContext2D = Reflect.get(FontCache, '_context');
        const measure = vi.isMockFunction(measurement.measureText)
            ? vi.mocked(measurement.measureText).getMockImplementation()!
            : measurement.measureText;
        vi.spyOn(measurement, 'measureText').mockImplementation((text) => {
            const metrics = measure.call(measurement, text);
            return measurement.font.includes('Vertical overflow test')
                ? {
                    ...metrics,
                    width: metrics.width,
                    fontBoundingBoxAscent: 80,
                    fontBoundingBoxDescent: 16,
                    actualBoundingBoxAscent: 75,
                    actualBoundingBoxDescent: 15,
                }
                : metrics;
        });
        FontCache.invalidateMetrics((font) => font.includes('Vertical overflow test'));
        const info = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 1000, 500) });
        skeleton.setStylesCache(info);
        const context = mainCanvas.getContext();
        const fill = vi.spyOn(context._context, 'fillText');
        const font = spreadsheet.getExtensionByKey('DefaultFontExtension') as Font;
        const range = { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
        font.draw(context, { scaleX: 1, scaleY: 1 }, skeleton, [range], {
            viewRanges: [range],
            viewBound: info.cacheBound,
            checkOutOfViewBound: true,
            hasMergeData: false,
            textClipBound: createBound(0, 0, 500, 4),
            viewportKey: info.viewportKey,
        });
        try {
            expect(fill.mock.calls.map(([text]) => text)).toContain('TALL SOURCE');
            const reads = vi.spyOn(skeleton.stylesCache.fontMatrix, 'getValue');
            const farRange = { startRow: 150, endRow: 150, startColumn: 0, endColumn: 0 };
            font.draw(context, { scaleX: 1, scaleY: 1 }, skeleton, [farRange], {
                viewRanges: [farRange],
                viewBound: createBound(0, skeleton.columnHeaderHeightAndMarginTop + 400, 1000, skeleton.columnHeaderHeightAndMarginTop + 800),
                checkOutOfViewBound: true,
                hasMergeData: false,
                textClipBound: createBound(0, 600, 500, 604),
                viewportKey: info.viewportKey,
            });
            // A previously visited large font must not expand an unrelated cache's source-row scan.
            expect(reads).toHaveBeenCalled();
            expect(reads.mock.calls.every(([row]) => row === 150)).toBe(true);
            skeleton.resetRangeCache([{ startRow: 4, endRow: 4, startColumn: 0, endColumn: 0 }]);
            expect(skeleton.getPlainTextVerticalOverflow()).toBeGreaterThan(0);
            skeleton.resetRangeCache([{ startRow: 4, endRow: 4, startColumn: 1, endColumn: 1 }]);
            expect(skeleton.getPlainTextVerticalOverflow()).toBe(0);
            skeleton.resetCache();
            expect(skeleton.getPlainTextVerticalOverflow()).toBe(0);
        } finally {
            FontCache.invalidateMetrics((font) => font.includes('Vertical overflow test'));
        }
    });

    it.each(['x', 'y'])('skips plain overflow glyphs wholly outside the physical %s damage clip', (axis) => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        const sheet = data.sheets['sheet-1'];
        sheet.mergeData = [];
        sheet.rowData = {};
        sheet.columnData = {};
        sheet.cellData = {
            0: { 0: { v: 'left-'.repeat(30) }, 6: { v: 'right-'.repeat(30) } },
            6: { 0: { v: 'bottom-'.repeat(30) } },
        };
        fixture = createFixture(data);
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 1000, 500) });
        skeleton.setStylesCache(info);
        const context = mainCanvas.getContext();
        context.setTransform(1.34, 0, 0, 1.34, 10, 20);
        const fill = vi.spyOn(context._context, 'fillText');
        const clip = axis === 'x'
            ? createBound(432 * 1.34 + 13, 20, 864 * 1.34 + 10, 24 * 1.34 + 20)
            : createBound(10, 144 * 1.34 + 23, 864 * 1.34 + 10, 168 * 1.34 + 20);
        const font = spreadsheet.getExtensionByKey('DefaultFontExtension') as Font;
        const render = (textClipBound?: IBoundRectNoAngle) => {
            fill.mockClear();
            font.draw(context, { scaleX: 1, scaleY: 1 }, skeleton, [], {
                viewRanges: [{ startRow: 0, endRow: 19, startColumn: 0, endColumn: 11 }],
                checkOutOfViewBound: true,
                hasMergeData: false,
                textClipBound,
                viewportKey: info.viewportKey,
            });
            return fill.mock.calls.map(([value]) => value).join('');
        };
        const text = render(clip);
        expect(text).toContain(axis === 'x' ? 'right-' : 'bottom-');
        expect(text).not.toContain('left-');
        expect(text).not.toContain(axis === 'x' ? 'bottom-' : 'right-');
        const fullText = render();
        expect(fullText).toContain('left-');
        expect(fullText).toContain('right-');
        expect(fullText).toContain('bottom-');
        if (axis === 'x') {
            // Retain a cell ending one physical pixel outside the damage edge.
            const overflow = skeleton.overflowCache.getValue(0, 0)!;
            const renderCell = vi.spyOn(font, '_renderFontEachCell');
            render({ ...clip, left: skeleton.columnWidthAccumulation[overflow.endColumn] * 1.34 + 11 });
            expect(renderCell.mock.calls.some(([, row, column]) => row === 0 && column === 0)).toBe(true);
        }
        context.__mode = 'printing';
        const printedText = render(clip);
        expect(printedText).toContain('left-');
        expect(printedText).toContain('right-');
        expect(printedText).toContain('bottom-');
    });

    it.each([false, true])('skips absent sparse extensions on merged sheets, repair=%s', (repair) => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const sparseDraw = vi.fn();
        const regularDraw = vi.fn();

        vi.spyOn(skeleton.worksheet, 'getCell').mockReturnValue(undefined);
        vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
            {
                draw: sparseDraw,
                uKey: 'DefaultCustomExtension',
            },
            {
                draw: regularDraw,
                uKey: 'RegularExtension',
            },
        ]);

        (spreadsheet as any)._refreshIncrementalState = true;
        spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            diffCacheBounds: [createBound(100, 60, 220, 140)],
        }), repair);
        (spreadsheet as any)._refreshIncrementalState = false;

        expect(sparseDraw).not.toHaveBeenCalled();
        expect(regularDraw).toHaveBeenCalledOnce();
    });

    it.each([false, true])('includes an off-strip merged feature through a visible cell, hidden=%s', (hidden) => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        const sheet = data.sheets['sheet-1'];
        sheet.mergeData = [{ startRow: 0, endRow: 6, startColumn: 0, endColumn: 4 }];
        const cell: ICellDataForSheetInterceptor = { markers: { tr: { color: '#ff0000', size: 4 } } };
        sheet.cellData = { 0: { 0: cell } };
        if (hidden) {
            sheet.rowData = { 1: { hd: BooleanNumber.TRUE } };
            sheet.columnData = { 0: { hd: BooleanNumber.TRUE } };
        }
        fixture = createFixture(data);
        const { spreadsheet, scene, cacheCanvas, mainCanvas } = fixture;
        const injector = fixture.univer.__getInjector();
        injector.add([Marker]);
        const marker = injector.get(Marker);
        spreadsheet.register(marker);
        const markerDraw = vi.spyOn(marker, 'draw');
        const fill = vi.spyOn(mainCanvas.getContext(), 'fill');
        Reflect.set(spreadsheet, '_refreshIncrementalState', true);
        spreadsheet.draw(mainCanvas.getContext(), createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            diffCacheBounds: [createBound(100, 60, 220, 140)],
        }), true);
        Reflect.set(spreadsheet, '_refreshIncrementalState', false);
        expect(markerDraw).toHaveBeenCalledOnce();
        expect(markerDraw.mock.calls[0][3]).toContainEqual({
            startRow: hidden ? 2 : 1,
            endRow: hidden ? 2 : 1,
            startColumn: hidden ? 1 : 0,
            endColumn: hidden ? 1 : 0,
        });
        expect(fill).toHaveBeenCalled();
    });

    it('does not skip conditional-formatting render extensions during sparse scans', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const dataBarDraw = vi.fn();
        const iconDraw = vi.fn();
        const markerDraw = vi.fn();

        vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
        vi.spyOn(skeleton.worksheet, 'getCell').mockReturnValue(undefined);
        vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
            {
                draw: dataBarDraw,
                uKey: 'sheet-conditional-rule-data-bar',
            },
            {
                draw: iconDraw,
                uKey: 'sheet-conditional-rule-icon',
            },
            {
                draw: markerDraw,
                uKey: 'DefaultMarkerExtension',
            },
        ]);

        (spreadsheet as any)._refreshIncrementalState = true;
        spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            diffCacheBounds: [createBound(100, 60, 220, 140)],
        }));
        (spreadsheet as any)._refreshIncrementalState = false;

        expect(dataBarDraw).toHaveBeenCalledOnce();
        expect(iconDraw).toHaveBeenCalledOnce();
        expect(markerDraw).not.toHaveBeenCalled();
    });

    it('does not scan sparse extension features when no sparse extension is registered', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const regularDraw = vi.fn();
        const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');

        vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
        vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
            {
                draw: regularDraw,
                uKey: 'RegularExtension',
            },
        ]);

        (spreadsheet as any)._refreshIncrementalState = true;
        spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            diffCacheBounds: [createBound(100, 60, 220, 140)],
        }));
        (spreadsheet as any)._refreshIncrementalState = false;

        expect(regularDraw).toHaveBeenCalledOnce();
        expect(getCellSpy).not.toHaveBeenCalled();
    });

    it('narrows sparse extension diff ranges to matching cells during merge-free incremental drawing', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const markerDraw = vi.fn();

        vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
        vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (
            row === 2 && col === 1 ? { markers: { tr: { color: '#ff0000', size: 4 } } } : undefined
        ));
        vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
            {
                draw: markerDraw,
                uKey: 'DefaultMarkerExtension',
            },
        ]);

        (spreadsheet as any)._refreshIncrementalState = true;
        spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(48, 48, 240, 120)],
            diffCacheBounds: [createBound(48, 48, 240, 120)],
        }));
        (spreadsheet as any)._refreshIncrementalState = false;

        expect(markerDraw).toHaveBeenCalledOnce();
        expect(markerDraw.mock.calls[0][3]).toEqual([{
            startRow: 2,
            endRow: 2,
            startColumn: 1,
            endColumn: 1,
        }]);
    });

    it('reuses style cache cell data when scanning sparse extension features', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const markerDraw = vi.fn();
        const diffBound = createBound(48, 48, 240, 120);
        const diffRange = skeleton.getRangeByViewBound(diffBound);
        const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');

        vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
        for (let row = diffRange.startRow; row <= diffRange.endRow; row++) {
            for (let col = diffRange.startColumn; col <= diffRange.endColumn; col++) {
                skeleton.stylesCache.fontMatrix.setValue(row, col, {
                    cellData: row === 2 && col === 1
                        ? { markers: { tr: { color: '#ff0000', size: 4 } } }
                        : { v: `${row}-${col}` },
                } as any);
            }
        }
        vi.spyOn(spreadsheet as any, 'getExtensionsByOrder').mockReturnValue([
            {
                draw: markerDraw,
                uKey: 'DefaultMarkerExtension',
            },
        ]);

        (spreadsheet as any)._refreshIncrementalState = true;
        spreadsheet.draw(context, createViewportInfo(scene, cacheCanvas, {
            diffBounds: [diffBound],
            diffCacheBounds: [diffBound],
        }));
        (spreadsheet as any)._refreshIncrementalState = false;

        expect(getCellSpy).not.toHaveBeenCalled();
        expect(markerDraw).toHaveBeenCalledOnce();
        expect(markerDraw.mock.calls[0][3]).toEqual([{
            startRow: 2,
            endRow: 2,
            startColumn: 1,
            endColumn: 1,
        }]);
    });

    it.each([
        { axis: 'row', edge: 'cell', delta: 5 / 6 },
        { axis: 'column', edge: 'cell', delta: 5 / 6 },
        { axis: 'row', edge: 'stroke', delta: 1 },
        { axis: 'column', edge: 'stroke', delta: 1 },
    ])('includes the $axis $edge intersecting a repair edge', ({ axis, edge, delta }) => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        const sheet = data.sheets['sheet-1'];
        sheet.rowCount = 160;
        sheet.columnCount = 64;
        sheet.defaultRowHeight = 25;
        sheet.defaultColumnWidth = 54;
        sheet.columnHeader = { height: 24 };
        sheet.rowData = {};
        sheet.columnData = {};
        sheet.mergeData = [];
        sheet.cellData = { 13: { 3: { v: 'repair edge', s: 'style-bg-border' } } };
        fixture = createFixture(data);
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        cacheCanvas.setSize(1000, 760, 3);
        const context = mainCanvas.getContext();
        context.setTransform(6, 0, 0, 6, 0, 0);
        const damage = axis === 'row'
            ? createBound(46, 373 + delta, 700, 450)
            : createBound(261 + delta, 24, 500, 450);
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            cacheBound: createBound(0, 0, 800, 1000),
            diffBounds: [damage],
            diffCacheBounds: [damage],
            diffX: axis === 'column' ? -1 : 0,
            diffY: axis === 'row' ? -1 : 0,
        });
        skeleton.setStylesCache(viewportInfo);
        const extension = edge === 'stroke' ? spreadsheet.borderExtension : spreadsheet.backgroundExtension;
        const draw = vi.spyOn(extension, 'draw');

        spreadsheet.paintNewAreaForScrolling(viewportInfo, {
            cacheCanvas,
            cacheCtx: cacheCanvas.getContext(),
            mainCtx: context,
            topOrigin: 0,
            leftOrigin: 0,
            bufferEdgeX: viewportInfo.bufferEdgeX,
            bufferEdgeY: viewportInfo.bufferEdgeY,
            rowHeaderWidthAndMarginLeft: skeleton.rowHeaderWidthAndMarginLeft,
            columnHeaderHeightAndMarginTop: skeleton.columnHeaderHeightAndMarginTop,
            scaleX: 6,
            scaleY: 6,
        });

        const ranges = draw.mock.calls.flatMap((call) => call[3]);
        expect(ranges.some((range) => range.startRow <= 13 && range.endRow >= 13
            && range.startColumn <= 3 && range.endColumn >= 3)).toBe(true);
    });

    it('keeps viewport ranges without recalculating styles for an unchanged cached viewport', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        const styleSpy = vi.spyOn(skeleton, 'setStylesCache');
        const rangeSpy = vi.spyOn(skeleton, 'updateVisibleRange');
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });

        spreadsheet.render(mainCanvas.getContext(), viewportInfo);

        expect(styleSpy).not.toHaveBeenCalled();
        expect(rangeSpy).toHaveBeenCalledWith(viewportInfo);
        expect(skeleton.rowColumnSegment).toEqual(skeleton.getCacheRangeByViewport(viewportInfo));
    });

    it.each(['dirty', 'uncached'])('calculates styles for a %s viewport even without scroll movement', (mode) => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        spreadsheet.makeForceDirty(false);
        spreadsheet.makeDirty(mode === 'dirty');
        const styleSpy = vi.spyOn(skeleton, 'setStylesCache');
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            cacheCanvas: mode === 'uncached' ? undefined : cacheCanvas,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });

        spreadsheet.render(mainCanvas.getContext(), viewportInfo);

        expect(styleSpy).toHaveBeenCalledOnce();
    });

    it('skips style cache cell visits when scrolling inside the existing cache area', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
        const styleCellSpy = vi.spyOn(skeleton as any, '_setStylesCacheForOneCell');
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            diffCacheBounds: [],
            diffX: 0,
            diffY: 12,
            shouldCacheUpdate: 0,
            isDirty: 0,
            isForceDirty: false,
        });

        skeleton.setStylesCache(viewportInfo);

        expect(styleCellSpy).not.toHaveBeenCalled();
        expect(skeleton.rowColumnSegment).toEqual(skeleton.getCacheRangeByViewport(viewportInfo));
    });

    it('reuses prepared member and merged styles while scrolling within the covered range', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
        const cachedStyle = skeleton.stylesCache.fontMatrix.getValue(1, 1);
        expect(cachedStyle).toBeDefined();
        const borderStyleSpy = vi.spyOn(skeleton, '_setBorderStylesCache');

        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(100, 60, 220, 140)],
            diffCacheBounds: [createBound(100, 60, 220, 140)],
            diffX: 0,
            diffY: 12,
            shouldCacheUpdate: 1,
            isDirty: 0,
            isForceDirty: false,
        }));

        expect(skeleton.stylesCache.fontMatrix.getValue(1, 1)).toBe(cachedStyle);
        expect(borderStyleSpy).not.toHaveBeenCalled();
    });

    it('reuses a fully prepared merged anchor without recomposing its perimeter during scrolling', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
        const mergeRange = skeleton.worksheet.getMergeData()[0];
        const cachedFont = skeleton.stylesCache.fontMatrix.getValue(2, 2);
        const composed = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
        const borders = vi.spyOn(skeleton as any, '_setMergeBorderProps');

        (skeleton as any)._setStylesCacheForOneCell(2, 2, { mergeRange, reuseExisting: true, hasMergeData: true });

        expect(composed).not.toHaveBeenCalled();
        expect(borders).not.toHaveBeenCalled();
        expect(skeleton.stylesCache.fontMatrix.getValue(2, 2)).toBe(cachedFont);
    });

    it('prepares all merged edges after the ordinary anchor was visited first', () => {
        const { skeleton } = fixture;
        const mergeRange = skeleton.worksheet.getMergeData()[0];
        (skeleton as any)._setStylesCacheForOneCell(2, 2, {
            cacheItem: { bg: true, border: true },
            hasMergeData: true,
            reuseExisting: true,
        });
        const borders = vi.spyOn(skeleton as any, '_setMergeBorderProps');
        (skeleton as any)._setStylesCacheForOneCell(2, 2, { mergeRange, reuseExisting: true, hasMergeData: true });
        expect(borders).toHaveBeenCalledTimes(4);
    });

    it('recomposes merged styles after a theme change even during a scroll preparation pass', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
        const mergeRange = skeleton.worksheet.getMergeData()[0];
        const composed = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
        const themeService = fixture.univer.__getInjector().get(ThemeService);
        const theme = themeService.getCurrentTheme();
        themeService.setTheme({ ...theme, gray: { ...theme.gray, 200: '#ccddee' } });
        (skeleton as any)._setStylesCacheForOneCell(2, 2, { mergeRange, reuseExisting: true, hasMergeData: true });
        expect(composed).toHaveBeenCalled();
    });

    it('bounds dense background candidates to the damaged columns across many cached rows', () => {
        disposeFixture(fixture);
        const data = workbookDataFactory();
        const sheet = data.sheets['sheet-1'];
        sheet.columnCount = 64;
        sheet.mergeData = [];
        sheet.cellData = Object.fromEntries(Array.from({ length: 20 }, (_, row) => [row, Object.fromEntries(Array.from({ length: 64 }, (_, col) => [col, { s: { bg: { rgb: '#fef3c7' } } }]))]));
        fixture = createFixture(data);
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 5000, 600) });
        skeleton.setStylesCache(info);
        const background = spreadsheet.backgroundExtension;
        const candidates = vi.spyOn(background, 'renderBGByCell');
        const damage = [{ startRow: 0, endRow: 19, startColumn: 20, endColumn: 21 }];

        background.draw(mainCanvas.getContext(), { scaleX: 1, scaleY: 1 }, skeleton, damage, {
            viewRanges: damage,
            checkOutOfViewBound: true,
            hasMergeData: false,
            viewportKey: 'viewMain',
        });

        expect(candidates).toHaveBeenCalledTimes(38);
        expect(candidates.mock.calls.every(([, , col]) => col === 20 || col === 21)).toBe(true);
    });

    it('skips merge lookups for one-cell style cache when merge data is absent', () => {
        const { skeleton } = fixture;
        const mergeInfoSpy = vi.spyOn(skeleton.worksheet, 'getCellInfoInMergeData');

        (skeleton as any)._setStylesCacheForOneCell(0, 0, {
            cacheItem: { bg: true, border: true },
            hasMergeData: false,
        });

        expect(mergeInfoSpy).not.toHaveBeenCalled();
    });

    it('reuses row visibility from the style cache row scan', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        const getRowVisibleSpy = vi.spyOn(skeleton.worksheet, 'getRowVisible');
        const viewportInfo = createViewportInfo(scene, cacheCanvas);

        skeleton.setStylesCache(viewportInfo);

        const visibleRange = skeleton.rowColumnSegment;
        const visibleRowCount = visibleRange.endRow - visibleRange.startRow + 1;
        expect(getRowVisibleSpy.mock.calls.length).toBeLessThan(visibleRowCount * 3);
    });

    it('reuses cached overflow-only font styles without reading cell data again', () => {
        const { skeleton } = fixture;
        const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
        const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
        const options = { cacheItem: { bg: false, border: false }, reuseExisting: true };

        (skeleton as any)._setStylesCacheForOneCell(0, 0, options);
        const getCellCalls = getCellSpy.mock.calls.length;
        const getStyleCalls = getStyleSpy.mock.calls.length;

        (skeleton as any)._setStylesCacheForOneCell(0, 0, options);

        expect(getCellSpy.mock.calls.length).toBe(getCellCalls);
        expect(getStyleSpy.mock.calls.length).toBe(getStyleCalls);
    });

    it('reuses fully cached cell styles during incremental scrolling', () => {
        const { skeleton } = fixture;
        const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
        const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');

        (skeleton as any)._setStylesCacheForOneCell(0, 0, { cacheItem: { bg: true, border: true } });
        const getCellCalls = getCellSpy.mock.calls.length;
        const getStyleCalls = getStyleSpy.mock.calls.length;

        (skeleton as any)._setStylesCacheForOneCell(0, 0, { cacheItem: { bg: true, border: true }, reuseExisting: true });

        expect(getCellSpy.mock.calls.length).toBe(getCellCalls);
        expect(getStyleSpy.mock.calls.length).toBe(getStyleCalls);
    });

    it('reuses styled cells without text during incremental scrolling', () => {
        const { skeleton } = fixture;
        const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
        const getStyleSpy = vi.spyOn(skeleton.worksheet, 'getComposedCellStyleByCellData');
        const options = { cacheItem: { bg: true, border: true }, reuseExisting: true };
        (skeleton as any)._setStylesCacheForOneCell(0, 4, options);
        expect(skeleton.stylesCache.fontMatrix.getValue(0, 4)).toBeUndefined();
        getCellSpy.mockClear();
        getStyleSpy.mockClear();

        (skeleton as any)._setStylesCacheForOneCell(0, 4, options);

        expect(getCellSpy).not.toHaveBeenCalled();
        expect(getStyleSpy).not.toHaveBeenCalled();
        expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
        expect(skeleton.stylesCache.border?.getValue(0, 4)).toBeDefined();
    });

    it.each(['range', 'all'])('invalidates cached text absence on %s cache reset', (reset) => {
        const { skeleton } = fixture;
        const options = { cacheItem: { bg: true, border: true }, reuseExisting: true };
        (skeleton as any)._setStylesCacheForOneCell(0, 4, options);
        if (reset === 'range') {
            skeleton.resetRangeCache([{ startRow: 0, endRow: 0, startColumn: 4, endColumn: 4 }]);
        } else {
            skeleton.resetCache();
        }
        const cell = skeleton.worksheet.getCellRaw(0, 4)!;
        skeleton.worksheet.getCellMatrix().setValue(0, 4, { ...cell, v: 'New text' });

        (skeleton as any)._setStylesCacheForOneCell(0, 4, options);

        expect(skeleton.stylesCache.fontMatrix.getValue(0, 4)?.cellData?.v).toBe('New text');
    });

    it('skips overflow boundary scanning when text fits in the current column', () => {
        const { skeleton } = fixture;
        const overflowBoundSpy = vi.spyOn(skeleton as any, '_getOverflowBound');
        const fontCache = {
            cellData: { v: 'A1' },
            fontString: '12px Arial',
            horizontalAlign: HorizontalAlign.LEFT,
            verticalAlign: VerticalAlign.TOP,
            wrapStrategy: WrapStrategy.OVERFLOW,
        } as any;

        const result = (skeleton as any)._calculateOverflowCell(0, 0, fontCache);

        expect(result).toBe(true);
        expect(fontCache.textFitsCurrentCell).toBe(true);
        expect(overflowBoundSpy).not.toHaveBeenCalled();
    });

    it('skips overflow text measurement when the adjacent cell blocks overflow', () => {
        const { skeleton } = fixture;
        const measureSpy = vi.spyOn(FontCache, 'getMeasureText');
        vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (
            row === 0 && col === 1 ? { v: 'blocked' } as any : { v: 'long text' } as any
        ));

        const result = (skeleton as any)._calculateOverflowCell(0, 0, {
            cellData: { v: 'this is a very long text that would normally be measured' },
            fontString: '12px Arial',
            horizontalAlign: HorizontalAlign.LEFT,
            verticalAlign: VerticalAlign.TOP,
            wrapStrategy: WrapStrategy.OVERFLOW,
        });

        expect(result).toBe(true);
        expect(measureSpy).not.toHaveBeenCalled();
    });

    it('uses raw adjacent cell data to block overflow without worksheet reads', () => {
        const { skeleton } = fixture;
        const getCellSpy = vi.spyOn(skeleton.worksheet, 'getCell');
        const measureSpy = vi.spyOn(FontCache, 'getMeasureText');

        const result = (skeleton as any)._calculateOverflowCell(0, 0, {
            cellData: { v: 'this is a very long text that would normally inspect the adjacent cell' },
            fontString: '12px Arial',
            horizontalAlign: HorizontalAlign.LEFT,
            verticalAlign: VerticalAlign.TOP,
            wrapStrategy: WrapStrategy.OVERFLOW,
        });

        expect(result).toBe(true);
        expect(getCellSpy).not.toHaveBeenCalled();
        expect(measureSpy).not.toHaveBeenCalled();
    });

    it('skips merge checks during overflow calculation when the sheet has no merged cells', () => {
        const { skeleton } = fixture;
        const mergeSpy = vi.spyOn(skeleton, 'intersectMergeRange');
        vi.spyOn(skeleton.worksheet, 'getCell').mockImplementation((row: number, col: number) => (
            row === 0 && col === 1 ? { v: 'blocked' } as any : { v: 'long text' } as any
        ));

        const result = (skeleton as any)._calculateOverflowCell(0, 0, {
            cellData: { v: 'this is a very long text that would normally check merge ranges' },
            fontString: '12px Arial',
            horizontalAlign: HorizontalAlign.LEFT,
            verticalAlign: VerticalAlign.TOP,
            wrapStrategy: WrapStrategy.OVERFLOW,
        }, false);

        expect(result).toBe(true);
        expect(mergeSpy).not.toHaveBeenCalled();
    });

    it('skips style cache work for sheet header viewports', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext();
        const styleCacheSpy = vi.spyOn(skeleton, 'setStylesCache');
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            viewportKey: SHEET_VIEWPORT_KEY.VIEW_ROW_TOP,
        });

        spreadsheet.render(context, viewportInfo);

        expect(styleCacheSpy).not.toHaveBeenCalled();
    });

    it('copies the full cache viewport so the first row and column remain visible', () => {
        const { spreadsheet, skeleton, scene, cacheCanvas, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;
        const applyCacheSpy = vi.spyOn(spreadsheet as any, '_applyCache').mockImplementation(() => {});
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [],
            diffCacheBounds: [],
            isDirty: 0,
            isForceDirty: false,
            viewPortPosition: createBound(10, 20, 410, 220),
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        spreadsheet.renderByViewports(context, viewportInfo, skeleton);

        expect(applyCacheSpy).toHaveBeenCalledWith(
            cacheCanvas,
            context,
            12,
            8,
            400 + skeleton.rowHeaderWidthAndMarginLeft,
            200 + skeleton.columnHeaderHeightAndMarginTop,
            10,
            20,
            400 + skeleton.rowHeaderWidthAndMarginLeft,
            200 + skeleton.columnHeaderHeightAndMarginTop
        );
    });

    it('refreshes cache instead of incremental painting for large scroll jumps', () => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        const context = mainCanvas.getContext();
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(0, 10000, 460, 10280)],
            diffCacheBounds: [createBound(0, 10000, 460, 10280)],
            diffX: 0,
            diffY: -10000,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');

        spreadsheet.renderByViewports(context, viewportInfo, skeleton);

        expect(refreshSpy).toHaveBeenCalledOnce();
        expect(paintSpy).not.toHaveBeenCalled();
    });

    it('uses backing-store cache size when detecting large scroll jumps', () => {
        const { spreadsheet, skeleton, mainCanvas, scene } = fixture;
        const context = mainCanvas.getContext();
        const cacheCanvas = fixture.univer.__getInjector().createInstance(Canvas, { width: 700, height: 420, pixelRatio: 1.5 });
        vi.spyOn(skeleton.worksheet, 'getMergeData').mockReturnValue([]);
        context.setTransform(1.5, 0, 0, 1.5, 0, 0);
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(0, 360, 460, 640)],
            diffCacheBounds: [createBound(0, 360, 460, 640)],
            diffX: 0,
            diffY: -360,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');

        spreadsheet.renderByViewports(context, viewportInfo, skeleton);

        expect(paintSpy).toHaveBeenCalledOnce();
        expect(refreshSpy).not.toHaveBeenCalled();
        cacheCanvas.dispose();
    });

    it('clips merge repair to the exposed strip while retaining the merged text anchor', () => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        const context = mainCanvas.getContext();
        const mergeInfo = skeleton.getCellWithCoordByIndex(2, 2, false).mergeInfo;
        const mergedBound = createBound(
            mergeInfo.startX + skeleton.rowHeaderWidthAndMarginLeft,
            mergeInfo.startY + skeleton.columnHeaderHeightAndMarginTop,
            mergeInfo.endX + skeleton.rowHeaderWidthAndMarginLeft,
            mergeInfo.endY + skeleton.columnHeaderHeightAndMarginTop
        );
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(mergedBound.right - 8, mergedBound.top, mergedBound.right, mergedBound.bottom)],
            diffCacheBounds: [],
            diffX: 0,
            diffY: -8,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        skeleton.setStylesCache({ ...viewportInfo, isDirty: 1, shouldCacheUpdate: 1 });
        const drawSpy = vi.spyOn(spreadsheet, 'draw');
        const fontSpy = vi.spyOn(spreadsheet.fontExtension, '_renderFontEachCell');
        const clear = vi.spyOn(cacheCanvas.getContext(), 'clearRect');

        spreadsheet.renderByViewports(context, viewportInfo, skeleton);

        expect(refreshSpy).not.toHaveBeenCalled();
        expect(paintSpy).toHaveBeenCalledOnce();
        const repair = drawSpy.mock.calls.find((call) => call[2]);
        expect(repair?.[1].diffBounds).toEqual(viewportInfo.diffBounds.map((bound) => createBound(
            bound.left - 2,
            bound.top - 2,
            bound.right + 2,
            bound.bottom + 2
        )));
        expect(clear).toHaveBeenCalledWith(mergeInfo.endX - 8 + 12, mergeInfo.startY + 8, 8, mergeInfo.endY - mergeInfo.startY);
        expect(fontSpy.mock.calls.some(([, row, col]) => row === 2 && col === 2)).toBe(true);
    });

    it('keeps a wide merged title incremental when only a narrow frozen strip is exposed', () => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        skeleton.worksheet.setMergeData([{ startRow: 0, endRow: 2, startColumn: 0, endColumn: 11 }]);
        const cacheBound = createBound(46, 28, 506, 118);
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
            cacheBound,
            diffBounds: [createBound(498, 28, 506, 118)],
            diffCacheBounds: [],
            diffX: -8,
            diffY: 0,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });
        skeleton.setStylesCache({ ...viewportInfo, isDirty: 1, shouldCacheUpdate: 1 });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const draw = vi.spyOn(spreadsheet, 'draw');
        const font = vi.spyOn(spreadsheet.fontExtension, '_renderFontEachCell');
        const clear = vi.spyOn(cacheCanvas.getContext(), 'clearRect');
        spreadsheet.renderByViewports(mainCanvas.getContext(), viewportInfo, skeleton);
        expect(refresh).not.toHaveBeenCalled();
        const repair = draw.mock.calls.find((call) => call[2]);
        expect(repair?.[1].diffBounds).toEqual([createBound(496, 26, 508, 102)]);
        expect(clear).toHaveBeenCalledWith(464, 8, 8, 72);
        expect(font.mock.calls.some(([, row, col]) => row === 0 && col === 0)).toBe(true);
    });

    it('retains whole-merge repair for fractional bitmap shifts', () => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        skeleton.worksheet.setMergeData([{ startRow: 0, endRow: 2, startColumn: 0, endColumn: 11 }]);
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            cacheBound: createBound(46, 28, 506, 118),
            diffBounds: [createBound(498, 28, 506, 118)],
            diffCacheBounds: [],
            diffX: -0.5,
            diffY: 0,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        spreadsheet.renderByViewports(mainCanvas.getContext(), viewportInfo, skeleton);
        expect(refresh).toHaveBeenCalledOnce();
        expect(paint).not.toHaveBeenCalled();
    });

    it('refreshes the cache when merge repair covers most of the cache area', () => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        const context = mainCanvas.getContext();
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(46, 28, 506, 240)],
            diffCacheBounds: [],
            diffX: 0,
            diffY: -80,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        skeleton.worksheet.setMergeData([
            { startRow: 0, endRow: 9, startColumn: 0, endColumn: 11, rangeType: RANGE_TYPE.NORMAL },
        ]);

        const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');

        spreadsheet.renderByViewports(context, viewportInfo, skeleton);

        expect(refreshSpy).toHaveBeenCalledOnce();
        expect(paintSpy).not.toHaveBeenCalled();
    });

    it('does not repaint merged cells outside the scroll diff', () => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        const context = mainCanvas.getContext();
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(0, 360, 460, 640)],
            diffCacheBounds: [],
            diffX: 0,
            diffY: -48,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const drawSpy = vi.spyOn(spreadsheet, 'draw').mockImplementation(() => {});

        spreadsheet.renderByViewports(context, viewportInfo, skeleton);

        expect(drawSpy).not.toHaveBeenCalled();
    });

    it('limits horizontal style work to exposed columns while preparing new backgrounds', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        const initial = createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 300, 280) });
        skeleton.setStylesCache(initial);
        const cachedFont = skeleton.stylesCache.fontMatrix.getValue(0, 1);
        expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeUndefined();
        const cacheBuilder = skeleton as unknown as { _setStylesCacheForOneCell(...args: unknown[]): void };
        const styleVisits = vi.spyOn(cacheBuilder, '_setStylesCacheForOneCell');
        const changed = createViewportInfo(scene, cacheCanvas, {
            cacheBound: createBound(72, 0, 460, 280),
            diffBounds: [createBound(440, 0, 460, 280)],
            diffCacheBounds: [createBound(300, 0, 460, 280)],
            diffX: -72,
            diffY: 0,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        });
        skeleton.setStylesCache(changed, { scaleY: 1 });
        const incrementalVisits = styleVisits.mock.calls.length;
        expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
        expect(skeleton.stylesCache.fontMatrix.getValue(0, 1)).toBe(cachedFont);
        styleVisits.mockClear();
        skeleton.setStylesCache({ ...changed, isDirty: 1 }, { scaleY: 1 });
        expect(incrementalVisits).toBeLessThan(styleVisits.mock.calls.length);
    });

    it.each(['distance', 'origin'])('reuses prepared merged styles when fractional %s needs a pixel refresh', (fractional) => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const cacheCanvas = viewport.canvas!;
        cacheCanvas.setSize(700, 420, 1);
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas));
        const mergedFont = skeleton.stylesCache.fontMatrix.getValue(2, 2);
        expect(mergedFont).toBeDefined();
        const prepareFont = vi.spyOn(skeleton, '_setFontStylesCache');
        const renderFont = vi.spyOn(spreadsheet.fontExtension, '_renderFontEachCell');
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        const context = mainCanvas.getContext();
        if (fractional === 'origin') {
            context.translate(0.5, 0);
        }
        spreadsheet.render(context, createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(440, 0, 460, 280)],
            diffCacheBounds: [],
            diffX: fractional === 'distance' ? -20.5 : -20,
            diffY: 0,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        }));
        expect(skeleton.stylesCache.fontMatrix.getValue(2, 2)).toBeDefined();
        expect(prepareFont).not.toHaveBeenCalled();
        expect(renderFont.mock.calls.some(([, row, col]) => row === 2 && col === 2)).toBe(true);
    });

    it.each([
        { from: 69, to: 38.7, scale: 1.5, y: 11.25, reported: -20, expected: -30 },
        { from: -287.15, to: -287.5, scale: 0.5, y: 0, reported: -2, expected: 0 },
        { from: -287.5, to: -287.7, scale: 1, y: 0, reported: 0, expected: -1 },
    ])('moves cached pixels by the actual raster origin: $from to $to at $scale', ({ from, to, scale, y, reported, expected }) => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 1);
        const ctx = mainCanvas.getContext();
        ctx.setTransform(scale, 0, 0, scale, from, y);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        ctx.setTransform(scale, 0, 0, scale, to, y);
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const copyTarget = spreadsheet as unknown as { _copyCacheForScrolling(...args: unknown[]): void };
        const copy = vi.spyOn(copyTarget, '_copyCacheForScrolling');
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
            diffBounds: reported ? [createBound(400, 0, 420, 240)] : [],
            diffCacheBounds: [],
            diffX: reported,
            diffY: 0,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        }), skeleton);
        expect(refresh).not.toHaveBeenCalled();
        if (expected) {
            expect(copy).toHaveBeenCalledWith(expect.anything(), canvas, expected, 0);
        } else {
            expect(copy).not.toHaveBeenCalled();
        }
    });

    it.each(['x', 'y'])('keeps text repairs local when the native origin crosses a precision band on %s scroll', (axis) => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 1);
        const ctx = mainCanvas.getContext();
        ctx.setTransform(12, 0, 0, 12, axis === 'x' ? 1056 : 0, axis === 'y' ? 1104 : 0);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
        ctx.setTransform(12, 0, 0, 12, axis === 'x' ? 410 : 0, axis === 'y' ? 458 : 0);
        const info = createViewportInfo(scene, viewport.canvas!, {
            diffBounds: [axis === 'x' ? createBound(400, 0, 420, 240) : createBound(0, 220, 420, 240)],
            diffCacheBounds: [],
            diffX: axis === 'x' ? -646 / 12 : 0,
            diffY: axis === 'y' ? -646 / 12 : 0,
            shouldCacheUpdate: 0,
            isDirty: 0,
        });
        const repaint = spreadsheet as unknown as {
            _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
        };
        const nativeClipRanges = vi.spyOn(spreadsheet.getExtensionByKey('DefaultFontExtension') as Font, 'getNativeTextClipRepairRanges');
        const bounds = repaint._getRepaintBounds(info, [], ctx);
        expect(bounds).toEqual([]);
        expect(nativeClipRanges).not.toHaveBeenCalled();
        const point = axis === 'x' ? { x: 142, y: 40 } : { x: 82, y: 112 };
        expect(bounds.some(({ bound }) => bound.left < point.x && bound.right > point.x
            && bound.top < point.y && bound.bottom > point.y)).toBe(false);
        // Panning over existing buffer pixels needs no refill; actual exposed cache pixels still do.
        const refillBounds = repaint._getRepaintBounds({
            ...info,
            shouldCacheUpdate: 1,
            diffCacheBounds: info.diffBounds,
        }, [], ctx);
        expect(nativeClipRanges).toHaveBeenCalledOnce();
        const exposedPoint = axis === 'x' ? { x: 410, y: 40 } : { x: 82, y: 230 };
        expect(refillBounds.some(({ bound }) => bound.left < exposedPoint.x && bound.right > exposedPoint.x
            && bound.top < exposedPoint.y && bound.bottom > exposedPoint.y)).toBe(true);
        const repairedArea = refillBounds.reduce((area, { bound }) => area + (bound.right - bound.left) * (bound.bottom - bound.top), 0);
        const cacheArea = (info.cacheBound.right - info.cacheBound.left) * (info.cacheBound.bottom - info.cacheBound.top);
        expect(repairedArea).toBeLessThan(cacheArea * 0.2);
    });

    it.each(['x', 'y'])('keeps retained cells cached within a stable native precision band on %s scroll', (axis) => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 1);
        const ctx = mainCanvas.getContext();
        ctx.setTransform(12, 0, 0, 12, 9856, 9904);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
        ctx.setTransform(12, 0, 0, 12, axis === 'x' ? 9844 : 9856, axis === 'y' ? 9892 : 9904);
        const info = createViewportInfo(scene, viewport.canvas!, {
            diffBounds: [axis === 'x' ? createBound(400, 0, 420, 240) : createBound(0, 220, 420, 240)],
            diffCacheBounds: [],
            diffX: axis === 'x' ? -1 : 0,
            diffY: axis === 'y' ? -1 : 0,
            shouldCacheUpdate: 0,
            isDirty: 0,
        });
        const repaint = spreadsheet as unknown as {
            _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
        };
        expect(repaint._getRepaintBounds(info, [], ctx).some(({ bound }) => bound.left < 142 && bound.right > 142
            && bound.top < 40 && bound.bottom > 40)).toBe(false);
    });

    it('keeps native rotated glyphs whole when a repair halo touches their cell clip', () => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 1);
        skeleton.setStylesCache(createViewportInfo(scene, canvas));
        const ctx = mainCanvas.getContext();
        ctx.setTransform(12, 0, 0, 12, 9856, 9904);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
        ctx.setTransform(12, 0, 0, 12, 9856, 9892);
        const info = createViewportInfo(scene, viewport.canvas!, {
            diffBounds: [createBound(117.9, 51.9, 125, 60)],
            diffCacheBounds: [createBound(117.9, 51.9, 125, 60)],
            diffX: 0,
            diffY: -1,
            shouldCacheUpdate: 1,
            isDirty: 0,
        });
        const repaint = spreadsheet as unknown as {
            _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
        };
        expect(repaint._getRepaintBounds(info, [], ctx).some(({ bound }) => bound.left < 142 && bound.right > 142
            && bound.top < 75 && bound.bottom > 75)).toBe(true);
    });

    it('keeps the full native cell clip when a repair halo reaches shrink-to-fit text', () => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas, workbook } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 1);
        const worksheet = workbook.getActiveSheet()!;
        const cell = worksheet.getCell(0, 3)!;
        vi.spyOn(FontCache, 'getMeasureText').mockReturnValue({ width: 240 } as TextMetrics);
        skeleton._setFontStylesCache(0, 3, cell, worksheet.getComposedCellStyleByCellData(0, 3, cell)!);
        skeleton.setStylesCache(createViewportInfo(scene, canvas));
        expect(skeleton.stylesCache.fontMatrix.getValue(0, 3)?.shrinkScale).toBeLessThan(1);
        const ctx = mainCanvas.getContext();
        ctx.setTransform(12, 0, 0, 12, 9856, 9904);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
        ctx.setTransform(12, 0, 0, 12, 9856, 9892);
        const info = createViewportInfo(scene, viewport.canvas!, {
            diffBounds: [createBound(229.9, 28, 240, 40)],
            diffCacheBounds: [createBound(229.9, 28, 240, 40)],
            diffX: 0,
            diffY: -1,
            shouldCacheUpdate: 1,
            isDirty: 0,
        });
        const repaint = spreadsheet as unknown as {
            _getRepaintBounds(info: IViewportInfo, merges: IBoundRectNoAngle[], context: typeof ctx): { bound: IBoundRectNoAngle }[];
        };
        expect(repaint._getRepaintBounds(info, [], ctx).some(({ bound }) => bound.left < 290 && bound.right > 290
            && bound.top < 40 && bound.bottom > 40)).toBe(true);
    });

    it.each([SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP])(
        'preserves native fixed-edge coverage when text repair reaches %s',
        (viewportKey) => {
            const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
            const getViewport = scene.getViewport.bind(scene);
            vi.spyOn(scene, 'getViewport').mockImplementation((key) => key === viewportKey ? viewport : getViewport(key));
            const canvas = viewport.canvas!;
            canvas.setSize(700, 420, 1);
            skeleton.setStylesCache(createViewportInfo(scene, canvas));
            const ctx = mainCanvas.getContext();
            const vertical = viewportKey === SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT;
            const bounds = vertical ? createBound(118, 28, 166, 240) : createBound(46, 52, 302, 76);
            const initial = createViewportInfo(scene, canvas, {
                viewportKey,
                viewBound: bounds,
                cacheBound: bounds,
                bufferEdgeX: 0,
                bufferEdgeY: 0,
            });
            spreadsheet.renderByViewports(ctx, initial, skeleton);
            spreadsheet.makeDirty(false);
            spreadsheet.makeForceDirty(false);
            ctx.translate(vertical ? 0 : -10, vertical ? -10 : 0);
            const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
            const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
            spreadsheet.renderByViewports(ctx, {
                ...initial,
                diffX: vertical ? 0 : -10,
                diffY: vertical ? -10 : 0,
                diffBounds: [vertical ? createBound(118, 51.9, 166, 60) : createBound(117.9, 52, 125, 76)],
                diffCacheBounds: [vertical ? createBound(118, 51.9, 166, 60) : createBound(117.9, 52, 125, 76)],
                isDirty: 0,
                isForceDirty: false,
                shouldCacheUpdate: 1,
            }, skeleton);
            expect(refresh).toHaveBeenCalledOnce();
            expect(paint).not.toHaveBeenCalled();
        }
    );

    it('rebuilds style coverage after a range reset even when the viewport stays in place', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        const info = createViewportInfo(scene, cacheCanvas);
        skeleton.setStylesCache(info, { scaleY: 1 });
        skeleton.resetRangeCache([{ startRow: 2, endRow: 3, startColumn: 2, endColumn: 3 }]);
        const cell = skeleton.worksheet.getCellRaw(2, 2)!;
        skeleton.worksheet.getCellMatrix().setValue(2, 2, { ...cell, v: 'Updated merge' });
        skeleton.setStylesCache({ ...info, isDirty: 0, shouldCacheUpdate: 0, diffX: -0.2 }, { scaleY: 1 });
        expect(skeleton.stylesCache.fontMatrix.getValue(2, 2)?.cellData?.v).toBe('Updated merge');
    });

    it.each(['scale', 'size', 'pixel-ratio', 'untracked-origin', 'fractional-viewport'])('refreshes an existing bitmap after its %s changes', (change) => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 1);
        const ctx = mainCanvas.getContext();
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        if (change === 'scale') {
            ctx.setTransform(2, 0, 0, 2, 0, 0);
        } else if (change === 'untracked-origin' || change === 'fractional-viewport') {
            ctx.translate(-4, 0);
        } else {
            canvas.setSize(change === 'size' ? 710 : 700, 420, change === 'pixel-ratio' ? 2 : 1);
        }
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
            diffX: change === 'fractional-viewport' ? -4 : 0,
            viewPortPosition: createBound(change === 'fractional-viewport' ? 0.25 : 0, 0, 420, 240),
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        }), skeleton);
        expect(refresh).toHaveBeenCalledOnce();
    });

    it.each([
        { zoom: 0.3333, pixelRatio: 3 },
        { zoom: 0.67, pixelRatio: 1.25 },
        { zoom: 0.9, pixelRatio: 2 },
        { zoom: 1.1, pixelRatio: 2 },
        { zoom: 1.25, pixelRatio: 3 },
        { zoom: 4, pixelRatio: 1.25 },
    ])('reuses stable fractional viewport pixels at zoom $zoom and DPR $pixelRatio', ({ zoom, pixelRatio }) => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, pixelRatio);
        const ctx = mainCanvas.getContext();
        const scale = zoom * pixelRatio;
        const position = createBound(46 * zoom, 24 * zoom, 420, 240);
        ctx.setTransform(scale, 0, 0, scale, 0, 0);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, { viewPortPosition: position }), skeleton);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        ctx.setTransform(scale, 0, 0, scale, -10.2 * scale, 0);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
            viewPortPosition: position,
            diffX: -10.2,
            diffBounds: [createBound(400, 0, 420, 240)],
            diffCacheBounds: [createBound(400, 0, 460, 280)],
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        }), skeleton);
        expect(refresh).not.toHaveBeenCalled();
        expect(paint).toHaveBeenCalledOnce();
    });

    it.each([
        { zoom: 1.33, pixelRatio: 2 },
        { zoom: 1.34, pixelRatio: 2 },
        { zoom: 1.35, pixelRatio: 2 },
        { zoom: 1.33, pixelRatio: 3 },
        { zoom: 1.34, pixelRatio: 3 },
        { zoom: 1.35, pixelRatio: 3 },
    ].flatMap((scale) => ['x', 'y'].map((axis) => ({ ...scale, axis }))))(
        'preserves the one-pixel scroll allowance with Float32 canvas scales at $zoom / $pixelRatio on $axis',
        ({ zoom, pixelRatio, axis }) => {
            const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
            const canvas = viewport.canvas!;
            canvas.setSize(700, 700, pixelRatio);
            scene.setScaleValueOnly(zoom, zoom);
            const ctx = mainCanvas.getContext();
            const logicalScale = zoom * pixelRatio;
            const nativeScale = Math.fround(logicalScale);
            const position = createBound(46 * zoom, 24 * zoom, 420, 240);
            ctx.setTransform(nativeScale, 0, 0, nativeScale, 0, 0);
            spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, { viewPortPosition: position }), skeleton);
            spreadsheet.makeDirty(false);
            spreadsheet.makeForceDirty(false);

            const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
            const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
            const displacement = nativeScale > logicalScale ? -999 : -1001;
            ctx.setTransform(nativeScale, 0, 0, nativeScale, axis === 'x' ? displacement : 0, axis === 'y' ? displacement : 0);
            spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
                viewPortPosition: position,
                diffX: axis === 'x' ? -1000 / logicalScale : 0,
                diffY: axis === 'y' ? -1000 / logicalScale : 0,
                diffBounds: [createBound(400, 200, 420, 240)],
                diffCacheBounds: [createBound(400, 200, 460, 280)],
                isDirty: 0,
                isForceDirty: false,
                shouldCacheUpdate: 1,
            }), skeleton);
            expect(refresh).not.toHaveBeenCalled();
            expect(paint).toHaveBeenCalledOnce();
        }
    );

    it.each(['unmatched-transform', 'larger-displacement'])(
        'retains scroll-cache rejection for $0 after Float32 scale normalization',
        (reason) => {
            const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
            const canvas = viewport.canvas!;
            canvas.setSize(700, 700, 2);
            scene.setScaleValueOnly(reason === 'unmatched-transform' ? 1.35 : 1.34, 1.34);
            const ctx = mainCanvas.getContext();
            const nativeScale = Math.fround(2.68);
            ctx.setTransform(nativeScale, 0, 0, nativeScale, 0, 0);
            spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
            spreadsheet.makeDirty(false);
            spreadsheet.makeForceDirty(false);

            const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
            const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
            ctx.setTransform(nativeScale, 0, 0, nativeScale, reason === 'larger-displacement' ? -998 : -999, 0);
            spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
                diffX: -1000 / 2.68,
                diffBounds: [createBound(400, 200, 420, 240)],
                diffCacheBounds: [createBound(400, 200, 460, 280)],
                isDirty: 0,
                isForceDirty: false,
                shouldCacheUpdate: 1,
            }), skeleton);
            expect(refresh).toHaveBeenCalledOnce();
            expect(paint).not.toHaveBeenCalled();
        }
    );

    it('retains full repaint for simultaneous axes at a fractional viewport edge', () => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 2);
        const ctx = mainCanvas.getContext();
        const position = createBound(41.4, 21.6, 420, 240);
        ctx.setTransform(1.8, 0, 0, 1.8, 0, 0);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, { viewPortPosition: position }), skeleton);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        ctx.setTransform(1.8, 0, 0, 1.8, -18, -18);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
            viewPortPosition: position,
            diffX: -10,
            diffY: -10,
            diffBounds: [createBound(400, 0, 420, 240)],
            diffCacheBounds: [createBound(400, 0, 460, 280)],
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        }), skeleton);
        expect(refresh).toHaveBeenCalledOnce();
        expect(paint).not.toHaveBeenCalled();
    });

    it('retains full repaint for horizontal scrolling in a fractionally clipped frozen row band', () => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const getViewport = scene.getViewport.bind(scene);
        vi.spyOn(scene, 'getViewport').mockImplementation((key) => key === SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP ? viewport : getViewport(key));
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 3);
        const ctx = mainCanvas.getContext();
        const position = createBound(77, 12, 420, 49.5);
        ctx.setTransform(1.5, 0, 0, 1.5, 0, 0);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
            viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
            viewPortPosition: position,
        }), skeleton);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        ctx.setTransform(1.5, 0, 0, 1.5, -15, 0);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas, {
            viewportKey: SHEET_VIEWPORT_KEY.VIEW_MAIN_TOP,
            viewPortPosition: position,
            diffX: -10,
            diffY: 0,
            diffBounds: [createBound(400, 0, 420, 240)],
            diffCacheBounds: [createBound(400, 0, 460, 280)],
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        }), skeleton);
        expect(refresh).toHaveBeenCalledOnce();
        expect(paint).not.toHaveBeenCalled();
    });

    it('prepares missing style coverage independently of the bitmap damage strips', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas, { cacheBound: createBound(0, 0, 300, 280) }));
        expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeUndefined();
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas, {
            cacheBound: createBound(72, 0, 460, 280),
            diffX: -72,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        }));
        expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
    });

    it('batches styles at the cache boundary while the prepared range covers the visible cells', () => {
        const { skeleton, scene, cacheCanvas } = fixture;
        skeleton.setStylesCache(createViewportInfo(scene, cacheCanvas, {
            cacheBound: createBound(0, 0, 300, 280),
            viewBound: createBound(46, 28, 250, 240),
        }));
        const info = createViewportInfo(scene, cacheCanvas, {
            cacheBound: createBound(20, 0, 320, 280),
            viewBound: createBound(66, 28, 270, 240),
            diffX: -20,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 0,
        });
        const prepareFont = vi.spyOn(skeleton, '_setFontStylesCache');
        skeleton.setStylesCache(info);
        expect(prepareFont).not.toHaveBeenCalled();
        expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeUndefined();
        skeleton.setStylesCache({ ...info, shouldCacheUpdate: 1 });
        expect(skeleton.stylesCache.backgroundPositions?.getValue(0, 4)).toBeDefined();
    });

    it('keeps full and incremental raster origins integral at non-binary zooms', () => {
        const { spreadsheet, skeleton, viewport, scene, mainCanvas } = fixture;
        const canvas = viewport.canvas!;
        canvas.setSize(700, 420, 1);
        const ctx = mainCanvas.getContext();
        const origins: { left: number; top: number }[] = [];
        const draw = spreadsheet.draw.bind(spreadsheet);
        vi.spyOn(spreadsheet, 'draw').mockImplementation((context, info, repair) => {
            const transform = context.getTransform();
            origins.push({ left: transform.e, top: transform.f });
            return draw(context, info, repair);
        });
        ctx.setTransform(2.01, 0, 0, 2.01, -387.123, 20.7);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, canvas), skeleton);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        ctx.setTransform(2.01, 0, 0, 2.01, -407.4, 20.7);
        spreadsheet.renderByViewports(ctx, createViewportInfo(scene, viewport.canvas!, {
            diffX: -10.09,
            diffY: 0,
            diffBounds: [createBound(400, 0, 420, 240)],
            diffCacheBounds: [createBound(400, 0, 460, 280)],
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        }), skeleton);
        expect(origins.length).toBeGreaterThan(1);
        expect(origins.every(({ left, top }) => Number.isInteger(left) && Number.isInteger(top))).toBe(true);
    });

    it('uses independent viewport buffers to repaint only newly exposed horizontal cache strips', () => {
        const { spreadsheet, skeleton, mainCanvas, viewport, scene } = fixture;
        const cacheCanvas = viewport.canvas!;
        cacheCanvas.setSize(700, 420, 1);
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(440, 0, 460, 280)],
            diffCacheBounds: [createBound(400, 0, 460, 280)],
            diffX: -20,
            diffY: 0,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        spreadsheet.render(mainCanvas.getContext(), viewportInfo);
        expect(refresh).not.toHaveBeenCalled();
        expect(paint).toHaveBeenCalledOnce();
        expect(viewport.canvas).not.toBe(cacheCanvas);
    });

    it.each([
        { key: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, width: 32.16, full: true },
        { key: SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, width: 32, full: false },
        { key: SHEET_VIEWPORT_KEY.VIEW_MAIN, width: 32.16, full: false },
    ])('protects a fractional frozen edge without broadening main viewport refresh: $key $width', ({ key, width, full }) => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        const info = createViewportInfo(scene, cacheCanvas, {
            viewportKey: key,
            viewPortPosition: createBound(0, 0, width, 240),
            diffY: -10,
            diffBounds: [createBound(0, 240, 420, 250)],
            diffCacheBounds: [createBound(0, 240, 460, 280)],
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        });
        skeleton.setStylesCache(info);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        spreadsheet.renderByViewports(mainCanvas.getContext(), info, skeleton);
        expect(refresh).toHaveBeenCalledTimes(full ? 1 : 0);
        expect(paint).toHaveBeenCalledTimes(full ? 0 : 1);
    });

    it.each(['dirty', 'force', 'fractional', 'within-buffer-fractional', 'fractional-origin', 'within-buffer-fractional-origin', 'missing-strip', 'jump'])('retains the horizontal full-refresh fallback for %s', (reason) => {
        const { spreadsheet, skeleton, mainCanvas, viewport, scene } = fixture;
        const cacheCanvas = viewport.canvas!;
        cacheCanvas.setSize(700, 420, 1);
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(440, 0, 460, 280)],
            diffCacheBounds: reason === 'missing-strip' ? [] : [createBound(400, 0, 460, 280)],
            diffX: reason.endsWith('fractional') ? -20.5 : -20,
            diffY: 0,
            isDirty: reason === 'dirty' ? 1 : 0,
            isForceDirty: reason === 'force',
            shouldCacheUpdate: reason.startsWith('within-buffer') ? 0 : 1,
        });
        if (reason === 'jump') {
            viewportInfo.diffX = -10000;
        }
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        if (reason.endsWith('fractional-origin')) {
            mainCanvas.getContext().translate(0.5, 0);
        }
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        spreadsheet.renderByViewports(mainCanvas.getContext(), viewportInfo, skeleton);
        expect(refresh).toHaveBeenCalledOnce();
        expect(paint).not.toHaveBeenCalled();
    });

    it.each([
        { axis: 'row', index: 0, size: 32, diffX: -20, diffY: 0, update: 1, full: true },
        { axis: 'row', index: 0, size: 32, diffX: -20, diffY: 0, update: 0, full: true },
        { axis: 'column', index: 0, size: 16, diffX: 0, diffY: -20, update: 1, full: true },
        { axis: 'column', index: 0, size: 16, diffX: 0, diffY: -20, update: 0, full: true },
        { axis: 'row', index: 19, size: 32, diffX: -20, diffY: 0, update: 1, full: false },
        { axis: 'column', index: 11, size: 16, diffX: 0, diffY: -20, update: 1, full: false },
        { axis: 'row', index: 0, size: 32, diffX: 0, diffY: -20, update: 1, full: false },
        { axis: 'column', index: 0, size: 16, diffX: -20, diffY: 0, update: 1, full: false },
        { axis: 'row', index: 0, size: 0, diffX: -20, diffY: 0, update: 1, full: false },
    ])('preserves gap stripe phase on $axis scrolls (gap: $index, cache update: $update)', ({ axis, index, size, diffX, diffY, update, full }) => {
        const { spreadsheet, skeleton, mainCanvas, viewport, scene } = fixture;
        const cacheCanvas = viewport.canvas!;
        cacheCanvas.setSize(700, 420, 1);
        skeleton.setGapConfig(axis === 'row'
            ? { rowGaps: { [index]: { size } } }
            : { colGaps: { [index]: { size } } });
        const info = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [diffX ? createBound(400, 0, 420, 240) : createBound(0, 220, 420, 240)],
            diffCacheBounds: update ? [diffX ? createBound(400, 0, 460, 280) : createBound(0, 220, 460, 280)] : [],
            diffX,
            diffY,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: update,
        });
        skeleton.setStylesCache(info);
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);
        const refresh = vi.spyOn(spreadsheet, 'refreshCacheCanvas');
        const paint = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');

        spreadsheet.renderByViewports(mainCanvas.getContext(), info, skeleton);

        expect(refresh).toHaveBeenCalledTimes(full ? 1 : 0);
        expect(paint).toHaveBeenCalledTimes(full ? 0 : 1);
    });

    it('retains full horizontal refresh when the cache is not owned by the viewport', () => {
        const { spreadsheet, skeleton, mainCanvas, cacheCanvas, scene } = fixture;
        const context = mainCanvas.getContext();
        const viewportInfo = createViewportInfo(scene, cacheCanvas, {
            diffBounds: [createBound(520, 0, 640, 280)],
            diffCacheBounds: [createBound(520, 0, 640, 280)],
            diffX: -80,
            diffY: 0,
            isDirty: 0,
            isForceDirty: false,
            shouldCacheUpdate: 1,
        });
        spreadsheet.makeDirty(false);
        spreadsheet.makeForceDirty(false);

        const paintSpy = vi.spyOn(spreadsheet, 'paintNewAreaForScrolling');
        const refreshSpy = vi.spyOn(spreadsheet, 'refreshCacheCanvas');

        spreadsheet.renderByViewports(context, viewportInfo, skeleton);

        expect(refreshSpy).toHaveBeenCalledOnce();
        expect(paintSpy).not.toHaveBeenCalled();
    });

    it('draws row and column gap areas using defaults from gapConfig', () => {
        const { spreadsheet, skeleton, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;

        skeleton.setGapConfig({
            defaultBackgroundColor: 'rgba(11, 22, 33, 0.08)',
            defaultStripeColor: 'rgba(11, 22, 33, 0.25)',
            rowGaps: {
                1: { size: 6 },
            },
            colGaps: {
                1: { size: 5 },
            },
        });

        const drawSingleGapRectSpy = vi.spyOn(spreadsheet as any, '_drawSingleGapRect');

        (spreadsheet as any)._drawGapAreas(
            context,
            skeleton,
            0,
            3,
            0,
            3,
            0,
            400,
            0,
            240
        );

        expect(drawSingleGapRectSpy).toHaveBeenCalled();
        expect(drawSingleGapRectSpy).toHaveBeenCalledWith(
            expect.anything(),
            expect.objectContaining({ size: 6 }),
            expect.any(Number),
            expect.any(Number),
            expect.any(Number),
            6,
            'rgba(11, 22, 33, 0.08)',
            'rgba(11, 22, 33, 0.25)'
        );
        expect(drawSingleGapRectSpy).toHaveBeenCalledWith(
            expect.anything(),
            expect.objectContaining({ size: 5 }),
            expect.any(Number),
            expect.any(Number),
            5,
            expect.any(Number),
            'rgba(11, 22, 33, 0.08)',
            'rgba(11, 22, 33, 0.25)'
        );

        // Cover fallback branch in _drawSingleGapRect: use default colors when item colors are absent.
        expect(() => {
            (spreadsheet as any)._drawSingleGapRect(
                context,
                { size: 3 },
                1,
                2,
                30,
                12,
                'rgba(11, 22, 33, 0.08)',
                'rgba(11, 22, 33, 0.25)'
            );
        }).not.toThrow();
    });

    it('draws the reusable gap fixture with mixed default and item colors', () => {
        const { spreadsheet, skeleton, mainCanvas } = fixture;
        const context = mainCanvas.getContext() as any;

        skeleton.setGapConfig(createSheetGapTestConfig());

        const drawSingleGapRectSpy = vi.spyOn(spreadsheet as any, '_drawSingleGapRect');

        (spreadsheet as any)._drawGapAreas(
            context,
            skeleton,
            0,
            7,
            0,
            5,
            0,
            500,
            0,
            320
        );

        expect(drawSingleGapRectSpy).toHaveBeenCalledTimes(6);
        expect(drawSingleGapRectSpy).toHaveBeenCalledWith(
            expect.anything(),
            expect.objectContaining({
                size: 10,
                color: 'rgba(245, 158, 11, 0.14)',
            }),
            expect.any(Number),
            expect.any(Number),
            expect.any(Number),
            10,
            'rgba(24, 119, 242, 0.08)',
            'rgba(24, 119, 242, 0.25)'
        );
        expect(drawSingleGapRectSpy).toHaveBeenCalledWith(
            expect.anything(),
            expect.objectContaining({
                size: 8,
                stripeColor: 'rgba(59, 130, 246, 0.35)',
            }),
            expect.any(Number),
            expect.any(Number),
            8,
            expect.any(Number),
            'rgba(24, 119, 242, 0.08)',
            'rgba(24, 119, 242, 0.25)'
        );
    });

    it.each([
        { browser: 'Safari', iPhone: false, swaps: false },
        { browser: 'Chrome', iPhone: true, swaps: false },
        { browser: 'Chrome', iPhone: false, swaps: true },
        { browser: 'FF', iPhone: false, swaps: true },
    ])('preserves native text context on $browser (iPhone: $iPhone)', ({ browser, iPhone, swaps }) => {
        const { spreadsheet, skeleton, scene, viewport, mainCanvas } = fixture;
        const mainCtx = mainCanvas.getContext();
        vi.spyOn(mainCtx, 'getBrowserType').mockReturnValue(browser);
        vi.spyOn(Tools, 'isIPhone').mockReturnValue(iPhone);
        const initialCanvas = viewport.canvas!;
        initialCanvas.setSize(460, 280, 1);
        let source = initialCanvas;

        for (const direction of [1, -1]) {
            const next = spreadsheet.paintNewAreaForScrolling(
                createViewportInfo(scene, source, {
                    diffX: direction * 4,
                    diffY: direction * 3,
                    diffBounds: [createBound(100, 60, 220, 140)],
                    diffCacheBounds: [createBound(100, 60, 220, 140)],
                }),
                {
                    cacheCanvas: source,
                    cacheCtx: source.getContext(),
                    mainCtx,
                    topOrigin: 0,
                    leftOrigin: 0,
                    bufferEdgeX: 8,
                    bufferEdgeY: 6,
                    rowHeaderWidthAndMarginLeft: skeleton.rowHeaderWidthAndMarginLeft,
                    columnHeaderHeightAndMarginTop: skeleton.columnHeaderHeightAndMarginTop,
                    scaleX: 1,
                    scaleY: 1,
                }
            );
            expect(next === source).toBe(!swaps);
            expect(viewport.canvas).toBe(next);
            source = next;
        }
    });

    it('alternates scroll buffers independently for each viewport', () => {
        const { spreadsheet, skeleton, scene, viewport, mainCanvas } = fixture;
        const mainCtx = mainCanvas.getContext() as any;
        const mainCache = viewport.canvas!;
        mainCache.setSize(460, 280, 1);
        const frozenViewport = fixture.univer.__getInjector().createInstance(Viewport, SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, scene, {
            left: 0,
            top: 0,
            width: 80,
            height: 240,
            active: true,
            allowCache: true,
        });
        const frozenCache = frozenViewport.canvas!;
        frozenCache.setSize(120, 280, 1);

        const paint = (viewportKey: string, cacheCanvas: Canvas) => spreadsheet.paintNewAreaForScrolling(
            createViewportInfo(scene, cacheCanvas, {
                viewportKey,
                cacheCanvas,
                diffX: 4,
                diffY: 3,
                diffBounds: [createBound(100, 60, 220, 140)],
                diffCacheBounds: [createBound(100, 60, 220, 140)],
            }),
            {
                cacheCanvas,
                cacheCtx: cacheCanvas.getContext() as any,
                mainCtx,
                topOrigin: 0,
                leftOrigin: 0,
                bufferEdgeX: 8,
                bufferEdgeY: 6,
                rowHeaderWidthAndMarginLeft: skeleton.rowHeaderWidthAndMarginLeft,
                columnHeaderHeightAndMarginTop: skeleton.columnHeaderHeightAndMarginTop,
                scaleX: 1,
                scaleY: 1,
            }
        );

        const nextMainCache = paint(SHEET_VIEWPORT_KEY.VIEW_MAIN, mainCache);
        const nextFrozenCache = paint(SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, frozenCache);
        expect(viewport.canvas).toBe(nextMainCache);
        expect(frozenViewport.canvas).toBe(nextFrozenCache);
        expect(nextMainCache).not.toBe(mainCache);
        expect(nextFrozenCache).not.toBe(frozenCache);
        expect(nextMainCache.getWidth()).toBe(460);
        expect(nextFrozenCache.getWidth()).toBe(120);

        expect(paint(SHEET_VIEWPORT_KEY.VIEW_MAIN, nextMainCache)).toBe(mainCache);
        expect(paint(SHEET_VIEWPORT_KEY.VIEW_MAIN_LEFT, nextFrozenCache)).toBe(frozenCache);
    });
});