@logtape/file 1.0.5 → 1.0.6-dev.351

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.0.5",
+  "version": "1.0.6-dev.351+8407c5e9",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

package/dist/streamfilesink.cjs

@@ -53,7 +53,8 @@ const node_stream = require_rolldown_runtime.__toESM(require("node:stream"));
 *             if it doesn't exist, or appended to if it does exist.
 * @param options Configuration options for the stream-based sink.
 * @returns A sink that writes formatted log records to the specified file.
-*          The returned sink implements `Disposable` for proper resource cleanup.
+*          The returned sink implements `AsyncDisposable` for proper resource cleanup
+*          that waits for all data to be flushed to disk.
 *
 * @since 1.0.0
 */
@@ -71,11 +72,17 @@ 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();
+		await new Promise((resolve) => {
+			writeStream.once("finish", () => {
+				writeStream.close(() => {
+					resolve();
+				});
+			});
+		});
 	};
 	return sink;
 }

package/dist/streamfilesink.d.cts

@@ -84,11 +84,12 @@ interface StreamFileSinkOptions {
  *             if it doesn't exist, or appended to if it does exist.
  * @param options Configuration options for the stream-based sink.
  * @returns A sink that writes formatted log records to the specified file.
- *          The returned sink implements `Disposable` for proper resource cleanup.
+ *          The returned sink implements `AsyncDisposable` for proper resource cleanup
+ *          that waits for all data to be flushed to disk.
  *
  * @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":["../streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}
