Explain the difference between `ObjectMode` and `Buffer` mode in a readable stream.

0-2 years experience

1. 1We have a readable stream reading JSON lines from a file. If we set `objectMode: true`, what does our `data` event handler actually receive compared to when it's set to `false`? How does this change how we parse the incoming data?
2. 2You're writing a stream to process user records from a database. You notice that when you push a plain JavaScript object into your readable stream, it throws an error saying 'Invalid non-string/buffer chunk'. What's causing this, and how do you fix it?

2-5 years experience

1. 1We are processing a massive CSV file. The developer wrote a custom transform stream that parses rows into JS objects, but they forgot to set `objectMode: true` on the downstream writable stream. What kind of runtime errors or silent failures should we expect to see here, and how do we safely bridge the binary-to-object boundary?
2. 2We have an API that streams database rows to a client. We enabled `objectMode: true` on our query stream, but now we're seeing memory spikes under heavy load. How does the `highWaterMark` setting change when you switch to object mode, and how might that explain the memory leak?

5-8 years experience

1. 1We're building an ETL pipeline in Node.js that processes millions of complex nested objects per minute. We're debating between keeping everything in `objectMode` streams versus serializing to NDJSON (newline-delimited JSON) buffers at each step. What are the CPU, memory, and garbage collection tradeoffs of these two approaches?
2. 2You are designing a custom stream-based rate limiter for an internal event-processing engine. If the upstream is an object-mode stream emitting heavy payload objects, how would you design the backpressure mechanism to ensure we don't run out of memory, given that `highWaterMark` only counts the number of objects rather than their actual byte size?

8+ years experience

1. 1Our core platform relies on a legacy event-streaming library built on Node.js object-mode streams. As our event sizes have grown from small metadata payloads to large, multi-megabyte documents, we're hitting severe V8 heap fragmentation and GC pauses. How would you architect a migration path away from object-mode streams to a buffer-based or zero-copy architecture without breaking downstream consumer teams?
2. 2We are designing an enterprise-grade plugin architecture where third-party developers can pipe their own custom streams into our data ingestion pipeline. How do we enforce strict memory limits and backpressure safety when we don't know if a plugin will return an object-mode stream or a raw buffer stream? What defensive patterns would you establish at the integration boundaries?