perf(ccusage): scan Bun JSONL usage bytes

For Bun usage-only JSONL loading, read buffered files with Bun.file().bytes() and scan the byte buffer for the usage marker before decoding only matching usage rows. Node keeps the existing text path, and blocks still uses the full text path because it needs non-usage timestamps.

This avoids decoding the full 1.28GB local JSONL corpus for daily/session commands when most non-usage content is discarded before parsing.

Built Bun JSON A/B against 5db98c7: daily --offline --json 423.3ms ± 7.0ms -> 370.6ms ± 24.7ms (~1.14x faster), session 443.3ms ± 19.1ms -> 373.9ms ± 2.7ms (~1.19x faster), blocks 556.2ms ± 22.0ms -> 549.3ms ± 5.5ms (noise-level, mostly unchanged).

Built Bun table A/B: daily table 426.7ms ± 9.3ms -> 363.0ms ± 9.3ms (~1.18x faster), session table 442.3ms ± 3.8ms -> 384.2ms ± 14.0ms (~1.15x faster), blocks table 560.3ms ± 16.5ms -> 554.5ms ± 10.6ms (noise-level).

Rust reference after this change: JS daily 366.1ms ± 11.9ms vs Rust #977 daily 294.4ms ± 3.5ms (Rust ~1.24x faster); JS session 388.4ms ± 20.4ms vs Rust 300.3ms ± 3.8ms (Rust ~1.29x faster).

Output parity matched the previous built dist for daily/session/blocks/monthly/weekly JSON and daily/session/blocks table output. Node and Bun JSON outputs matched for daily/session/blocks/monthly/weekly. Build size is 404.85 kB. Validation: pnpm run format, pnpm typecheck, targeted data-loader tests, pnpm --filter ccusage run build, and pnpm run test (28 files, 351 passed, 1 skipped).

Author: ryoppippi

apps/ccusage/src/data-loader.ts

@@ -69,6 +69,7 @@ import { unreachable } from './_utils.ts';
 import { logger } from './logger.ts';
 
 const USAGE_LINE_MARKER = '"usage":{';
+const USAGE_LINE_MARKER_BUFFER = Buffer.from(USAGE_LINE_MARKER);
 const CACHE_CREATION_INPUT_TOKENS_MARKER = '"cache_creation_input_tokens":';
 const CACHE_READ_INPUT_TOKENS_MARKER = '"cache_read_input_tokens":';
 const COST_USD_MARKER = '"costUSD":';
@@ -861,6 +862,7 @@ type UsageSummaryAccumulator = {
 
 type BunFileLike = {
 	size: number;
+	bytes: () => Promise<Uint8Array>;
 	text: () => Promise<string>;
 };
 
@@ -1205,6 +1207,43 @@ async function processBufferedJSONLUsageContent(
 	}
 }
 
+async function processBufferedJSONLUsageBytes(
+	bytes: Uint8Array,
+	processLine: (line: string) => void,
+): Promise<void> {
+	const content = Buffer.isBuffer(bytes)
+		? bytes
+		: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let lineStart = 0;
+	let markerIndex = content.indexOf(USAGE_LINE_MARKER_BUFFER);
+	while (markerIndex !== -1) {
+		let lineEnd = content.indexOf(10, lineStart);
+		while (lineEnd !== -1 && lineEnd < markerIndex) {
+			lineStart = lineEnd + 1;
+			lineEnd = content.indexOf(10, lineStart);
+		}
+		if (lineEnd === -1) {
+			lineEnd = content.length;
+		}
+
+		const decodeEnd = lineEnd > lineStart && content[lineEnd - 1] === 13 ? lineEnd - 1 : lineEnd;
+		processLine(content.subarray(lineStart, decodeEnd).toString('utf8'));
+
+		lineStart = lineEnd + 1;
+		markerIndex = content.indexOf(USAGE_LINE_MARKER_BUFFER, lineStart);
+	}
+}
+
+async function readBufferedJSONLBytes(filePath: string): Promise<Uint8Array | null> {
+	const bun = getBunRuntime();
+	if (bun == null) {
+		return null;
+	}
+
+	const file = bun.file(filePath);
+	return file.size <= MAX_BUFFERED_JSONL_BYTES ? file.bytes() : null;
+}
+
 async function readBufferedJSONLContent(filePath: string): Promise<string | null> {
 	const bun = getBunRuntime();
 	if (bun != null) {
@@ -1264,6 +1303,12 @@ async function processJSONLUsageFileByLine(
 	filePath: string,
 	processLine: (line: string) => void,
 ): Promise<void> {
+	const bytes = await readBufferedJSONLBytes(filePath);
+	if (bytes != null) {
+		await processBufferedJSONLUsageBytes(bytes, processLine);
+		return;
+	}
+
 	const content = await readBufferedJSONLContent(filePath);
 	if (content != null) {
 		await processBufferedJSONLUsageContent(content, processLine);