+{"version":3,"file":"streamfilesink.d.cts","names":[],"sources":["../streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AAgFA;;;;;AAGyB;UAnFR,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDP,iBAAA,yBAEL,wBACR,OAAO"}

package/dist/streamfilesink.d.ts

@@ -84,11 +84,12 @@ interface StreamFileSinkOptions {
  *             if it doesn't exist, or appended to if it does exist.
  * @param options Configuration options for the stream-based sink.
  * @returns A sink that writes formatted log records to the specified file.
- *          The returned sink implements `Disposable` for proper resource cleanup.
+ *          The returned sink implements `AsyncDisposable` for proper resource cleanup
+ *          that waits for all data to be flushed to disk.
  *
  * @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":["../streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}
+{"version":3,"file":"streamfilesink.d.ts","names":[],"sources":["../streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AAgFA;;;;;AAGyB;UAnFR,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDP,iBAAA,yBAEL,wBACR,OAAO"}

package/dist/streamfilesink.js

@@ -52,7 +52,8 @@ import { PassThrough } from "node:stream";
 *             if it doesn't exist, or appended to if it does exist.
 * @param options Configuration options for the stream-based sink.
 * @returns A sink that writes formatted log records to the specified file.
-*          The returned sink implements `Disposable` for proper resource cleanup.
+*          The returned sink implements `AsyncDisposable` for proper resource cleanup
+*          that waits for all data to be flushed to disk.
 *
 * @since 1.0.0
 */
@@ -70,11 +71,17 @@ 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();
+		await new Promise((resolve) => {
+			writeStream.once("finish", () => {
+				writeStream.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":["../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":["../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 `AsyncDisposable` for proper resource cleanup\n *          that waits for all data to be flushed to disk.\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  // Async disposal that waits for streams to finish\n  sink[Symbol.asyncDispose] = async () => {\n    if (disposed) return;\n    disposed = true;\n\n    // End the PassThrough stream\n    passThrough.end();\n\n    // Wait for both finish (data flushed) and close (file handle closed) events\n    await new Promise<void>((resolve) => {\n      writeStream.once(\"finish\", () => {\n        writeStream.close(() => {\n          resolve();\n        });\n      });\n    });\n  };\n\n  return sink;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkGA,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,cAAY,KAAK;AAGjB,QAAM,IAAI,QAAc,CAAC,YAAY;AACnC,eAAY,KAAK,UAAU,MAAM;AAC/B,gBAAY,MAAM,MAAM;AACtB,cAAS;IACV,EAAC;GACH,EAAC;EACH;CACF;AAED,QAAO;AACR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.0.5",
+  "version": "1.0.6-dev.351+8407c5e9",
   "description": "File sink and rotating file sink for LogTape",
   "keywords": [
     "logging",
@@ -57,7 +57,7 @@
   },
   "sideEffects": false,
   "peerDependencies": {
-    "@logtape/logtape": "^1.0.5"
+    "@logtape/logtape": "^1.0.6-dev.351+8407c5e9"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/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, fatal, info, warning } from "../logtape/fixtures.ts";
 
 const test = suite(import.meta);
@@ -17,7 +17,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);
@@ -25,10 +25,7 @@ test("getStreamFileSink() basic functionality", async () => {
   sink(error);
   sink(fatal);
 
-  sink[Symbol.dispose]();
-
-  // Allow stream to fully flush
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assertEquals(
@@ -47,9 +44,7 @@ test("getStreamFileSink() with custom highWaterMark", async () => {
 
   sink(debug);
   sink(info);
-  sink[Symbol.dispose]();
-
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assertEquals(
@@ -67,9 +62,7 @@ test("getStreamFileSink() with custom formatter", async () => {
 
   sink(debug);
   sink(info);
-  sink[Symbol.dispose]();
-
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assertEquals(
@@ -87,9 +80,7 @@ test("getStreamFileSink() appends to existing file", async () => {
 
   const sink = getStreamFileSink(path);
   sink(debug);
-  sink[Symbol.dispose]();
-
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assert(content.startsWith("Initial content\n"));
@@ -109,8 +100,7 @@ test("getStreamFileSink() high-volume logging", async () => {
     sink(record);
   }
 
-  sink[Symbol.dispose]();
-  await delay(100); // Allow streams to finish
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   const lines = content.split("\n").filter((line) => line.length > 0);
@@ -126,14 +116,12 @@ 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);
   sink(warning);
 
-  await delay(50);
-
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   const lines = content.split("\n").filter((line) => line.length > 0);
   assertEquals(lines.length, 1); // Only debug record
@@ -147,10 +135,8 @@ test("getStreamFileSink() double disposal", async () => {
   const sink = getStreamFileSink(path);
 
   sink(debug);
-  sink[Symbol.dispose]();
-  sink[Symbol.dispose](); // Should not throw
-
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
+  await sink[Symbol.asyncDispose](); // Should not throw
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   const lines = content.split("\n").filter((line) => line.length > 0);
@@ -163,9 +149,7 @@ test("getStreamFileSink() handles rapid disposal", async () => {
 
   sink(debug);
   // Dispose immediately without waiting
-  sink[Symbol.dispose]();
-
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assert(content.includes("Hello, 123 & 456!"));
@@ -193,8 +177,7 @@ test("getStreamFileSink() concurrent writes", async () => {
   }
 
   await Promise.all(promises);
-  sink[Symbol.dispose]();
-  await delay(100);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   const lines = content.split("\n").filter((line) => line.length > 0);
@@ -216,9 +199,7 @@ test("getStreamFileSink() with empty records", async () => {
   };
 
   sink(emptyRecord);
-  sink[Symbol.dispose]();
-
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assert(content.includes("[DBG]"));
@@ -237,9 +218,7 @@ test("getStreamFileSink() with large messages", async () => {
   };
 
   sink(largeRecord);
-  sink[Symbol.dispose]();
-
-  await delay(100); // Give more time for large write
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assert(content.includes(largeMessage));
@@ -264,8 +243,7 @@ test("getStreamFileSink() memory efficiency", async () => {
     }
   }
 
-  sink[Symbol.dispose]();
-  await delay(platform() === "win32" ? 1000 : 200);
+  await sink[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   const lines = content.split("\n").filter((line) => line.length > 0);
@@ -283,9 +261,7 @@ test("getStreamFileSink() creates new file when it doesn't exist", async () => {
 
   const sink = getStreamFileSink(path);
   sink(debug);
-  sink[Symbol.dispose]();
-
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   // File should have been created
   assert(fs.existsSync(path));
@@ -302,10 +278,8 @@ test("getStreamFileSink() multiple instances on same file", async () => {
   sink1(debug);
   sink2(info);
 
-  sink1[Symbol.dispose]();
-  sink2[Symbol.dispose]();
-
-  await delay(100);
+  await sink1[Symbol.asyncDispose]();
+  await sink2[Symbol.asyncDispose]();
 
   const content = fs.readFileSync(path, { encoding: "utf-8" });
   assert(content.includes("[DBG]"));
@@ -317,8 +291,7 @@ test("getStreamFileSink() stream error handling", async () => {
   const sink = getStreamFileSink(path);
 
   sink(debug);
-  sink[Symbol.dispose]();
-  await delay(50);
+  await sink[Symbol.asyncDispose]();
 
   // Delete the file after disposal
   try {

package/streamfilesink.ts

@@ -91,14 +91,15 @@ export interface StreamFileSinkOptions {
  *             if it doesn't exist, or appended to if it does exist.
  * @param options Configuration options for the stream-based sink.
  * @returns A sink that writes formatted log records to the specified file.
- *          The returned sink implements `Disposable` for proper resource cleanup.
+ *          The returned sink implements `AsyncDisposable` for proper resource cleanup
+ *          that waits for all data to be flushed to disk.
  *
  * @since 1.0.0
  */
 export function getStreamFileSink(
   path: string,
   options: StreamFileSinkOptions = {},
-): Sink & Disposable {
+): Sink & AsyncDisposable {
   const highWaterMark = options.highWaterMark ?? 16384;
   const formatter = options.formatter ?? defaultTextFormatter;
 
@@ -117,19 +118,29 @@ 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] = () => {
+  // Async disposal that waits for streams to finish
+  sink[Symbol.asyncDispose] = async () => {
     if (disposed) return;
     disposed = true;
+
+    // End the PassThrough stream
     passThrough.end();
-    writeStream.end();
+
+    // Wait for both finish (data flushed) and close (file handle closed) events
+    await new Promise<void>((resolve) => {
+      writeStream.once("finish", () => {
+        writeStream.close(() => {
+          resolve();
+        });
+      });
+    });
   };
 
   return sink;