edf2csv 0.5.79 → 0.5.81

package/CHANGELOG.md

@@ -3,6 +3,55 @@
 Notable changes to edf2csv. Versions follow [semantic versioning](https://semver.org); while the
 major version is 0, a minor bump may contain breaking changes.
 
+## 0.5.81
+
+### Fixed: the listener leak 0.5.36 fixed, still there one flag away
+
+```js
+for (let i = 0; i < 12; i++) await convert(rec, { toStdout: true, gzip: true });
+```
+
+leaves twelve `'error'` listeners on `process.stdout` and prints Node's
+MaxListenersExceededWarning on the eleventh — which is 0.5.36's entry word for word, including
+the count. That version fixed it for the writer's own listener, through
+`BufferedLineWriter`'s `#release()`, and wrote a regression test that loops fifteen `toStdout`
+conversions and asserts the count comes back. The test never passes `gzip: true`.
+
+It could not have caught this one anyway. `#release()` only detaches from a stream the writer
+holds, and under gzip the writer's stream is the compressor — `process.stdout` is the
+compressor's *destination*, and the listener on it is `compressed()`'s error forwarding, which
+was attached and never removed. Same leak, same stream, same warning, behind one flag.
+
+The forwarder is removable now, released after the conversion settles and in a `finally`, with
+the ownership rule the writer already uses: detach from `process.stdout` and `process.stderr`,
+leave a file stream alone, since a file stream is created for the conversion and closed with
+it. In a `finally` for 0.5.45's reason — a conversion that fails still has to leave stdout as
+it found it, and a failure is exactly when a caller goes on to convert something else.
+
+The CLI could never accumulate these: `--stdout` takes one recording and the process exits.
+It is the library API that leaks, which is the surface 0.5.36's entry says its fix was for.
+
+The regression test runs both paths now.
+
+## 0.5.80
+
+### Fixed: "Wrote 1 rows to stdout." — and the sweep that kept missing this family
+
+The third message in three versions to disagree with itself about number, and the third found
+the same way: by running a mode the test did not.
+
+0.5.74 fixed the header lines and swept whole-recording conversions. The estimate line and the
+written-files table were never seen at a count of one, so both still read "1 rows" — a window
+narrow enough to select a single sample is what produces that, and 0.5.78 fixed them and added
+the window. It still never ran `--stdout`, whose summary is a separate line: "Wrote 1 rows to
+stdout."
+
+A count that is never one in the run is a count the sweep cannot check, so the modes are
+enumerated now rather than sampled: plain, windowed, `--gzip`, `--layout long`,
+`--annotations-only` and `--stdout`, each with an assertion that the narrow window really does
+estimate, write and stream exactly one row, so a mode cannot quietly stop exercising the case
+it was added for.
+
 ## 0.5.79
 
 ### Fixed: two refusals printed in a shape nothing else uses, so `^error:` missed them

package/dist/cli.js

@@ -796,13 +796,18 @@ async function convertOne(input, destination, options, emit = writeThrough) {
                   the reader is not knowable from this side either way.
                 */
                 const expected = result.plan.estimate.rows;
+                // Singular at one, like every other count. A window narrow enough to select a single
+                // sample is an ordinary thing to pipe, and this said "Wrote 1 rows to stdout." — the
+                // third message in this family, after 0.5.74 and 0.5.78, each found because the sweep
+                // that checks for it was narrower than the set of modes that print a count.
+                const written = `${rows.toLocaleString('en-US')} ${rows === 1 ? 'row' : 'rows'}`;
                 emit('err', !result.readerHungUp
-                    ? `Wrote ${rows.toLocaleString('en-US')} rows to stdout.\n`
+                    ? `Wrote ${written} to stdout.\n`
                     : rows < expected
                         ? `Stopped: the reader closed the pipe after ${rows.toLocaleString('en-US')} of ` +
                             `${expected.toLocaleString('en-US')} rows had been written. The recording was ` +
                             `not converted in full.\n`
-                        : `Wrote ${rows.toLocaleString('en-US')} rows to stdout, but the reader closed ` +
+                        : `Wrote ${written} to stdout, but the reader closed ` +
                             `the pipe before the end, so not all of them reached it.\n`);
             }
             else {