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

package/deno.json

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

package/dist/filesink.base.cjs

@@ -2,6 +2,15 @@ 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();
@@ -10,79 +19,43 @@ function getBaseFileSink(path, options) {
 	let fd = options.lazy ? null : options.openSync(path);
 	let buffer = "";
 	let 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);
+	function flushBuffer() {
+		if (fd == null) return;
+		if (buffer.length > 0) {
+			options.writeSync(fd, encoder.encode(buffer));
+			buffer = "";
+			options.flushSync(fd);
 			lastFlushTimestamp = Date.now();
-		} catch {}
-	}
-	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;
-		if (fd == null) fd = asyncOptions.openSync(path);
+	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) scheduleFlush();
-		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
+		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
 	};
-	nonBlockingSink[Symbol.asyncDispose] = async () => {
-		disposed = true;
-		if (flushTimer !== null) {
-			clearInterval(flushTimer);
-			flushTimer = null;
+	sink[Symbol.dispose] = () => {
+		if (fd !== null) {
+			flushBuffer();
+			options.closeSync(fd);
 		}
-		await flushBuffer();
-		if (fd !== null) try {
-			await asyncOptions.close(fd);
-		} catch {}
 	};
-	return nonBlockingSink;
+	return sink;
 }
+/**
+* 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();
@@ -97,7 +70,6 @@ function getBaseRotatingFileSink(path, options) {
 	} catch {}
 	let fd = options.openSync(path);
 	let lastFlushTimestamp = Date.now();
-	let buffer = "";
 	function shouldRollover(bytes) {
 		return offset + bytes.length > maxSize;
 	}
@@ -114,79 +86,29 @@ function getBaseRotatingFileSink(path, options) {
 		offset = 0;
 		fd = options.openSync(path);
 	}
-	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);
+	function flushBuffer() {
+		if (buffer.length > 0) {
+			const bytes = encoder.encode(buffer);
+			buffer = "";
 			if (shouldRollover(bytes)) performRollover();
-			asyncOptions.writeSync(fd, bytes);
-			await asyncOptions.flush(fd);
+			options.writeSync(fd, bytes);
+			options.flushSync(fd);
 			offset += bytes.length;
 			lastFlushTimestamp = Date.now();
-		} catch {}
-	}
-	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;
+	let buffer = "";
+	const sink = (record) => {
 		buffer += formatter(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
-		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
+		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
 	};
-	nonBlockingSink[Symbol.asyncDispose] = async () => {
-		disposed = true;
-		if (flushTimer !== null) {
-			clearInterval(flushTimer);
-			flushTimer = null;
-		}
-		await flushBuffer();
-		try {
-			await asyncOptions.close(fd);
-		} catch {}
+	sink[Symbol.dispose] = () => {
+		flushBuffer();
+		options.closeSync(fd);
 	};
-	return nonBlockingSink;
+	return sink;
 }
 
 //#endregion

package/dist/filesink.base.d.cts

@@ -26,15 +26,6 @@ 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.
@@ -63,23 +54,6 @@ 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.
  *
@@ -87,8 +61,7 @@ interface AsyncFileSinkDriver<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. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
 
 /**
@@ -123,26 +96,6 @@ 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.
  *
@@ -154,9 +107,8 @@ interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<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. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
 //#endregion
-export { AsyncRotatingFileSinkDriver, FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
+export { 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;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"}
+{"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"}

package/dist/filesink.base.d.ts

@@ -26,15 +26,6 @@ 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.
@@ -63,23 +54,6 @@ 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.
  *
@@ -87,8 +61,7 @@ interface AsyncFileSinkDriver<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. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
 
 /**
@@ -123,26 +96,6 @@ 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.
  *
@@ -154,9 +107,8 @@ interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<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. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
 //#endregion
-export { AsyncRotatingFileSinkDriver, FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
+export { 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;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"}
+{"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"}

package/dist/filesink.base.js

@@ -1,6 +1,15 @@
 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();
@@ -9,79 +18,43 @@ function getBaseFileSink(path, options) {
 	let fd = options.lazy ? null : options.openSync(path);
 	let buffer = "";
 	let 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);
+	function flushBuffer() {
+		if (fd == null) return;
+		if (buffer.length > 0) {
+			options.writeSync(fd, encoder.encode(buffer));
+			buffer = "";
+			options.flushSync(fd);
 			lastFlushTimestamp = Date.now();
-		} catch {}
-	}
-	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;
-		if (fd == null) fd = asyncOptions.openSync(path);
+	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) scheduleFlush();
-		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
+		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
 	};
-	nonBlockingSink[Symbol.asyncDispose] = async () => {
-		disposed = true;
-		if (flushTimer !== null) {
-			clearInterval(flushTimer);
-			flushTimer = null;
+	sink[Symbol.dispose] = () => {
+		if (fd !== null) {
+			flushBuffer();
+			options.closeSync(fd);
 		}
-		await flushBuffer();
-		if (fd !== null) try {
-			await asyncOptions.close(fd);
-		} catch {}
 	};
-	return nonBlockingSink;
+	return sink;
 }
+/**
+* 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();
@@ -96,7 +69,6 @@ function getBaseRotatingFileSink(path, options) {
 	} catch {}
 	let fd = options.openSync(path);
 	let lastFlushTimestamp = Date.now();
-	let buffer = "";
 	function shouldRollover(bytes) {
 		return offset + bytes.length > maxSize;
 	}
@@ -113,79 +85,29 @@ function getBaseRotatingFileSink(path, options) {
 		offset = 0;
 		fd = options.openSync(path);
 	}
-	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);
+	function flushBuffer() {
+		if (buffer.length > 0) {
+			const bytes = encoder.encode(buffer);
+			buffer = "";
 			if (shouldRollover(bytes)) performRollover();
-			asyncOptions.writeSync(fd, bytes);
-			await asyncOptions.flush(fd);
+			options.writeSync(fd, bytes);
+			options.flushSync(fd);
 			offset += bytes.length;
 			lastFlushTimestamp = Date.now();
-		} catch {}
-	}
-	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;
+	let buffer = "";
+	const sink = (record) => {
 		buffer += formatter(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
-		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
+		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
 	};
-	nonBlockingSink[Symbol.asyncDispose] = async () => {
-		disposed = true;
-		if (flushTimer !== null) {
-			clearInterval(flushTimer);
-			flushTimer = null;
-		}
-		await flushBuffer();
-		try {
-			await asyncOptions.close(fd);
-		} catch {}
+	sink[Symbol.dispose] = () => {
+		flushBuffer();
+		options.closeSync(fd);
 	};
-	return nonBlockingSink;
+	return sink;
 }
 
 //#endregion