@logtape/logtape 1.0.0-dev.236 → 1.0.0-dev.237

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "1.0.0-dev.236+0c0f47bf",
+  "version": "1.0.0-dev.237+0615301b",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

package/dist/sink.cjs

@@ -112,22 +112,73 @@ function getStreamSink(stream, options = {}) {
 	const formatter = options.formatter ?? require_formatter.defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
 	const writer = stream.getWriter();
-	let lastPromise = Promise.resolve();
-	const sink = (record) => {
-		const bytes = encoder.encode(formatter(record));
-		lastPromise = lastPromise.then(() => writer.ready).then(() => writer.write(bytes));
+	if (!options.nonBlocking) {
+		let lastPromise = Promise.resolve();
+		const sink = (record) => {
+			const bytes = encoder.encode(formatter(record));
+			lastPromise = lastPromise.then(() => writer.ready).then(() => writer.write(bytes));
+		};
+		sink[Symbol.asyncDispose] = async () => {
+			await lastPromise;
+			await writer.close();
+		};
+		return sink;
+	}
+	const nonBlockingConfig = options.nonBlocking === true ? {} : options.nonBlocking;
+	const bufferSize = nonBlockingConfig.bufferSize ?? 100;
+	const flushInterval = nonBlockingConfig.flushInterval ?? 100;
+	const buffer = [];
+	let flushTimer = null;
+	let disposed = false;
+	let activeFlush = null;
+	const maxBufferSize = bufferSize * 2;
+	async function flush() {
+		if (buffer.length === 0) return;
+		const records = buffer.splice(0);
+		for (const record of records) try {
+			const bytes = encoder.encode(formatter(record));
+			await writer.ready;
+			await writer.write(bytes);
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (activeFlush) return;
+		activeFlush = flush().finally(() => {
+			activeFlush = null;
+		});
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			scheduleFlush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		if (buffer.length >= maxBufferSize) buffer.shift();
+		buffer.push(record);
+		if (buffer.length >= bufferSize) scheduleFlush();
+		else if (flushTimer === null) startFlushTimer();
 	};
-	sink[Symbol.asyncDispose] = async () => {
-		await lastPromise;
-		await writer.close();
+	nonBlockingSink[Symbol.asyncDispose] = async () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		await flush();
+		try {
+			await writer.close();
+		} catch {}
 	};
-	return sink;
+	return nonBlockingSink;
 }
 /**
 * A console sink factory that returns a sink that logs to the console.
 *
 * @param options The options for the sink.
-* @returns A sink that logs to the console.
+* @returns A sink that logs to the console. If `nonBlocking` is enabled,
+*          returns a sink that also implements {@link Disposable}.
 */
 function getConsoleSink(options = {}) {
 	const formatter = options.formatter ?? require_formatter.defaultConsoleFormatter;
@@ -141,7 +192,7 @@ function getConsoleSink(options = {}) {
 		...options.levelMap ?? {}
 	};
 	const console = options.console ?? globalThis.console;
-	return (record) => {
+	const baseSink = (record) => {
 		const args = formatter(record);
 		const method = levelMap[record.level];
 		if (method === void 0) throw new TypeError(`Invalid log level: ${record.level}.`);
@@ -150,6 +201,52 @@ function getConsoleSink(options = {}) {
 			console[method](msg);
 		} else console[method](...args);
 	};
+	if (!options.nonBlocking) return baseSink;
+	const nonBlockingConfig = options.nonBlocking === true ? {} : options.nonBlocking;
+	const bufferSize = nonBlockingConfig.bufferSize ?? 100;
+	const flushInterval = nonBlockingConfig.flushInterval ?? 100;
+	const buffer = [];
+	let flushTimer = null;
+	let disposed = false;
+	let flushScheduled = false;
+	const maxBufferSize = bufferSize * 2;
+	function flush() {
+		if (buffer.length === 0) return;
+		const records = buffer.splice(0);
+		for (const record of records) try {
+			baseSink(record);
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (flushScheduled) return;
+		flushScheduled = true;
+		setTimeout(() => {
+			flushScheduled = false;
+			flush();
+		}, 0);
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			flush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		if (buffer.length >= maxBufferSize) buffer.shift();
+		buffer.push(record);
+		if (buffer.length >= bufferSize) scheduleFlush();
+		else if (flushTimer === null) startFlushTimer();
+	};
+	nonBlockingSink[Symbol.dispose] = () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		flush();
+	};
+	return nonBlockingSink;
 }
 /**
 * Converts an async sink into a regular sink with proper async handling.

package/dist/sink.d.cts

@@ -92,6 +92,40 @@ interface StreamSinkOptions {
   encoder?: {
     encode(text: string): Uint8Array;
   };
+  /**
+   * Enable non-blocking mode with optional buffer configuration.
+   * When enabled, log records are buffered and flushed in the background.
+   *
+   * @example Simple non-blocking mode
+   * ```typescript
+   * getStreamSink(stream, { nonBlocking: true });
+   * ```
+   *
+   * @example Custom buffer configuration
+   * ```typescript
+   * getStreamSink(stream, {
+   *   nonBlocking: {
+   *     bufferSize: 1000,
+   *     flushInterval: 50
+   *   }
+   * });
+   * ```
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean | {
+    /**
+     * Maximum number of records to buffer before flushing.
+     * @default `100`
+     */
+    bufferSize?: number;
+    /**
+     * Interval in milliseconds between automatic flushes.
+     * @default `100`
+     */
+    flushInterval?: number;
+  };
 }
 /**
  * A factory that returns a sink that writes to a {@link WritableStream}.
@@ -148,14 +182,49 @@ interface ConsoleSinkOptions {
    * The console to log to.  Defaults to {@link console}.
    */
   console?: Console;
+  /**
+   * Enable non-blocking mode with optional buffer configuration.
+   * When enabled, log records are buffered and flushed in the background.
+   *
+   * @example Simple non-blocking mode
+   * ```typescript
+   * getConsoleSink({ nonBlocking: true });
+   * ```
+   *
+   * @example Custom buffer configuration
+   * ```typescript
+   * getConsoleSink({
+   *   nonBlocking: {
+   *     bufferSize: 1000,
+   *     flushInterval: 50
+   *   }
+   * });
+   * ```
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean | {
+    /**
+     * Maximum number of records to buffer before flushing.
+     * @default `100`
+     */
+    bufferSize?: number;
+    /**
+     * Interval in milliseconds between automatic flushes.
+     * @default `100`
+     */
+    flushInterval?: number;
+  };
 }
 /**
  * A console sink factory that returns a sink that logs to the console.
  *
  * @param options The options for the sink.
- * @returns A sink that logs to the console.
+ * @returns A sink that logs to the console. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link Disposable}.
  */
