@logtape/file 1.1.0-dev.323 → 1.1.0-dev.332

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.1.0-dev.323+146f8194",
+  "version": "1.1.0-dev.332+cfc70069",
   "license": "MIT",
   "exports": "./src/mod.ts",
   "imports": {

package/dist/streamfilesink.cjs

@@ -71,11 +71,23 @@ function getStreamFileSink(path, options = {}) {
 		if (disposed) return;
 		passThrough.write(formatter(record));
 	};
-	sink[Symbol.dispose] = () => {
+	sink[Symbol.asyncDispose] = async () => {
 		if (disposed) return;
 		disposed = true;
-		passThrough.end();
-		writeStream.end();
+		if (passThrough.writableNeedDrain) await new Promise((resolve) => {
+			passThrough.once("drain", resolve);
+		});
+		await new Promise((resolve) => {
+			passThrough.once("finish", resolve);
+			passThrough.end();
+		});
+		await new Promise((resolve) => {
+			if (writeStream.closed || writeStream.destroyed) {
+				resolve();
+				return;
+			}
+			writeStream.once("close", resolve);
+		});
 	};
 	return sink;
 }

package/dist/streamfilesink.d.cts

@@ -88,7 +88,7 @@ interface StreamFileSinkOptions {
  *
  * @since 1.0.0
  */
-declare function getStreamFileSink(path: string, options?: StreamFileSinkOptions): Sink & Disposable;
+declare function getStreamFileSink(path: string, options?: StreamFileSinkOptions): Sink & AsyncDisposable;
 //# sourceMappingURL=streamfilesink.d.ts.map
 //#endregion
 export { StreamFileSinkOptions, getStreamFileSink };

package/dist/streamfilesink.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"streamfilesink.d.cts","names":[],"sources":["../src/streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}
+{"version":3,"file":"streamfilesink.d.cts","names":[],"sources":["../src/streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGyB;UAlFR,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}

package/dist/streamfilesink.d.ts

@@ -88,7 +88,7 @@ interface StreamFileSinkOptions {
  *
  * @since 1.0.0
  */
-declare function getStreamFileSink(path: string, options?: StreamFileSinkOptions): Sink & Disposable;
+declare function getStreamFileSink(path: string, options?: StreamFileSinkOptions): Sink & AsyncDisposable;
 //# sourceMappingURL=streamfilesink.d.ts.map
 //#endregion
 export { StreamFileSinkOptions, getStreamFileSink };

package/dist/streamfilesink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamfilesink.d.ts","names":[],"sources":["../src/streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}
+{"version":3,"file":"streamfilesink.d.ts","names":[],"sources":["../src/streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGyB;UAlFR,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}

package/dist/streamfilesink.js

@@ -70,11 +70,23 @@ function getStreamFileSink(path, options = {}) {
 		if (disposed) return;
 		passThrough.write(formatter(record));
 	};
-	sink[Symbol.dispose] = () => {
+	sink[Symbol.asyncDispose] = async () => {
 		if (disposed) return;
 		disposed = true;
-		passThrough.end();
-		writeStream.end();
+		if (passThrough.writableNeedDrain) await new Promise((resolve) => {
+			passThrough.once("drain", resolve);
+		});
+		await new Promise((resolve) => {
+			passThrough.once("finish", resolve);
+			passThrough.end();
+		});
+		await new Promise((resolve) => {
+			if (writeStream.closed || writeStream.destroyed) {
+				resolve();
+				return;
+			}
+			writeStream.once("close", resolve);
+		});
 	};
 	return sink;
 }

package/dist/streamfilesink.js.map

@@ -1 +1 @@
-{"version":3,"file":"streamfilesink.js","names":["path: string","options: StreamFileSinkOptions","sink: Sink & Disposable","record: LogRecord"],"sources":["../src/streamfilesink.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n} from \"@logtape/logtape\";\nimport { createWriteStream } from \"node:fs\";\nimport { PassThrough } from \"node:stream\";\n\n/**\n * Options for the {@link getStreamFileSink} function.\n *\n * This interface configures the high-performance stream-based file sink that\n * uses Node.js PassThrough streams for optimal I/O performance with automatic\n * backpressure management.\n *\n * @since 1.0.0\n */\nexport interface StreamFileSinkOptions {\n  /**\n   * High water mark for the PassThrough stream buffer in bytes.\n   *\n   * This controls the internal buffer size of the PassThrough stream.\n   * Higher values can improve performance for high-volume logging but use\n   * more memory. Lower values reduce memory usage but may impact performance.\n   *\n   * @default 16384\n   * @since 1.0.0\n   */\n  readonly highWaterMark?: number;\n\n  /**\n   * A custom formatter for log records.\n   *\n   * If not specified, the default text formatter will be used, which formats\n   * records in the standard LogTape format with timestamp, level, category,\n   * and message.\n   *\n   * @default defaultTextFormatter\n   * @since 1.0.0\n   */\n  readonly formatter?: TextFormatter;\n}\n\n/**\n * Create a high-performance stream-based file sink that writes log records to a file.\n *\n * This sink uses Node.js PassThrough streams piped to WriteStreams for optimal\n * I/O performance. It leverages the Node.js stream infrastructure to provide\n * automatic backpressure management, efficient buffering, and asynchronous writes\n * without blocking the main thread.\n *\n * ## Performance Characteristics\n *\n * - **High Performance**: Optimized for high-volume logging scenarios\n * - **Non-blocking**: Uses asynchronous I/O that doesn't block the main thread\n * - **Memory Efficient**: Automatic backpressure prevents memory buildup\n * - **Stream-based**: Leverages Node.js native stream optimizations\n *\n * ## When to Use\n *\n * Use this sink when you need:\n * - High-performance file logging for production applications\n * - Non-blocking I/O behavior for real-time applications\n * - Automatic backpressure handling for high-volume scenarios\n * - Simple file output without complex buffering configuration\n *\n * For more control over buffering behavior, consider using {@link getFileSink}\n * instead, which provides options for buffer size, flush intervals, and\n * non-blocking modes.\n *\n * ## Example\n *\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getStreamFileSink } from \"@logtape/file\";\n *\n * await configure({\n *   sinks: {\n *     file: getStreamFileSink(\"app.log\", {\n *       highWaterMark: 32768  // 32KB buffer for high-volume logging\n *     })\n *   },\n *   loggers: [\n *     { category: [\"myapp\"], sinks: [\"file\"] }\n *   ]\n * });\n * ```\n *\n * @param path The path to the file to write logs to. The file will be created\n *             if it doesn't exist, or appended to if it does exist.\n * @param options Configuration options for the stream-based sink.\n * @returns A sink that writes formatted log records to the specified file.\n *          The returned sink implements `Disposable` for proper resource cleanup.\n *\n * @since 1.0.0\n */\nexport function getStreamFileSink(\n  path: string,\n  options: StreamFileSinkOptions = {},\n): Sink & Disposable {\n  const highWaterMark = options.highWaterMark ?? 16384;\n  const formatter = options.formatter ?? defaultTextFormatter;\n\n  // Create PassThrough stream for optimal performance\n  const passThrough = new PassThrough({\n    highWaterMark,\n    objectMode: false,\n  });\n\n  // Create WriteStream immediately (not lazy)\n  const writeStream = createWriteStream(path, { flags: \"a\" });\n\n  // Pipe PassThrough to WriteStream for automatic backpressure handling\n  passThrough.pipe(writeStream);\n\n  let disposed = false;\n\n  // Stream-based sink function for high performance\n  const sink: Sink & Disposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Direct write to PassThrough stream\n    passThrough.write(formatter(record));\n  };\n\n  // Minimal disposal\n  sink[Symbol.dispose] = () => {\n    if (disposed) return;\n    disposed = true;\n    passThrough.end();\n    writeStream.end();\n  };\n\n  return sink;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,SAAgB,kBACdA,MACAC,UAAiC,CAAE,GAChB;CACnB,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,YAAY,QAAQ,aAAa;CAGvC,MAAM,cAAc,IAAI,YAAY;EAClC;EACA,YAAY;CACb;CAGD,MAAM,cAAc,kBAAkB,MAAM,EAAE,OAAO,IAAK,EAAC;AAG3D,aAAY,KAAK,YAAY;CAE7B,IAAI,WAAW;CAGf,MAAMC,OAA0B,CAACC,WAAsB;AACrD,MAAI,SAAU;AAGd,cAAY,MAAM,UAAU,OAAO,CAAC;CACrC;AAGD,MAAK,OAAO,WAAW,MAAM;AAC3B,MAAI,SAAU;AACd,aAAW;AACX,cAAY,KAAK;AACjB,cAAY,KAAK;CAClB;AAED,QAAO;AACR"}
+{"version":3,"file":"streamfilesink.js","names":["path: string","options: StreamFileSinkOptions","sink: Sink & AsyncDisposable","record: LogRecord"],"sources":["../src/streamfilesink.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n} from \"@logtape/logtape\";\nimport { createWriteStream } from \"node:fs\";\nimport { PassThrough } from \"node:stream\";\n\n/**\n * Options for the {@link getStreamFileSink} function.\n *\n * This interface configures the high-performance stream-based file sink that\n * uses Node.js PassThrough streams for optimal I/O performance with automatic\n * backpressure management.\n *\n * @since 1.0.0\n */\nexport interface StreamFileSinkOptions {\n  /**\n   * High water mark for the PassThrough stream buffer in bytes.\n   *\n   * This controls the internal buffer size of the PassThrough stream.\n   * Higher values can improve performance for high-volume logging but use\n   * more memory. Lower values reduce memory usage but may impact performance.\n   *\n   * @default 16384\n   * @since 1.0.0\n   */\n  readonly highWaterMark?: number;\n\n  /**\n   * A custom formatter for log records.\n   *\n   * If not specified, the default text formatter will be used, which formats\n   * records in the standard LogTape format with timestamp, level, category,\n   * and message.\n   *\n   * @default defaultTextFormatter\n   * @since 1.0.0\n   */\n  readonly formatter?: TextFormatter;\n}\n\n/**\n * Create a high-performance stream-based file sink that writes log records to a file.\n *\n * This sink uses Node.js PassThrough streams piped to WriteStreams for optimal\n * I/O performance. It leverages the Node.js stream infrastructure to provide\n * automatic backpressure management, efficient buffering, and asynchronous writes\n * without blocking the main thread.\n *\n * ## Performance Characteristics\n *\n * - **High Performance**: Optimized for high-volume logging scenarios\n * - **Non-blocking**: Uses asynchronous I/O that doesn't block the main thread\n * - **Memory Efficient**: Automatic backpressure prevents memory buildup\n * - **Stream-based**: Leverages Node.js native stream optimizations\n *\n * ## When to Use\n *\n * Use this sink when you need:\n * - High-performance file logging for production applications\n * - Non-blocking I/O behavior for real-time applications\n * - Automatic backpressure handling for high-volume scenarios\n * - Simple file output without complex buffering configuration\n *\n * For more control over buffering behavior, consider using {@link getFileSink}\n * instead, which provides options for buffer size, flush intervals, and\n * non-blocking modes.\n *\n * ## Example\n *\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getStreamFileSink } from \"@logtape/file\";\n *\n * await configure({\n *   sinks: {\n *     file: getStreamFileSink(\"app.log\", {\n *       highWaterMark: 32768  // 32KB buffer for high-volume logging\n *     })\n *   },\n *   loggers: [\n *     { category: [\"myapp\"], sinks: [\"file\"] }\n *   ]\n * });\n * ```\n *\n * @param path The path to the file to write logs to. The file will be created\n *             if it doesn't exist, or appended to if it does exist.\n * @param options Configuration options for the stream-based sink.\n * @returns A sink that writes formatted log records to the specified file.\n *          The returned sink implements `Disposable` for proper resource cleanup.\n *\n * @since 1.0.0\n */\nexport function getStreamFileSink(\n  path: string,\n  options: StreamFileSinkOptions = {},\n): Sink & AsyncDisposable {\n  const highWaterMark = options.highWaterMark ?? 16384;\n  const formatter = options.formatter ?? defaultTextFormatter;\n\n  // Create PassThrough stream for optimal performance\n  const passThrough = new PassThrough({\n    highWaterMark,\n    objectMode: false,\n  });\n\n  // Create WriteStream immediately (not lazy)\n  const writeStream = createWriteStream(path, { flags: \"a\" });\n\n  // Pipe PassThrough to WriteStream for automatic backpressure handling\n  passThrough.pipe(writeStream);\n\n  let disposed = false;\n\n  // Stream-based sink function for high performance\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Direct write to PassThrough stream\n    passThrough.write(formatter(record));\n  };\n\n  // Asynchronous disposal with sequential stream closure\n  sink[Symbol.asyncDispose] = async () => {\n    if (disposed) return;\n    disposed = true;\n\n    // Wait for PassThrough to drain if needed\n    if (passThrough.writableNeedDrain) {\n      await new Promise<void>((resolve) => {\n        passThrough.once(\"drain\", resolve);\n      });\n    }\n\n    // End the PassThrough stream first and wait for it to finish\n    await new Promise<void>((resolve) => {\n      passThrough.once(\"finish\", resolve);\n      passThrough.end();\n    });\n\n    // Wait for WriteStream to finish and close (piped streams auto-close)\n    await new Promise<void>((resolve) => {\n      if (writeStream.closed || writeStream.destroyed) {\n        resolve();\n        return;\n      }\n      writeStream.once(\"close\", resolve);\n    });\n  };\n\n  return sink;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,SAAgB,kBACdA,MACAC,UAAiC,CAAE,GACX;CACxB,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,YAAY,QAAQ,aAAa;CAGvC,MAAM,cAAc,IAAI,YAAY;EAClC;EACA,YAAY;CACb;CAGD,MAAM,cAAc,kBAAkB,MAAM,EAAE,OAAO,IAAK,EAAC;AAG3D,aAAY,KAAK,YAAY;CAE7B,IAAI,WAAW;CAGf,MAAMC,OAA+B,CAACC,WAAsB;AAC1D,MAAI,SAAU;AAGd,cAAY,MAAM,UAAU,OAAO,CAAC;CACrC;AAGD,MAAK,OAAO,gBAAgB,YAAY;AACtC,MAAI,SAAU;AACd,aAAW;AAGX,MAAI,YAAY,kBACd,OAAM,IAAI,QAAc,CAAC,YAAY;AACnC,eAAY,KAAK,SAAS,QAAQ;EACnC;AAIH,QAAM,IAAI,QAAc,CAAC,YAAY;AACnC,eAAY,KAAK,UAAU,QAAQ;AACnC,eAAY,KAAK;EAClB;AAGD,QAAM,IAAI,QAAc,CAAC,YAAY;AACnC,OAAI,YAAY,UAAU,YAAY,WAAW;AAC/C,aAAS;AACT;GACD;AACD,eAAY,KAAK,SAAS,QAAQ;EACnC;CACF;AAED,QAAO;AACR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.1.0-dev.323+146f8194",
+  "version": "1.1.0-dev.332+cfc70069",
   "description": "File sink and rotating file sink for LogTape",
   "keywords": [
     "logging",
@@ -57,7 +57,7 @@
   },
   "sideEffects": false,
   "peerDependencies": {
-    "@logtape/logtape": "1.1.0-dev.323+146f8194"
+    "@logtape/logtape": "1.1.0-dev.332+cfc70069"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/src/streamfilesink.test.ts

@@ -1,12 +1,12 @@
 import { getStreamFileSink } from "./streamfilesink.ts";
 import { suite } from "@alinea/suite";
-import type { LogRecord, Sink } from "@logtape/logtape";
+import type { LogRecord } from "@logtape/logtape";
 import { assert } from "@std/assert/assert";
 import { assertEquals } from "@std/assert/equals";
 import { delay } from "@std/async/delay";
 import { join } from "@std/path/join";
 import fs from "node:fs";
-import { platform, tmpdir } from "node:os";
+import { tmpdir } from "node:os";
 import {
   debug,
   error,
@@ -23,7 +23,7 @@ function makeTempFileSync(): string {
 
 test("getStreamFileSink() basic functionality", async () => {
   const path = makeTempFileSync();
-  const sink: Sink & Disposable = getStreamFileSink(path);
+  const sink = getStreamFileSink(path);
 
   sink(debug);
   sink(info);
@@ -31,7 +31,7 @@ test("getStreamFileSink() basic functionality", async () => {
   sink(error);
   sink(fatal);
 
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   // Allow stream to fully flush
   await delay(50);
@@ -53,7 +53,7 @@ test("getStreamFileSink() with custom highWaterMark", async () => {
 
   sink(debug);
   sink(info);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   await delay(50);
 
@@ -73,7 +73,7 @@ test("getStreamFileSink() with custom formatter", async () => {
 
   sink(debug);
   sink(info);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   await delay(50);
 
@@ -93,7 +93,7 @@ test("getStreamFileSink() appends to existing file", async () => {
 
   const sink = getStreamFileSink(path);
   sink(debug);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   await delay(50);
 
@@ -115,7 +115,7 @@ test("getStreamFileSink() high-volume logging", async () => {
     sink(record);
   }
 
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
   await delay(100); // Allow streams to finish
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
@@ -132,7 +132,7 @@ test("getStreamFileSink() disposal stops writing", async () => {
   const sink = getStreamFileSink(path);
 
   sink(debug);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   // Writing after disposal should be ignored
   sink(info);
@@ -153,8 +153,8 @@ test("getStreamFileSink() double disposal", async () => {
   const sink = getStreamFileSink(path);
 
   sink(debug);
-  sink[Symbol.dispose]();
-  sink[Symbol.dispose](); // Should not throw
+  await sink[Symbol.asyncDispose]();
+  await sink[Symbol.asyncDispose](); // Should not throw
 
   await delay(50);
 
@@ -169,7 +169,7 @@ test("getStreamFileSink() handles rapid disposal", async () => {
 
   sink(debug);
   // Dispose immediately without waiting
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   await delay(50);
 
@@ -199,7 +199,7 @@ test("getStreamFileSink() concurrent writes", async () => {
   }
 
   await Promise.all(promises);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
   await delay(100);
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
@@ -222,7 +222,7 @@ test("getStreamFileSink() with empty records", async () => {
   };
 
   sink(emptyRecord);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   await delay(50);
 
@@ -243,7 +243,7 @@ test("getStreamFileSink() with large messages", async () => {
   };
 
   sink(largeRecord);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   await delay(100); // Give more time for large write
 
@@ -270,8 +270,8 @@ test("getStreamFileSink() memory efficiency", async () => {
     }
   }
 
-  sink[Symbol.dispose]();
-  await delay(platform() === "win32" ? 1000 : 200);
+  // Use async disposal to ensure all streams are properly flushed
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   const lines = content.split("\n").filter((line) => line.length > 0);
@@ -289,7 +289,7 @@ test("getStreamFileSink() creates new file when it doesn't exist", async () => {
 
   const sink = getStreamFileSink(path);
   sink(debug);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
 
   await delay(50);
 
@@ -308,8 +308,8 @@ test("getStreamFileSink() multiple instances on same file", async () => {
   sink1(debug);
   sink2(info);
 
-  sink1[Symbol.dispose]();
-  sink2[Symbol.dispose]();
+  await sink1[Symbol.asyncDispose]();
+  await sink2[Symbol.asyncDispose]();
 
   await delay(100);
 
@@ -323,7 +323,7 @@ test("getStreamFileSink() stream error handling", async () => {
   const sink = getStreamFileSink(path);
 
   sink(debug);
-  sink[Symbol.dispose]();
+  await sink[Symbol.asyncDispose]();
   await delay(50);
 
   // Delete the file after disposal

package/src/streamfilesink.ts

@@ -98,7 +98,7 @@ export interface StreamFileSinkOptions {
 export function getStreamFileSink(
   path: string,
   options: StreamFileSinkOptions = {},
-): Sink & Disposable {
+): Sink & AsyncDisposable {
   const highWaterMark = options.highWaterMark ?? 16384;
   const formatter = options.formatter ?? defaultTextFormatter;
 
@@ -117,19 +117,39 @@ export function getStreamFileSink(
   let disposed = false;
 
   // Stream-based sink function for high performance
-  const sink: Sink & Disposable = (record: LogRecord) => {
+  const sink: Sink & AsyncDisposable = (record: LogRecord) => {
     if (disposed) return;
 
     // Direct write to PassThrough stream
     passThrough.write(formatter(record));
   };
 
-  // Minimal disposal
-  sink[Symbol.dispose] = () => {
+  // Asynchronous disposal with sequential stream closure
+  sink[Symbol.asyncDispose] = async () => {
     if (disposed) return;
     disposed = true;
-    passThrough.end();
-    writeStream.end();
+
+    // Wait for PassThrough to drain if needed
+    if (passThrough.writableNeedDrain) {
+      await new Promise<void>((resolve) => {
+        passThrough.once("drain", resolve);
+      });
+    }
+
+    // End the PassThrough stream first and wait for it to finish
+    await new Promise<void>((resolve) => {
+      passThrough.once("finish", resolve);
+      passThrough.end();
+    });
+
+    // Wait for WriteStream to finish and close (piped streams auto-close)
+    await new Promise<void>((resolve) => {
+      if (writeStream.closed || writeStream.destroyed) {
+        resolve();
+        return;
+      }
+      writeStream.once("close", resolve);
+    });
   };
 
   return sink;