@gajae-code/tui 0.13.3 → 0.14.0

package/src/components/gajae-pet.ts

@@ -1,5 +1,6 @@
 import * as zlib from "node:zlib";
 
+import { encodeITerm2Multipart, wrapITerm2RecordsForTmux } from "../terminal-capabilities";
 import {
 	OUROBOROS_HEART_STEPS,
 	OUROBOROS_IDLE_STEPS,
@@ -231,7 +232,8 @@ const PIXEL_GRIDS: Record<GajaePixelFrameName, string[]> = {
 };
 
 /** Para-para work dance beats: the working loop and each skin's burst "work-in" intro. */
-export const PARA_PARA_STEPS: ReadonlyArray<readonly [GajaePixelFrameName, number]> = [
+export type GajaeGifFrameTuple = readonly [GajaePixelFrameName, number];
+export const PARA_PARA_STEPS: readonly GajaeGifFrameTuple[] = [
 	["danceL", 300],
 	["danceR", 300],
 	["base", 260],
@@ -329,19 +331,19 @@ export const PET_SKINS: Record<PetSkinId, PetSkin> = {
 
 /** Total burst duration (intro beats plus the looping tail). */
 export function petBurstDurationMs(burst: PetBurst): number {
-	const introMs = burst.intro.reduce((sum, [, ms]) => sum + ms, 0);
+	const introMs = burst.intro.reduce((sum, [, delayMs]) => sum + delayMs, 0);
 	return introMs + (burst.tail?.ms ?? 0);
 }
 
 /** The frame to show `elapsed` ms into a burst (`now` cycles the looping tail). */
 export function petBurstFrame(burst: PetBurst, elapsed: number, now: number): PetFrameName {
 	let t = elapsed;
-	for (const [frame, ms] of burst.intro) {
-		if (t < ms) return frame;
-		t -= ms;
+	for (const [name, delayMs] of burst.intro) {
+		if (t < delayMs) return name;
+		t -= delayMs;
 	}
 	const tail = burst.tail;
-	if (!tail) return burst.intro[burst.intro.length - 1][0];
+	if (!tail || tail.frames.length === 0) return burst.intro[burst.intro.length - 1]?.[0] ?? "base";
 	return tail.frames[Math.floor(now / tail.stepMs) % tail.frames.length];
 }
 
@@ -354,6 +356,301 @@ export const __gajaePetTestHooks = {
 	},
 };
 
+export interface GajaeGifFrame {
+	readonly name: PetFrameName;
+	readonly delayMs: number;
+}
+export type GajaeGifTimeline = readonly GajaeGifFrame[];
+export interface GajaeGifRectangle {
+	readonly width?: number;
+	readonly height?: number;
+}
+export interface GajaeGifDisplaySize {
+	/** iTerm2 display width: bare numbers are terminal cells; strings may use px or auto. */
+	readonly width: number | string;
+	/** iTerm2 display height: bare numbers are terminal cells; strings may use px or auto. */
+	readonly height: number | string;
+}
+export interface GajaeGifContentInset {
+	/** Transparent top padding in source pixels. */
+	readonly topPx?: number;
+	/** Transparent bottom padding in source pixels. */
+	readonly bottomPx?: number;
+}
+export interface GajaePetGifArtifact {
+	readonly bytes: Uint8Array;
+	readonly base64: string;
+	readonly width: number;
+	readonly height: number;
+	readonly frames: readonly GajaeGifFrame[];
+	readonly skin: PetSkinId;
+	readonly multipart: readonly string[];
+	readonly tmuxDcs: readonly string[];
+}
+export interface GajaePetGifOptions {
+	readonly skin?: PetSkinId;
+	readonly timeline?: GajaeGifTimeline;
+	readonly cellWidthPx?: number;
+	readonly cellHeightPx?: number;
+	readonly targetRows?: number;
+	readonly rectangle?: GajaeGifRectangle;
+	readonly displaySize?: GajaeGifDisplaySize;
+	readonly contentInset?: GajaeGifContentInset;
+}
+const GIF_CLEAR = 256,
+	GIF_END = 257;
+function gifLzw(pixels: number[], minCodeSize = 8): Uint8Array {
+	const out: number[] = [],
+		codes = pixels.flatMap(p => [GIF_CLEAR, p]).concat(GIF_END);
+	let bits = 0,
+		value = 0;
+	for (const code of codes) {
+		value |= code << bits;
+		bits += minCodeSize + 1;
+		while (bits >= 8) {
+			out.push(value & 255);
+			value >>>= 8;
+			bits -= 8;
+		}
+	}
+	if (bits) out.push(value & 255);
+	const blocks: number[] = [minCodeSize];
+	for (let i = 0; i < out.length; i += 255) {
+		const part = out.slice(i, i + 255);
+		blocks.push(part.length, ...part);
+	}
+	blocks.push(0);
+	return Uint8Array.from(blocks);
+}
+export const idleTimeline = (): GajaeGifTimeline => [
+	{ name: "base", delayMs: 700 },
+	{ name: "gazeL", delayMs: 180 },
+	{ name: "base", delayMs: 700 },
+	{ name: "gazeR", delayMs: 180 },
+	{ name: "flicker", delayMs: 120 },
+];
+export const workingTimeline = (): GajaeGifTimeline => PARA_PARA_STEPS.map(([name, delayMs]) => ({ name, delayMs }));
+export const burstTimeline = (skin: PetSkinId = "red"): GajaeGifTimeline => {
+	const burst = PET_SKINS[skin].burst;
+	const frames: GajaeGifFrame[] = burst.intro.map(([name, delayMs]) => ({ name, delayMs }));
+	const tail = burst.tail;
+	if (!tail || tail.frames.length === 0) return frames;
+	for (let elapsed = 0; elapsed < tail.ms; elapsed += tail.stepMs) {
+		frames.push({
+			name: tail.frames[Math.floor(elapsed / tail.stepMs) % tail.frames.length],
+			delayMs: Math.min(tail.stepMs, tail.ms - elapsed),
+		});
+	}
+	return frames;
+};
+export const previewTimeline = (skin: PetSkinId = "red"): GajaeGifTimeline => burstTimeline(skin);
+function isGifTimeline(input: GajaePetGifOptions | GajaeGifTimeline): input is GajaeGifTimeline {
+	return Array.isArray(input);
+}
+function gifOptions(input: GajaePetGifOptions | GajaeGifTimeline): Required<
+	Pick<GajaePetGifOptions, "skin" | "timeline" | "cellWidthPx" | "cellHeightPx" | "targetRows">
+> & {
+	rectangle?: GajaeGifRectangle;
+	displaySize?: GajaeGifDisplaySize;
+	contentInset?: GajaeGifContentInset;
+} {
+	if (isGifTimeline(input)) {
+		return { skin: "red", timeline: input, cellWidthPx: 1, cellHeightPx: 1, targetRows: 16 };
+	}
+	return {
+		skin: input.skin ?? "red",
+		timeline: input.timeline ?? idleTimeline(),
+		cellWidthPx: input.cellWidthPx ?? 1,
+		cellHeightPx: input.cellHeightPx ?? 1,
+		targetRows: input.targetRows ?? 16,
+		rectangle: input.rectangle,
+		displaySize: input.displaySize,
+		contentInset: input.contentInset,
+	};
+}
+export function encodeGajaePetGif(input: GajaePetGifOptions | GajaeGifTimeline = {}): GajaePetGifArtifact {
+	const o = gifOptions(input),
+		rect = o.rectangle ?? {};
+	if (o.timeline.length === 0) throw new Error("GIF timeline must not be empty");
+	for (const frame of o.timeline) {
+		if (!Number.isFinite(frame.delayMs) || frame.delayMs < 0) throw new Error("Invalid GIF frame delay");
+	}
+	const width = rect.width ?? rect.height ?? Math.round(Math.max(1, o.targetRows * o.cellHeightPx));
+	const height = rect.height ?? Math.round(Math.max(1, o.targetRows * o.cellHeightPx));
+	const valid = (n: number, label: string): number => {
+		if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0 || n > 0xffff) throw new Error(`Invalid GIF ${label}`);
+		return n;
+	};
+	valid(width, "width");
+	valid(height, "height");
+	const inset = o.contentInset ?? {};
+	const topInset = inset.topPx ?? 0;
+	const bottomInset = inset.bottomPx ?? 0;
+	if (
+		![topInset, bottomInset].every(value => Number.isFinite(value) && Number.isInteger(value) && value >= 0) ||
+		topInset + bottomInset >= height
+	)
+		throw new Error("Invalid GIF content inset");
+	const contentHeight = height - topInset - bottomInset;
+	if (width * height * o.timeline.length > 64 * 1024 * 1024) throw new Error("GIF allocation exceeds safety budget");
+	const paletteKeys = Object.keys(PET_SKINS[o.skin].palette).filter(k => k !== ".");
+	const palette = [[0, 0, 0], ...paletteKeys.map(k => PET_SKINS[o.skin].palette[k]!)];
+	const chunks: number[] = [
+		...Buffer.from("GIF89a"),
+		width & 255,
+		width >> 8,
+		height & 255,
+		height >> 8,
+		0xf7,
+		0,
+		0,
+		...palette.flat(),
+		...Array((256 - palette.length) * 3).fill(0),
+		33,
+		255,
+		11,
+		...Buffer.from("NETSCAPE2.0"),
+		3,
+		1,
+		0,
+		0,
+		0,
+	];
+	for (const frame of o.timeline) {
+		const pixels: number[] = [],
+			grid = PET_SKINS[o.skin].frames[frame.name];
+		if (!grid) throw new Error(`Unknown ${o.skin} GIF frame: ${frame.name}`);
+		for (let y = 0; y < height; y++)
+			for (let x = 0; x < width; x++) {
+				const contentY = y - topInset;
+				if (contentY < 0 || contentY >= contentHeight) {
+					pixels.push(0);
+					continue;
+				}
+				const sx = Math.min(15, Math.floor((x * 16) / width));
+				const sy = Math.min(15, Math.floor((contentY * 16) / contentHeight));
+				const ch = grid[sy][sx];
+				pixels.push(ch === "." ? 0 : Math.max(1, paletteKeys.indexOf(ch) + 1));
+			}
+		const delay = Math.round(frame.delayMs / 10);
+		chunks.push(
+			33,
+			249,
+			4,
+			0x09,
+			delay & 255,
+			delay >> 8,
+			0,
+			0,
+			44,
+			0,
+			0,
+			0,
+			0,
+			width & 255,
+			width >> 8,
+			height & 255,
+			height >> 8,
+			0,
+			...gifLzw(pixels),
+		);
+	}
+	chunks.push(59);
+	const bytes = Uint8Array.from(chunks);
+	const base64 = Buffer.from(bytes).toString("base64");
+	const multipart = encodeITerm2Multipart(base64, {
+		width: o.displaySize?.width ?? `${width}px`,
+		height: o.displaySize?.height ?? `${height}px`,
+	});
+	const tmuxDcs = wrapITerm2RecordsForTmux(multipart);
+	return {
+		bytes,
+		base64,
+		width,
+		height,
+		frames: [...o.timeline],
+		skin: o.skin,
+		multipart,
+		tmuxDcs,
+	};
+}
+const gifCache = new Map<string, GajaePetGifArtifact>();
+let gifCacheBytes = 0;
+let gifCacheBase64Bytes = 0;
+let gifCacheMultipartBytes = 0;
+let gifCacheTmuxDcsBytes = 0;
+let gifCacheEvictions = 0;
+const GIF_CACHE_MAX_ENTRIES = 32;
+const GIF_CACHE_MAX_BYTES = 8 * 1024 * 1024;
+const byteLength = (value: string): number => Buffer.byteLength(value, "utf8");
+
+export function getGajaePetGifCached(input: GajaePetGifOptions | GajaeGifTimeline = {}): GajaePetGifArtifact {
+	const o = gifOptions(input),
+		key = JSON.stringify([
+			o.skin,
+			o.timeline,
+			o.cellWidthPx,
+			o.cellHeightPx,
+			o.targetRows,
+			o.rectangle,
+			o.displaySize,
+			o.contentInset,
+		]),
+		hit = gifCache.get(key);
+	if (hit) {
+		gifCache.delete(key);
+		gifCache.set(key, hit);
+		return hit;
+	}
+	const value = encodeGajaePetGif(o);
+	gifCache.set(key, value);
+	gifCacheBytes += value.bytes.byteLength;
+	gifCacheBase64Bytes += byteLength(value.base64);
+	gifCacheMultipartBytes += value.multipart.reduce((sum, record) => sum + byteLength(record), 0);
+	gifCacheTmuxDcsBytes += value.tmuxDcs.reduce((sum, record) => sum + byteLength(record), 0);
+	while (
+		gifCache.size > GIF_CACHE_MAX_ENTRIES ||
+		gifCacheBytes + gifCacheBase64Bytes + gifCacheMultipartBytes + gifCacheTmuxDcsBytes > GIF_CACHE_MAX_BYTES
+	) {
+		const k = gifCache.keys().next().value as string,
+			old = gifCache.get(k)!;
+		gifCache.delete(k);
+		gifCacheBytes -= old.bytes.byteLength;
+		gifCacheBase64Bytes -= byteLength(old.base64);
+		gifCacheMultipartBytes -= old.multipart.reduce((sum, record) => sum + byteLength(record), 0);
+		gifCacheTmuxDcsBytes -= old.tmuxDcs.reduce((sum, record) => sum + byteLength(record), 0);
+		gifCacheEvictions++;
+	}
+	return value;
+}
+export function getGajaePetGifCacheStats(): {
+	size: number;
+	bytes: number;
+	gifBytes: number;
+	base64Bytes: number;
+	multipartBytes: number;
+	tmuxDcsBytes: number;
+	evictions: number;
+} {
+	return {
+		size: gifCache.size,
+		bytes: gifCacheBytes + gifCacheBase64Bytes + gifCacheMultipartBytes + gifCacheTmuxDcsBytes,
+		gifBytes: gifCacheBytes,
+		base64Bytes: gifCacheBase64Bytes,
+		multipartBytes: gifCacheMultipartBytes,
+		tmuxDcsBytes: gifCacheTmuxDcsBytes,
+		evictions: gifCacheEvictions,
+	};
+}
+export function resetGajaePetGifCache(): void {
+	gifCache.clear();
+	gifCacheBytes = 0;
+	gifCacheBase64Bytes = 0;
+	gifCacheMultipartBytes = 0;
+	gifCacheTmuxDcsBytes = 0;
+	gifCacheEvictions = 0;
+}
+export const clearGajaePetGifCache = resetGajaePetGifCache;
 /** Encode a grid as a transparent SIXEL image, optionally bottom-aligned by top padding. */
 export function encodeGridSixel(
 	grid: string[],
@@ -445,9 +742,12 @@ function validatePngGrid(
 	scale: number,
 	topPaddingPx: number,
 	bottomPaddingPx: number,
+	leftPaddingPx: number,
+	rightPaddingPx: number,
 ): {
 	gridWidth: number;
 	gridHeight: number;
+	spriteWidth: number;
 	width: number;
 	spriteHeight: number;
 	height: number;
@@ -461,19 +761,24 @@ function validatePngGrid(
 	for (const [name, value] of [
 		["top padding", topPaddingPx],
 		["bottom padding", bottomPaddingPx],
+		["left padding", leftPaddingPx],
+		["right padding", rightPaddingPx],
 	] as const) {
 		if (!Number.isSafeInteger(value) || value < 0)
 			throw new Error(`iTerm2 pet ${name} must be a non-negative integer`);
 	}
-	const width = Math.round(gridWidth * scale);
+	const spriteWidth = Math.round(gridWidth * scale);
 	const spriteHeight = Math.round(gridHeight * scale);
+	const width = spriteWidth + leftPaddingPx + rightPaddingPx;
 	const height = spriteHeight + topPaddingPx + bottomPaddingPx;
 	if (
-		!Number.isSafeInteger(width) ||
+		!Number.isSafeInteger(spriteWidth) ||
 		!Number.isSafeInteger(spriteHeight) ||
+		!Number.isSafeInteger(width) ||
 		!Number.isSafeInteger(height) ||
-		width <= 0 ||
+		spriteWidth <= 0 ||
 		spriteHeight <= 0 ||
+		width <= 0 ||
 		height <= 0 ||
 		width > MAX_PET_PNG_DIMENSION ||
 		height > MAX_PET_PNG_DIMENSION
@@ -485,33 +790,57 @@ function validatePngGrid(
 	if (!Number.isSafeInteger(rawBytes) || rawBytes > MAX_PET_PNG_RAW_BYTES) {
 		throw new Error("iTerm2 pet PNG allocation is out of bounds");
 	}
-	return { gridWidth, gridHeight, width, spriteHeight, height };
+	return { gridWidth, gridHeight, spriteWidth, spriteHeight, width, height };
 }
 
-/** Encode a grid as an iTerm2 inline PNG. */
+/**
+ * Encode a grid as an iTerm2 inline PNG spanning a terminal cell block.
+ *
+ * The escape's `width`/`height` are the reserved cell-block footprint in
+ * character cells (unitless numbers per the iTerm2 inline-images protocol).
+ * iTerm2 resolves cells against its own live font metrics, so the sprite
+ * scales with the real terminal geometry — including Retina, where iTerm2
+ * divides `Npx` values by the backing-scale factor and would render a fixed
+ * pixel box at half size.
+ */
 export function encodeGridIterm2(
 	grid: string[],
 	scale: number,
+	columns: number,
+	rows: number,
 	topPaddingPx = 0,
 	bottomPaddingPx = 0,
+	leftPaddingPx = 0,
+	rightPaddingPx = 0,
 	palette: Palette = RED_PALETTE,
 ): string {
-	const { gridWidth, gridHeight, width, spriteHeight, height } = validatePngGrid(
+	for (const [name, value] of [
+		["column count", columns],
+		["row count", rows],
+	] as const) {
+		if (!Number.isSafeInteger(value) || value <= 0) {
+			throw new Error(`iTerm2 pet ${name} must be a positive integer`);
+		}
+	}
+	const { gridWidth, gridHeight, spriteWidth, spriteHeight, width, height } = validatePngGrid(
 		grid,
 		scale,
 		topPaddingPx,
 		bottomPaddingPx,
+		leftPaddingPx,
+		rightPaddingPx,
 	);
 	const raw = Buffer.alloc((width * 4 + 1) * height);
 	for (let y = 0; y < height; y++) {
 		for (let x = 0; x < width; x++) {
+			const sourceX = x - leftPaddingPx;
 			const sourceY = y - topPaddingPx;
 			const rgb =
-				sourceY < 0 || sourceY >= spriteHeight
+				sourceX < 0 || sourceX >= spriteWidth || sourceY < 0 || sourceY >= spriteHeight
 					? null
 					: palette[
 							grid[Math.min(gridHeight - 1, Math.floor(sourceY / scale))][
-								Math.min(gridWidth - 1, Math.floor(x / scale))
+								Math.min(gridWidth - 1, Math.floor(sourceX / scale))
 							]
 						];
 			const offset = y * (width * 4 + 1) + 1 + x * 4;
@@ -534,10 +863,12 @@ export function encodeGridIterm2(
 		pngChunk("IDAT", compressed),
 		pngChunk("IEND", new Uint8Array()),
 	]);
-	// Use explicit pixel dimensions. Cell dimensions are only a layout hint for
-	// the surrounding TUI; asking iTerm2 to fit a small PNG into a cell box makes
-	// it stretch or shrink differently from Kitty/Ghostty.
-	const params = `width=${width}px;height=${height}px;preserveAspectRatio=0;inline=1`;
+	// Size in character cells, not pixels: iTerm2 applies its own cell metrics
+	// (and divides px values by the Retina backing scale), so cells keep the
+	// padded canvas 1:1 with the reserved block at every geometry.
+	// iTerm uses the supplied filename when a user drags this inline image out.
+	// The unique name lets the composer discard only this pet's automatic path paste.
+	const params = `name=Z2FqYWUtcGV0LnBuZw==;width=${columns};height=${rows};preserveAspectRatio=0;inline=1`;
 	return `\x1b]1337;File=${params}:${png.toString("base64")}\x1b\\`;
 }
 
@@ -602,7 +933,9 @@ export interface GajaePixelFrames {
 	frames: Record<string, string>;
 	/** protocol the frames were encoded for */
 	protocol: "sixel" | "kitty" | "iterm2";
+	/** Scaled sprite width before transparent cell-block padding. */
 	widthPx: number;
+	/** Encoded raster height, including protocol-specific transparent padding. */
 	heightPx: number;
 	columns: number;
 	rows: number;
@@ -614,6 +947,17 @@ export interface GajaePixelFrames {
  * Build overlay pixel frames exactly `targetRows` terminal rows tall when the
  * terminal cells permit it. Each skin owns its source resolution so future
  * additions can opt into denser art without changing the terminal footprint.
+ *
+ * Geometry contract:
+ * - `scale = max(1, targetRows * cellHeightPx / gridHeight)`
+ * - `columns = ceil(scaledSpriteWidthPx / cellWidthPx)`
+ * - `rows = ceil(scaledSpriteHeightPx / cellHeightPx)`
+ * - the square sprite is centered in a `columns * cellWidthPx` PNG canvas
+ *
+ * iTerm2 receives unitless `width=columns;height=rasterRows`, so it resolves the
+ * padded block with its live cell metrics. The PNG has that block's pixel aspect
+ * ratio, allowing `preserveAspectRatio=0` without stretching the authored square
+ * sprite. Kitty and Sixel retain their protocol-specific paths.
  */
 export function buildGajaePixelFrames(options: {
 	protocol: "sixel" | "kitty" | "iterm2";
@@ -625,9 +969,9 @@ export function buildGajaePixelFrames(options: {
 	/** Native sub-cell `Y=` pixel offset that drops the kitty sprite within its first cell. */
 	kittyCellYOffsetPx?: number;
 	kittyImageId?: number;
-	/** Transparent iTerm2-only top padding for half-cell vertical alignment. */
+	/** Additional transparent iTerm2-only top padding for sub-cell vertical alignment. */
 	iterm2TopPaddingPx?: number;
-	/** Transparent iTerm2-only bottom padding inside the two-row canvas. */
+	/** Transparent iTerm2-only bottom padding inside the canvas. */
 	iterm2BottomPaddingPx?: number;
 	/** Color skin for the sprite palette (default "red"). */
 	skin?: PetSkinId;
@@ -660,12 +1004,23 @@ export function buildGajaePixelFrames(options: {
 	const topPaddingPx =
 		allocatedHeightPx - visibleHeightPx + (options.protocol === "sixel" ? (options.sixelTopPaddingPx ?? 0) : 0);
 	const heightPx = visibleHeightPx + topPaddingPx;
+	const kittyYOffsetPx = options.protocol === "kitty" ? Math.max(0, Math.round(options.kittyCellYOffsetPx ?? 0)) : 0;
 	// Center the square sprite in its (cols * cellWidth) block, which the ceil()
 	// column rounding can make wider than the sprite itself.
 	const horizontalPaddingPx = Math.max(0, columns * options.cellWidthPx - widthPx);
 	const leftPaddingPx = Math.floor(horizontalPaddingPx / 2);
 	const rightPaddingPx = horizontalPaddingPx - leftPaddingPx;
 	const canvasWidthPx = widthPx + leftPaddingPx + rightPaddingPx;
+	// When minimum 1x art is taller than targetRows (only possible with tiny
+	// cells), top-pad iTerm2 to the full reserved row block. Its unitless OSC
+	// height then maps the PNG 1:1 without vertically stretching the authored square sprite.
+	const iterm2TopPaddingPx =
+		allocatedHeightPx - visibleHeightPx + (options.protocol === "iterm2" ? (options.iterm2TopPaddingPx ?? 0) : 0);
+	const protocolHeightPx =
+		options.protocol === "iterm2"
+			? visibleHeightPx + iterm2TopPaddingPx + (options.iterm2BottomPaddingPx ?? 0)
+			: heightPx;
+	const rasterRows = Math.ceil((protocolHeightPx + kittyYOffsetPx) / options.cellHeightPx);
 	if (
 		widthPx > MAX_PET_FRAME_DIMENSION ||
 		heightPx > MAX_PET_FRAME_DIMENSION ||
@@ -685,8 +1040,12 @@ export function buildGajaePixelFrames(options: {
 					? encodeGridIterm2(
 							grid,
 							scale,
-							options.iterm2TopPaddingPx ?? 0,
+							columns,
+							rasterRows,
+							iterm2TopPaddingPx,
 							options.iterm2BottomPaddingPx ?? 0,
+							leftPaddingPx,
+							rightPaddingPx,
 							skin.palette,
 						)
 					: encodeGridKitty(
@@ -703,10 +1062,6 @@ export function buildGajaePixelFrames(options: {
 						);
 	}
 
-	const protocolHeightPx =
-		options.protocol === "iterm2"
-			? visibleHeightPx + (options.iterm2TopPaddingPx ?? 0) + (options.iterm2BottomPaddingPx ?? 0)
-			: heightPx;
 	return {
 		frames,
 		protocol: options.protocol,
@@ -714,6 +1069,6 @@ export function buildGajaePixelFrames(options: {
 		heightPx: protocolHeightPx,
 		columns,
 		rows,
-		rasterRows: Math.ceil(protocolHeightPx / options.cellHeightPx),
+		rasterRows,
 	};
 }