-declare function getConsoleSink(options?: ConsoleSinkOptions): Sink;
+declare function getConsoleSink(options?: ConsoleSinkOptions): Sink | (Sink & Disposable);
 /**
  * Converts an async sink into a regular sink with proper async handling.
  * The returned sink chains async operations to ensure proper ordering and

package/dist/sink.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.cts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAWhE;AAmCA;;;;AAGG,KAjES,SAAA,GAiET,CAAA,MAAA,EAjE8B,SAiE9B,EAAA,GAjE4C,OAiE5C,CAAA,IAAA,CAAA;;AAAsB;AAsEzB;;;;AAS8C;AA2B9C;;;;;;AAGyB;AAkBpB,iBAhLW,UAAA,CAgLE,IAAA,EAhLe,IAgLf,EAAA,MAAA,EAhL6B,UAgL7B,CAAA,EAhL0C,IAgL1C;AAKlB;;;;AAsBoB,UAhMH,iBAAA,CAgMG;EAAQ;;;AAKT;AASnB;EAA8B,UAAA,CAAA,EAAA,MAAA;EAAA;;AAAwC;AA+CtE;;;EAAkD,aAAG,CAAA,EAAA,MAAA;;AAAsB;;;;;;;;;;;;;;;;;;iBA1N3D,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkBL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;iBASI,cAAA,WAAwB,qBAA0B;;;;;;;;;;;;;;;;;;;;;iBA+ClD,aAAA,YAAyB,YAAY,OAAO"}
+{"version":3,"file":"sink.d.cts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAWhE;AAmCA;;;;AAGG,KAjES,SAAA,GAiET,CAAA,MAAA,EAjE8B,SAiE9B,EAAA,GAjE4C,OAiE5C,CAAA,IAAA,CAAA;;AAAsB;AAsEzB;;;;AAS8C;AA+D9C;;;;;;AAGyB;AAkGpB,iBApSW,UAAA,CAoSE,IAAA,EApSe,IAoSf,EAAA,MAAA,EApS6B,UAoS7B,CAAA,EApS0C,IAoS1C;AAKlB;;;;AAsBoB,UApTH,iBAAA,CAoTG;EAAQ;;;AAKT;AA8CnB;EAA8B,UAAA,CAAA,EAAA,MAAA;EAAA;;;;AAEF;AA4H5B;EAA6B,aAAA,CAAA,EAAA,MAAA;;;;AAA8C;;;;;;;;;;;;;;;;iBAlc3D,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkGL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CI,cAAA,WACL,qBACR,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;iBA4HF,aAAA,YAAyB,YAAY,OAAO"}

package/dist/sink.d.ts

@@ -92,6 +92,40 @@ interface StreamSinkOptions {
   encoder?: {
     encode(text: string): Uint8Array;
   };
+  /**
+   * Enable non-blocking mode with optional buffer configuration.
+   * When enabled, log records are buffered and flushed in the background.
+   *
+   * @example Simple non-blocking mode
+   * ```typescript
+   * getStreamSink(stream, { nonBlocking: true });
+   * ```
+   *
+   * @example Custom buffer configuration
+   * ```typescript
+   * getStreamSink(stream, {
+   *   nonBlocking: {
+   *     bufferSize: 1000,
+   *     flushInterval: 50
+   *   }
+   * });
+   * ```
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean | {
+    /**
+     * Maximum number of records to buffer before flushing.
+     * @default `100`
+     */
+    bufferSize?: number;
+    /**
+     * Interval in milliseconds between automatic flushes.
+     * @default `100`
+     */
+    flushInterval?: number;
+  };
 }
 /**
  * A factory that returns a sink that writes to a {@link WritableStream}.
@@ -148,14 +182,49 @@ interface ConsoleSinkOptions {
    * The console to log to.  Defaults to {@link console}.
    */
   console?: Console;
+  /**
+   * Enable non-blocking mode with optional buffer configuration.
+   * When enabled, log records are buffered and flushed in the background.
+   *
+   * @example Simple non-blocking mode
+   * ```typescript
+   * getConsoleSink({ nonBlocking: true });
+   * ```
+   *
+   * @example Custom buffer configuration
+   * ```typescript
+   * getConsoleSink({
+   *   nonBlocking: {
+   *     bufferSize: 1000,
+   *     flushInterval: 50
+   *   }
+   * });
+   * ```
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean | {
+    /**
+     * Maximum number of records to buffer before flushing.
+     * @default `100`
+     */
+    bufferSize?: number;
+    /**
+     * Interval in milliseconds between automatic flushes.
+     * @default `100`
+     */
+    flushInterval?: number;
+  };
 }
 /**
  * A console sink factory that returns a sink that logs to the console.
  *
  * @param options The options for the sink.
- * @returns A sink that logs to the console.
+ * @returns A sink that logs to the console. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link Disposable}.
  */
