revert: drop PrefixSource.buffer() override that was slower than the default

claude · claude · commit 728aed545cdb · 2026-04-28T16:11:40.000Z
Bench data (es6-promise.js fixture, 10 calls per task body): Source.buffer() default: ~1143 ops/s Hand-written single-pass buffer(): ~960 ops/s V8's optimized string replace + Buffer.from utf8 encode beats a JS-side indexOf+copy loop on typical ASCII inputs. The earlier commit shipped a slower buffer() in exchange for halved transient memory, but the CPU regression isn't worth that trade-off — and Source.buffer() already routes through this.source(), so subclasses that want the prefixed bytes don't lose anything. buffers() keeps the zero-copy splice implementation (~57% faster than the default [this.buffer()] path), which is the genuine win from addressing the TODO. https://claude.ai/code/session_01EHhGq9PRFRGefVtwwasCqZ
diff --git a/lib/PrefixSource.js b/lib/PrefixSource.js
@@ -62,51 +62,17 @@ class PrefixSource extends Source {
 		return prefix + node.replace(REPLACE_REGEX, `\n${prefix}`);
 	}
 
-	/**
-	 * Build the prefixed output directly from the underlying source's
-	 * buffer, skipping the regex replace + string-to-utf8 encoding that
-	 * `Source.prototype.buffer()` would do via `this.source()`. Two linear
-	 * passes (one to count `\n` followed by content, one to copy) so the
-	 * result buffer is sized exactly and written into a single allocation.
-	 * @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;
-		let extraPrefixes = 0;
-		{
-			let nl = content.indexOf(0x0a);
-			while (nl !== -1 && nl + 1 < contentLen) {
-				extraPrefixes++;
-				nl = content.indexOf(0x0a, nl + 1);
-			}
-		}
-		const result = Buffer.allocUnsafe(
-			prefixLen + contentLen + prefixLen * extraPrefixes,
-		);
-		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);
-			if (nl !== -1 && nl + 1 < contentLen) {
-				writePos += prefixBuffer.copy(result, writePos);
-			}
-			readPos = end;
-		}
-		return result;
-	}
-
 	/**
 	 * 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.
+	 * only the prefix buffer is materialized. This skips both the regex
+	 * replace and the string-to-utf8 encoding that the default
+	 * `[this.buffer()]` path would do.
+	 *
+	 * `buffer()` itself stays on the `Source.prototype` default (which
+	 * goes through `this.source()` plus `Buffer.from`); benchmarking shows
+	 * V8's optimized string replace + utf8 encode beats a hand-written
+	 * single-pass copy here.
 	 * @returns {Buffer[]} buffers
 	 */
 	buffers() {
