@logtape/logtape 2.4.0-dev.855 → 2.4.0-dev.862

package/dist/mod.d.cts

@@ -3,7 +3,7 @@ import { LogLevel, compareLogLevel, getLogLevels, isLogLevel, parseLogLevel } fr
 import { LogRecord } from "./record.cjs";
 import { Filter, FilterLike, ThrottlingFilterOptions, ThrottlingFilterSummary, ThrottlingFilterSummaryOptions, ThrottlingSummaryLogger, getLevelFilter, getThrottlingFilter, toFilter } from "./filter.cjs";
 import { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, ConsoleFormatter, FormattedValues, JsonLinesFormatterOptions, LogfmtFormatterOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, defaultConsoleFormatter, defaultTextFormatter, getAnsiColorFormatter, getJsonLinesFormatter, getLogfmtFormatter, getTextFormatter, jsonLinesFormatter, logfmtFormatter } from "./formatter.cjs";
-import { AsyncSink, ConsoleSinkOptions, FingersCrossedOptions, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter } from "./sink.cjs";
+import { AsyncSink, ConsoleSinkOptions, FingersCrossedBufferAction, FingersCrossedBufferSelector, FingersCrossedOptions, FingersCrossedSink, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter } from "./sink.cjs";
 import { Config, ConfigError, LoggerConfig, ScopedConfig, configure, configureSync, dispose, disposeSync, getConfig, reset, resetSync, withConfig, withConfigSync } from "./config.cjs";
 import { Lazy, LogMethod, Logger, getLogger, isLazy, lazy } from "./logger.cjs";
-export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, AsyncSink, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FingersCrossedOptions, FormattedValues, JsonLinesFormatterOptions, Lazy, LogLevel, LogMethod, LogRecord, LogfmtFormatterOptions, Logger, LoggerConfig, ScopedConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ThrottlingFilterOptions, ThrottlingFilterSummary, ThrottlingFilterSummaryOptions, ThrottlingSummaryLogger, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, fingersCrossed, fromAsyncSink, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogfmtFormatter, getLogger, getStreamSink, getTextFormatter, getThrottlingFilter, isLazy, isLogLevel, jsonLinesFormatter, lazy, logfmtFormatter, parseLogLevel, reset, resetSync, toFilter, withCategoryPrefix, withConfig, withConfigSync, withContext, withFilter };
+export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, AsyncSink, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FingersCrossedBufferAction, FingersCrossedBufferSelector, FingersCrossedOptions, FingersCrossedSink, FormattedValues, JsonLinesFormatterOptions, Lazy, LogLevel, LogMethod, LogRecord, LogfmtFormatterOptions, Logger, LoggerConfig, ScopedConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ThrottlingFilterOptions, ThrottlingFilterSummary, ThrottlingFilterSummaryOptions, ThrottlingSummaryLogger, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, fingersCrossed, fromAsyncSink, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogfmtFormatter, getLogger, getStreamSink, getTextFormatter, getThrottlingFilter, isLazy, isLogLevel, jsonLinesFormatter, lazy, logfmtFormatter, parseLogLevel, reset, resetSync, toFilter, withCategoryPrefix, withConfig, withConfigSync, withContext, withFilter };

package/dist/mod.d.ts

@@ -3,7 +3,7 @@ import { LogLevel, compareLogLevel, getLogLevels, isLogLevel, parseLogLevel } fr
 import { LogRecord } from "./record.js";
 import { Filter, FilterLike, ThrottlingFilterOptions, ThrottlingFilterSummary, ThrottlingFilterSummaryOptions, ThrottlingSummaryLogger, getLevelFilter, getThrottlingFilter, toFilter } from "./filter.js";
 import { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, ConsoleFormatter, FormattedValues, JsonLinesFormatterOptions, LogfmtFormatterOptions, TextFormatter, TextFormatterOptions, ansiColorFormatter, defaultConsoleFormatter, defaultTextFormatter, getAnsiColorFormatter, getJsonLinesFormatter, getLogfmtFormatter, getTextFormatter, jsonLinesFormatter, logfmtFormatter } from "./formatter.js";
-import { AsyncSink, ConsoleSinkOptions, FingersCrossedOptions, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter } from "./sink.js";
+import { AsyncSink, ConsoleSinkOptions, FingersCrossedBufferAction, FingersCrossedBufferSelector, FingersCrossedOptions, FingersCrossedSink, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter } from "./sink.js";
 import { Config, ConfigError, LoggerConfig, ScopedConfig, configure, configureSync, dispose, disposeSync, getConfig, reset, resetSync, withConfig, withConfigSync } from "./config.js";
 import { Lazy, LogMethod, Logger, getLogger, isLazy, lazy } from "./logger.js";
-export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, AsyncSink, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FingersCrossedOptions, FormattedValues, JsonLinesFormatterOptions, Lazy, LogLevel, LogMethod, LogRecord, LogfmtFormatterOptions, Logger, LoggerConfig, ScopedConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ThrottlingFilterOptions, ThrottlingFilterSummary, ThrottlingFilterSummaryOptions, ThrottlingSummaryLogger, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, fingersCrossed, fromAsyncSink, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogfmtFormatter, getLogger, getStreamSink, getTextFormatter, getThrottlingFilter, isLazy, isLogLevel, jsonLinesFormatter, lazy, logfmtFormatter, parseLogLevel, reset, resetSync, toFilter, withCategoryPrefix, withConfig, withConfigSync, withContext, withFilter };
+export { AnsiColor, AnsiColorFormatterOptions, AnsiStyle, AsyncSink, Config, ConfigError, ConsoleFormatter, ConsoleSinkOptions, ContextLocalStorage, Filter, FilterLike, FingersCrossedBufferAction, FingersCrossedBufferSelector, FingersCrossedOptions, FingersCrossedSink, FormattedValues, JsonLinesFormatterOptions, Lazy, LogLevel, LogMethod, LogRecord, LogfmtFormatterOptions, Logger, LoggerConfig, ScopedConfig, Sink, StreamSinkOptions, TextFormatter, TextFormatterOptions, ThrottlingFilterOptions, ThrottlingFilterSummary, ThrottlingFilterSummaryOptions, ThrottlingSummaryLogger, ansiColorFormatter, compareLogLevel, configure, configureSync, defaultConsoleFormatter, defaultTextFormatter, dispose, disposeSync, fingersCrossed, fromAsyncSink, getAnsiColorFormatter, getConfig, getConsoleSink, getJsonLinesFormatter, getLevelFilter, getLogLevels, getLogfmtFormatter, getLogger, getStreamSink, getTextFormatter, getThrottlingFilter, isLazy, isLogLevel, jsonLinesFormatter, lazy, logfmtFormatter, parseLogLevel, reset, resetSync, toFilter, withCategoryPrefix, withConfig, withConfigSync, withContext, withFilter };

package/dist/sink.cjs

@@ -311,6 +311,11 @@ function fingersCrossed(sink, options = {}) {
 		}
 		if (require_level.compareLogLevel(bufferLevel, triggerLevel) >= 0) throw new RangeError(`bufferLevel (${JSON.stringify(bufferLevel)}) must be lower than triggerLevel (${JSON.stringify(triggerLevel)}).`);
 	}