-declare function getConsoleSink(options?: ConsoleSinkOptions): Sink;
+declare function getConsoleSink(options?: ConsoleSinkOptions): Sink | (Sink & Disposable);
 /**
  * Converts an async sink into a regular sink with proper async handling.
  * The returned sink chains async operations to ensure proper ordering and

package/dist/sink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.ts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAWhE;AAmCA;;;;AAGG,KAjES,SAAA,GAiET,CAAA,MAAA,EAjE8B,SAiE9B,EAAA,GAjE4C,OAiE5C,CAAA,IAAA,CAAA;;AAAsB;AAsEzB;;;;AAS8C;AA2B9C;;;;;;AAGyB;AAkBpB,iBAhLW,UAAA,CAgLE,IAAA,EAhLe,IAgLf,EAAA,MAAA,EAhL6B,UAgL7B,CAAA,EAhL0C,IAgL1C;AAKlB;;;;AAsBoB,UAhMH,iBAAA,CAgMG;EAAQ;;;AAKT;AASnB;EAA8B,UAAA,CAAA,EAAA,MAAA;EAAA;;AAAwC;AA+CtE;;;EAAkD,aAAG,CAAA,EAAA,MAAA;;AAAsB;;;;;;;;;;;;;;;;;;iBA1N3D,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkBL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;iBASI,cAAA,WAAwB,qBAA0B;;;;;;;;;;;;;;;;;;;;;iBA+ClD,aAAA,YAAyB,YAAY,OAAO"}
+{"version":3,"file":"sink.d.ts","names":[],"sources":["../sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAmBA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAWhE;AAmCA;;;;AAGG,KAjES,SAAA,GAiET,CAAA,MAAA,EAjE8B,SAiE9B,EAAA,GAjE4C,OAiE5C,CAAA,IAAA,CAAA;;AAAsB;AAsEzB;;;;AAS8C;AA+D9C;;;;;;AAGyB;AAkGpB,iBApSW,UAAA,CAoSE,IAAA,EApSe,IAoSf,EAAA,MAAA,EApS6B,UAoS7B,CAAA,EApS0C,IAoS1C;AAKlB;;;;AAsBoB,UApTH,iBAAA,CAoTG;EAAQ;;;AAKT;AA8CnB;EAA8B,UAAA,CAAA,EAAA,MAAA;EAAA;;;;AAEF;AA4H5B;EAA6B,aAAA,CAAA,EAAA,MAAA;;;;AAA8C;;;;;;;;;;;;;;;;iBAlc3D,UAAA,OACR,gBACG,oBACR,OAAO;;;;UAsEO,iBAAA;;;;cAIH;;;;;0BAKsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DpB,aAAA,SACN,0BACC,oBACR,OAAO;KAkGL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CI,cAAA,WACL,qBACR,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;iBA4HF,aAAA,YAAyB,YAAY,OAAO"}

package/dist/sink.js

@@ -112,22 +112,73 @@ function getStreamSink(stream, options = {}) {
 	const formatter = options.formatter ?? defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
 	const writer = stream.getWriter();
-	let lastPromise = Promise.resolve();
-	const sink = (record) => {
-		const bytes = encoder.encode(formatter(record));
-		lastPromise = lastPromise.then(() => writer.ready).then(() => writer.write(bytes));
+	if (!options.nonBlocking) {
+		let lastPromise = Promise.resolve();
+		const sink = (record) => {
+			const bytes = encoder.encode(formatter(record));
+			lastPromise = lastPromise.then(() => writer.ready).then(() => writer.write(bytes));
+		};
+		sink[Symbol.asyncDispose] = async () => {
+			await lastPromise;
+			await writer.close();
+		};
+		return sink;
+	}
+	const nonBlockingConfig = options.nonBlocking === true ? {} : options.nonBlocking;
+	const bufferSize = nonBlockingConfig.bufferSize ?? 100;
+	const flushInterval = nonBlockingConfig.flushInterval ?? 100;
+	const buffer = [];
+	let flushTimer = null;
+	let disposed = false;
+	let activeFlush = null;
+	const maxBufferSize = bufferSize * 2;
+	async function flush() {
+		if (buffer.length === 0) return;
+		const records = buffer.splice(0);
+		for (const record of records) try {
+			const bytes = encoder.encode(formatter(record));
+			await writer.ready;
+			await writer.write(bytes);
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (activeFlush) return;
+		activeFlush = flush().finally(() => {
+			activeFlush = null;
+		});
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			scheduleFlush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		if (buffer.length >= maxBufferSize) buffer.shift();
+		buffer.push(record);
+		if (buffer.length >= bufferSize) scheduleFlush();
+		else if (flushTimer === null) startFlushTimer();
 	};
-	sink[Symbol.asyncDispose] = async () => {
-		await lastPromise;
-		await writer.close();
+	nonBlockingSink[Symbol.asyncDispose] = async () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		await flush();
+		try {
+			await writer.close();
+		} catch {}
 	};
-	return sink;
+	return nonBlockingSink;
 }
 /**
 * A console sink factory that returns a sink that logs to the console.
 *
 * @param options The options for the sink.
-* @returns A sink that logs to the console.
+* @returns A sink that logs to the console. If `nonBlocking` is enabled,
+*          returns a sink that also implements {@link Disposable}.
 */
 function getConsoleSink(options = {}) {
 	const formatter = options.formatter ?? defaultConsoleFormatter;
@@ -141,7 +192,7 @@ function getConsoleSink(options = {}) {
 		...options.levelMap ?? {}
 	};
 	const console = options.console ?? globalThis.console;
-	return (record) => {
+	const baseSink = (record) => {
 		const args = formatter(record);
 		const method = levelMap[record.level];
 		if (method === void 0) throw new TypeError(`Invalid log level: ${record.level}.`);
@@ -150,6 +201,52 @@ function getConsoleSink(options = {}) {
 			console[method](msg);
 		} else console[method](...args);
 	};
+	if (!options.nonBlocking) return baseSink;
+	const nonBlockingConfig = options.nonBlocking === true ? {} : options.nonBlocking;
+	const bufferSize = nonBlockingConfig.bufferSize ?? 100;
+	const flushInterval = nonBlockingConfig.flushInterval ?? 100;
+	const buffer = [];
+	let flushTimer = null;
+	let disposed = false;
+	let flushScheduled = false;
+	const maxBufferSize = bufferSize * 2;
+	function flush() {
+		if (buffer.length === 0) return;
+		const records = buffer.splice(0);
+		for (const record of records) try {
+			baseSink(record);
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (flushScheduled) return;
+		flushScheduled = true;
+		setTimeout(() => {
+			flushScheduled = false;
+			flush();
+		}, 0);
+	}
+	function startFlushTimer() {
+		if (flushTimer !== null || disposed) return;
+		flushTimer = setInterval(() => {
+			flush();
+		}, flushInterval);
+	}
+	const nonBlockingSink = (record) => {
+		if (disposed) return;
+		if (buffer.length >= maxBufferSize) buffer.shift();
+		buffer.push(record);
+		if (buffer.length >= bufferSize) scheduleFlush();
+		else if (flushTimer === null) startFlushTimer();
+	};
+	nonBlockingSink[Symbol.dispose] = () => {
+		disposed = true;
+		if (flushTimer !== null) {
+			clearInterval(flushTimer);
+			flushTimer = null;
+		}
+		flush();
+	};
+	return nonBlockingSink;
 }
 /**
 * Converts an async sink into a regular sink with proper async handling.

package/dist/sink.js.map

@@ -1 +1 @@
-{"version":3,"file":"sink.js","names":["sink: Sink","filter: FilterLike","record: LogRecord","options: BufferSinkOptions","buffer: LogRecord[]","flushTimer: ReturnType<typeof setTimeout> | null","bufferedSink: Sink & AsyncDisposable","stream: WritableStream","options: StreamSinkOptions","sink: Sink & AsyncDisposable","options: ConsoleSinkOptions","levelMap: Record<LogLevel, ConsoleMethod>","asyncSink: AsyncSink"],"sources":["../sink.ts"],"sourcesContent":["import { type FilterLike, toFilter } from \"./filter.ts\";\nimport {\n  type ConsoleFormatter,\n  defaultConsoleFormatter,\n  defaultTextFormatter,\n  type TextFormatter,\n} from \"./formatter.ts\";\nimport type { LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\n\n/**\n * A sink is a function that accepts a log record and prints it somewhere.\n * Thrown exceptions will be suppressed and then logged to the meta logger,\n * a {@link Logger} with the category `[\"logtape\", \"meta\"]`.  (In that case,\n * the meta log record will not be passed to the sink to avoid infinite\n * recursion.)\n *\n * @param record The log record to sink.\n */\nexport type Sink = (record: LogRecord) => void;\n\n/**\n * An async sink is a function that accepts a log record and asynchronously\n * processes it. This type is used with {@link fromAsyncSink} to create\n * a regular sink that properly handles asynchronous operations.\n *\n * @param record The log record to process asynchronously.\n * @returns A promise that resolves when the record has been processed.\n * @since 1.0.0\n */\nexport type AsyncSink = (record: LogRecord) => Promise<void>;\n\n/**\n * Turns a sink into a filtered sink.  The returned sink only logs records that\n * pass the filter.\n *\n * @example Filter a console sink to only log records with the info level\n * ```typescript\n * const sink = withFilter(getConsoleSink(), \"info\");\n * ```\n *\n * @param sink A sink to be filtered.\n * @param filter A filter to apply to the sink.  It can be either a filter\n *               function or a {@link LogLevel} string.\n * @returns A sink that only logs records that pass the filter.\n */\nexport function withFilter(sink: Sink, filter: FilterLike): Sink {\n  const filterFunc = toFilter(filter);\n  return (record: LogRecord) => {\n    if (filterFunc(record)) sink(record);\n  };\n}\n\n/**\n * Options for the {@link withBuffer} function.\n * @since 1.0.0\n */\nexport interface BufferSinkOptions {\n  /**\n   * The maximum number of log records to buffer before flushing to the\n   * underlying sink.\n   * @default `10`\n   */\n  bufferSize?: number;\n\n  /**\n   * The maximum time in milliseconds to wait before flushing buffered records\n   * to the underlying sink.  Defaults to 5000 (5 seconds).  Set to 0 or\n   * negative to disable time-based flushing.\n   * @default `5000`\n   */\n  flushInterval?: number;\n}\n\n/**\n * Turns a sink into a buffered sink.  The returned sink buffers log records\n * in memory and flushes them to the underlying sink when the buffer is full\n * or after a specified time interval.\n *\n * @example Buffer a console sink with custom options\n * ```typescript\n * const sink = withBuffer(getConsoleSink(), {\n *   bufferSize: 5,\n *   flushInterval: 1000\n * });\n * ```\n *\n * @param sink A sink to be buffered.\n * @param options Options for the buffered sink.\n * @returns A buffered sink that flushes records periodically.\n * @since 1.0.0\n */\nexport function withBuffer(\n  sink: Sink,\n  options: BufferSinkOptions = {},\n): Sink & AsyncDisposable {\n  const bufferSize = options.bufferSize ?? 10;\n  const flushInterval = options.flushInterval ?? 5000;\n\n  const buffer: LogRecord[] = [];\n  let flushTimer: ReturnType<typeof setTimeout> | null = null;\n  let disposed = false;\n\n  function flush(): void {\n    if (buffer.length === 0) return;\n\n    const records = buffer.splice(0);\n    for (const record of records) {\n      try {\n        sink(record);\n      } catch (error) {\n        // Errors are handled by the sink infrastructure\n        throw error;\n      }\n    }\n\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (flushInterval <= 0 || flushTimer !== null || disposed) return;\n\n    flushTimer = setTimeout(() => {\n      flushTimer = null;\n      flush();\n    }, flushInterval);\n  }\n\n  const bufferedSink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    buffer.push(record);\n\n    if (buffer.length >= bufferSize) {\n      flush();\n    } else {\n      scheduleFlush();\n    }\n  };\n\n  bufferedSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n    flush();\n\n    // Dispose the underlying sink if it's disposable\n    if (Symbol.asyncDispose in sink) {\n      await (sink as AsyncDisposable)[Symbol.asyncDispose]();\n    } else if (Symbol.dispose in sink) {\n      (sink as Disposable)[Symbol.dispose]();\n    }\n  };\n\n  return bufferedSink;\n}\n\n/**\n * Options for the {@link getStreamSink} function.\n */\nexport interface StreamSinkOptions {\n  /**\n   * The text formatter to use.  Defaults to {@link defaultTextFormatter}.\n   */\n  formatter?: TextFormatter;\n\n  /**\n   * The text encoder to use.  Defaults to an instance of {@link TextEncoder}.\n   */\n  encoder?: { encode(text: string): Uint8Array };\n}\n\n/**\n * A factory that returns a sink that writes to a {@link WritableStream}.\n *\n * Note that the `stream` is of Web Streams API, which is different from\n * Node.js streams.  You can convert a Node.js stream to a Web Streams API\n * stream using [`stream.Writable.toWeb()`] method.\n *\n * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable\n *\n * @example Sink to the standard error in Deno\n * ```typescript\n * const stderrSink = getStreamSink(Deno.stderr.writable);\n * ```\n *\n * @example Sink to the standard error in Node.js\n * ```typescript\n * import stream from \"node:stream\";\n * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));\n * ```\n *\n * @param stream The stream to write to.\n * @param options The options for the sink.\n * @returns A sink that writes to the stream.\n */\nexport function getStreamSink(\n  stream: WritableStream,\n  options: StreamSinkOptions = {},\n): Sink & AsyncDisposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const writer = stream.getWriter();\n  let lastPromise = Promise.resolve();\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    const bytes = encoder.encode(formatter(record));\n    lastPromise = lastPromise\n      .then(() => writer.ready)\n      .then(() => writer.write(bytes));\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    await lastPromise;\n    await writer.close();\n  };\n  return sink;\n}\n\ntype ConsoleMethod = \"debug\" | \"info\" | \"log\" | \"warn\" | \"error\";\n\n/**\n * Options for the {@link getConsoleSink} function.\n */\nexport interface ConsoleSinkOptions {\n  /**\n   * The console formatter or text formatter to use.\n   * Defaults to {@link defaultConsoleFormatter}.\n   */\n  formatter?: ConsoleFormatter | TextFormatter;\n\n  /**\n   * The mapping from log levels to console methods.  Defaults to:\n   *\n   * ```typescript\n   * {\n   *   trace: \"trace\",\n   *   debug: \"debug\",\n   *   info: \"info\",\n   *   warning: \"warn\",\n   *   error: \"error\",\n   *   fatal: \"error\",\n   * }\n   * ```\n   * @since 0.9.0\n   */\n  levelMap?: Record<LogLevel, ConsoleMethod>;\n\n  /**\n   * The console to log to.  Defaults to {@link console}.\n   */\n  console?: Console;\n}\n\n/**\n * A console sink factory that returns a sink that logs to the console.\n *\n * @param options The options for the sink.\n * @returns A sink that logs to the console.\n */\nexport function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {\n  const formatter = options.formatter ?? defaultConsoleFormatter;\n  const levelMap: Record<LogLevel, ConsoleMethod> = {\n    trace: \"debug\",\n    debug: \"debug\",\n    info: \"info\",\n    warning: \"warn\",\n    error: \"error\",\n    fatal: \"error\",\n    ...(options.levelMap ?? {}),\n  };\n  const console = options.console ?? globalThis.console;\n  return (record: LogRecord) => {\n    const args = formatter(record);\n    const method = levelMap[record.level];\n    if (method === undefined) {\n      throw new TypeError(`Invalid log level: ${record.level}.`);\n    }\n    if (typeof args === \"string\") {\n      const msg = args.replace(/\\r?\\n$/, \"\");\n      console[method](msg);\n    } else {\n      console[method](...args);\n    }\n  };\n}\n\n/**\n * Converts an async sink into a regular sink with proper async handling.\n * The returned sink chains async operations to ensure proper ordering and\n * implements AsyncDisposable to wait for all pending operations on disposal.\n *\n * @example Create a sink that asynchronously posts to a webhook\n * ```typescript\n * const asyncSink: AsyncSink = async (record) => {\n *   await fetch(\"https://example.com/logs\", {\n *     method: \"POST\",\n *     body: JSON.stringify(record),\n *   });\n * };\n * const sink = fromAsyncSink(asyncSink);\n * ```\n *\n * @param asyncSink The async sink function to convert.\n * @returns A sink that properly handles async operations and disposal.\n * @since 1.0.0\n */\nexport function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable {\n  let lastPromise = Promise.resolve();\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    lastPromise = lastPromise\n      .then(() => asyncSink(record))\n      .catch(() => {\n        // Errors are handled by the sink infrastructure\n      });\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    await lastPromise;\n  };\n  return sink;\n}\n"],"mappings":"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"}
+{"version":3,"file":"sink.js","names":["sink: Sink","filter: FilterLike","record: LogRecord","options: BufferSinkOptions","buffer: LogRecord[]","flushTimer: ReturnType<typeof setTimeout> | null","bufferedSink: Sink & AsyncDisposable","stream: WritableStream","options: StreamSinkOptions","sink: Sink & AsyncDisposable","flushTimer: ReturnType<typeof setInterval> | null","activeFlush: Promise<void> | null","nonBlockingSink: Sink & AsyncDisposable","options: ConsoleSinkOptions","levelMap: Record<LogLevel, ConsoleMethod>","nonBlockingSink: Sink & Disposable","asyncSink: AsyncSink"],"sources":["../sink.ts"],"sourcesContent":["import { type FilterLike, toFilter } from \"./filter.ts\";\nimport {\n  type ConsoleFormatter,\n  defaultConsoleFormatter,\n  defaultTextFormatter,\n  type TextFormatter,\n} from \"./formatter.ts\";\nimport type { LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\n\n/**\n * A sink is a function that accepts a log record and prints it somewhere.\n * Thrown exceptions will be suppressed and then logged to the meta logger,\n * a {@link Logger} with the category `[\"logtape\", \"meta\"]`.  (In that case,\n * the meta log record will not be passed to the sink to avoid infinite\n * recursion.)\n *\n * @param record The log record to sink.\n */\nexport type Sink = (record: LogRecord) => void;\n\n/**\n * An async sink is a function that accepts a log record and asynchronously\n * processes it. This type is used with {@link fromAsyncSink} to create\n * a regular sink that properly handles asynchronous operations.\n *\n * @param record The log record to process asynchronously.\n * @returns A promise that resolves when the record has been processed.\n * @since 1.0.0\n */\nexport type AsyncSink = (record: LogRecord) => Promise<void>;\n\n/**\n * Turns a sink into a filtered sink.  The returned sink only logs records that\n * pass the filter.\n *\n * @example Filter a console sink to only log records with the info level\n * ```typescript\n * const sink = withFilter(getConsoleSink(), \"info\");\n * ```\n *\n * @param sink A sink to be filtered.\n * @param filter A filter to apply to the sink.  It can be either a filter\n *               function or a {@link LogLevel} string.\n * @returns A sink that only logs records that pass the filter.\n */\nexport function withFilter(sink: Sink, filter: FilterLike): Sink {\n  const filterFunc = toFilter(filter);\n  return (record: LogRecord) => {\n    if (filterFunc(record)) sink(record);\n  };\n}\n\n/**\n * Options for the {@link withBuffer} function.\n * @since 1.0.0\n */\nexport interface BufferSinkOptions {\n  /**\n   * The maximum number of log records to buffer before flushing to the\n   * underlying sink.\n   * @default `10`\n   */\n  bufferSize?: number;\n\n  /**\n   * The maximum time in milliseconds to wait before flushing buffered records\n   * to the underlying sink.  Defaults to 5000 (5 seconds).  Set to 0 or\n   * negative to disable time-based flushing.\n   * @default `5000`\n   */\n  flushInterval?: number;\n}\n\n/**\n * Turns a sink into a buffered sink.  The returned sink buffers log records\n * in memory and flushes them to the underlying sink when the buffer is full\n * or after a specified time interval.\n *\n * @example Buffer a console sink with custom options\n * ```typescript\n * const sink = withBuffer(getConsoleSink(), {\n *   bufferSize: 5,\n *   flushInterval: 1000\n * });\n * ```\n *\n * @param sink A sink to be buffered.\n * @param options Options for the buffered sink.\n * @returns A buffered sink that flushes records periodically.\n * @since 1.0.0\n */\nexport function withBuffer(\n  sink: Sink,\n  options: BufferSinkOptions = {},\n): Sink & AsyncDisposable {\n  const bufferSize = options.bufferSize ?? 10;\n  const flushInterval = options.flushInterval ?? 5000;\n\n  const buffer: LogRecord[] = [];\n  let flushTimer: ReturnType<typeof setTimeout> | null = null;\n  let disposed = false;\n\n  function flush(): void {\n    if (buffer.length === 0) return;\n\n    const records = buffer.splice(0);\n    for (const record of records) {\n      try {\n        sink(record);\n      } catch (error) {\n        // Errors are handled by the sink infrastructure\n        throw error;\n      }\n    }\n\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (flushInterval <= 0 || flushTimer !== null || disposed) return;\n\n    flushTimer = setTimeout(() => {\n      flushTimer = null;\n      flush();\n    }, flushInterval);\n  }\n\n  const bufferedSink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    buffer.push(record);\n\n    if (buffer.length >= bufferSize) {\n      flush();\n    } else {\n      scheduleFlush();\n    }\n  };\n\n  bufferedSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearTimeout(flushTimer);\n      flushTimer = null;\n    }\n    flush();\n\n    // Dispose the underlying sink if it's disposable\n    if (Symbol.asyncDispose in sink) {\n      await (sink as AsyncDisposable)[Symbol.asyncDispose]();\n    } else if (Symbol.dispose in sink) {\n      (sink as Disposable)[Symbol.dispose]();\n    }\n  };\n\n  return bufferedSink;\n}\n\n/**\n * Options for the {@link getStreamSink} function.\n */\nexport interface StreamSinkOptions {\n  /**\n   * The text formatter to use.  Defaults to {@link defaultTextFormatter}.\n   */\n  formatter?: TextFormatter;\n\n  /**\n   * The text encoder to use.  Defaults to an instance of {@link TextEncoder}.\n   */\n  encoder?: { encode(text: string): Uint8Array };\n\n  /**\n   * Enable non-blocking mode with optional buffer configuration.\n   * When enabled, log records are buffered and flushed in the background.\n   *\n   * @example Simple non-blocking mode\n   * ```typescript\n   * getStreamSink(stream, { nonBlocking: true });\n   * ```\n   *\n   * @example Custom buffer configuration\n   * ```typescript\n   * getStreamSink(stream, {\n   *   nonBlocking: {\n   *     bufferSize: 1000,\n   *     flushInterval: 50\n   *   }\n   * });\n   * ```\n   *\n   * @default `false`\n   * @since 1.0.0\n   */\n  nonBlocking?: boolean | {\n    /**\n     * Maximum number of records to buffer before flushing.\n     * @default `100`\n     */\n    bufferSize?: number;\n\n    /**\n     * Interval in milliseconds between automatic flushes.\n     * @default `100`\n     */\n    flushInterval?: number;\n  };\n}\n\n/**\n * A factory that returns a sink that writes to a {@link WritableStream}.\n *\n * Note that the `stream` is of Web Streams API, which is different from\n * Node.js streams.  You can convert a Node.js stream to a Web Streams API\n * stream using [`stream.Writable.toWeb()`] method.\n *\n * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable\n *\n * @example Sink to the standard error in Deno\n * ```typescript\n * const stderrSink = getStreamSink(Deno.stderr.writable);\n * ```\n *\n * @example Sink to the standard error in Node.js\n * ```typescript\n * import stream from \"node:stream\";\n * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));\n * ```\n *\n * @param stream The stream to write to.\n * @param options The options for the sink.\n * @returns A sink that writes to the stream.\n */\nexport function getStreamSink(\n  stream: WritableStream,\n  options: StreamSinkOptions = {},\n): Sink & AsyncDisposable {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const writer = stream.getWriter();\n\n  if (!options.nonBlocking) {\n    let lastPromise = Promise.resolve();\n    const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n      const bytes = encoder.encode(formatter(record));\n      lastPromise = lastPromise\n        .then(() => writer.ready)\n        .then(() => writer.write(bytes));\n    };\n    sink[Symbol.asyncDispose] = async () => {\n      await lastPromise;\n      await writer.close();\n    };\n    return sink;\n  }\n\n  // Non-blocking mode implementation\n  const nonBlockingConfig = options.nonBlocking === true\n    ? {}\n    : options.nonBlocking;\n  const bufferSize = nonBlockingConfig.bufferSize ?? 100;\n  const flushInterval = nonBlockingConfig.flushInterval ?? 100;\n\n  const buffer: LogRecord[] = [];\n  let flushTimer: ReturnType<typeof setInterval> | null = null;\n  let disposed = false;\n  let activeFlush: Promise<void> | null = null;\n  const maxBufferSize = bufferSize * 2; // Overflow protection\n\n  async function flush(): Promise<void> {\n    if (buffer.length === 0) return;\n\n    const records = buffer.splice(0);\n    for (const record of records) {\n      try {\n        const bytes = encoder.encode(formatter(record));\n        await writer.ready;\n        await writer.write(bytes);\n      } catch {\n        // Silently ignore errors in non-blocking mode to avoid disrupting the application\n      }\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (activeFlush) return;\n\n    activeFlush = flush().finally(() => {\n      activeFlush = null;\n    });\n  }\n\n  function startFlushTimer(): void {\n    if (flushTimer !== null || disposed) return;\n\n    flushTimer = setInterval(() => {\n      scheduleFlush();\n    }, flushInterval);\n  }\n\n  const nonBlockingSink: Sink & AsyncDisposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Buffer overflow protection: drop oldest records if buffer is too large\n    if (buffer.length >= maxBufferSize) {\n      buffer.shift(); // Remove oldest record\n    }\n\n    buffer.push(record);\n\n    if (buffer.length >= bufferSize) {\n      scheduleFlush();\n    } else if (flushTimer === null) {\n      startFlushTimer();\n    }\n  };\n\n  nonBlockingSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearInterval(flushTimer);\n      flushTimer = null;\n    }\n    await flush();\n    try {\n      await writer.close();\n    } catch {\n      // Writer might already be closed or errored\n    }\n  };\n\n  return nonBlockingSink;\n}\n\ntype ConsoleMethod = \"debug\" | \"info\" | \"log\" | \"warn\" | \"error\";\n\n/**\n * Options for the {@link getConsoleSink} function.\n */\nexport interface ConsoleSinkOptions {\n  /**\n   * The console formatter or text formatter to use.\n   * Defaults to {@link defaultConsoleFormatter}.\n   */\n  formatter?: ConsoleFormatter | TextFormatter;\n\n  /**\n   * The mapping from log levels to console methods.  Defaults to:\n   *\n   * ```typescript\n   * {\n   *   trace: \"trace\",\n   *   debug: \"debug\",\n   *   info: \"info\",\n   *   warning: \"warn\",\n   *   error: \"error\",\n   *   fatal: \"error\",\n   * }\n   * ```\n   * @since 0.9.0\n   */\n  levelMap?: Record<LogLevel, ConsoleMethod>;\n\n  /**\n   * The console to log to.  Defaults to {@link console}.\n   */\n  console?: Console;\n\n  /**\n   * Enable non-blocking mode with optional buffer configuration.\n   * When enabled, log records are buffered and flushed in the background.\n   *\n   * @example Simple non-blocking mode\n   * ```typescript\n   * getConsoleSink({ nonBlocking: true });\n   * ```\n   *\n   * @example Custom buffer configuration\n   * ```typescript\n   * getConsoleSink({\n   *   nonBlocking: {\n   *     bufferSize: 1000,\n   *     flushInterval: 50\n   *   }\n   * });\n   * ```\n   *\n   * @default `false`\n   * @since 1.0.0\n   */\n  nonBlocking?: boolean | {\n    /**\n     * Maximum number of records to buffer before flushing.\n     * @default `100`\n     */\n    bufferSize?: number;\n\n    /**\n     * Interval in milliseconds between automatic flushes.\n     * @default `100`\n     */\n    flushInterval?: number;\n  };\n}\n\n/**\n * A console sink factory that returns a sink that logs to the console.\n *\n * @param options The options for the sink.\n * @returns A sink that logs to the console. If `nonBlocking` is enabled,\n *          returns a sink that also implements {@link Disposable}.\n */\nexport function getConsoleSink(\n  options: ConsoleSinkOptions = {},\n): Sink | (Sink & Disposable) {\n  const formatter = options.formatter ?? defaultConsoleFormatter;\n  const levelMap: Record<LogLevel, ConsoleMethod> = {\n    trace: \"debug\",\n    debug: \"debug\",\n    info: \"info\",\n    warning: \"warn\",\n    error: \"error\",\n    fatal: \"error\",\n    ...(options.levelMap ?? {}),\n  };\n  const console = options.console ?? globalThis.console;\n\n  const baseSink = (record: LogRecord) => {\n    const args = formatter(record);\n    const method = levelMap[record.level];\n    if (method === undefined) {\n      throw new TypeError(`Invalid log level: ${record.level}.`);\n    }\n    if (typeof args === \"string\") {\n      const msg = args.replace(/\\r?\\n$/, \"\");\n      console[method](msg);\n    } else {\n      console[method](...args);\n    }\n  };\n\n  if (!options.nonBlocking) {\n    return baseSink;\n  }\n\n  // Non-blocking mode implementation\n  const nonBlockingConfig = options.nonBlocking === true\n    ? {}\n    : options.nonBlocking;\n  const bufferSize = nonBlockingConfig.bufferSize ?? 100;\n  const flushInterval = nonBlockingConfig.flushInterval ?? 100;\n\n  const buffer: LogRecord[] = [];\n  let flushTimer: ReturnType<typeof setInterval> | null = null;\n  let disposed = false;\n  let flushScheduled = false;\n  const maxBufferSize = bufferSize * 2; // Overflow protection\n\n  function flush(): void {\n    if (buffer.length === 0) return;\n\n    const records = buffer.splice(0);\n    for (const record of records) {\n      try {\n        baseSink(record);\n      } catch {\n        // Silently ignore errors in non-blocking mode to avoid disrupting the application\n      }\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (flushScheduled) return;\n\n    flushScheduled = true;\n    setTimeout(() => {\n      flushScheduled = false;\n      flush();\n    }, 0);\n  }\n\n  function startFlushTimer(): void {\n    if (flushTimer !== null || disposed) return;\n\n    flushTimer = setInterval(() => {\n      flush();\n    }, flushInterval);\n  }\n\n  const nonBlockingSink: Sink & Disposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Buffer overflow protection: drop oldest records if buffer is too large\n    if (buffer.length >= maxBufferSize) {\n      buffer.shift(); // Remove oldest record\n    }\n\n    buffer.push(record);\n\n    if (buffer.length >= bufferSize) {\n      scheduleFlush();\n    } else if (flushTimer === null) {\n      startFlushTimer();\n    }\n  };\n\n  nonBlockingSink[Symbol.dispose] = () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearInterval(flushTimer);\n      flushTimer = null;\n    }\n    flush();\n  };\n\n  return nonBlockingSink;\n}\n\n/**\n * Converts an async sink into a regular sink with proper async handling.\n * The returned sink chains async operations to ensure proper ordering and\n * implements AsyncDisposable to wait for all pending operations on disposal.\n *\n * @example Create a sink that asynchronously posts to a webhook\n * ```typescript\n * const asyncSink: AsyncSink = async (record) => {\n *   await fetch(\"https://example.com/logs\", {\n *     method: \"POST\",\n *     body: JSON.stringify(record),\n *   });\n * };\n * const sink = fromAsyncSink(asyncSink);\n * ```\n *\n * @param asyncSink The async sink function to convert.\n * @returns A sink that properly handles async operations and disposal.\n * @since 1.0.0\n */\nexport function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable {\n  let lastPromise = Promise.resolve();\n  const sink: Sink & AsyncDisposable = (record: LogRecord) => {\n    lastPromise = lastPromise\n      .then(() => asyncSink(record))\n      .catch(() => {\n        // Errors are handled by the sink infrastructure\n      });\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    await lastPromise;\n  };\n  return sink;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "1.0.0-dev.236+0c0f47bf",
+  "version": "1.0.0-dev.237+0615301b",
   "description": "Simple logging library with zero dependencies for Deno/Node.js/Bun/browsers",
   "keywords": [
     "logging",

package/sink.test.ts

@@ -1,4 +1,5 @@
 import { suite } from "@alinea/suite";
+import { assert } from "@std/assert/assert";
 import { assertEquals } from "@std/assert/equals";
 import { assertInstanceOf } from "@std/assert/instance-of";
 import { assertThrows } from "@std/assert/throws";
@@ -67,6 +68,254 @@ test("getStreamSink()", async () => {
   );
 });
 
+test("getStreamSink() with nonBlocking - simple boolean", async () => {
+  let buffer: string = "";
+  const decoder = new TextDecoder();
+  const sink = getStreamSink(
+    new WritableStream({
+      write(chunk: Uint8Array) {
+        buffer += decoder.decode(chunk);
+        return Promise.resolve();
+      },
+    }),
+    { nonBlocking: true },
+  );
+
+  // Check that it returns AsyncDisposable
+  assertInstanceOf(sink, Function);
+  assert(Symbol.asyncDispose in sink);
+
+  // Add records - they should not be written immediately
+  sink(trace);
+  sink(debug);
+  assertEquals(buffer, ""); // Not written yet
+
+  // Wait for flush interval (default 100ms)
+  await delay(150);
+  assertEquals(
+    buffer,
+    `2023-11-14 22:13:20.000 +00:00 [TRC] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  await sink[Symbol.asyncDispose]();
+});
+
+test("getStreamSink() with nonBlocking - custom buffer config", async () => {
+  let buffer: string = "";
+  const decoder = new TextDecoder();
+  const sink = getStreamSink(
+    new WritableStream({
+      write(chunk: Uint8Array) {
+        buffer += decoder.decode(chunk);
+        return Promise.resolve();
+      },
+    }),
+    {
+      nonBlocking: {
+        bufferSize: 2,
+        flushInterval: 50,
+      },
+    },
+  );
+
+  // Add records up to buffer size
+  sink(trace);
+  assertEquals(buffer, ""); // Not flushed yet
+
+  sink(debug); // This should trigger immediate flush (buffer size = 2)
+  await delay(10); // Small delay for async flush
+  assertEquals(
+    buffer,
+    `2023-11-14 22:13:20.000 +00:00 [TRC] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  // Add more records
+  const prevLength = buffer.length;
+  sink(info);
+  assertEquals(buffer.length, prevLength); // Not flushed yet
+
+  // Wait for flush interval
+  await delay(60);
+  assertEquals(
+    buffer.substring(prevLength),
+    `2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+
+  await sink[Symbol.asyncDispose]();
+});
+
+test("getStreamSink() with nonBlocking - no operations after dispose", async () => {
+  let buffer: string = "";
+  const decoder = new TextDecoder();
+  const sink = getStreamSink(
+    new WritableStream({
+      write(chunk: Uint8Array) {
+        buffer += decoder.decode(chunk);
+        return Promise.resolve();
+      },
+    }),
+    { nonBlocking: true },
+  );
+
+  // Dispose immediately
+  await sink[Symbol.asyncDispose]();
+
+  // Try to add records after dispose
+  sink(trace);
+  sink(debug);
+
+  // No records should be written
+  assertEquals(buffer, "");
+});
+
+test("getStreamSink() with nonBlocking - error handling", async () => {
+  const sink = getStreamSink(
+    new WritableStream({
+      write() {
+        return Promise.reject(new Error("Write error"));
+      },
+    }),
+    { nonBlocking: true },
+  );
+
+  // Should not throw when adding records
+  sink(trace);
+  sink(info);
+  sink(error);
+
+  // Wait for flush - errors should be silently ignored
+  await delay(150);
+
+  // Dispose - should not throw
+  await sink[Symbol.asyncDispose]();
+});
+
+test("getStreamSink() with nonBlocking - flush on dispose", async () => {
+  let buffer: string = "";
+  const decoder = new TextDecoder();
+  const sink = getStreamSink(
+    new WritableStream({
+      write(chunk: Uint8Array) {
+        buffer += decoder.decode(chunk);
+        return Promise.resolve();
+      },
+    }),
+    {
+      nonBlocking: {
+        bufferSize: 100,
+        flushInterval: 5000, // Very long interval
+      },
+    },
+  );
+
+  // Add records
+  sink(trace);
+  sink(debug);
+  sink(info);
+  assertEquals(buffer, ""); // Not flushed yet due to large buffer and long interval
+
+  // Dispose should flush all remaining records
+  await sink[Symbol.asyncDispose]();
+  assertEquals(
+    buffer,
+    `2023-11-14 22:13:20.000 +00:00 [TRC] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+`,
+  );
+});
+
+test("getStreamSink() with nonBlocking - buffer overflow protection", async () => {
+  let buffer: string = "";
+  const decoder = new TextDecoder();
+  let recordsReceived = 0;
+  const sink = getStreamSink(
+    new WritableStream({
+      write(chunk: Uint8Array) {
+        const text = decoder.decode(chunk);
+        buffer += text;
+        // Count how many log records we actually receive
+        recordsReceived += text.split("\n").filter((line) =>
+          line.trim() !== ""
+        ).length;
+        return Promise.resolve();
+      },
+    }),
+    {
+      nonBlocking: {
+        bufferSize: 3,
+        flushInterval: 50, // Short interval to ensure flushes happen
+      },
+    },
+  );
+
+  // Add many more records than maxBufferSize (6) very rapidly
+  // This should trigger multiple flushes and potentially overflow protection
+  for (let i = 0; i < 20; i++) {
+    sink(trace);
+  }
+
+  // Wait for all flushes to complete
+  await delay(200);
+
+  // Force final flush
+  await sink[Symbol.asyncDispose]();
+
+  // Due to overflow protection, we should receive fewer than 20 records
+  // The exact number depends on timing, but some should be dropped
+  assert(
+    recordsReceived < 20,
+    `Expected < 20 records due to potential overflow, got ${recordsReceived}`,
+  );
+  assert(recordsReceived > 0, "Expected some records to be logged");
+});
+
+test("getStreamSink() with nonBlocking - high volume non-blocking behavior", async () => {
+  let buffer: string = "";
+  const decoder = new TextDecoder();
+  const sink = getStreamSink(
+    new WritableStream({
+      write(chunk: Uint8Array) {
+        buffer += decoder.decode(chunk);
+        return Promise.resolve();
+      },
+    }),
+    {
+      nonBlocking: {
+        bufferSize: 3,
+        flushInterval: 50,
+      },
+    },
+  );
+
+  // Simulate rapid logging - this should not block
+  const startTime = performance.now();
+  for (let i = 0; i < 100; i++) {
+    sink(trace);
+  }
+  const endTime = performance.now();
+
+  // Adding logs should be very fast (non-blocking)
+  const duration = endTime - startTime;
+  assert(
+    duration < 100,
+    `Adding 100 logs took ${duration}ms, should be much faster`,
+  );
+
+  // Wait for flushes to complete
+  await delay(200);
+
+  // Should have logged some records
+  assert(buffer.length > 0, "Expected some records to be logged");
+
+  await sink[Symbol.asyncDispose]();
+});
+
 test("getConsoleSink()", () => {
   // @ts-ignore: consolemock is not typed
   const mock: ConsoleMock = makeConsoleMock();
@@ -257,6 +506,176 @@ test("getConsoleSink()", () => {
   ]);
 });
 
+test("getConsoleSink() with nonBlocking - simple boolean", async () => {
+  // @ts-ignore: consolemock is not typed
+  const mock: ConsoleMock = makeConsoleMock();
+  const sink = getConsoleSink({ console: mock, nonBlocking: true });
+
+  // Check that it returns a Disposable
+  assertInstanceOf(sink, Function);
+  assert(Symbol.dispose in sink);
+
+  // Add records - they should not be logged immediately
+  sink(trace);
+  sink(debug);
+  assertEquals(mock.history().length, 0); // Not logged yet
+
+  // Wait for flush interval (default 100ms)
+  await delay(150);
+  assertEquals(mock.history().length, 2); // Now they should be logged
+
+  // Dispose the sink
+  (sink as Sink & Disposable)[Symbol.dispose]();
+});
+
+test("getConsoleSink() with nonBlocking - custom buffer config", async () => {
+  // @ts-ignore: consolemock is not typed
+  const mock: ConsoleMock = makeConsoleMock();
+  const sink = getConsoleSink({
+    console: mock,
+    nonBlocking: {
+      bufferSize: 3,
+      flushInterval: 50,
+    },
+  });
+
+  // Add records up to buffer size
+  sink(trace);
+  sink(debug);
+  assertEquals(mock.history().length, 0); // Not flushed yet
+
+  sink(info); // This should trigger scheduled flush (buffer size = 3)
+  await delay(10); // Wait for scheduled flush to execute
+  assertEquals(mock.history().length, 3); // Flushed due to buffer size
+
+  // Add more records
+  sink(warning);
+  assertEquals(mock.history().length, 3); // Not flushed yet
+
+  // Wait for flush interval
+  await delay(60);
+  assertEquals(mock.history().length, 4); // Flushed due to interval
+
+  // Dispose and check remaining records are flushed
+  sink(error);
+  sink(fatal);
+  (sink as Sink & Disposable)[Symbol.dispose]();
+  assertEquals(mock.history().length, 6); // All records flushed on dispose
+});
+
+test("getConsoleSink() with nonBlocking - no operations after dispose", () => {
+  // @ts-ignore: consolemock is not typed
+  const mock: ConsoleMock = makeConsoleMock();
+  const sink = getConsoleSink({ console: mock, nonBlocking: true });
+
+  // Dispose immediately
+  (sink as Sink & Disposable)[Symbol.dispose]();
+
+  // Try to add records after dispose
+  sink(trace);
+  sink(debug);
+
+  // No records should be logged
+  assertEquals(mock.history().length, 0);
+});
+
+test("getConsoleSink() with nonBlocking - error handling", async () => {
+  const errorConsole = {
+    ...console,
+    debug: () => {
+      throw new Error("Console error");
+    },
+    info: () => {
+      throw new Error("Console error");
+    },
+    warn: () => {
+      throw new Error("Console error");
+    },
+    error: () => {
+      throw new Error("Console error");
+    },
+  };
+
+  const sink = getConsoleSink({
+    console: errorConsole,
+    nonBlocking: true,
+  });
+
+  // Should not throw when adding records
+  sink(trace);
+  sink(info);
+  sink(error);
+
+  // Wait for flush - errors should be silently ignored
+  await delay(150);
+
+  // Dispose - should not throw
+  (sink as Sink & Disposable)[Symbol.dispose]();
+});
+
+test("getConsoleSink() with nonBlocking - buffer overflow protection", async () => {
+  // @ts-ignore: consolemock is not typed
+  const mock: ConsoleMock = makeConsoleMock();
+  const sink = getConsoleSink({
+    console: mock,
+    nonBlocking: {
+      bufferSize: 5,
+      flushInterval: 1000, // Long interval to prevent automatic flushing
+    },
+  });
+
+  // Add more records than 2x buffer size (which should trigger overflow protection)
+  for (let i = 0; i < 12; i++) {
+    sink(trace);
+  }
+
+  // Should have dropped oldest records, keeping buffer size manageable
+  // Wait a bit for any scheduled flushes
+  await delay(10);
+
+  // Force flush by disposing
+  (sink as Sink & Disposable)[Symbol.dispose]();
+
+  // Should have logged records, but not more than maxBufferSize (10)
+  const historyLength = mock.history().length;
+  assert(historyLength <= 10, `Expected <= 10 records, got ${historyLength}`);
+  assert(historyLength > 0, "Expected some records to be logged");
+});
+
+test("getConsoleSink() with nonBlocking - high volume non-blocking behavior", async () => {
+  // @ts-ignore: consolemock is not typed
+  const mock: ConsoleMock = makeConsoleMock();
+  const sink = getConsoleSink({
+    console: mock,
+    nonBlocking: {
+      bufferSize: 3,
+      flushInterval: 50,
+    },
+  });
+
+  // Simulate rapid logging - this should not block
+  const startTime = performance.now();
+  for (let i = 0; i < 100; i++) {
+    sink(trace);
+  }
+  const endTime = performance.now();
+
+  // Adding logs should be very fast (non-blocking)
+  const duration = endTime - startTime;
+  assert(
+    duration < 100,
+    `Adding 100 logs took ${duration}ms, should be much faster`,
+  );
+
+  // Wait for flushes to complete
+  await delay(200);
+
+  // Should have logged some records
+  assert(mock.history().length > 0, "Expected some records to be logged");
+
+  (sink as Sink & Disposable)[Symbol.dispose]();
+});
+
 test("withBuffer() - buffer size limit", async () => {
   const buffer: LogRecord[] = [];
   const sink = withBuffer(buffer.push.bind(buffer), { bufferSize: 3 });
@@ -381,7 +800,7 @@ test("withBuffer() - disposes underlying AsyncDisposable sink", async () => {
 
   await bufferedSink[Symbol.asyncDispose]();
 
-  assertEquals(disposed, true); // Underlying sink should be disposed
+  assert(disposed); // Underlying sink should be disposed
 });
 
 test("withBuffer() - disposes underlying Disposable sink", async () => {
@@ -399,7 +818,7 @@ test("withBuffer() - disposes underlying Disposable sink", async () => {
 
   await bufferedSink[Symbol.asyncDispose]();
 
-  assertEquals(disposed, true); // Underlying sink should be disposed
+  assert(disposed); // Underlying sink should be disposed
 });
 
 test("withBuffer() - handles non-disposable sink gracefully", async () => {
@@ -414,7 +833,7 @@ test("withBuffer() - handles non-disposable sink gracefully", async () => {
   await bufferedSink[Symbol.asyncDispose]();
 
   // This test passes if no error is thrown
-  assertEquals(true, true);
+  assert(true);
 });
 
 test("withBuffer() - edge case: bufferSize 1", async () => {
@@ -597,7 +1016,7 @@ test("withBuffer() - edge case: underlying AsyncDisposable throws error", async
   } catch (error) {
     assertInstanceOf(error, Error);
     assertEquals(error.message, "Dispose error");
-    assertEquals(disposed, true); // Should still be disposed
+    assert(disposed); // Should still be disposed
     assertEquals(buffer.length, 1); // Buffer should have been flushed before dispose error
   }
 });
@@ -834,5 +1253,5 @@ test("fromAsyncSink() - empty async sink", async () => {
   await sink[Symbol.asyncDispose]();
 
   // Test passes if no errors thrown
-  assertEquals(true, true);
+  assert(true);
 });

package/sink.ts

@@ -173,6 +173,42 @@ export interface StreamSinkOptions {
    * The text encoder to use.  Defaults to an instance of {@link TextEncoder}.
    */
   encoder?: { encode(text: string): Uint8Array };
+
+  /**
+   * Enable non-blocking mode with optional buffer configuration.
+   * When enabled, log records are buffered and flushed in the background.
+   *
+   * @example Simple non-blocking mode
+   * ```typescript
+   * getStreamSink(stream, { nonBlocking: true });
+   * ```
+   *
+   * @example Custom buffer configuration
+   * ```typescript
+   * getStreamSink(stream, {
+   *   nonBlocking: {
+   *     bufferSize: 1000,
+   *     flushInterval: 50
+   *   }
+   * });
+   * ```
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean | {
+    /**
+     * Maximum number of records to buffer before flushing.
+     * @default `100`
+     */
+    bufferSize?: number;
+
+    /**
+     * Interval in milliseconds between automatic flushes.
+     * @default `100`
+     */
+    flushInterval?: number;
+  };
 }
 
 /**
@@ -206,18 +242,98 @@ export function getStreamSink(
   const formatter = options.formatter ?? defaultTextFormatter;
   const encoder = options.encoder ?? new TextEncoder();
   const writer = stream.getWriter();
-  let lastPromise = Promise.resolve();
-  const sink: Sink & AsyncDisposable = (record: LogRecord) => {
-    const bytes = encoder.encode(formatter(record));
-    lastPromise = lastPromise
-      .then(() => writer.ready)
-      .then(() => writer.write(bytes));
+
+  if (!options.nonBlocking) {
+    let lastPromise = Promise.resolve();
+    const sink: Sink & AsyncDisposable = (record: LogRecord) => {
+      const bytes = encoder.encode(formatter(record));
+      lastPromise = lastPromise
+        .then(() => writer.ready)
+        .then(() => writer.write(bytes));
+    };
+    sink[Symbol.asyncDispose] = async () => {
+      await lastPromise;
+      await writer.close();
+    };
+    return sink;
+  }
+
+  // Non-blocking mode implementation
+  const nonBlockingConfig = options.nonBlocking === true
+    ? {}
+    : options.nonBlocking;
+  const bufferSize = nonBlockingConfig.bufferSize ?? 100;
+  const flushInterval = nonBlockingConfig.flushInterval ?? 100;
+
+  const buffer: LogRecord[] = [];
+  let flushTimer: ReturnType<typeof setInterval> | null = null;
+  let disposed = false;
+  let activeFlush: Promise<void> | null = null;
+  const maxBufferSize = bufferSize * 2; // Overflow protection
+
+  async function flush(): Promise<void> {
+    if (buffer.length === 0) return;
+
+    const records = buffer.splice(0);
+    for (const record of records) {
+      try {
+        const bytes = encoder.encode(formatter(record));
+        await writer.ready;
+        await writer.write(bytes);
+      } catch {
+        // Silently ignore errors in non-blocking mode to avoid disrupting the application
+      }
+    }
+  }
+
+  function scheduleFlush(): void {
+    if (activeFlush) return;
+
+    activeFlush = flush().finally(() => {
+      activeFlush = null;
+    });
+  }
+
+  function startFlushTimer(): void {
+    if (flushTimer !== null || disposed) return;
+
+    flushTimer = setInterval(() => {
+      scheduleFlush();
+    }, flushInterval);
+  }
+
+  const nonBlockingSink: Sink & AsyncDisposable = (record: LogRecord) => {
+    if (disposed) return;
+
+    // Buffer overflow protection: drop oldest records if buffer is too large
+    if (buffer.length >= maxBufferSize) {
+      buffer.shift(); // Remove oldest record
+    }
+
+    buffer.push(record);
+
+    if (buffer.length >= bufferSize) {
+      scheduleFlush();
+    } else if (flushTimer === null) {
+      startFlushTimer();
+    }
   };
-  sink[Symbol.asyncDispose] = async () => {
-    await lastPromise;
-    await writer.close();
+
+  nonBlockingSink[Symbol.asyncDispose] = async () => {
+    disposed = true;
+    if (flushTimer !== null) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+    await flush();
+    try {
+      await writer.close();
+    } catch {
+      // Writer might already be closed or errored
+    }
   };
-  return sink;
+
+  return nonBlockingSink;
 }
 
 type ConsoleMethod = "debug" | "info" | "log" | "warn" | "error";
@@ -253,15 +369,54 @@ export interface ConsoleSinkOptions {
    * The console to log to.  Defaults to {@link console}.
    */
   console?: Console;
+
+  /**
+   * Enable non-blocking mode with optional buffer configuration.
+   * When enabled, log records are buffered and flushed in the background.
+   *
+   * @example Simple non-blocking mode
+   * ```typescript
+   * getConsoleSink({ nonBlocking: true });
+   * ```
+   *
+   * @example Custom buffer configuration
+   * ```typescript
+   * getConsoleSink({
+   *   nonBlocking: {
+   *     bufferSize: 1000,
+   *     flushInterval: 50
+   *   }
+   * });
+   * ```
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean | {
+    /**
+     * Maximum number of records to buffer before flushing.
+     * @default `100`
+     */
+    bufferSize?: number;
+
+    /**
+     * Interval in milliseconds between automatic flushes.
+     * @default `100`
+     */
+    flushInterval?: number;
+  };
 }
 
 /**
  * A console sink factory that returns a sink that logs to the console.
  *
  * @param options The options for the sink.
- * @returns A sink that logs to the console.
+ * @returns A sink that logs to the console. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link Disposable}.
  */
-export function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {
+export function getConsoleSink(
+  options: ConsoleSinkOptions = {},
+): Sink | (Sink & Disposable) {
   const formatter = options.formatter ?? defaultConsoleFormatter;
   const levelMap: Record<LogLevel, ConsoleMethod> = {
     trace: "debug",
@@ -273,7 +428,8 @@ export function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {
     ...(options.levelMap ?? {}),
   };
   const console = options.console ?? globalThis.console;
-  return (record: LogRecord) => {
+
+  const baseSink = (record: LogRecord) => {
     const args = formatter(record);
     const method = levelMap[record.level];
     if (method === undefined) {
@@ -286,6 +442,82 @@ export function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {
       console[method](...args);
     }
   };
+
+  if (!options.nonBlocking) {
+    return baseSink;
+  }
+
+  // Non-blocking mode implementation
+  const nonBlockingConfig = options.nonBlocking === true
+    ? {}
+    : options.nonBlocking;
+  const bufferSize = nonBlockingConfig.bufferSize ?? 100;
+  const flushInterval = nonBlockingConfig.flushInterval ?? 100;
+
+  const buffer: LogRecord[] = [];
+  let flushTimer: ReturnType<typeof setInterval> | null = null;
+  let disposed = false;
+  let flushScheduled = false;
+  const maxBufferSize = bufferSize * 2; // Overflow protection
+
+  function flush(): void {
+    if (buffer.length === 0) return;
+
+    const records = buffer.splice(0);
+    for (const record of records) {
+      try {
+        baseSink(record);
+      } catch {
+        // Silently ignore errors in non-blocking mode to avoid disrupting the application
+      }
+    }
+  }
+
+  function scheduleFlush(): void {
+    if (flushScheduled) return;
+
+    flushScheduled = true;
+    setTimeout(() => {
+      flushScheduled = false;
+      flush();
+    }, 0);
+  }
+
+  function startFlushTimer(): void {
+    if (flushTimer !== null || disposed) return;
+
+    flushTimer = setInterval(() => {
+      flush();
+    }, flushInterval);
+  }
+
+  const nonBlockingSink: Sink & Disposable = (record: LogRecord) => {
+    if (disposed) return;
+
+    // Buffer overflow protection: drop oldest records if buffer is too large
+    if (buffer.length >= maxBufferSize) {
+      buffer.shift(); // Remove oldest record
+    }
+
+    buffer.push(record);
+
+    if (buffer.length >= bufferSize) {
+      scheduleFlush();
+    } else if (flushTimer === null) {
+      startFlushTimer();
+    }
+  };
+
+  nonBlockingSink[Symbol.dispose] = () => {
+    disposed = true;
+    if (flushTimer !== null) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+    flush();
+  };
+
+  return nonBlockingSink;
 }
 
 /**