@logtape/file 1.0.0-dev.236 → 1.0.0-dev.240

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.0.0-dev.236+0c0f47bf",
+  "version": "1.0.0-dev.240+9524a425",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

package/dist/filesink.base.cjs

@@ -2,15 +2,6 @@ const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
 
 //#region filesink.base.ts
-/**
-* Get a platform-independent file sink.
-*
-* @typeParam TFile The type of the file descriptor.
-* @param path A path to the file to write to.
-* @param options The options for the sink and the file driver.
-* @returns A sink that writes to the file.  The sink is also a disposable
-*          object that closes the file when disposed.
-*/
 function getBaseFileSink(path, options) {
 	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
@@ -19,43 +10,79 @@ function getBaseFileSink(path, options) {
 	let fd = options.lazy ? null : options.openSync(path);
 	let buffer = "";
 	let lastFlushTimestamp = Date.now();
-	function flushBuffer() {
-		if (fd == null) return;
-		if (buffer.length > 0) {
-			options.writeSync(fd, encoder.encode(buffer));
-			buffer = "";
-			options.flushSync(fd);
-			lastFlushTimestamp = Date.now();
+	if (!options.nonBlocking) {
+		function flushBuffer$1() {
+			if (fd == null) return;
+			if (buffer.length > 0) {
+				options.writeSync(fd, encoder.encode(buffer));
+				buffer = "";
+				options.flushSync(fd);
+				lastFlushTimestamp = Date.now();
+			}
 		}
+		const sink = (record) => {
+			if (fd == null) fd = options.openSync(path);
+			buffer += formatter(record);
+			const shouldFlushBySize = buffer.length >= bufferSize;
+			const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
+			if (shouldFlushBySize || shouldFlushByTime) flushBuffer$1();
+		};
+		sink[Symbol.dispose] = () => {
+			if (fd !== null) {
+				flushBuffer$1();
+				options.closeSync(fd);
+			}
+		};
+		return sink;
+	}
+	const asyncOptions = options;
+	let disposed = false;
+	let activeFlush = null;
+	let flushTimer = null;
+	async function flushBuffer() {
+		if (fd == null || buffer.length === 0) return;
+		const data = buffer;
+		buffer = "";
+		try {
+			asyncOptions.writeSync(fd, encoder.encode(data));
+			await asyncOptions.flush(fd);
+			lastFlushTimestamp = Date.now();
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (activeFlush || disposed) return;
+		activeFlush = flushBuffer().finally(() => {
+			activeFlush = null;
+		});
 	}
-	const sink = (record) => {
-		if (fd == null) fd = options.openSync(path);
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			scheduleFlush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		if (fd == null) fd = asyncOptions.openSync(path);
 		buffer += formatter(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
+		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
+		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
 	};
-	sink[Symbol.dispose] = () => {
-		if (fd !== null) {
-			flushBuffer();
-			options.closeSync(fd);
+	nonBlockingSink[Symbol.asyncDispose] = async () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
 		}
+		await flushBuffer();
+		if (fd !== null) try {
+			await asyncOptions.close(fd);
+		} catch {}
 	};
-	return sink;
+	return nonBlockingSink;
 }
-/**
-* Get a platform-independent rotating file sink.
-*
-* This sink writes log records to a file, and rotates the file when it reaches
-* the `maxSize`.  The rotated files are named with the original file name
-* followed by a dot and a number, starting from 1.  The number is incremented
-* for each rotation, and the maximum number of files to keep is `maxFiles`.
-*
-* @param path A path to the file to write to.
-* @param options The options for the sink and the file driver.
-* @returns A sink that writes to the file.  The sink is also a disposable
-*          object that closes the file when disposed.
-*/
 function getBaseRotatingFileSink(path, options) {
 	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
@@ -70,6 +97,7 @@ function getBaseRotatingFileSink(path, options) {
 	} catch {}
 	let fd = options.openSync(path);
 	let lastFlushTimestamp = Date.now();
+	let buffer = "";
 	function shouldRollover(bytes) {
 		return offset + bytes.length > maxSize;
 	}
@@ -86,29 +114,79 @@ function getBaseRotatingFileSink(path, options) {
 		offset = 0;
 		fd = options.openSync(path);
 	}
-	function flushBuffer() {
-		if (buffer.length > 0) {
-			const bytes = encoder.encode(buffer);
-			buffer = "";
+	if (!options.nonBlocking) {
+		function flushBuffer$1() {
+			if (buffer.length > 0) {
+				const bytes = encoder.encode(buffer);
+				buffer = "";
+				if (shouldRollover(bytes)) performRollover();
+				options.writeSync(fd, bytes);
+				options.flushSync(fd);
+				offset += bytes.length;
+				lastFlushTimestamp = Date.now();
+			}
+		}
+		const sink = (record) => {
+			buffer += formatter(record);
+			const shouldFlushBySize = buffer.length >= bufferSize;
+			const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
+			if (shouldFlushBySize || shouldFlushByTime) flushBuffer$1();
+		};
+		sink[Symbol.dispose] = () => {
+			flushBuffer$1();
+			options.closeSync(fd);
+		};
+		return sink;
+	}
+	const asyncOptions = options;
+	let disposed = false;
+	let activeFlush = null;
+	let flushTimer = null;
+	async function flushBuffer() {
+		if (buffer.length === 0) return;
+		const data = buffer;
+		buffer = "";
+		try {
+			const bytes = encoder.encode(data);
 			if (shouldRollover(bytes)) performRollover();
-			options.writeSync(fd, bytes);
-			options.flushSync(fd);
+			asyncOptions.writeSync(fd, bytes);
+			await asyncOptions.flush(fd);
 			offset += bytes.length;
 			lastFlushTimestamp = Date.now();
-		}
+		} catch {}
 	}
-	let buffer = "";
-	const sink = (record) => {
+	function scheduleFlush() {
+		if (activeFlush || disposed) return;
+		activeFlush = flushBuffer().finally(() => {
+			activeFlush = null;
+		});
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			scheduleFlush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
 		buffer += formatter(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
+		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
+		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
 	};
-	sink[Symbol.dispose] = () => {
-		flushBuffer();
-		options.closeSync(fd);
+	nonBlockingSink[Symbol.asyncDispose] = async () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		await flushBuffer();
+		try {
+			await asyncOptions.close(fd);
+		} catch {}
 	};
-	return sink;
+	return nonBlockingSink;
 }
 
 //#endregion

package/dist/filesink.base.d.cts

@@ -26,6 +26,15 @@ type FileSinkOptions = StreamSinkOptions & {
    * @since 0.12.0
    */
   flushInterval?: number;
+  /**
+   * Enable non-blocking mode with background flushing.
+   * When enabled, flush operations are performed asynchronously to prevent
+   * blocking the main thread during file I/O operations.
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean;
 };
 /**
  * A platform-specific file sink driver.
@@ -54,6 +63,23 @@ interface FileSinkDriver<TFile> {
    */
   closeSync(fd: TFile): void;
 }
+/**
+ * A platform-specific async file sink driver.
+ * @typeParam TFile The type of the file descriptor.
+ * @since 1.0.0
+ */
+interface AsyncFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
+  /**
+   * Asynchronously flush the file to ensure that all data is written to the disk.
+   * @param fd The file descriptor.
+   */
+  flush(fd: TFile): Promise<void>;
+  /**
+   * Asynchronously close the file.
+   * @param fd The file descriptor.
+   */
+  close(fd: TFile): Promise<void>;
+}
 /**
  * Get a platform-independent file sink.
  *
@@ -61,7 +87,8 @@ interface FileSinkDriver<TFile> {
  * @param path A path to the file to write to.
  * @param options The options for the sink and the file driver.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed.
+ *          object that closes the file when disposed. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link AsyncDisposable}.
  */
 
 /**
@@ -96,6 +123,26 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
    */
   renameSync(oldPath: string, newPath: string): void;
 }
+/**
+ * A platform-specific async rotating file sink driver.
+ * @since 1.0.0
+ */
+interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile> {
+  /**
+   * Get the size of the file.
+   * @param path A path to the file.
+   * @returns The `size` of the file in bytes, in an object.
+   */
+  statSync(path: string): {
+    size: number;
+  };
+  /**
+   * Rename a file.
+   * @param oldPath A path to the file to rename.
+   * @param newPath A path to be renamed to.
+   */
+  renameSync(oldPath: string, newPath: string): void;
+}
 /**
  * Get a platform-independent rotating file sink.
  *
@@ -107,8 +154,9 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
  * @param path A path to the file to write to.
  * @param options The options for the sink and the file driver.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed.
+ *          object that closes the file when disposed. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link AsyncDisposable}.
  */
 //#endregion
-export { FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
+export { AsyncRotatingFileSinkDriver, FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
 //# sourceMappingURL=filesink.base.d.cts.map

package/dist/filesink.base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AA6BiB,KA7BL,eAAA,GAAkB,iBA6BC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AA0DrB;;;;EAAqD,UAAA,CAAA,EAAA,MAAA;EAepC;;;;AAAoD;;;;;;;;;UAjGpD;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UA0DC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}
+{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AAQrB;;;;EAKiB,UAAG,CAAA,EAAA,MAAA;EAAO;;;AALuC;AA0JlE;;;EAAqE,aAApB,CAAA,EAAA,MAAA;EAAI;AAerD;;;;AAAqE;AAoBrE;;EAA4C,WACd,CAAA,EAAA,OAAA;CAAK;AAAN;;;;UA9NZ;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;YAKvD,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA+IH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;UAoBrD,2CACP,oBAAoB"}

package/dist/filesink.base.d.ts

@@ -26,6 +26,15 @@ type FileSinkOptions = StreamSinkOptions & {
    * @since 0.12.0
    */
   flushInterval?: number;
+  /**
+   * Enable non-blocking mode with background flushing.
+   * When enabled, flush operations are performed asynchronously to prevent
+   * blocking the main thread during file I/O operations.
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean;
 };
 /**
  * A platform-specific file sink driver.
@@ -54,6 +63,23 @@ interface FileSinkDriver<TFile> {
    */
   closeSync(fd: TFile): void;
 }
+/**
+ * A platform-specific async file sink driver.
+ * @typeParam TFile The type of the file descriptor.
+ * @since 1.0.0
+ */
+interface AsyncFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
+  /**
+   * Asynchronously flush the file to ensure that all data is written to the disk.
+   * @param fd The file descriptor.
+   */
+  flush(fd: TFile): Promise<void>;
+  /**
+   * Asynchronously close the file.
+   * @param fd The file descriptor.
+   */
+  close(fd: TFile): Promise<void>;
+}
 /**
  * Get a platform-independent file sink.
  *
@@ -61,7 +87,8 @@ interface FileSinkDriver<TFile> {
  * @param path A path to the file to write to.
  * @param options The options for the sink and the file driver.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed.
+ *          object that closes the file when disposed. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link AsyncDisposable}.
  */
 
 /**
@@ -96,6 +123,26 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
    */
   renameSync(oldPath: string, newPath: string): void;
 }
+/**
+ * A platform-specific async rotating file sink driver.
+ * @since 1.0.0
+ */
+interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile> {
+  /**
+   * Get the size of the file.
+   * @param path A path to the file.
+   * @returns The `size` of the file in bytes, in an object.
+   */
+  statSync(path: string): {
+    size: number;
+  };
+  /**
+   * Rename a file.
+   * @param oldPath A path to the file to rename.
+   * @param newPath A path to be renamed to.
+   */
+  renameSync(oldPath: string, newPath: string): void;
+}
 /**
  * Get a platform-independent rotating file sink.
  *
@@ -107,8 +154,9 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
  * @param path A path to the file to write to.
  * @param options The options for the sink and the file driver.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed.
+ *          object that closes the file when disposed. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link AsyncDisposable}.
  */
 //#endregion
-export { FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
+export { AsyncRotatingFileSinkDriver, FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
 //# sourceMappingURL=filesink.base.d.ts.map

package/dist/filesink.base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AA6BiB,KA7BL,eAAA,GAAkB,iBA6BC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AA0DrB;;;;EAAqD,UAAA,CAAA,EAAA,MAAA;EAepC;;;;AAAoD;;;;;;;;;UAjGpD;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UA0DC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}
+{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AAQrB;;;;EAKiB,UAAG,CAAA,EAAA,MAAA;EAAO;;;AALuC;AA0JlE;;;EAAqE,aAApB,CAAA,EAAA,MAAA;EAAI;AAerD;;;;AAAqE;AAoBrE;;EAA4C,WACd,CAAA,EAAA,OAAA;CAAK;AAAN;;;;UA9NZ;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;YAKvD,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA+IH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;UAoBrD,2CACP,oBAAoB"}

package/dist/filesink.base.js

@@ -1,15 +1,6 @@
 import { defaultTextFormatter } from "@logtape/logtape";
 
 //#region filesink.base.ts
-/**
-* Get a platform-independent file sink.
-*
-* @typeParam TFile The type of the file descriptor.
-* @param path A path to the file to write to.
-* @param options The options for the sink and the file driver.
-* @returns A sink that writes to the file.  The sink is also a disposable
-*          object that closes the file when disposed.
-*/
 function getBaseFileSink(path, options) {
 	const formatter = options.formatter ?? defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
@@ -18,43 +9,79 @@ function getBaseFileSink(path, options) {
 	let fd = options.lazy ? null : options.openSync(path);
 	let buffer = "";
 	let lastFlushTimestamp = Date.now();
-	function flushBuffer() {
-		if (fd == null) return;
-		if (buffer.length > 0) {
-			options.writeSync(fd, encoder.encode(buffer));
-			buffer = "";
-			options.flushSync(fd);
-			lastFlushTimestamp = Date.now();
+	if (!options.nonBlocking) {
+		function flushBuffer$1() {
+			if (fd == null) return;
+			if (buffer.length > 0) {
+				options.writeSync(fd, encoder.encode(buffer));
+				buffer = "";
+				options.flushSync(fd);
+				lastFlushTimestamp = Date.now();
+			}
 		}
+		const sink = (record) => {
+			if (fd == null) fd = options.openSync(path);
+			buffer += formatter(record);
+			const shouldFlushBySize = buffer.length >= bufferSize;
+			const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
+			if (shouldFlushBySize || shouldFlushByTime) flushBuffer$1();
+		};
+		sink[Symbol.dispose] = () => {
+			if (fd !== null) {
+				flushBuffer$1();
+				options.closeSync(fd);
+			}
+		};
+		return sink;
+	}
+	const asyncOptions = options;
+	let disposed = false;
+	let activeFlush = null;
+	let flushTimer = null;
+	async function flushBuffer() {
+		if (fd == null || buffer.length === 0) return;
+		const data = buffer;
+		buffer = "";
+		try {
+			asyncOptions.writeSync(fd, encoder.encode(data));
+			await asyncOptions.flush(fd);
+			lastFlushTimestamp = Date.now();
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (activeFlush || disposed) return;
+		activeFlush = flushBuffer().finally(() => {
+			activeFlush = null;
+		});
 	}
-	const sink = (record) => {
-		if (fd == null) fd = options.openSync(path);
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			scheduleFlush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		if (fd == null) fd = asyncOptions.openSync(path);
 		buffer += formatter(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
+		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
+		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
 	};
-	sink[Symbol.dispose] = () => {
-		if (fd !== null) {
-			flushBuffer();
-			options.closeSync(fd);
+	nonBlockingSink[Symbol.asyncDispose] = async () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
 		}
+		await flushBuffer();
+		if (fd !== null) try {
+			await asyncOptions.close(fd);
+		} catch {}
 	};
-	return sink;
+	return nonBlockingSink;
 }
-/**
-* Get a platform-independent rotating file sink.
-*
-* This sink writes log records to a file, and rotates the file when it reaches
-* the `maxSize`.  The rotated files are named with the original file name
-* followed by a dot and a number, starting from 1.  The number is incremented
-* for each rotation, and the maximum number of files to keep is `maxFiles`.
-*
-* @param path A path to the file to write to.
-* @param options The options for the sink and the file driver.
-* @returns A sink that writes to the file.  The sink is also a disposable
-*          object that closes the file when disposed.
-*/
 function getBaseRotatingFileSink(path, options) {
 	const formatter = options.formatter ?? defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
@@ -69,6 +96,7 @@ function getBaseRotatingFileSink(path, options) {
 	} catch {}
 	let fd = options.openSync(path);
 	let lastFlushTimestamp = Date.now();
+	let buffer = "";
 	function shouldRollover(bytes) {
 		return offset + bytes.length > maxSize;
 	}
@@ -85,29 +113,79 @@ function getBaseRotatingFileSink(path, options) {
 		offset = 0;
 		fd = options.openSync(path);
 	}
-	function flushBuffer() {
-		if (buffer.length > 0) {
-			const bytes = encoder.encode(buffer);
-			buffer = "";
+	if (!options.nonBlocking) {
+		function flushBuffer$1() {
+			if (buffer.length > 0) {
+				const bytes = encoder.encode(buffer);
+				buffer = "";
+				if (shouldRollover(bytes)) performRollover();
+				options.writeSync(fd, bytes);
+				options.flushSync(fd);
+				offset += bytes.length;
+				lastFlushTimestamp = Date.now();
+			}
+		}
+		const sink = (record) => {
+			buffer += formatter(record);
+			const shouldFlushBySize = buffer.length >= bufferSize;
+			const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
+			if (shouldFlushBySize || shouldFlushByTime) flushBuffer$1();
+		};
+		sink[Symbol.dispose] = () => {
+			flushBuffer$1();
+			options.closeSync(fd);
+		};
+		return sink;
+	}
+	const asyncOptions = options;
+	let disposed = false;
+	let activeFlush = null;
+	let flushTimer = null;
+	async function flushBuffer() {
+		if (buffer.length === 0) return;
+		const data = buffer;
+		buffer = "";
+		try {
+			const bytes = encoder.encode(data);
 			if (shouldRollover(bytes)) performRollover();
-			options.writeSync(fd, bytes);
-			options.flushSync(fd);
+			asyncOptions.writeSync(fd, bytes);
+			await asyncOptions.flush(fd);
 			offset += bytes.length;
 			lastFlushTimestamp = Date.now();
-		}
+		} catch {}
 	}
-	let buffer = "";
-	const sink = (record) => {
+	function scheduleFlush() {
+		if (activeFlush || disposed) return;
+		activeFlush = flushBuffer().finally(() => {
+			activeFlush = null;
+		});
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			scheduleFlush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
 		buffer += formatter(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
+		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
+		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
 	};
-	sink[Symbol.dispose] = () => {
-		flushBuffer();
-		options.closeSync(fd);
+	nonBlockingSink[Symbol.asyncDispose] = async () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		await flushBuffer();
+		try {
+			await asyncOptions.close(fd);
+		} catch {}
 	};
-	return sink;
+	return nonBlockingSink;
 }
 
 //#endregion