+	function getBufferAction(record) {
+		const action = options.bufferAction?.(record);
+		if (action !== void 0 && action !== "flush" && action !== "discard") throw new TypeError(`Invalid buffer action: ${JSON.stringify(action)}. Expected "flush", "discard", or undefined.`);
+		return action;
+	}
 	function isDescendant(parent, child) {
 		if (parent.length === 0 || child.length === 0) return false;
 		if (parent.length > child.length) return false;
@@ -337,36 +342,21 @@ function fingersCrossed(sink, options = {}) {
 	function getCategoryKey(category) {
 		return JSON.stringify(category);
 	}
-	function parseCategoryKey(key) {
-		return JSON.parse(key);
-	}
 	function getContextKey(properties) {
 		if (!isolateByContext || isolateByContext.keys.length === 0) return "";
 		const contextValues = {};
 		for (const key of isolateByContext.keys) if (key in properties) contextValues[key] = properties[key];
 		return JSON.stringify(contextValues);
 	}
-	function getBufferKey(category, properties) {
-		const categoryKey = getCategoryKey(category);
+	function getBufferKey(identity) {
+		const categoryKey = getCategoryKey(identity.category);
 		if (!isolateByContext) return categoryKey;
-		const contextKey = getContextKey(properties);
-		return `${categoryKey}:${contextKey}`;
+		return `${categoryKey}:${identity.context}`;
 	}
-	function parseBufferKey(key) {
-		if (!isolateByContext) return {
-			category: parseCategoryKey(key),
-			context: ""
-		};
-		const separatorIndex = key.indexOf("]:");
-		if (separatorIndex === -1) return {
-			category: parseCategoryKey(key),
-			context: ""
-		};
-		const categoryPart = key.substring(0, separatorIndex + 1);
-		const contextPart = key.substring(separatorIndex + 2);
+	function getBufferIdentity(record) {
 		return {
-			category: parseCategoryKey(categoryPart),
-			context: contextPart
+			category: record.category,
+			context: getContextKey(record.properties)
 		};
 	}
 	function cleanupExpiredBuffers(buffers, triggered) {
@@ -382,7 +372,7 @@ function fingersCrossed(sink, options = {}) {
 			buffers.delete(key);
 			triggered.delete(key);
 		}
-		for (const [key, triggeredAt] of triggered) if (now - triggeredAt > bufferTtlMs) triggered.delete(key);
+		for (const [key, metadata] of triggered) if (now - metadata.triggeredAt > bufferTtlMs) triggered.delete(key);
 	}
 	function evictLruBuffers(buffers, numToEvict) {
 		if (!hasLru) return;
@@ -397,7 +387,31 @@ function fingersCrossed(sink, options = {}) {
 	if (!isolateByCategory && !isolateByContext) {
 		const buffer = [];
 		let triggered = false;
-		return wrapSink((record) => {
+		const validateGlobalSelector = (selector) => {
+			if (selector?.context != null || selector?.category != null) throw new TypeError("A buffer selector cannot be used without buffer isolation.");
+		};
+		const flush = (selector) => {
+			validateGlobalSelector(selector);
+			const bufferedRecords = buffer.splice(0);
+			triggered = false;
+			for (const bufferedRecord of bufferedRecords) sink(bufferedRecord);
+		};
+		const discard = (selector) => {
+			validateGlobalSelector(selector);
+			buffer.length = 0;
+			triggered = false;
+		};
+		const fingersCrossedSink = (record) => {
+			const action = getBufferAction(record);
+			if (action === "flush") {
+				flush();
+				sink(record);
+				return;
+			}
+			if (action === "discard") {
+				discard();
+				return;
+			}
 			if (triggered) {
 				sink(record);
 				return;
@@ -412,51 +426,112 @@ function fingersCrossed(sink, options = {}) {
 				buffer.push(record);
 				while (buffer.length > maxBufferSize) buffer.shift();
 			}
-		});
+		};
+		fingersCrossedSink.flush = flush;
+		fingersCrossedSink.discard = discard;
+		return wrapSink(fingersCrossedSink);
 	} else {
 		const buffers = /* @__PURE__ */ new Map();
 		const triggered = /* @__PURE__ */ new Map();
 		let accessCounter = 0;
+		const getRecordSelection = (identity) => {
+			return {
+				category: isolateByCategory ? identity.category : void 0,
+				context: isolateByContext ? identity.context : void 0
+			};
+		};
+		const getManualSelection = (selector) => {
+			let context;
+			if (selector?.context != null) {
+				if (!isolateByContext) throw new TypeError("A context selector requires isolateByContext.");
+				const missingKeys = isolateByContext.keys.filter((key) => !(key in selector.context));
+				if (missingKeys.length > 0) throw new TypeError(`Missing context selector keys: ${missingKeys.join(", ")}.`);
+				context = getContextKey(selector.context);
+			}
+			return {
+				category: selector?.category,
+				context
+			};
+		};
+		const matchesSelection = (identity, selection) => {
+			if (selection.context != null && selection.context !== identity.context) return false;
+			if (selection.category == null) return true;
+			if (getCategoryKey(selection.category) === getCategoryKey(identity.category)) return true;
+			if (!isolateByCategory || shouldFlushBuffer == null) return false;
+			try {
+				return shouldFlushBuffer(selection.category, identity.category);
+			} catch {
+				return false;
+			}
+		};
+		const takeBufferedRecords = (selection) => {
+			const selectedBuffers = [];
+			const records = [];
+			for (const [key, metadata] of buffers) {
+				if (!matchesSelection(metadata, selection)) continue;
+				selectedBuffers.push({
+					key,
+					identity: metadata
+				});
+				records.push(...metadata.buffer);
+				buffers.delete(key);
+			}
+			records.sort((a, b) => a.timestamp - b.timestamp);
+			return {
+				selectedBuffers,
+				records
+			};
+		};
+		const releaseTriggeredState = (selection) => {
+			for (const [key, metadata] of triggered) if (matchesSelection(metadata, selection)) triggered.delete(key);
+		};
+		const flushSelection = (selection) => {
+			const { records } = takeBufferedRecords(selection);
+			releaseTriggeredState(selection);
+			for (const record of records) sink(record);
+		};
+		const discardSelection = (selection) => {
+			for (const [key, metadata] of buffers) if (matchesSelection(metadata, selection)) buffers.delete(key);
+			releaseTriggeredState(selection);
+		};
 		let cleanupTimer = null;
 		if (hasTtl) cleanupTimer = setInterval(() => {
 			cleanupExpiredBuffers(buffers, triggered);
 		}, cleanupIntervalMs);
 		const fingersCrossedSink = (record) => {
-			const bufferKey = getBufferKey(record.category, record.properties);
-			if (triggered.has(bufferKey)) {
-				triggered.set(bufferKey, Date.now());
+			const identity = getBufferIdentity(record);
+			const bufferKey = getBufferKey(identity);
+			const selection = getRecordSelection(identity);
+			const action = getBufferAction(record);
+			if (action === "flush") {
+				flushSelection(selection);
+				sink(record);
+				return;
+			}
+			if (action === "discard") {
+				discardSelection(selection);
+				return;
+			}
+			const triggeredMetadata = triggered.get(bufferKey);
+			if (triggeredMetadata != null) {
+				triggeredMetadata.triggeredAt = Date.now();
 				sink(record);
 				return;
 			}
 			if (require_level.compareLogLevel(record.level, triggerLevel) >= 0) {
-				const keysToFlush = /* @__PURE__ */ new Set();
-				for (const [bufferedKey] of buffers) if (bufferedKey === bufferKey) keysToFlush.add(bufferedKey);
-				else {
-					const { category: bufferedCategory, context: bufferedContext } = parseBufferKey(bufferedKey);
-					const { context: triggerContext } = parseBufferKey(bufferKey);
-					let contextMatches = true;
-					if (isolateByContext) contextMatches = bufferedContext === triggerContext;
-					let categoryMatches = false;
-					if (!isolateByCategory) categoryMatches = contextMatches;
-					else if (shouldFlushBuffer) try {
-						categoryMatches = shouldFlushBuffer(record.category, bufferedCategory);
-					} catch {}
-					else categoryMatches = getCategoryKey(record.category) === getCategoryKey(bufferedCategory);
-					if (contextMatches && categoryMatches) keysToFlush.add(bufferedKey);
-				}
-				const allRecordsToFlush = [];
+				const { selectedBuffers, records } = takeBufferedRecords(selection);
 				const triggeredAt = Date.now();
-				for (const key of keysToFlush) {
-					const metadata = buffers.get(key);
-					if (metadata) {
-						allRecordsToFlush.push(...metadata.buffer);
-						buffers.delete(key);
-						triggered.set(key, triggeredAt);
-					}
-				}
-				allRecordsToFlush.sort((a, b) => a.timestamp - b.timestamp);
-				for (const bufferedRecord of allRecordsToFlush) sink(bufferedRecord);
-				triggered.set(bufferKey, triggeredAt);
+				for (const { key, identity: identity$1 } of selectedBuffers) triggered.set(key, {
+					category: identity$1.category,
+					context: identity$1.context,
+					triggeredAt
+				});
+				for (const bufferedRecord of records) sink(bufferedRecord);
+				triggered.set(bufferKey, {
+					category: identity.category,
+					context: identity.context,
+					triggeredAt
+				});
 				sink(record);
 			} else if (bufferLevel != null && require_level.compareLogLevel(record.level, bufferLevel) > 0) sink(record);
 			else {
@@ -468,6 +543,7 @@ function fingersCrossed(sink, options = {}) {
 					}
 					metadata = {
 						buffer: [],
+						...identity,
 						lastAccess: ++accessCounter
 					};
 					buffers.set(bufferKey, metadata);
@@ -476,6 +552,12 @@ function fingersCrossed(sink, options = {}) {
 				while (metadata.buffer.length > maxBufferSize) metadata.buffer.shift();
 			}
 		};
+		fingersCrossedSink.flush = (selector) => {
+			flushSelection(getManualSelection(selector));
+		};
+		fingersCrossedSink.discard = (selector) => {
+			discardSelection(getManualSelection(selector));
+		};
 		return wrapSink(fingersCrossedSink, cleanupTimer === null ? void 0 : () => {
 			if (cleanupTimer !== null) {
 				clearInterval(cleanupTimer);

package/dist/sink.d.cts

@@ -217,11 +217,86 @@ declare function getConsoleSink(options?: ConsoleSinkOptions): Sink | (Sink & Di
  * @since 1.0.0
  */
 declare function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable;
+/**
+ * An action returned by {@link FingersCrossedOptions.bufferAction}.
+ *
+ * Both actions end the matching buffer lifecycle.  `"flush"` emits the
+ * buffered records and the action record, while `"discard"` drops them.
+ * @since 2.4.0
+ */
+type FingersCrossedBufferAction = "flush" | "discard";
+/**
+ * Selects buffers controlled by a {@link FingersCrossedSink}.
+ * @since 2.4.0
+ */
+interface FingersCrossedBufferSelector {
+  /**
+   * Context values to match.  Every key configured by
+   * {@link FingersCrossedOptions.isolateByContext} must be present.
+   * When omitted, buffers from every context are selected.
+   */
+  readonly context?: Readonly<Record<string, unknown>>;
+  /**
+   * Category to match.  When category isolation is enabled, its configured
+   * matcher also applies to descendant or ancestor buffers.  When omitted,
+   * buffers from every category are selected.
+   */
+  readonly category?: readonly string[];
+}
+/**
+ * A sink returned by {@link fingersCrossed} with manual buffer controls.
+ * @since 2.4.0
+ */
+interface FingersCrossedSink {
+  /**
+   * Processes a log record.
+   * @param record The log record to process.
+   */
+  (record: LogRecord): void;
+  /**
+   * Emits the selected buffered records, then releases their buffered and
+   * triggered state.  With no selector, every buffer is flushed.
+   *
+   * @param selector The buffers to flush.
+   */
+  flush(selector?: FingersCrossedBufferSelector): void;
+  /**
+   * Drops the selected buffered records, then releases their buffered and
+   * triggered state.  With no selector, every buffer is discarded.
+   *
+   * @param selector The buffers to discard.
+   */
+  discard(selector?: FingersCrossedBufferSelector): void;
+}
 /**
  * Options for the {@link fingersCrossed} function.
  * @since 1.1.0
  */
 interface FingersCrossedOptions {
+  /**
+   * Chooses a terminal action for a log record and its matching buffer.
+   * Returning `undefined` applies the regular {@link triggerLevel} and
+   * {@link bufferLevel} behavior.
+   *
+   * The callback runs before checking whether the matching buffer has already
+   * been triggered.  This lets a final request or job record release both
+   * buffered and triggered state.
+   *
+   * @example Flush failed requests and discard successful requests
+   * ```typescript
+   * fingersCrossed(sink, {
+   *   isolateByContext: { keys: ["requestId"] },
+   *   bufferAction(record) {
+   *     const status = record.properties.status;
+   *     if (typeof status !== "number") return undefined;
+   *     return status >= 500 ? "flush" : "discard";
+   *   },
+   * });
+   * ```
+   *
+   * @since 2.4.0
+   */
+  readonly bufferAction?: (record: LogRecord) => FingersCrossedBufferAction | undefined;
   /**
    * Minimum log level that triggers buffer flush.
    * When a log record at or above this level is received, all buffered
@@ -391,10 +466,10 @@ interface FingersCrossedOptions {
  * @returns A sink that buffers records until the trigger level is reached.
  * @since 1.1.0
  */
-declare function fingersCrossed(sink: Sink & Disposable & AsyncDisposable, options?: FingersCrossedOptions): Sink & Disposable & AsyncDisposable;
-declare function fingersCrossed(sink: Sink & AsyncDisposable, options?: FingersCrossedOptions): Sink & AsyncDisposable & Partial<Disposable>;
-declare function fingersCrossed(sink: Sink & Disposable, options?: FingersCrossedOptions): Sink & Disposable;
-declare function fingersCrossed(sink: Sink, options?: FingersCrossedOptions): Sink & Partial<Disposable>;
+declare function fingersCrossed(sink: Sink & Disposable & AsyncDisposable, options?: FingersCrossedOptions): FingersCrossedSink & Disposable & AsyncDisposable;
+declare function fingersCrossed(sink: Sink & AsyncDisposable, options?: FingersCrossedOptions): FingersCrossedSink & AsyncDisposable & Partial<Disposable>;
+declare function fingersCrossed(sink: Sink & Disposable, options?: FingersCrossedOptions): FingersCrossedSink & Disposable;
+declare function fingersCrossed(sink: Sink, options?: FingersCrossedOptions): FingersCrossedSink & Partial<Disposable>;
 //#endregion
-export { AsyncSink, ConsoleSinkOptions, FingersCrossedOptions, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter };
+export { AsyncSink, ConsoleSinkOptions, FingersCrossedBufferAction, FingersCrossedBufferSelector, FingersCrossedOptions, FingersCrossedSink, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter };
 //# sourceMappingURL=sink.d.cts.map

package/dist/sink.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.cts","names":[],"sources":["../src/sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA+BA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAsBhE;;;;AAS8C;AAyE9B,KAxHJ,SAAA,GAwHiB,CAAA,MAAA,EAxHI,SAwHJ,EAAA,GAxHkB,OAwHlB,CAAA,IAAA,CAAA;;;;;;AAGJ;AA4GxB;AAOD;;;;;;;AA2BY,iBAzPI,UAAA,CAyPJ,IAAA,EAzPqB,IAyPrB,EAAA,MAAA,EAzPmC,UAyPnC,CAAA,EAzPgD,IAyPhD;AAAO;AA8CnB;;AACW,UAlRM,iBAAA,CAkRN;EAAuB;;;EACN,SAAA,CAAA,EA/Qd,aA+Qc;EAmIZ;;;EAAkC,OAAG,CAAA,EAAA;IAAO,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EA7YxB,UA6YwB;EAAe,CAAA;EA2C1D;;;;AAiCgB;AA0KjC;;;EACY,WAAG,CAAA,EAAA,OAAA;EAAU;;;;;AAEa;AACtC;;;;;;;;;AAGmC;AACnC;;;;;;EAGO,WAAG,CAAA,EAAA,OAAA,GAAA;IAAU;AACpB;;;IAEY,UAAA,CAAA,EAAA,MAAA;IACT;;;AAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAzkBD,aAAA,SACN,0BACC,oBACR,OAAO;KA8GL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CI,cAAA,WACL,qBACR,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;iBAmIF,aAAA,YAAyB,YAAY,OAAO;;;;;UA2C3C,qBAAA;;;;;;;0BAOS;;;;;;;;;;;;;;;;;;;;;;;;;yBA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0KT,cAAA,OACR,OAAO,aAAa,2BAChB,wBACT,OAAO,aAAa;iBACP,cAAA,OACR,OAAO,2BACH,wBACT,OAAO,kBAAkB,QAAQ;iBACpB,cAAA,OACR,OAAO,sBACH,wBACT,OAAO;iBACM,cAAA,OACR,gBACI,wBACT,OAAO,QAAQ"}
+{"version":3,"file":"sink.d.cts","names":[],"sources":["../src/sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA+BA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAsBhE;;;;AAS8C;AAyE9B,KAxHJ,SAAA,GAwHiB,CAAA,MAAA,EAxHI,SAwHJ,EAAA,GAxHkB,OAwHlB,CAAA,IAAA,CAAA;;;;;;AAGJ;AA4GxB;AAOD;;;;;;;AA2BY,iBAzPI,UAAA,CAyPJ,IAAA,EAzPqB,IAyPrB,EAAA,MAAA,EAzPmC,UAyPnC,CAAA,EAzPgD,IAyPhD;AAAO;AA8CnB;;AACW,UAlRM,iBAAA,CAkRN;EAAuB;;;EACN,SAAA,CAAA,EA/Qd,aA+Qc;EAmIZ;;;EAAkC,OAAG,CAAA,EAAA;IAAO,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EA7YxB,UA6YwB;EAAe,CAAA;EA8C/D;AAMZ;;;;AAM6B;AAc7B;;EAAmC,WAKxB,CAAA,EAAA,OAAA;EAAS;;AAgB6B;AAOjD;;;;;;AA4DiC;AAiMjC;;;;;;;;;AAGoD;AACpD;;EAA8B,WACtB,CAAA,EAAA,OAAA,GAAA;IAAO;;;;IAEmC,UAAA,CAAA,EAAA,MAAA;IAAR;AAAO;AACjD;;IACQ,aAAA,CAAA,EAAA,MAAA;EAAI,CAAA;;;;AAEsB;AAClC;;;;;;;AAG+B;;;;;;;;;;;;;;iBAprBf,aAAA,SACN,0BACC,oBACR,OAAO;KA8GL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CI,cAAA,WACL,qBACR,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;iBAmIF,aAAA,YAAyB,YAAY,OAAO;;;;;;;;KA8ChD,0BAAA;;;;;UAMK,4BAAA;;;;;;qBAMI,SAAS;;;;;;;;;;;;UAcb,kBAAA;;;;;WAKN;;;;;;;mBAQQ;;;;;;;qBAQE;;;;;;UAOJ,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;mCAyBL,cACL;;;;;;;0BAQmB;;;;;;;;;;;;;;;;;;;;;;;;;yBA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiMT,cAAA,OACR,OAAO,aAAa,2BAChB,wBACT,qBAAqB,aAAa;iBACrB,cAAA,OACR,OAAO,2BACH,wBACT,qBAAqB,kBAAkB,QAAQ;iBAClC,cAAA,OACR,OAAO,sBACH,wBACT,qBAAqB;iBACR,cAAA,OACR,gBACI,wBACT,qBAAqB,QAAQ"}

package/dist/sink.d.ts

@@ -217,11 +217,86 @@ declare function getConsoleSink(options?: ConsoleSinkOptions): Sink | (Sink & Di
  * @since 1.0.0
  */
 declare function fromAsyncSink(asyncSink: AsyncSink): Sink & AsyncDisposable;
+/**
+ * An action returned by {@link FingersCrossedOptions.bufferAction}.
+ *
+ * Both actions end the matching buffer lifecycle.  `"flush"` emits the
+ * buffered records and the action record, while `"discard"` drops them.
+ * @since 2.4.0
+ */
+type FingersCrossedBufferAction = "flush" | "discard";
+/**
+ * Selects buffers controlled by a {@link FingersCrossedSink}.
+ * @since 2.4.0
+ */
+interface FingersCrossedBufferSelector {
+  /**
+   * Context values to match.  Every key configured by
+   * {@link FingersCrossedOptions.isolateByContext} must be present.
+   * When omitted, buffers from every context are selected.
+   */
+  readonly context?: Readonly<Record<string, unknown>>;
+  /**
+   * Category to match.  When category isolation is enabled, its configured
+   * matcher also applies to descendant or ancestor buffers.  When omitted,
+   * buffers from every category are selected.
+   */
+  readonly category?: readonly string[];
+}
+/**
+ * A sink returned by {@link fingersCrossed} with manual buffer controls.
+ * @since 2.4.0
+ */
+interface FingersCrossedSink {
+  /**
+   * Processes a log record.
+   * @param record The log record to process.
+   */
+  (record: LogRecord): void;
+  /**
+   * Emits the selected buffered records, then releases their buffered and
+   * triggered state.  With no selector, every buffer is flushed.
+   *
+   * @param selector The buffers to flush.
+   */
+  flush(selector?: FingersCrossedBufferSelector): void;
+  /**
+   * Drops the selected buffered records, then releases their buffered and
+   * triggered state.  With no selector, every buffer is discarded.
+   *
+   * @param selector The buffers to discard.
+   */
+  discard(selector?: FingersCrossedBufferSelector): void;
+}
 /**
  * Options for the {@link fingersCrossed} function.
  * @since 1.1.0
  */
 interface FingersCrossedOptions {
+  /**
+   * Chooses a terminal action for a log record and its matching buffer.
+   * Returning `undefined` applies the regular {@link triggerLevel} and
+   * {@link bufferLevel} behavior.
+   *
+   * The callback runs before checking whether the matching buffer has already
+   * been triggered.  This lets a final request or job record release both
+   * buffered and triggered state.
+   *
+   * @example Flush failed requests and discard successful requests
+   * ```typescript
+   * fingersCrossed(sink, {
+   *   isolateByContext: { keys: ["requestId"] },
+   *   bufferAction(record) {
+   *     const status = record.properties.status;
+   *     if (typeof status !== "number") return undefined;
+   *     return status >= 500 ? "flush" : "discard";
+   *   },
+   * });
+   * ```
+   *
+   * @since 2.4.0
+   */
+  readonly bufferAction?: (record: LogRecord) => FingersCrossedBufferAction | undefined;
   /**
    * Minimum log level that triggers buffer flush.
    * When a log record at or above this level is received, all buffered
@@ -391,10 +466,10 @@ interface FingersCrossedOptions {
  * @returns A sink that buffers records until the trigger level is reached.
  * @since 1.1.0
  */
-declare function fingersCrossed(sink: Sink & Disposable & AsyncDisposable, options?: FingersCrossedOptions): Sink & Disposable & AsyncDisposable;
-declare function fingersCrossed(sink: Sink & AsyncDisposable, options?: FingersCrossedOptions): Sink & AsyncDisposable & Partial<Disposable>;
-declare function fingersCrossed(sink: Sink & Disposable, options?: FingersCrossedOptions): Sink & Disposable;
-declare function fingersCrossed(sink: Sink, options?: FingersCrossedOptions): Sink & Partial<Disposable>;
+declare function fingersCrossed(sink: Sink & Disposable & AsyncDisposable, options?: FingersCrossedOptions): FingersCrossedSink & Disposable & AsyncDisposable;
+declare function fingersCrossed(sink: Sink & AsyncDisposable, options?: FingersCrossedOptions): FingersCrossedSink & AsyncDisposable & Partial<Disposable>;
+declare function fingersCrossed(sink: Sink & Disposable, options?: FingersCrossedOptions): FingersCrossedSink & Disposable;
+declare function fingersCrossed(sink: Sink, options?: FingersCrossedOptions): FingersCrossedSink & Partial<Disposable>;
 //#endregion
-export { AsyncSink, ConsoleSinkOptions, FingersCrossedOptions, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter };
+export { AsyncSink, ConsoleSinkOptions, FingersCrossedBufferAction, FingersCrossedBufferSelector, FingersCrossedOptions, FingersCrossedSink, Sink, StreamSinkOptions, fingersCrossed, fromAsyncSink, getConsoleSink, getStreamSink, withFilter };
 //# sourceMappingURL=sink.d.ts.map

package/dist/sink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sink.d.ts","names":[],"sources":["../src/sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA+BA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAsBhE;;;;AAS8C;AAyE9B,KAxHJ,SAAA,GAwHiB,CAAA,MAAA,EAxHI,SAwHJ,EAAA,GAxHkB,OAwHlB,CAAA,IAAA,CAAA;;;;;;AAGJ;AA4GxB;AAOD;;;;;;;AA2BY,iBAzPI,UAAA,CAyPJ,IAAA,EAzPqB,IAyPrB,EAAA,MAAA,EAzPmC,UAyPnC,CAAA,EAzPgD,IAyPhD;AAAO;AA8CnB;;AACW,UAlRM,iBAAA,CAkRN;EAAuB;;;EACN,SAAA,CAAA,EA/Qd,aA+Qc;EAmIZ;;;EAAkC,OAAG,CAAA,EAAA;IAAO,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EA7YxB,UA6YwB;EAAe,CAAA;EA2C1D;;;;AAiCgB;AA0KjC;;;EACY,WAAG,CAAA,EAAA,OAAA;EAAU;;;;;AAEa;AACtC;;;;;;;;;AAGmC;AACnC;;;;;;EAGO,WAAG,CAAA,EAAA,OAAA,GAAA;IAAU;AACpB;;;IAEY,UAAA,CAAA,EAAA,MAAA;IACT;;;AAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAzkBD,aAAA,SACN,0BACC,oBACR,OAAO;KA8GL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CI,cAAA,WACL,qBACR,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;iBAmIF,aAAA,YAAyB,YAAY,OAAO;;;;;UA2C3C,qBAAA;;;;;;;0BAOS;;;;;;;;;;;;;;;;;;;;;;;;;yBA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0KT,cAAA,OACR,OAAO,aAAa,2BAChB,wBACT,OAAO,aAAa;iBACP,cAAA,OACR,OAAO,2BACH,wBACT,OAAO,kBAAkB,QAAQ;iBACpB,cAAA,OACR,OAAO,sBACH,wBACT,OAAO;iBACM,cAAA,OACR,gBACI,wBACT,OAAO,QAAQ"}
+{"version":3,"file":"sink.d.ts","names":[],"sources":["../src/sink.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA+BA;AAWA;;;;AAAsD;AAgBtD;AAA0B,KA3Bd,IAAA,GA2Bc,CAAA,MAAA,EA3BE,SA2BF,EAAA,GAAA,IAAA;;;;AAAsC;AAsBhE;;;;AAS8C;AAyE9B,KAxHJ,SAAA,GAwHiB,CAAA,MAAA,EAxHI,SAwHJ,EAAA,GAxHkB,OAwHlB,CAAA,IAAA,CAAA;;;;;;AAGJ;AA4GxB;AAOD;;;;;;;AA2BY,iBAzPI,UAAA,CAyPJ,IAAA,EAzPqB,IAyPrB,EAAA,MAAA,EAzPmC,UAyPnC,CAAA,EAzPgD,IAyPhD;AAAO;AA8CnB;;AACW,UAlRM,iBAAA,CAkRN;EAAuB;;;EACN,SAAA,CAAA,EA/Qd,aA+Qc;EAmIZ;;;EAAkC,OAAG,CAAA,EAAA;IAAO,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EA7YxB,UA6YwB;EAAe,CAAA;EA8C/D;AAMZ;;;;AAM6B;AAc7B;;EAAmC,WAKxB,CAAA,EAAA,OAAA;EAAS;;AAgB6B;AAOjD;;;;;;AA4DiC;AAiMjC;;;;;;;;;AAGoD;AACpD;;EAA8B,WACtB,CAAA,EAAA,OAAA,GAAA;IAAO;;;;IAEmC,UAAA,CAAA,EAAA,MAAA;IAAR;AAAO;AACjD;;IACQ,aAAA,CAAA,EAAA,MAAA;EAAI,CAAA;;;;AAEsB;AAClC;;;;;;;AAG+B;;;;;;;;;;;;;;iBAprBf,aAAA,SACN,0BACC,oBACR,OAAO;KA8GL,aAAA;;;;UAKY,kBAAA;;;;;cAKH,mBAAmB;;;;;;;;;;;;;;;;aAiBpB,OAAO,UAAU;;;;YAKlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CI,cAAA,WACL,qBACR,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;iBAmIF,aAAA,YAAyB,YAAY,OAAO;;;;;;;;KA8ChD,0BAAA;;;;;UAMK,4BAAA;;;;;;qBAMI,SAAS;;;;;;;;;;;;UAcb,kBAAA;;;;;WAKN;;;;;;;mBAQQ;;;;;;;qBAQE;;;;;;UAOJ,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;mCAyBL,cACL;;;;;;;0BAQmB;;;;;;;;;;;;;;;;;;;;;;;;;yBA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiMT,cAAA,OACR,OAAO,aAAa,2BAChB,wBACT,qBAAqB,aAAa;iBACrB,cAAA,OACR,OAAO,2BACH,wBACT,qBAAqB,kBAAkB,QAAQ;iBAClC,cAAA,OACR,OAAO,sBACH,wBACT,qBAAqB;iBACR,cAAA,OACR,gBACI,wBACT,qBAAqB,QAAQ"}

package/dist/sink.js

@@ -311,6 +311,11 @@ function fingersCrossed(sink, options = {}) {
 		}
 		if (compareLogLevel(bufferLevel, triggerLevel) >= 0) throw new RangeError(`bufferLevel (${JSON.stringify(bufferLevel)}) must be lower than triggerLevel (${JSON.stringify(triggerLevel)}).`);
 	}
+	function getBufferAction(record) {
+		const action = options.bufferAction?.(record);
+		if (action !== void 0 && action !== "flush" && action !== "discard") throw new TypeError(`Invalid buffer action: ${JSON.stringify(action)}. Expected "flush", "discard", or undefined.`);
+		return action;
+	}
 	function isDescendant(parent, child) {
 		if (parent.length === 0 || child.length === 0) return false;
 		if (parent.length > child.length) return false;
@@ -337,36 +342,21 @@ function fingersCrossed(sink, options = {}) {
 	function getCategoryKey(category) {
 		return JSON.stringify(category);
 	}
-	function parseCategoryKey(key) {
-		return JSON.parse(key);
-	}
 	function getContextKey(properties) {
 		if (!isolateByContext || isolateByContext.keys.length === 0) return "";
 		const contextValues = {};
 		for (const key of isolateByContext.keys) if (key in properties) contextValues[key] = properties[key];
 		return JSON.stringify(contextValues);
 	}
-	function getBufferKey(category, properties) {
-		const categoryKey = getCategoryKey(category);
+	function getBufferKey(identity) {
+		const categoryKey = getCategoryKey(identity.category);
 		if (!isolateByContext) return categoryKey;
-		const contextKey = getContextKey(properties);
-		return `${categoryKey}:${contextKey}`;
+		return `${categoryKey}:${identity.context}`;
 	}
-	function parseBufferKey(key) {
-		if (!isolateByContext) return {
-			category: parseCategoryKey(key),
-			context: ""
-		};
-		const separatorIndex = key.indexOf("]:");
-		if (separatorIndex === -1) return {
-			category: parseCategoryKey(key),
-			context: ""
-		};
-		const categoryPart = key.substring(0, separatorIndex + 1);
-		const contextPart = key.substring(separatorIndex + 2);
+	function getBufferIdentity(record) {
 		return {
-			category: parseCategoryKey(categoryPart),
-			context: contextPart
+			category: record.category,
+			context: getContextKey(record.properties)
 		};
 	}
 	function cleanupExpiredBuffers(buffers, triggered) {
@@ -382,7 +372,7 @@ function fingersCrossed(sink, options = {}) {
 			buffers.delete(key);
 			triggered.delete(key);
 		}
-		for (const [key, triggeredAt] of triggered) if (now - triggeredAt > bufferTtlMs) triggered.delete(key);
+		for (const [key, metadata] of triggered) if (now - metadata.triggeredAt > bufferTtlMs) triggered.delete(key);
 	}
 	function evictLruBuffers(buffers, numToEvict) {
 		if (!hasLru) return;
@@ -397,7 +387,31 @@ function fingersCrossed(sink, options = {}) {
 	if (!isolateByCategory && !isolateByContext) {
 		const buffer = [];
 		let triggered = false;
-		return wrapSink((record) => {
+		const validateGlobalSelector = (selector) => {
+			if (selector?.context != null || selector?.category != null) throw new TypeError("A buffer selector cannot be used without buffer isolation.");
+		};
+		const flush = (selector) => {
+			validateGlobalSelector(selector);
+			const bufferedRecords = buffer.splice(0);
+			triggered = false;
+			for (const bufferedRecord of bufferedRecords) sink(bufferedRecord);
+		};
+		const discard = (selector) => {
+			validateGlobalSelector(selector);
+			buffer.length = 0;
+			triggered = false;
+		};
+		const fingersCrossedSink = (record) => {
+			const action = getBufferAction(record);
+			if (action === "flush") {
+				flush();
+				sink(record);
+				return;
+			}
+			if (action === "discard") {
+				discard();
+				return;
+			}
 			if (triggered) {
 				sink(record);
 				return;
@@ -412,51 +426,112 @@ function fingersCrossed(sink, options = {}) {
 				buffer.push(record);
 				while (buffer.length > maxBufferSize) buffer.shift();
 			}
-		});
+		};
+		fingersCrossedSink.flush = flush;
+		fingersCrossedSink.discard = discard;
+		return wrapSink(fingersCrossedSink);
 	} else {
 		const buffers = /* @__PURE__ */ new Map();
 		const triggered = /* @__PURE__ */ new Map();
 		let accessCounter = 0;
+		const getRecordSelection = (identity) => {
+			return {
+				category: isolateByCategory ? identity.category : void 0,
+				context: isolateByContext ? identity.context : void 0
+			};
+		};
+		const getManualSelection = (selector) => {
+			let context;
+			if (selector?.context != null) {
+				if (!isolateByContext) throw new TypeError("A context selector requires isolateByContext.");
+				const missingKeys = isolateByContext.keys.filter((key) => !(key in selector.context));
+				if (missingKeys.length > 0) throw new TypeError(`Missing context selector keys: ${missingKeys.join(", ")}.`);
+				context = getContextKey(selector.context);
+			}
+			return {
+				category: selector?.category,
+				context
+			};
+		};
+		const matchesSelection = (identity, selection) => {
+			if (selection.context != null && selection.context !== identity.context) return false;
+			if (selection.category == null) return true;
+			if (getCategoryKey(selection.category) === getCategoryKey(identity.category)) return true;
+			if (!isolateByCategory || shouldFlushBuffer == null) return false;
+			try {
+				return shouldFlushBuffer(selection.category, identity.category);
+			} catch {
+				return false;
+			}
+		};
+		const takeBufferedRecords = (selection) => {
+			const selectedBuffers = [];
+			const records = [];
+			for (const [key, metadata] of buffers) {
+				if (!matchesSelection(metadata, selection)) continue;
+				selectedBuffers.push({
+					key,
+					identity: metadata
+				});
+				records.push(...metadata.buffer);
+				buffers.delete(key);
+			}
+			records.sort((a, b) => a.timestamp - b.timestamp);
+			return {
+				selectedBuffers,
+				records
+			};
+		};
+		const releaseTriggeredState = (selection) => {
+			for (const [key, metadata] of triggered) if (matchesSelection(metadata, selection)) triggered.delete(key);
+		};
+		const flushSelection = (selection) => {
+			const { records } = takeBufferedRecords(selection);
+			releaseTriggeredState(selection);
+			for (const record of records) sink(record);
+		};
+		const discardSelection = (selection) => {
+			for (const [key, metadata] of buffers) if (matchesSelection(metadata, selection)) buffers.delete(key);
+			releaseTriggeredState(selection);
+		};
 		let cleanupTimer = null;
 		if (hasTtl) cleanupTimer = setInterval(() => {
 			cleanupExpiredBuffers(buffers, triggered);
 		}, cleanupIntervalMs);
 		const fingersCrossedSink = (record) => {
-			const bufferKey = getBufferKey(record.category, record.properties);
-			if (triggered.has(bufferKey)) {
-				triggered.set(bufferKey, Date.now());
+			const identity = getBufferIdentity(record);
+			const bufferKey = getBufferKey(identity);
+			const selection = getRecordSelection(identity);
+			const action = getBufferAction(record);
+			if (action === "flush") {
+				flushSelection(selection);
+				sink(record);
+				return;
+			}
+			if (action === "discard") {
+				discardSelection(selection);
+				return;
+			}
+			const triggeredMetadata = triggered.get(bufferKey);
+			if (triggeredMetadata != null) {
+				triggeredMetadata.triggeredAt = Date.now();
 				sink(record);
 				return;
 			}
 			if (compareLogLevel(record.level, triggerLevel) >= 0) {
-				const keysToFlush = /* @__PURE__ */ new Set();
-				for (const [bufferedKey] of buffers) if (bufferedKey === bufferKey) keysToFlush.add(bufferedKey);
-				else {
-					const { category: bufferedCategory, context: bufferedContext } = parseBufferKey(bufferedKey);
-					const { context: triggerContext } = parseBufferKey(bufferKey);
-					let contextMatches = true;
-					if (isolateByContext) contextMatches = bufferedContext === triggerContext;
-					let categoryMatches = false;
-					if (!isolateByCategory) categoryMatches = contextMatches;
-					else if (shouldFlushBuffer) try {
-						categoryMatches = shouldFlushBuffer(record.category, bufferedCategory);
-					} catch {}
-					else categoryMatches = getCategoryKey(record.category) === getCategoryKey(bufferedCategory);
-					if (contextMatches && categoryMatches) keysToFlush.add(bufferedKey);
-				}
-				const allRecordsToFlush = [];
+				const { selectedBuffers, records } = takeBufferedRecords(selection);
 				const triggeredAt = Date.now();
-				for (const key of keysToFlush) {
-					const metadata = buffers.get(key);
-					if (metadata) {
-						allRecordsToFlush.push(...metadata.buffer);
-						buffers.delete(key);
-						triggered.set(key, triggeredAt);
-					}
-				}
-				allRecordsToFlush.sort((a, b) => a.timestamp - b.timestamp);
-				for (const bufferedRecord of allRecordsToFlush) sink(bufferedRecord);
-				triggered.set(bufferKey, triggeredAt);
+				for (const { key, identity: identity$1 } of selectedBuffers) triggered.set(key, {
+					category: identity$1.category,
+					context: identity$1.context,
+					triggeredAt
+				});
+				for (const bufferedRecord of records) sink(bufferedRecord);
+				triggered.set(bufferKey, {
+					category: identity.category,
+					context: identity.context,
+					triggeredAt
+				});
 				sink(record);
 			} else if (bufferLevel != null && compareLogLevel(record.level, bufferLevel) > 0) sink(record);
 			else {
@@ -468,6 +543,7 @@ function fingersCrossed(sink, options = {}) {
 					}
 					metadata = {
 						buffer: [],
+						...identity,
 						lastAccess: ++accessCounter
 					};
 					buffers.set(bufferKey, metadata);
@@ -476,6 +552,12 @@ function fingersCrossed(sink, options = {}) {
 				while (metadata.buffer.length > maxBufferSize) metadata.buffer.shift();
 			}
 		};
+		fingersCrossedSink.flush = (selector) => {
+			flushSelection(getManualSelection(selector));
+		};
+		fingersCrossedSink.discard = (selector) => {
+			discardSelection(getManualSelection(selector));
+		};
 		return wrapSink(fingersCrossedSink, cleanupTimer === null ? void 0 : () => {
 			if (cleanupTimer !== null) {
 				clearInterval(cleanupTimer);

package/dist/sink.js.map

@@ -1 +1 @@
-{"version":3,"file":"sink.js","names":["sink: T","sink: Sink","filter: FilterLike","filtered: Sink & Partial<Disposable & AsyncDisposable>","record: LogRecord","stream: WritableStream","options: StreamSinkOptions","sink: Sink & AsyncDisposable","buffer: LogRecord[]","flushTimer: ReturnType<typeof setInterval> | null","activeFlush: Promise<void> | null","nonBlockingSink: Sink & AsyncDisposable","options: ConsoleSinkOptions","levelMap: Record<LogLevel, ConsoleMethod>","scheduledFlushTimer: ReturnType<typeof setTimeout> | null","nonBlockingSink: Sink & Disposable","asyncSink: AsyncSink","options: FingersCrossedOptions","wrapped: Sink","disposeSelf?: () => void","parent: readonly string[]","child: readonly string[]","shouldFlushBuffer:\n    | ((\n      triggerCategory: readonly string[],\n      bufferedCategory: readonly string[],\n    ) => boolean)\n    | null","category: readonly string[]","key: string","properties: Record<string, unknown>","contextValues: Record<string, unknown>","buffers: Map<string, BufferMetadata>","triggered: Map<string, number>","expiredKeys: string[]","numToEvict?: number","cleanupTimer: ReturnType<typeof setInterval> | null","allRecordsToFlush: LogRecord[]"],"sources":["../src/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 { compareLogLevel, type LogLevel } from \"./level.ts\";\nimport { LoggerImpl } from \"./logger.ts\";\nimport type { LogRecord } from \"./record.ts\";\n\nconst immediateSinkSymbol = Symbol.for(\n  \"LogTape.sinkSnapshotPolicy.immediate\",\n);\n\nfunction markSinkAsImmediate<T extends Sink>(sink: T): T {\n  Object.defineProperty(sink, immediateSinkSymbol, {\n    value: true,\n  });\n  return sink;\n}\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  const filtered: Sink & Partial<Disposable & AsyncDisposable> = (\n    record: LogRecord,\n  ) => {\n    if (filterFunc(record)) sink(record);\n  };\n  const disposableSink = sink as Sink & Partial<Disposable & AsyncDisposable>;\n  if (Symbol.dispose in disposableSink) {\n    filtered[Symbol.dispose] = disposableSink[Symbol.dispose]?.bind(sink);\n  }\n  if (Symbol.asyncDispose in disposableSink) {\n    filtered[Symbol.asyncDispose] = disposableSink[Symbol.asyncDispose]?.bind(\n      sink,\n    );\n  }\n  return filtered;\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   * Whether to close the stream when the sink is disposed.  Set this to\n   * `false` for caller-owned streams that need to remain open after disposal.\n   * The sink still waits for pending writes and releases its writer lock.\n   *\n   * @default `true`\n   * @since 2.4.0\n   */\n  closeStream?: boolean;\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 closeStream = options.closeStream ?? true;\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      try {\n        await lastPromise;\n        if (closeStream) await writer.close();\n      } finally {\n        writer.releaseLock();\n      }\n    };\n    return markSinkAsImmediate(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    try {\n      await activeFlush;\n      await flush();\n      if (closeStream) {\n        try {\n          await writer.close();\n        } catch {\n          // Writer might already be closed or errored\n        }\n      }\n    } finally {\n      writer.releaseLock();\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 scheduledFlushTimer: ReturnType<typeof setTimeout> | 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    scheduledFlushTimer = setTimeout(() => {\n      scheduledFlushTimer = null;\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    if (scheduledFlushTimer !== null) {\n      clearTimeout(scheduledFlushTimer);\n      scheduledFlushTimer = null;\n      flushScheduled = false;\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((error) => {\n        try {\n          if (_asyncSinkError in record) return;\n\n          const metaLogger = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n          const errorRecord = {\n            category: [\"logtape\", \"meta\"],\n            level: \"error\",\n            timestamp: Date.now(),\n            rawMessage: \"Async sink error: {error}\",\n            message: [\"Async sink error: \", error, \"\"],\n            properties: { error, sink: asyncSink, record },\n            [_asyncSinkError]: true,\n          } as LogRecord;\n          metaLogger.emit(errorRecord, new Set([sink]));\n        } catch {\n          // Last resort – cannot log at all\n        }\n      });\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    // Drain the promise chain until it settles – catch handlers\n    // may enqueue additional async work (e.g., meta-logger writes)\n    for (;;) {\n      const promise = lastPromise;\n      await promise;\n      if (promise === lastPromise) break;\n    }\n  };\n  return sink;\n}\n\nconst _asyncSinkError = Symbol.for(\"logtape.asyncSinkError\");\n\n/**\n * Options for the {@link fingersCrossed} function.\n * @since 1.1.0\n */\nexport interface FingersCrossedOptions {\n  /**\n   * Minimum log level that triggers buffer flush.\n   * When a log record at or above this level is received, all buffered\n   * records are flushed to the wrapped sink.\n   * @default `\"error\"`\n   */\n  readonly triggerLevel?: LogLevel;\n\n  /**\n   * Maximum log level that will be buffered.\n   * Log records at or below this level are buffered, while records above\n   * this level (but below {@link triggerLevel}) pass through immediately\n   * without buffering.\n   *\n   * When `undefined` (default), all records below {@link triggerLevel} are\n   * buffered (equivalent to setting this to the level just below triggerLevel).\n   *\n   * When `null`, all records below {@link triggerLevel} are buffered\n   * (same as `undefined`, but explicit).\n   *\n   * @example Buffer only trace and debug, pass through info immediately\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   bufferLevel: \"debug\",     // trace, debug → buffered\n   *   triggerLevel: \"warning\",  // warning+ → trigger flush\n   *   // info → passes through immediately (not buffered, not trigger)\n   * })\n   * ```\n   *\n   * @default `undefined` (buffer all levels below triggerLevel)\n   * @since 2.0.0\n   */\n  readonly bufferLevel?: LogLevel | null;\n\n  /**\n   * Maximum buffer size before oldest records are dropped.\n   * When the buffer exceeds this size, the oldest records are removed\n   * to prevent unbounded memory growth.\n   * @default `1000`\n   */\n  readonly maxBufferSize?: number;\n\n  /**\n   * Category isolation mode or custom matcher function.\n   *\n   * When `undefined` (default), all log records share a single buffer.\n   *\n   * When set to a mode string:\n   *\n   * - `\"descendant\"`: Flush child category buffers when parent triggers\n   * - `\"ancestor\"`: Flush parent category buffers when child triggers\n   * - `\"both\"`: Flush both parent and child category buffers\n   *\n   * When set to a function, it receives the trigger category and buffered\n   * category and should return true if the buffered category should be flushed.\n   *\n   * @default `undefined` (no isolation, single global buffer)\n   */\n  readonly isolateByCategory?:\n    | \"descendant\"\n    | \"ancestor\"\n    | \"both\"\n    | ((\n      triggerCategory: readonly string[],\n      bufferedCategory: readonly string[],\n    ) => boolean);\n\n  /**\n   * Enable context-based buffer isolation.\n   * When enabled, buffers are isolated based on specified context keys.\n   * This is useful for scenarios like HTTP request tracing where logs\n   * should be isolated per request.\n   *\n   * @example\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   isolateByContext: { keys: ['requestId'] }\n   * })\n   * ```\n   *\n   * @example Combined with category isolation\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   isolateByCategory: 'descendant',\n   *   isolateByContext: { keys: ['requestId', 'sessionId'] }\n   * })\n   * ```\n   *\n   * @example With TTL-based buffer cleanup\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   isolateByContext: {\n   *     keys: ['requestId'],\n   *     bufferTtlMs: 30000,        // 30 seconds\n   *     cleanupIntervalMs: 10000   // cleanup every 10 seconds\n   *   }\n   * })\n   * ```\n   *\n   * @default `undefined` (no context isolation)\n   * @since 1.2.0\n   */\n  readonly isolateByContext?: {\n    /**\n     * Context keys to use for isolation.\n     * Buffers will be separate for different combinations of these context values.\n     */\n    readonly keys: readonly string[];\n\n    /**\n     * Maximum number of context buffers to maintain simultaneously.\n     * When this limit is exceeded, the least recently used (LRU) buffers\n     * will be evicted to make room for new ones.\n     *\n     * This provides memory protection in high-concurrency scenarios where\n     * many different context values might be active simultaneously.\n     *\n     * When set to 0 or undefined, no limit is enforced.\n     *\n     * @default `undefined` (no limit)\n     * @since 1.2.0\n     */\n    readonly maxContexts?: number;\n\n    /**\n     * Time-to-live for context buffers in milliseconds.\n     * Buffers that haven't been accessed for this duration will be automatically\n     * cleaned up to prevent memory leaks in long-running applications.\n     *\n     * When set to 0 or undefined, buffers will never expire based on time.\n     *\n     * @default `undefined` (no TTL)\n     * @since 1.2.0\n     */\n    readonly bufferTtlMs?: number;\n\n    /**\n     * Interval in milliseconds for running cleanup operations.\n     * The cleanup process removes expired buffers based on {@link bufferTtlMs}.\n     *\n     * This option is ignored if {@link bufferTtlMs} is not set.\n     *\n     * @default `30000` (30 seconds)\n     * @since 1.2.0\n     */\n    readonly cleanupIntervalMs?: number;\n  };\n}\n\n/**\n * Metadata for context-based buffer tracking.\n * Used internally by {@link fingersCrossed} to manage buffer lifecycle with LRU support.\n * @since 1.2.0\n */\ninterface BufferMetadata {\n  /**\n   * The actual log records buffer.\n   */\n  readonly buffer: LogRecord[];\n\n  /**\n   * Monotonically increasing order of the last access to this buffer.\n   * Used for LRU-based eviction when {@link FingersCrossedOptions.isolateByContext.maxContexts} is set.\n   */\n  lastAccess: number;\n}\n\n/**\n * Creates a sink that buffers log records until a trigger level is reached.\n * This pattern, known as \"fingers crossed\" logging, keeps detailed debug logs\n * in memory and only outputs them when an error or other significant event occurs.\n *\n * @example Basic usage with default settings\n * ```typescript\n * const sink = fingersCrossed(getConsoleSink());\n * // Debug and info logs are buffered\n * // When an error occurs, all buffered logs + the error are output\n * ```\n *\n * @example Custom trigger level and buffer size\n * ```typescript\n * const sink = fingersCrossed(getConsoleSink(), {\n *   triggerLevel: \"warning\",  // Trigger on warning or higher\n *   maxBufferSize: 500        // Keep last 500 records\n * });\n * ```\n *\n * @example Category isolation\n * ```typescript\n * const sink = fingersCrossed(getConsoleSink(), {\n *   isolateByCategory: \"descendant\"  // Separate buffers per category\n * });\n * // Error in [\"app\"] triggers flush of [\"app\"] and [\"app\", \"module\"] buffers\n * // But not [\"other\"] buffer\n * ```\n *\n * @param sink The sink to wrap. Buffered records are sent to this sink when\n *             triggered.\n * @param options Configuration options for the fingers crossed behavior.\n * @returns A sink that buffers records until the trigger level is reached.\n * @since 1.1.0\n */\nexport function fingersCrossed(\n  sink: Sink & Disposable & AsyncDisposable,\n  options?: FingersCrossedOptions,\n): Sink & Disposable & AsyncDisposable;\nexport function fingersCrossed(\n  sink: Sink & AsyncDisposable,\n  options?: FingersCrossedOptions,\n): Sink & AsyncDisposable & Partial<Disposable>;\nexport function fingersCrossed(\n  sink: Sink & Disposable,\n  options?: FingersCrossedOptions,\n): Sink & Disposable;\nexport function fingersCrossed(\n  sink: Sink,\n  options?: FingersCrossedOptions,\n): Sink & Partial<Disposable>;\nexport function fingersCrossed(\n  sink: Sink,\n  options: FingersCrossedOptions = {},\n): Sink & Partial<Disposable & AsyncDisposable> {\n  const triggerLevel = options.triggerLevel ?? \"error\";\n  const bufferLevel = options.bufferLevel;\n  const maxBufferSize = Math.max(0, options.maxBufferSize ?? 1000);\n  const isolateByCategory = options.isolateByCategory;\n  const isolateByContext = options.isolateByContext;\n\n  // TTL and LRU configuration\n  const bufferTtlMs = isolateByContext?.bufferTtlMs;\n  const cleanupIntervalMs = isolateByContext?.cleanupIntervalMs ?? 30000;\n  const maxContexts = isolateByContext?.maxContexts;\n  const hasTtl = bufferTtlMs != null && bufferTtlMs > 0;\n  const hasLru = maxContexts != null && maxContexts > 0;\n\n  function wrapSink(\n    wrapped: Sink,\n    disposeSelf?: () => void,\n  ): Sink & Partial<Disposable & AsyncDisposable> {\n    const disposableSink = sink as\n      & Sink\n      & Partial<Disposable & AsyncDisposable>;\n    const disposableWrapped = wrapped as\n      & Sink\n      & Partial<Disposable & AsyncDisposable>;\n    const disposeSink = disposableSink[Symbol.dispose];\n    const asyncDisposeSink = disposableSink[Symbol.asyncDispose];\n\n    if (disposeSelf != null || disposeSink != null) {\n      disposableWrapped[Symbol.dispose] = () => {\n        disposeSelf?.();\n        disposeSink?.call(sink);\n      };\n    }\n    if (asyncDisposeSink != null) {\n      disposableWrapped[Symbol.asyncDispose] = async () => {\n        disposeSelf?.();\n        await asyncDisposeSink.call(sink);\n      };\n    }\n    return disposableWrapped;\n  }\n\n  // Validate trigger level early\n  try {\n    compareLogLevel(\"trace\", triggerLevel); // Test with any valid level\n  } catch (error) {\n    throw new TypeError(\n      `Invalid triggerLevel: ${JSON.stringify(triggerLevel)}. ${\n        error instanceof Error ? error.message : String(error)\n      }`,\n    );\n  }\n\n  // Validate buffer level if provided\n  if (bufferLevel != null) {\n    try {\n      compareLogLevel(\"trace\", bufferLevel); // Test with any valid level\n    } catch (error) {\n      throw new TypeError(\n        `Invalid bufferLevel: ${JSON.stringify(bufferLevel)}. ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n      );\n    }\n\n    // bufferLevel must be strictly less than triggerLevel\n    if (compareLogLevel(bufferLevel, triggerLevel) >= 0) {\n      throw new RangeError(\n        `bufferLevel (${JSON.stringify(bufferLevel)}) must be lower than ` +\n          `triggerLevel (${JSON.stringify(triggerLevel)}).`,\n      );\n    }\n  }\n\n  // Helper functions for category matching\n  function isDescendant(\n    parent: readonly string[],\n    child: readonly string[],\n  ): boolean {\n    if (parent.length === 0 || child.length === 0) return false; // Empty categories are isolated\n    if (parent.length > child.length) return false;\n    return parent.every((p, i) => p === child[i]);\n  }\n\n  function isAncestor(\n    child: readonly string[],\n    parent: readonly string[],\n  ): boolean {\n    if (child.length === 0 || parent.length === 0) return false; // Empty categories are isolated\n    if (child.length < parent.length) return false;\n    return parent.every((p, i) => p === child[i]);\n  }\n\n  // Determine matcher function based on isolation mode\n  let shouldFlushBuffer:\n    | ((\n      triggerCategory: readonly string[],\n      bufferedCategory: readonly string[],\n    ) => boolean)\n    | null = null;\n\n  if (isolateByCategory) {\n    if (typeof isolateByCategory === \"function\") {\n      shouldFlushBuffer = isolateByCategory;\n    } else {\n      switch (isolateByCategory) {\n        case \"descendant\":\n          shouldFlushBuffer = (trigger, buffered) =>\n            isDescendant(trigger, buffered);\n          break;\n        case \"ancestor\":\n          shouldFlushBuffer = (trigger, buffered) =>\n            isAncestor(trigger, buffered);\n          break;\n        case \"both\":\n          shouldFlushBuffer = (trigger, buffered) =>\n            isDescendant(trigger, buffered) || isAncestor(trigger, buffered);\n          break;\n      }\n    }\n  }\n\n  // Helper functions for category serialization\n  function getCategoryKey(category: readonly string[]): string {\n    return JSON.stringify(category);\n  }\n\n  function parseCategoryKey(key: string): string[] {\n    return JSON.parse(key);\n  }\n\n  // Helper function to extract context values from properties\n  function getContextKey(properties: Record<string, unknown>): string {\n    if (!isolateByContext || isolateByContext.keys.length === 0) {\n      return \"\";\n    }\n    const contextValues: Record<string, unknown> = {};\n    for (const key of isolateByContext.keys) {\n      if (key in properties) {\n        contextValues[key] = properties[key];\n      }\n    }\n    return JSON.stringify(contextValues);\n  }\n\n  // Helper function to generate buffer key\n  function getBufferKey(\n    category: readonly string[],\n    properties: Record<string, unknown>,\n  ): string {\n    const categoryKey = getCategoryKey(category);\n    if (!isolateByContext) {\n      return categoryKey;\n    }\n    const contextKey = getContextKey(properties);\n    return `${categoryKey}:${contextKey}`;\n  }\n\n  // Helper function to parse buffer key\n  function parseBufferKey(key: string): {\n    category: string[];\n    context: string;\n  } {\n    if (!isolateByContext) {\n      return { category: parseCategoryKey(key), context: \"\" };\n    }\n    // Find the separator between category and context\n    // The category part is JSON-encoded, so we need to find where it ends\n    // We look for \"]:\" which indicates end of category array and start of context\n    const separatorIndex = key.indexOf(\"]:\");\n    if (separatorIndex === -1) {\n      // No context part, entire key is category\n      return { category: parseCategoryKey(key), context: \"\" };\n    }\n    const categoryPart = key.substring(0, separatorIndex + 1); // Include the ]\n    const contextPart = key.substring(separatorIndex + 2); // Skip ]:\n    return { category: parseCategoryKey(categoryPart), context: contextPart };\n  }\n\n  // TTL-based cleanup function\n  function cleanupExpiredBuffers(\n    buffers: Map<string, BufferMetadata>,\n    triggered: Map<string, number>,\n  ): void {\n    if (!hasTtl) return;\n\n    const now = Date.now();\n    const expiredKeys: string[] = [];\n\n    for (const [key, metadata] of buffers) {\n      if (metadata.buffer.length === 0) continue;\n\n      // Use the timestamp of the last (most recent) record in the buffer\n      const lastRecordTimestamp =\n        metadata.buffer[metadata.buffer.length - 1].timestamp;\n      if (now - lastRecordTimestamp > bufferTtlMs!) {\n        expiredKeys.push(key);\n      }\n    }\n\n    // Remove expired buffers\n    for (const key of expiredKeys) {\n      buffers.delete(key);\n      triggered.delete(key);\n    }\n\n    // Triggered buffers no longer have buffer metadata, so they must be\n    // expired separately to avoid unbounded growth for dynamic contexts.\n    for (const [key, triggeredAt] of triggered) {\n      if (now - triggeredAt > bufferTtlMs!) {\n        triggered.delete(key);\n      }\n    }\n  }\n\n  // LRU-based eviction function\n  function evictLruBuffers(\n    buffers: Map<string, BufferMetadata>,\n    numToEvict?: number,\n  ): void {\n    if (!hasLru) return;\n\n    // Use provided numToEvict or calculate based on current size vs limit\n    const toEvict = numToEvict ?? Math.max(0, buffers.size - maxContexts!);\n    if (toEvict <= 0) return;\n\n    // Sort by lastAccess timestamp (oldest first)\n    const sortedEntries = Array.from(buffers.entries())\n      .sort(([, a], [, b]) => a.lastAccess - b.lastAccess);\n\n    // Remove the oldest buffers\n    for (let i = 0; i < toEvict; i++) {\n      const [key] = sortedEntries[i];\n      buffers.delete(key);\n    }\n  }\n\n  // Buffer management\n  if (!isolateByCategory && !isolateByContext) {\n    // Single global buffer\n    const buffer: LogRecord[] = [];\n    let triggered = false;\n\n    return wrapSink((record: LogRecord) => {\n      if (triggered) {\n        // Already triggered, pass through directly\n        sink(record);\n        return;\n      }\n\n      // Check if this record triggers flush\n      if (compareLogLevel(record.level, triggerLevel) >= 0) {\n        triggered = true;\n\n        // Flush buffer\n        for (const bufferedRecord of buffer) {\n          sink(bufferedRecord);\n        }\n        buffer.length = 0;\n\n        // Send trigger record\n        sink(record);\n      } else if (\n        bufferLevel != null &&\n        compareLogLevel(record.level, bufferLevel) > 0\n      ) {\n        // Record is above bufferLevel but below triggerLevel: pass through\n        sink(record);\n      } else {\n        // Buffer the record\n        buffer.push(record);\n\n        // Enforce max buffer size\n        while (buffer.length > maxBufferSize) {\n          buffer.shift();\n        }\n      }\n    });\n  } else {\n    // Category and/or context-isolated buffers\n    const buffers = new Map<string, BufferMetadata>();\n    const triggered = new Map<string, number>();\n    let accessCounter = 0;\n\n    // Set up TTL cleanup timer if enabled\n    let cleanupTimer: ReturnType<typeof setInterval> | null = null;\n    if (hasTtl) {\n      cleanupTimer = setInterval(() => {\n        cleanupExpiredBuffers(buffers, triggered);\n      }, cleanupIntervalMs);\n    }\n\n    const fingersCrossedSink = (record: LogRecord) => {\n      const bufferKey = getBufferKey(record.category, record.properties);\n\n      // Check if this buffer is already triggered\n      if (triggered.has(bufferKey)) {\n        triggered.set(bufferKey, Date.now());\n        sink(record);\n        return;\n      }\n\n      // Check if this record triggers flush\n      if (compareLogLevel(record.level, triggerLevel) >= 0) {\n        // Find all buffers that should be flushed\n        const keysToFlush = new Set<string>();\n\n        for (const [bufferedKey] of buffers) {\n          if (bufferedKey === bufferKey) {\n            keysToFlush.add(bufferedKey);\n          } else {\n            const { category: bufferedCategory, context: bufferedContext } =\n              parseBufferKey(bufferedKey);\n            const { context: triggerContext } = parseBufferKey(bufferKey);\n\n            // Check context match\n            let contextMatches = true;\n            if (isolateByContext) {\n              contextMatches = bufferedContext === triggerContext;\n            }\n\n            // Check category match\n            let categoryMatches = false;\n            if (!isolateByCategory) {\n              // No category isolation, so all categories match if context matches\n              categoryMatches = contextMatches;\n            } else if (shouldFlushBuffer) {\n              try {\n                categoryMatches = shouldFlushBuffer(\n                  record.category,\n                  bufferedCategory,\n                );\n              } catch {\n                // Ignore errors from custom matcher\n              }\n            } else {\n              // Same category only\n              categoryMatches = getCategoryKey(record.category) ===\n                getCategoryKey(bufferedCategory);\n            }\n\n            // Both must match for the buffer to be flushed\n            if (contextMatches && categoryMatches) {\n              keysToFlush.add(bufferedKey);\n            }\n          }\n        }\n\n        // Flush matching buffers\n        const allRecordsToFlush: LogRecord[] = [];\n        const triggeredAt = Date.now();\n        for (const key of keysToFlush) {\n          const metadata = buffers.get(key);\n          if (metadata) {\n            allRecordsToFlush.push(...metadata.buffer);\n            buffers.delete(key);\n            triggered.set(key, triggeredAt);\n          }\n        }\n\n        // Sort by timestamp to maintain chronological order\n        allRecordsToFlush.sort((a, b) => a.timestamp - b.timestamp);\n\n        // Flush all records\n        for (const bufferedRecord of allRecordsToFlush) {\n          sink(bufferedRecord);\n        }\n\n        // Mark trigger buffer as triggered and send trigger record\n        triggered.set(bufferKey, triggeredAt);\n        sink(record);\n      } else if (\n        bufferLevel != null &&\n        compareLogLevel(record.level, bufferLevel) > 0\n      ) {\n        // Record is above bufferLevel but below triggerLevel: pass through\n        sink(record);\n      } else {\n        // Buffer the record\n        let metadata = buffers.get(bufferKey);\n        if (!metadata) {\n          // Apply LRU eviction if adding new buffer would exceed capacity\n          if (hasLru && buffers.size >= maxContexts!) {\n            // Calculate how many buffers to evict to make room for the new one\n            const numToEvict = buffers.size - maxContexts! + 1;\n            evictLruBuffers(buffers, numToEvict);\n          }\n\n          metadata = {\n            buffer: [],\n            lastAccess: ++accessCounter,\n          };\n          buffers.set(bufferKey, metadata);\n        } else {\n          // Update last access order for LRU\n          metadata.lastAccess = ++accessCounter;\n        }\n\n        metadata.buffer.push(record);\n\n        // Enforce max buffer size per buffer\n        while (metadata.buffer.length > maxBufferSize) {\n          metadata.buffer.shift();\n        }\n      }\n    };\n\n    return wrapSink(\n      fingersCrossedSink,\n      cleanupTimer === null ? undefined : () => {\n        if (cleanupTimer !== null) {\n          clearInterval(cleanupTimer);\n          cleanupTimer = null;\n        }\n      },\n    );\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"sink.js","names":["sink: T","sink: Sink","filter: FilterLike","filtered: Sink & Partial<Disposable & AsyncDisposable>","record: LogRecord","stream: WritableStream","options: StreamSinkOptions","sink: Sink & AsyncDisposable","buffer: LogRecord[]","flushTimer: ReturnType<typeof setInterval> | null","activeFlush: Promise<void> | null","nonBlockingSink: Sink & AsyncDisposable","options: ConsoleSinkOptions","levelMap: Record<LogLevel, ConsoleMethod>","scheduledFlushTimer: ReturnType<typeof setTimeout> | null","nonBlockingSink: Sink & Disposable","asyncSink: AsyncSink","options: FingersCrossedOptions","wrapped: TSink","disposeSelf?: () => void","parent: readonly string[]","child: readonly string[]","shouldFlushBuffer:\n    | ((\n      triggerCategory: readonly string[],\n      bufferedCategory: readonly string[],\n    ) => boolean)\n    | null","category: readonly string[]","properties: Readonly<Record<string, unknown>>","contextValues: Record<string, unknown>","identity: BufferIdentity","buffers: Map<string, BufferMetadata>","triggered: Map<string, TriggeredBufferMetadata>","expiredKeys: string[]","numToEvict?: number","selector: FingersCrossedBufferSelector | undefined","selector?: FingersCrossedBufferSelector","context: string | undefined","selection: BufferSelection","selectedBuffers: {\n        readonly key: string;\n        readonly identity: BufferIdentity;\n      }[]","records: LogRecord[]","cleanupTimer: ReturnType<typeof setInterval> | null","identity"],"sources":["../src/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 { compareLogLevel, type LogLevel } from \"./level.ts\";\nimport { LoggerImpl } from \"./logger.ts\";\nimport type { LogRecord } from \"./record.ts\";\n\nconst immediateSinkSymbol = Symbol.for(\n  \"LogTape.sinkSnapshotPolicy.immediate\",\n);\n\nfunction markSinkAsImmediate<T extends Sink>(sink: T): T {\n  Object.defineProperty(sink, immediateSinkSymbol, {\n    value: true,\n  });\n  return sink;\n}\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  const filtered: Sink & Partial<Disposable & AsyncDisposable> = (\n    record: LogRecord,\n  ) => {\n    if (filterFunc(record)) sink(record);\n  };\n  const disposableSink = sink as Sink & Partial<Disposable & AsyncDisposable>;\n  if (Symbol.dispose in disposableSink) {\n    filtered[Symbol.dispose] = disposableSink[Symbol.dispose]?.bind(sink);\n  }\n  if (Symbol.asyncDispose in disposableSink) {\n    filtered[Symbol.asyncDispose] = disposableSink[Symbol.asyncDispose]?.bind(\n      sink,\n    );\n  }\n  return filtered;\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   * Whether to close the stream when the sink is disposed.  Set this to\n   * `false` for caller-owned streams that need to remain open after disposal.\n   * The sink still waits for pending writes and releases its writer lock.\n   *\n   * @default `true`\n   * @since 2.4.0\n   */\n  closeStream?: boolean;\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 closeStream = options.closeStream ?? true;\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      try {\n        await lastPromise;\n        if (closeStream) await writer.close();\n      } finally {\n        writer.releaseLock();\n      }\n    };\n    return markSinkAsImmediate(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    try {\n      await activeFlush;\n      await flush();\n      if (closeStream) {\n        try {\n          await writer.close();\n        } catch {\n          // Writer might already be closed or errored\n        }\n      }\n    } finally {\n      writer.releaseLock();\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 scheduledFlushTimer: ReturnType<typeof setTimeout> | 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    scheduledFlushTimer = setTimeout(() => {\n      scheduledFlushTimer = null;\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    if (scheduledFlushTimer !== null) {\n      clearTimeout(scheduledFlushTimer);\n      scheduledFlushTimer = null;\n      flushScheduled = false;\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((error) => {\n        try {\n          if (_asyncSinkError in record) return;\n\n          const metaLogger = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n          const errorRecord = {\n            category: [\"logtape\", \"meta\"],\n            level: \"error\",\n            timestamp: Date.now(),\n            rawMessage: \"Async sink error: {error}\",\n            message: [\"Async sink error: \", error, \"\"],\n            properties: { error, sink: asyncSink, record },\n            [_asyncSinkError]: true,\n          } as LogRecord;\n          metaLogger.emit(errorRecord, new Set([sink]));\n        } catch {\n          // Last resort – cannot log at all\n        }\n      });\n  };\n  sink[Symbol.asyncDispose] = async () => {\n    // Drain the promise chain until it settles – catch handlers\n    // may enqueue additional async work (e.g., meta-logger writes)\n    for (;;) {\n      const promise = lastPromise;\n      await promise;\n      if (promise === lastPromise) break;\n    }\n  };\n  return sink;\n}\n\nconst _asyncSinkError = Symbol.for(\"logtape.asyncSinkError\");\n\n/**\n * An action returned by {@link FingersCrossedOptions.bufferAction}.\n *\n * Both actions end the matching buffer lifecycle.  `\"flush\"` emits the\n * buffered records and the action record, while `\"discard\"` drops them.\n * @since 2.4.0\n */\nexport type FingersCrossedBufferAction = \"flush\" | \"discard\";\n\n/**\n * Selects buffers controlled by a {@link FingersCrossedSink}.\n * @since 2.4.0\n */\nexport interface FingersCrossedBufferSelector {\n  /**\n   * Context values to match.  Every key configured by\n   * {@link FingersCrossedOptions.isolateByContext} must be present.\n   * When omitted, buffers from every context are selected.\n   */\n  readonly context?: Readonly<Record<string, unknown>>;\n\n  /**\n   * Category to match.  When category isolation is enabled, its configured\n   * matcher also applies to descendant or ancestor buffers.  When omitted,\n   * buffers from every category are selected.\n   */\n  readonly category?: readonly string[];\n}\n\n/**\n * A sink returned by {@link fingersCrossed} with manual buffer controls.\n * @since 2.4.0\n */\nexport interface FingersCrossedSink {\n  /**\n   * Processes a log record.\n   * @param record The log record to process.\n   */\n  (record: LogRecord): void;\n\n  /**\n   * Emits the selected buffered records, then releases their buffered and\n   * triggered state.  With no selector, every buffer is flushed.\n   *\n   * @param selector The buffers to flush.\n   */\n  flush(selector?: FingersCrossedBufferSelector): void;\n\n  /**\n   * Drops the selected buffered records, then releases their buffered and\n   * triggered state.  With no selector, every buffer is discarded.\n   *\n   * @param selector The buffers to discard.\n   */\n  discard(selector?: FingersCrossedBufferSelector): void;\n}\n\n/**\n * Options for the {@link fingersCrossed} function.\n * @since 1.1.0\n */\nexport interface FingersCrossedOptions {\n  /**\n   * Chooses a terminal action for a log record and its matching buffer.\n   * Returning `undefined` applies the regular {@link triggerLevel} and\n   * {@link bufferLevel} behavior.\n   *\n   * The callback runs before checking whether the matching buffer has already\n   * been triggered.  This lets a final request or job record release both\n   * buffered and triggered state.\n   *\n   * @example Flush failed requests and discard successful requests\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   isolateByContext: { keys: [\"requestId\"] },\n   *   bufferAction(record) {\n   *     const status = record.properties.status;\n   *     if (typeof status !== \"number\") return undefined;\n   *     return status >= 500 ? \"flush\" : \"discard\";\n   *   },\n   * });\n   * ```\n   *\n   * @since 2.4.0\n   */\n  readonly bufferAction?: (\n    record: LogRecord,\n  ) => FingersCrossedBufferAction | undefined;\n\n  /**\n   * Minimum log level that triggers buffer flush.\n   * When a log record at or above this level is received, all buffered\n   * records are flushed to the wrapped sink.\n   * @default `\"error\"`\n   */\n  readonly triggerLevel?: LogLevel;\n\n  /**\n   * Maximum log level that will be buffered.\n   * Log records at or below this level are buffered, while records above\n   * this level (but below {@link triggerLevel}) pass through immediately\n   * without buffering.\n   *\n   * When `undefined` (default), all records below {@link triggerLevel} are\n   * buffered (equivalent to setting this to the level just below triggerLevel).\n   *\n   * When `null`, all records below {@link triggerLevel} are buffered\n   * (same as `undefined`, but explicit).\n   *\n   * @example Buffer only trace and debug, pass through info immediately\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   bufferLevel: \"debug\",     // trace, debug → buffered\n   *   triggerLevel: \"warning\",  // warning+ → trigger flush\n   *   // info → passes through immediately (not buffered, not trigger)\n   * })\n   * ```\n   *\n   * @default `undefined` (buffer all levels below triggerLevel)\n   * @since 2.0.0\n   */\n  readonly bufferLevel?: LogLevel | null;\n\n  /**\n   * Maximum buffer size before oldest records are dropped.\n   * When the buffer exceeds this size, the oldest records are removed\n   * to prevent unbounded memory growth.\n   * @default `1000`\n   */\n  readonly maxBufferSize?: number;\n\n  /**\n   * Category isolation mode or custom matcher function.\n   *\n   * When `undefined` (default), all log records share a single buffer.\n   *\n   * When set to a mode string:\n   *\n   * - `\"descendant\"`: Flush child category buffers when parent triggers\n   * - `\"ancestor\"`: Flush parent category buffers when child triggers\n   * - `\"both\"`: Flush both parent and child category buffers\n   *\n   * When set to a function, it receives the trigger category and buffered\n   * category and should return true if the buffered category should be flushed.\n   *\n   * @default `undefined` (no isolation, single global buffer)\n   */\n  readonly isolateByCategory?:\n    | \"descendant\"\n    | \"ancestor\"\n    | \"both\"\n    | ((\n      triggerCategory: readonly string[],\n      bufferedCategory: readonly string[],\n    ) => boolean);\n\n  /**\n   * Enable context-based buffer isolation.\n   * When enabled, buffers are isolated based on specified context keys.\n   * This is useful for scenarios like HTTP request tracing where logs\n   * should be isolated per request.\n   *\n   * @example\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   isolateByContext: { keys: ['requestId'] }\n   * })\n   * ```\n   *\n   * @example Combined with category isolation\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   isolateByCategory: 'descendant',\n   *   isolateByContext: { keys: ['requestId', 'sessionId'] }\n   * })\n   * ```\n   *\n   * @example With TTL-based buffer cleanup\n   * ```typescript\n   * fingersCrossed(sink, {\n   *   isolateByContext: {\n   *     keys: ['requestId'],\n   *     bufferTtlMs: 30000,        // 30 seconds\n   *     cleanupIntervalMs: 10000   // cleanup every 10 seconds\n   *   }\n   * })\n   * ```\n   *\n   * @default `undefined` (no context isolation)\n   * @since 1.2.0\n   */\n  readonly isolateByContext?: {\n    /**\n     * Context keys to use for isolation.\n     * Buffers will be separate for different combinations of these context values.\n     */\n    readonly keys: readonly string[];\n\n    /**\n     * Maximum number of context buffers to maintain simultaneously.\n     * When this limit is exceeded, the least recently used (LRU) buffers\n     * will be evicted to make room for new ones.\n     *\n     * This provides memory protection in high-concurrency scenarios where\n     * many different context values might be active simultaneously.\n     *\n     * When set to 0 or undefined, no limit is enforced.\n     *\n     * @default `undefined` (no limit)\n     * @since 1.2.0\n     */\n    readonly maxContexts?: number;\n\n    /**\n     * Time-to-live for context buffers in milliseconds.\n     * Buffers that haven't been accessed for this duration will be automatically\n     * cleaned up to prevent memory leaks in long-running applications.\n     *\n     * When set to 0 or undefined, buffers will never expire based on time.\n     *\n     * @default `undefined` (no TTL)\n     * @since 1.2.0\n     */\n    readonly bufferTtlMs?: number;\n\n    /**\n     * Interval in milliseconds for running cleanup operations.\n     * The cleanup process removes expired buffers based on {@link bufferTtlMs}.\n     *\n     * This option is ignored if {@link bufferTtlMs} is not set.\n     *\n     * @default `30000` (30 seconds)\n     * @since 1.2.0\n     */\n    readonly cleanupIntervalMs?: number;\n  };\n}\n\n/**\n * Metadata for isolated buffer tracking.\n * Used internally by {@link fingersCrossed} to manage buffer lifecycle with\n * LRU support.\n * @since 1.2.0\n */\ninterface BufferIdentity {\n  /**\n   * The category associated with this buffer.\n   */\n  readonly category: readonly string[];\n\n  /**\n   * The serialized context associated with this buffer.\n   */\n  readonly context: string;\n}\n\ninterface BufferMetadata extends BufferIdentity {\n  /**\n   * The actual log records buffer.\n   */\n  readonly buffer: LogRecord[];\n\n  /**\n   * Monotonically increasing order of the last access to this buffer.\n   * Used for LRU-based eviction when {@link FingersCrossedOptions.isolateByContext.maxContexts} is set.\n   */\n  lastAccess: number;\n}\n\n/**\n * Metadata for a buffer that has already been triggered.\n */\ninterface TriggeredBufferMetadata extends BufferIdentity {\n  /**\n   * The time when this buffer was most recently triggered or accessed.\n   */\n  triggeredAt: number;\n}\n\n/**\n * Creates a sink that buffers log records until a trigger level is reached.\n * This pattern, known as \"fingers crossed\" logging, keeps detailed debug logs\n * in memory and only outputs them when an error or other significant event occurs.\n *\n * @example Basic usage with default settings\n * ```typescript\n * const sink = fingersCrossed(getConsoleSink());\n * // Debug and info logs are buffered\n * // When an error occurs, all buffered logs + the error are output\n * ```\n *\n * @example Custom trigger level and buffer size\n * ```typescript\n * const sink = fingersCrossed(getConsoleSink(), {\n *   triggerLevel: \"warning\",  // Trigger on warning or higher\n *   maxBufferSize: 500        // Keep last 500 records\n * });\n * ```\n *\n * @example Category isolation\n * ```typescript\n * const sink = fingersCrossed(getConsoleSink(), {\n *   isolateByCategory: \"descendant\"  // Separate buffers per category\n * });\n * // Error in [\"app\"] triggers flush of [\"app\"] and [\"app\", \"module\"] buffers\n * // But not [\"other\"] buffer\n * ```\n *\n * @param sink The sink to wrap. Buffered records are sent to this sink when\n *             triggered.\n * @param options Configuration options for the fingers crossed behavior.\n * @returns A sink that buffers records until the trigger level is reached.\n * @since 1.1.0\n */\nexport function fingersCrossed(\n  sink: Sink & Disposable & AsyncDisposable,\n  options?: FingersCrossedOptions,\n): FingersCrossedSink & Disposable & AsyncDisposable;\nexport function fingersCrossed(\n  sink: Sink & AsyncDisposable,\n  options?: FingersCrossedOptions,\n): FingersCrossedSink & AsyncDisposable & Partial<Disposable>;\nexport function fingersCrossed(\n  sink: Sink & Disposable,\n  options?: FingersCrossedOptions,\n): FingersCrossedSink & Disposable;\nexport function fingersCrossed(\n  sink: Sink,\n  options?: FingersCrossedOptions,\n): FingersCrossedSink & Partial<Disposable>;\nexport function fingersCrossed(\n  sink: Sink,\n  options: FingersCrossedOptions = {},\n): FingersCrossedSink & Partial<Disposable & AsyncDisposable> {\n  const triggerLevel = options.triggerLevel ?? \"error\";\n  const bufferLevel = options.bufferLevel;\n  const maxBufferSize = Math.max(0, options.maxBufferSize ?? 1000);\n  const isolateByCategory = options.isolateByCategory;\n  const isolateByContext = options.isolateByContext;\n\n  // TTL and LRU configuration\n  const bufferTtlMs = isolateByContext?.bufferTtlMs;\n  const cleanupIntervalMs = isolateByContext?.cleanupIntervalMs ?? 30000;\n  const maxContexts = isolateByContext?.maxContexts;\n  const hasTtl = bufferTtlMs != null && bufferTtlMs > 0;\n  const hasLru = maxContexts != null && maxContexts > 0;\n\n  function wrapSink<TSink extends Sink>(\n    wrapped: TSink,\n    disposeSelf?: () => void,\n  ): TSink & Partial<Disposable & AsyncDisposable> {\n    const disposableSink = sink as\n      & Sink\n      & Partial<Disposable & AsyncDisposable>;\n    const disposableWrapped = wrapped as\n      & TSink\n      & Partial<Disposable & AsyncDisposable>;\n    const disposeSink = disposableSink[Symbol.dispose];\n    const asyncDisposeSink = disposableSink[Symbol.asyncDispose];\n\n    if (disposeSelf != null || disposeSink != null) {\n      disposableWrapped[Symbol.dispose] = () => {\n        disposeSelf?.();\n        disposeSink?.call(sink);\n      };\n    }\n    if (asyncDisposeSink != null) {\n      disposableWrapped[Symbol.asyncDispose] = async () => {\n        disposeSelf?.();\n        await asyncDisposeSink.call(sink);\n      };\n    }\n    return disposableWrapped;\n  }\n\n  // Validate trigger level early\n  try {\n    compareLogLevel(\"trace\", triggerLevel); // Test with any valid level\n  } catch (error) {\n    throw new TypeError(\n      `Invalid triggerLevel: ${JSON.stringify(triggerLevel)}. ${\n        error instanceof Error ? error.message : String(error)\n      }`,\n    );\n  }\n\n  // Validate buffer level if provided\n  if (bufferLevel != null) {\n    try {\n      compareLogLevel(\"trace\", bufferLevel); // Test with any valid level\n    } catch (error) {\n      throw new TypeError(\n        `Invalid bufferLevel: ${JSON.stringify(bufferLevel)}. ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n      );\n    }\n\n    // bufferLevel must be strictly less than triggerLevel\n    if (compareLogLevel(bufferLevel, triggerLevel) >= 0) {\n      throw new RangeError(\n        `bufferLevel (${JSON.stringify(bufferLevel)}) must be lower than ` +\n          `triggerLevel (${JSON.stringify(triggerLevel)}).`,\n      );\n    }\n  }\n\n  function getBufferAction(\n    record: LogRecord,\n  ): FingersCrossedBufferAction | undefined {\n    const action = options.bufferAction?.(record);\n    if (action !== undefined && action !== \"flush\" && action !== \"discard\") {\n      throw new TypeError(\n        `Invalid buffer action: ${JSON.stringify(action)}. ` +\n          'Expected \"flush\", \"discard\", or undefined.',\n      );\n    }\n    return action;\n  }\n\n  // Helper functions for category matching\n  function isDescendant(\n    parent: readonly string[],\n    child: readonly string[],\n  ): boolean {\n    if (parent.length === 0 || child.length === 0) return false; // Empty categories are isolated\n    if (parent.length > child.length) return false;\n    return parent.every((p, i) => p === child[i]);\n  }\n\n  function isAncestor(\n    child: readonly string[],\n    parent: readonly string[],\n  ): boolean {\n    if (child.length === 0 || parent.length === 0) return false; // Empty categories are isolated\n    if (child.length < parent.length) return false;\n    return parent.every((p, i) => p === child[i]);\n  }\n\n  // Determine matcher function based on isolation mode\n  let shouldFlushBuffer:\n    | ((\n      triggerCategory: readonly string[],\n      bufferedCategory: readonly string[],\n    ) => boolean)\n    | null = null;\n\n  if (isolateByCategory) {\n    if (typeof isolateByCategory === \"function\") {\n      shouldFlushBuffer = isolateByCategory;\n    } else {\n      switch (isolateByCategory) {\n        case \"descendant\":\n          shouldFlushBuffer = (trigger, buffered) =>\n            isDescendant(trigger, buffered);\n          break;\n        case \"ancestor\":\n          shouldFlushBuffer = (trigger, buffered) =>\n            isAncestor(trigger, buffered);\n          break;\n        case \"both\":\n          shouldFlushBuffer = (trigger, buffered) =>\n            isDescendant(trigger, buffered) || isAncestor(trigger, buffered);\n          break;\n      }\n    }\n  }\n\n  // Helper functions for category serialization\n  function getCategoryKey(category: readonly string[]): string {\n    return JSON.stringify(category);\n  }\n\n  // Helper function to extract context values from properties\n  function getContextKey(\n    properties: Readonly<Record<string, unknown>>,\n  ): string {\n    if (!isolateByContext || isolateByContext.keys.length === 0) {\n      return \"\";\n    }\n    const contextValues: Record<string, unknown> = {};\n    for (const key of isolateByContext.keys) {\n      if (key in properties) {\n        contextValues[key] = properties[key];\n      }\n    }\n    return JSON.stringify(contextValues);\n  }\n\n  // Helper function to generate buffer key\n  function getBufferKey(identity: BufferIdentity): string {\n    const categoryKey = getCategoryKey(identity.category);\n    if (!isolateByContext) {\n      return categoryKey;\n    }\n    return `${categoryKey}:${identity.context}`;\n  }\n\n  // Helper function to capture the original buffer identity\n  function getBufferIdentity(record: LogRecord): BufferIdentity {\n    return {\n      category: record.category,\n      context: getContextKey(record.properties),\n    };\n  }\n\n  // TTL-based cleanup function\n  function cleanupExpiredBuffers(\n    buffers: Map<string, BufferMetadata>,\n    triggered: Map<string, TriggeredBufferMetadata>,\n  ): void {\n    if (!hasTtl) return;\n\n    const now = Date.now();\n    const expiredKeys: string[] = [];\n\n    for (const [key, metadata] of buffers) {\n      if (metadata.buffer.length === 0) continue;\n\n      // Use the timestamp of the last (most recent) record in the buffer\n      const lastRecordTimestamp =\n        metadata.buffer[metadata.buffer.length - 1].timestamp;\n      if (now - lastRecordTimestamp > bufferTtlMs!) {\n        expiredKeys.push(key);\n      }\n    }\n\n    // Remove expired buffers\n    for (const key of expiredKeys) {\n      buffers.delete(key);\n      triggered.delete(key);\n    }\n\n    // Triggered buffers no longer have buffer metadata, so they must be\n    // expired separately to avoid unbounded growth for dynamic contexts.\n    for (const [key, metadata] of triggered) {\n      if (now - metadata.triggeredAt > bufferTtlMs!) {\n        triggered.delete(key);\n      }\n    }\n  }\n\n  // LRU-based eviction function\n  function evictLruBuffers(\n    buffers: Map<string, BufferMetadata>,\n    numToEvict?: number,\n  ): void {\n    if (!hasLru) return;\n\n    // Use provided numToEvict or calculate based on current size vs limit\n    const toEvict = numToEvict ?? Math.max(0, buffers.size - maxContexts!);\n    if (toEvict <= 0) return;\n\n    // Sort by lastAccess timestamp (oldest first)\n    const sortedEntries = Array.from(buffers.entries())\n      .sort(([, a], [, b]) => a.lastAccess - b.lastAccess);\n\n    // Remove the oldest buffers\n    for (let i = 0; i < toEvict; i++) {\n      const [key] = sortedEntries[i];\n      buffers.delete(key);\n    }\n  }\n\n  // Buffer management\n  if (!isolateByCategory && !isolateByContext) {\n    // Single global buffer\n    const buffer: LogRecord[] = [];\n    let triggered = false;\n\n    const validateGlobalSelector = (\n      selector: FingersCrossedBufferSelector | undefined,\n    ): void => {\n      if (selector?.context != null || selector?.category != null) {\n        throw new TypeError(\n          \"A buffer selector cannot be used without buffer isolation.\",\n        );\n      }\n    };\n\n    const flush = (\n      selector?: FingersCrossedBufferSelector,\n    ): void => {\n      validateGlobalSelector(selector);\n      const bufferedRecords = buffer.splice(0);\n      triggered = false;\n      for (const bufferedRecord of bufferedRecords) sink(bufferedRecord);\n    };\n\n    const discard = (\n      selector?: FingersCrossedBufferSelector,\n    ): void => {\n      validateGlobalSelector(selector);\n      buffer.length = 0;\n      triggered = false;\n    };\n\n    const fingersCrossedSink = ((record: LogRecord) => {\n      const action = getBufferAction(record);\n      if (action === \"flush\") {\n        flush();\n        sink(record);\n        return;\n      }\n      if (action === \"discard\") {\n        discard();\n        return;\n      }\n\n      if (triggered) {\n        // Already triggered, pass through directly\n        sink(record);\n        return;\n      }\n\n      // Check if this record triggers flush\n      if (compareLogLevel(record.level, triggerLevel) >= 0) {\n        triggered = true;\n\n        // Flush buffer\n        for (const bufferedRecord of buffer) {\n          sink(bufferedRecord);\n        }\n        buffer.length = 0;\n\n        // Send trigger record\n        sink(record);\n      } else if (\n        bufferLevel != null &&\n        compareLogLevel(record.level, bufferLevel) > 0\n      ) {\n        // Record is above bufferLevel but below triggerLevel: pass through\n        sink(record);\n      } else {\n        // Buffer the record\n        buffer.push(record);\n\n        // Enforce max buffer size\n        while (buffer.length > maxBufferSize) {\n          buffer.shift();\n        }\n      }\n    }) as FingersCrossedSink;\n    fingersCrossedSink.flush = flush;\n    fingersCrossedSink.discard = discard;\n    return wrapSink(fingersCrossedSink);\n  } else {\n    // Category and/or context-isolated buffers\n    const buffers = new Map<string, BufferMetadata>();\n    const triggered = new Map<string, TriggeredBufferMetadata>();\n    let accessCounter = 0;\n\n    interface BufferSelection {\n      readonly category?: readonly string[];\n      readonly context?: string;\n    }\n\n    const getRecordSelection = (\n      identity: BufferIdentity,\n    ): BufferSelection => {\n      return {\n        category: isolateByCategory ? identity.category : undefined,\n        context: isolateByContext ? identity.context : undefined,\n      };\n    };\n\n    const getManualSelection = (\n      selector: FingersCrossedBufferSelector | undefined,\n    ): BufferSelection => {\n      let context: string | undefined;\n      if (selector?.context != null) {\n        if (!isolateByContext) {\n          throw new TypeError(\n            \"A context selector requires isolateByContext.\",\n          );\n        }\n        const missingKeys = isolateByContext.keys.filter(\n          (key) => !(key in selector.context!),\n        );\n        if (missingKeys.length > 0) {\n          throw new TypeError(\n            `Missing context selector keys: ${missingKeys.join(\", \")}.`,\n          );\n        }\n        context = getContextKey(selector.context);\n      }\n      return { category: selector?.category, context };\n    };\n\n    const matchesSelection = (\n      identity: BufferIdentity,\n      selection: BufferSelection,\n    ): boolean => {\n      if (\n        selection.context != null && selection.context !== identity.context\n      ) {\n        return false;\n      }\n      if (selection.category == null) return true;\n      if (\n        getCategoryKey(selection.category) ===\n          getCategoryKey(identity.category)\n      ) {\n        return true;\n      }\n      if (!isolateByCategory || shouldFlushBuffer == null) return false;\n      try {\n        return shouldFlushBuffer(selection.category, identity.category);\n      } catch {\n        return false;\n      }\n    };\n\n    const takeBufferedRecords = (selection: BufferSelection): {\n      readonly selectedBuffers: readonly {\n        readonly key: string;\n        readonly identity: BufferIdentity;\n      }[];\n      readonly records: readonly LogRecord[];\n    } => {\n      const selectedBuffers: {\n        readonly key: string;\n        readonly identity: BufferIdentity;\n      }[] = [];\n      const records: LogRecord[] = [];\n      for (const [key, metadata] of buffers) {\n        if (!matchesSelection(metadata, selection)) continue;\n        selectedBuffers.push({ key, identity: metadata });\n        records.push(...metadata.buffer);\n        buffers.delete(key);\n      }\n      records.sort((a, b) => a.timestamp - b.timestamp);\n      return { selectedBuffers, records };\n    };\n\n    const releaseTriggeredState = (selection: BufferSelection): void => {\n      for (const [key, metadata] of triggered) {\n        if (matchesSelection(metadata, selection)) triggered.delete(key);\n      }\n    };\n\n    const flushSelection = (selection: BufferSelection): void => {\n      const { records } = takeBufferedRecords(selection);\n      releaseTriggeredState(selection);\n      for (const record of records) sink(record);\n    };\n\n    const discardSelection = (selection: BufferSelection): void => {\n      for (const [key, metadata] of buffers) {\n        if (matchesSelection(metadata, selection)) buffers.delete(key);\n      }\n      releaseTriggeredState(selection);\n    };\n\n    // Set up TTL cleanup timer if enabled\n    let cleanupTimer: ReturnType<typeof setInterval> | null = null;\n    if (hasTtl) {\n      cleanupTimer = setInterval(() => {\n        cleanupExpiredBuffers(buffers, triggered);\n      }, cleanupIntervalMs);\n    }\n\n    const fingersCrossedSink = ((record: LogRecord) => {\n      const identity = getBufferIdentity(record);\n      const bufferKey = getBufferKey(identity);\n      const selection = getRecordSelection(identity);\n      const action = getBufferAction(record);\n\n      if (action === \"flush\") {\n        flushSelection(selection);\n        sink(record);\n        return;\n      }\n      if (action === \"discard\") {\n        discardSelection(selection);\n        return;\n      }\n\n      // Check if this buffer is already triggered\n      const triggeredMetadata = triggered.get(bufferKey);\n      if (triggeredMetadata != null) {\n        triggeredMetadata.triggeredAt = Date.now();\n        sink(record);\n        return;\n      }\n\n      // Check if this record triggers flush\n      if (compareLogLevel(record.level, triggerLevel) >= 0) {\n        const { selectedBuffers, records } = takeBufferedRecords(selection);\n        const triggeredAt = Date.now();\n        for (const { key, identity } of selectedBuffers) {\n          triggered.set(key, {\n            category: identity.category,\n            context: identity.context,\n            triggeredAt,\n          });\n        }\n\n        // Flush all records\n        for (const bufferedRecord of records) sink(bufferedRecord);\n\n        // Mark trigger buffer as triggered and send trigger record\n        triggered.set(bufferKey, {\n          category: identity.category,\n          context: identity.context,\n          triggeredAt,\n        });\n        sink(record);\n      } else if (\n        bufferLevel != null &&\n        compareLogLevel(record.level, bufferLevel) > 0\n      ) {\n        // Record is above bufferLevel but below triggerLevel: pass through\n        sink(record);\n      } else {\n        // Buffer the record\n        let metadata = buffers.get(bufferKey);\n        if (!metadata) {\n          // Apply LRU eviction if adding new buffer would exceed capacity\n          if (hasLru && buffers.size >= maxContexts!) {\n            // Calculate how many buffers to evict to make room for the new one\n            const numToEvict = buffers.size - maxContexts! + 1;\n            evictLruBuffers(buffers, numToEvict);\n          }\n\n          metadata = {\n            buffer: [],\n            ...identity,\n            lastAccess: ++accessCounter,\n          };\n          buffers.set(bufferKey, metadata);\n        } else {\n          // Update last access order for LRU\n          metadata.lastAccess = ++accessCounter;\n        }\n\n        metadata.buffer.push(record);\n\n        // Enforce max buffer size per buffer\n        while (metadata.buffer.length > maxBufferSize) {\n          metadata.buffer.shift();\n        }\n      }\n    }) as FingersCrossedSink;\n\n    fingersCrossedSink.flush = (selector) => {\n      flushSelection(getManualSelection(selector));\n    };\n    fingersCrossedSink.discard = (selector) => {\n      discardSelection(getManualSelection(selector));\n    };\n\n    return wrapSink(\n      fingersCrossedSink,\n      cleanupTimer === null ? undefined : () => {\n        if (cleanupTimer !== null) {\n          clearInterval(cleanupTimer);\n          cleanupTimer = null;\n        }\n      },\n    );\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "2.4.0-dev.855+0e5c5ddf",
+  "version": "2.4.0-dev.862+8721f923",
   "description": "Unobtrusive logging library with zero dependencies—library-first design for Deno/Node.js/Bun/browsers/edge",
   "keywords": [
     "logging",