Why does editing a Buffer slice change my original cleaned bytes?

Measured inputs and outputs

These are locally constructed test strings, not evidence that Claude inserts these characters. We executed the saved homepage script snapshot with a minimal DOM harness and compared exact strings. The invisible-checkbox state and dash mode appear in each row. The observations below test this page's specific question. Destination observations run independently on the exact input and cleaned strings in the recorded Node runtime. We make no detector-score or statistical-watermark removal claim.

A different object still changes the same bytes

The marked ASCII input encodes as hex 41e2808b42. The observer creates a full slice and an independent Buffer.from copy, then writes byte 0x58 through the slice. The source and slice both become 58e2808b42 while the copy retains its original hex. After cleanup, the corresponding initial bytes are 4142 and the source and slice become 5842; the copy stays 4142. The identity check says the view is not the source object in both branches. Different object identity therefore does not establish independent byte storage.

The emoji control exposes the byte-level edit

For the emoji source, initial UTF-8 hex is f09f9880. Changing the first byte through the slice yields 589f9880 in both source and view, while the copy keeps f09f9880. We report hex and do not label that mutated byte sequence a successfully edited character. The empty control has no first byte to write; all three buffers remain empty, though the object identity check still differs. Plain AB reproduces the aliasing without selected characters. These controls distinguish ownership from encoding correctness, length and the homepage removal count. No user file is opened or changed.

Copy bytes before an independent working edit

When retaining a before record for a byte transformation, create an independent copy before mutating the working buffer. Keep its initial hash or hex beside the later observation if exact bytes matter. A view can be useful for deliberate shared editing, but it is unsuitable as an independent baseline when another view will write the same storage. Our observer recreates its buffers for each call, so the before and after cleanup branches cannot modify each other. The homepage itself returns strings and does not use this buffer mutation path; all byte edits happen only in the downloaded experiment.

This test concerns storage rather than prefix validity

An earlier byte-prefix guide asks whether truncation splits UTF-8. Here the full byte length is retained and one deliberate write exposes storage sharing. We do not benchmark copying, test ArrayBuffer overloads, transfer memory to a worker or guarantee that a copied buffer remains unchanged by its own later writes. Four synthetic strings and the recorded Node version bound the results. The exact mutation is intentionally visible in the harness, avoiding any implication that cleanup silently damaged a buffer. Neither an intact copy nor a changed view establishes watermark removal, original authorship or the provenance of a document.

Reproduce this test

Save reproduce.cjs and tested-app.js in the same folder. Run the command below with Node.js. The harness prints its runtime, script SHA-256 and every measured row. Compare those rows with the original record. Using a newer script or runtime creates a new experiment; retain the version information with your rerun.

node reproduce.cjs