perf(prefix-source): implement buffer() that beats the Source default by ~17%

claude · claude · commit 683c2b7562d1 · 2026-04-28T21:34:14.000Z
Walks the underlying source's buffer directly instead of going through this.source() + Buffer.from. Skips both the regex replace and the intermediate prefixed-string allocation. Key trick that beats the V8 default: skip the count pass. Allocate worst-case `prefixLen + contentLen + prefixLen * contentLen` with allocUnsafe (cheap, no init), fill in one pass, return result.subarray. For typical short prefixes ("\t", " ") the worst case is bounded by ~2x and the subarray retains the over-allocation cheaply. For long prefixes the >50% waste threshold triggers a copy into a tight Buffer so the extra capacity gets GC'd. No caching — _source can be mutable (ReplaceSource etc.) and the result must reflect changes on each call. The existing "reflect-mutations-to-underlying-source" regression test still passes. A/B/A median over 5 alternating runs (es6-promise.js fixture, 10 calls per task body): baseline: 1130 ops/s this: 1322 ops/s (+17%) Earlier attempts (committed and reverted on this branch) — for the record so the next person doesn't redo them: - Buffer.concat(this.buffers()): array-iteration overhead -> slower - count-pass + exact alloc + copy: 2x indexOf walks -> slower - cache the result: faster but unsafe with mutable child https://claude.ai/code/session_01EHhGq9PRFRGefVtwwasCqZ
diff --git a/lib/PrefixSource.js b/lib/PrefixSource.js
@@ -62,19 +62,61 @@ class PrefixSource extends Source {
 		return prefix + node.replace(REPLACE_REGEX, `\n${prefix}`);
 	}
 
-	// Note: we deliberately don't cache buffer() / buffers() / size() here.
-	// `_source` can be mutable (ReplaceSource, ConcatSource, CompatSource
-	// wrapping a SourceLike) and `source()` reads it on every call; caching
-	// the derived result would silently go stale after a child mutation.
-	// `RawSource` / `OriginalSource` / `SourceMapSource` cache their own
-	// buffer because they're self-contained — that invariant doesn't hold
-	// here. Wrap PrefixSource in CachedSource if you need the speedup.
+	/**
+	 * Build the prefixed buffer by walking the underlying source's buffer
+	 * directly — skips both the regex replace and the intermediate
+	 * prefixed-string allocation that the default `Source.buffer()` path
+	 * does via `this.source()` + `Buffer.from`. Single linear pass: alloc
+	 * a worst-case-sized scratch with `Buffer.allocUnsafe`, splice the
+	 * prefix in after each `\n` that has more content following, then
+	 * return a tight result.
+	 *
+	 * The worst case is `prefixLen + contentLen + prefixLen * contentLen`
+	 * (every byte is a newline followed by content). For typical short
+	 * prefixes (`"\t"`, `"  "`) that's bounded by ~2x the content size and
+	 * we keep the allocUnsafe via `subarray` (zero-copy). For long
+	 * prefixes the ratio is unbounded, so when the over-allocation wastes
+	 * more than 50% we copy into a tight Buffer so the extra capacity
+	 * gets GC'd promptly. No caching — `_source` may be mutable
+	 * (ReplaceSource etc.) and we must reflect changes on each call.
+	 * @returns {Buffer} buffer
+	 */
+	buffer() {
+		const prefix = this._prefix;
+		if (prefix.length === 0) return this._source.buffer();
+		const content = this._source.buffer();
+		const contentLen = content.length;
+		if (contentLen === 0) return Buffer.from(prefix, "utf8");
+		const prefixBuffer = Buffer.from(prefix, "utf8");
+		const prefixLen = prefixBuffer.length;
+		const worst = prefixLen + contentLen + prefixLen * contentLen;
+		const result = Buffer.allocUnsafe(worst);
+		let writePos = prefixBuffer.copy(result, 0);
+		let readPos = 0;
+		while (readPos < contentLen) {
+			const nl = content.indexOf(0x0a, readPos);
+			const end = nl === -1 ? contentLen : nl + 1;
+			writePos += content.copy(result, writePos, readPos, end);
+			// Match the regex `/\n(?=.|\s)/g` — only re-emit the prefix when
+			// at least one more byte follows the newline.
+			if (nl !== -1 && nl + 1 < contentLen) {
+				writePos += prefixBuffer.copy(result, writePos);
+			}
+			readPos = end;
+		}
+		if (writePos * 2 < worst) {
+			const tight = Buffer.allocUnsafe(writePos);
+			result.copy(tight, 0, 0, writePos);
+			return tight;
+		}
+		return result.subarray(0, writePos);
+	}
 
 	/**
 	 * Returns a `Buffer[]` that concatenates to the prefixed source. Each
 	 * content chunk is a `subarray` of the underlying buffer (no copy);
 	 * only the prefix buffer is materialized. This skips the
-	 * [this.buffer()] wrap that the default Source.buffers() would do.
+	 * `[this.buffer()]` wrap that the default Source.buffers() would do.
 	 * @returns {Buffer[]} buffers
 	 */
 	buffers() {
