@logtape/file 2.2.0-dev.679 → 2.2.0-dev.683

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

@@ -0,0 +1,74 @@
+import { StreamSinkOptions } from "@logtape/logtape";
+
+//#region dist/filesink.base.d.ts
+
+//#region src/filesink.base.d.ts
+/**
+ * Options for the {@link getBaseFileSink} function.
+ */
+interface FileSinkOptions extends StreamSinkOptions {
+  /**
+   * If `true`, the file is not opened until the first write.  Defaults to `false`.
+   */
+  lazy?: boolean;
+  /**
+   * The size of the buffer to use when writing to the file.  If not specified,
+   * a default buffer size will be used.  If it is less or equal to 0,
+   * the file will be written directly without buffering.
+   * @default 8192
+   * @since 0.12.0
+   */
+  bufferSize?: number;
+  /**
+   * The maximum time interval in milliseconds between flushes.  If this time
+   * passes since the last flush, the buffer will be flushed regardless of size.
+   * This helps prevent log loss during unexpected process termination.
+   * @default 5000
+   * @since 0.12.0
+   */
+  flushInterval?: number;
+  /**
+   * Enable non-blocking mode with background flushing.
+   * When enabled, flush operations are performed asynchronously to prevent
+   * blocking the main thread during file I/O operations.
+   *
+   * @default `false`
+   * @since 1.0.0
+   */
+  nonBlocking?: boolean;
+}
+/**
+ * A platform-specific file sink driver.
+ * @template TFile The type of the file descriptor.
+ */
+
+/**
+ * Get a platform-independent file sink.
+ *
+ * @template TFile The type of the file descriptor.
+ * @param path A path to the file to write to.
+ * @param options The options for the sink and the file driver.
+ * @returns A sink that writes to the file.  The sink is also a disposable
+ *          object that closes the file when disposed. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link AsyncDisposable}.
+ */
+
+/**
+ * Options for the {@link getBaseRotatingFileSink} function.
+ */
+interface RotatingFileSinkOptions extends Omit<FileSinkOptions, "lazy"> {
+  /**
+   * The maximum bytes of the file before it is rotated.  1 MiB by default.
+   */
+  maxSize?: number;
+  /**
+   * The maximum number of files to keep.  5 by default.
+   */
+  maxFiles?: number;
+}
+/**
+ * A platform-specific rotating file sink driver.
+ */
+//#endregion
+export { FileSinkOptions, RotatingFileSinkOptions };
+//# sourceMappingURL=filesink.base.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filesink.base.d.cts","names":["Sink","StreamSinkOptions","FileSinkOptions","FileSinkDriver","TFile","Uint8Array","AsyncFileSinkDriver","Promise","RotatingFileSinkOptions","Omit","RotatingFileSinkDriver","AsyncRotatingFileSinkDriver"],"sources":["../filesink.base.d.ts"],"sourcesContent":["import { Sink, StreamSinkOptions } from \"@logtape/logtape\";\n\n//#region src/filesink.base.d.ts\n\n/**\n * Options for the {@link getBaseFileSink} function.\n */\ninterface FileSinkOptions extends StreamSinkOptions {\n  /**\n   * If `true`, the file is not opened until the first write.  Defaults to `false`.\n   */\n  lazy?: boolean;\n  /**\n   * The size of the buffer to use when writing to the file.  If not specified,\n   * a default buffer size will be used.  If it is less or equal to 0,\n   * the file will be written directly without buffering.\n   * @default 8192\n   * @since 0.12.0\n   */\n  bufferSize?: number;\n  /**\n   * The maximum time interval in milliseconds between flushes.  If this time\n   * passes since the last flush, the buffer will be flushed regardless of size.\n   * This helps prevent log loss during unexpected process termination.\n   * @default 5000\n   * @since 0.12.0\n   */\n  flushInterval?: number;\n  /**\n   * Enable non-blocking mode with background flushing.\n   * When enabled, flush operations are performed asynchronously to prevent\n   * blocking the main thread during file I/O operations.\n   *\n   * @default `false`\n   * @since 1.0.0\n   */\n  nonBlocking?: boolean;\n}\n/**\n * A platform-specific file sink driver.\n * @template TFile The type of the file descriptor.\n */\ninterface FileSinkDriver<TFile> {\n  /**\n   * Open a file for appending and return a file descriptor.\n   * @param path A path to the file to open.\n   */\n  openSync(path: string): TFile;\n  /**\n   * Write a chunk of data to the file.\n   * @param fd The file descriptor.\n   * @param chunk The data to write.\n   */\n  writeSync(fd: TFile, chunk: Uint8Array): void;\n  /**\n   * Write multiple chunks of data to the file in a single operation.\n   * This is optional - if not implemented, falls back to multiple writeSync calls.\n   * @param fd The file descriptor.\n   * @param chunks Array of data chunks to write.\n   */\n  writeManySync?(fd: TFile, chunks: Uint8Array[]): void;\n  /**\n   * Flush the file to ensure that all data is written to the disk.\n   * @param fd The file descriptor.\n   */\n  flushSync(fd: TFile): void;\n  /**\n   * Close the file.\n   * @param fd The file descriptor.\n   */\n  closeSync(fd: TFile): void;\n}\n/**\n * A platform-specific async file sink driver.\n * @template TFile The type of the file descriptor.\n * @since 1.0.0\n */\ninterface AsyncFileSinkDriver<TFile> extends FileSinkDriver<TFile> {\n  /**\n   * Asynchronously write multiple chunks of data to the file in a single operation.\n   * This is optional - if not implemented, falls back to multiple writeSync calls.\n   * @param fd The file descriptor.\n   * @param chunks Array of data chunks to write.\n   */\n  writeMany?(fd: TFile, chunks: Uint8Array[]): Promise<void>;\n  /**\n   * Asynchronously flush the file to ensure that all data is written to the disk.\n   * @param fd The file descriptor.\n   */\n  flush(fd: TFile): Promise<void>;\n  /**\n   * Asynchronously close the file.\n   * @param fd The file descriptor.\n   */\n  close(fd: TFile): Promise<void>;\n}\n/**\n * Get a platform-independent file sink.\n *\n * @template TFile The type of the file descriptor.\n * @param path A path to the file to write to.\n * @param options The options for the sink and the file driver.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed. If `nonBlocking` is enabled,\n *          returns a sink that also implements {@link AsyncDisposable}.\n */\n\n/**\n * Options for the {@link getBaseRotatingFileSink} function.\n */\ninterface RotatingFileSinkOptions extends Omit<FileSinkOptions, \"lazy\"> {\n  /**\n   * The maximum bytes of the file before it is rotated.  1 MiB by default.\n   */\n  maxSize?: number;\n  /**\n   * The maximum number of files to keep.  5 by default.\n   */\n  maxFiles?: number;\n}\n/**\n * A platform-specific rotating file sink driver.\n */\ninterface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {\n  /**\n   * Get the size of the file.\n   * @param path A path to the file.\n   * @returns The `size` of the file in bytes, in an object.\n   */\n  statSync(path: string): {\n    size: number;\n  };\n  /**\n   * Rename a file.\n   * @param oldPath A path to the file to rename.\n   * @param newPath A path to be renamed to.\n   */\n  renameSync(oldPath: string, newPath: string): void;\n  /**\n   * Delete a file.\n   * @param path A path to the file to delete.\n   */\n  unlinkSync?(path: string): void;\n}\n/**\n * A platform-specific async rotating file sink driver.\n * @since 1.0.0\n */\ninterface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile> {\n  /**\n   * Get the size of the file.\n   * @param path A path to the file.\n   * @returns The `size` of the file in bytes, in an object.\n   */\n  statSync(path: string): {\n    size: number;\n  };\n  /**\n   * Rename a file.\n   * @param oldPath A path to the file to rename.\n   * @param newPath A path to be renamed to.\n   */\n  renameSync(oldPath: string, newPath: string): void;\n  /**\n   * Delete a file.\n   * @param path A path to the file to delete.\n   */\n  unlinkSync?(path: string): void;\n}\n/**\n * Get a platform-independent rotating file sink.\n *\n * This sink writes log records to a file, and rotates the file when it reaches\n * the `maxSize`.  The rotated files are named with the original file name\n * followed by a dot and a number, starting from 1.  The number is incremented\n * for each rotation, and the maximum number of files to keep is `maxFiles`.\n *\n * @param path A path to the file to write to.\n * @param options The options for the sink and the file driver.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed. If `nonBlocking` is enabled,\n *          returns a sink that also implements {@link AsyncDisposable}.\n */\n//#endregion\nexport { AsyncFileSinkDriver, AsyncRotatingFileSinkDriver, FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };\n//# sourceMappingURL=filesink.base.d.ts.map"],"mappings":";;;;;AA6E2D;;;UAtEjDE,eAAAA,SAAwBD,iBAuGQQ,CAAAA;EAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAApCD,uBAAAA,SAAgCC,KAAKP"}

package/dist/dist/filesink.node.d.cts

@@ -0,0 +1,65 @@
+import { FileSinkOptions, RotatingFileSinkOptions } from "./filesink.base.cjs";
+import { TimeRotatingFileSinkOptions } from "./timefilesink.cjs";
+import { Sink } from "@logtape/logtape";
+
+//#region dist/filesink.node.d.ts
+
+/**
+ * Get a file sink.
+ *
+ * Note that this function is unavailable in the browser.
+ *
+ * @param path A path to the file to write to.
+ * @param options The options for the sink.
+ * @returns A sink that writes to the file.  The sink is also a disposable
+ *          object that closes the file when disposed. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link AsyncDisposable}.
+ */
+declare function getFileSink(path: string, options?: FileSinkOptions): Sink & Disposable;
+declare function getFileSink(path: string, options: FileSinkOptions & {
+  nonBlocking: true;
+}): Sink & AsyncDisposable;
+/**
+ * Get a rotating file sink.
+ *
+ * This sink writes log records to a file, and rotates the file when it reaches
+ * the `maxSize`.  The rotated files are named with the original file name
+ * followed by a dot and a number, starting from 1.  The number is incremented
+ * for each rotation, and the maximum number of files to keep is `maxFiles`.
+ *
+ * Note that this function is unavailable in the browser.
+ *
+ * @param path A path to the file to write to.
+ * @param options The options for the sink and the file driver.
+ * @returns A sink that writes to the file.  The sink is also a disposable
+ *          object that closes the file when disposed. If `nonBlocking` is enabled,
+ *          returns a sink that also implements {@link AsyncDisposable}.
+ */
+declare function getRotatingFileSink(path: string, options?: RotatingFileSinkOptions): Sink & Disposable;
+declare function getRotatingFileSink(path: string, options: RotatingFileSinkOptions & {
+  nonBlocking: true;
+}): Sink & AsyncDisposable;
+/**
+ * Get a time-rotating file sink.
+ *
+ * This sink writes log records to a file in a directory, rotating to a new
+ * file based on time intervals.  The filename is generated based on the
+ * current date/time and the configured interval.
+ *
+ * Note that this function is unavailable in the browser.
+ *
+ * @param options The options for the sink.
+ * @returns A sink that writes to the file.  The sink is also a disposable
+ *          object that closes the file when disposed. If `nonBlocking` is
+ *          enabled, returns a sink that also implements {@link AsyncDisposable}.
+ * @since 2.0.0
+ */
+declare function getTimeRotatingFileSink(options: TimeRotatingFileSinkOptions): Sink & Disposable;
+declare function getTimeRotatingFileSink(options: TimeRotatingFileSinkOptions & {
+  nonBlocking: true;
+}): Sink & AsyncDisposable;
+//# sourceMappingURL=filesink.node.d.ts.map
+//#endregion
+//#endregion
+export { getFileSink, getRotatingFileSink, getTimeRotatingFileSink };
+//# sourceMappingURL=filesink.node.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filesink.node.d.cts","names":["AsyncRotatingFileSinkDriver","FileSinkOptions","RotatingFileSinkDriver","RotatingFileSinkOptions","AsyncTimeRotatingFileSinkDriver","TimeRotatingFileSinkDriver","TimeRotatingFileSinkOptions","Sink","nodeDriver","nodeAsyncDriver","nodeTimeDriver","nodeAsyncTimeDriver","getFileSink","Disposable","AsyncDisposable","getRotatingFileSink","getTimeRotatingFileSink"],"sources":["../filesink.node.d.ts"],"sourcesContent":["import { AsyncRotatingFileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions } from \"./filesink.base.js\";\nimport { AsyncTimeRotatingFileSinkDriver, TimeRotatingFileSinkDriver, TimeRotatingFileSinkOptions } from \"./timefilesink.js\";\nimport { Sink } from \"@logtape/logtape\";\n\n//#region src/filesink.node.d.ts\n\n/**\n * A Node.js-specific file sink driver.\n */\ndeclare const nodeDriver: RotatingFileSinkDriver<number | void>;\n/**\n * A Node.js-specific async file sink driver.\n * @since 1.0.0\n */\ndeclare const nodeAsyncDriver: AsyncRotatingFileSinkDriver<number | void>;\n/**\n * A Node.js-specific time-rotating file sink driver.\n * @since 2.0.0\n */\ndeclare const nodeTimeDriver: TimeRotatingFileSinkDriver<number | void>;\n/**\n * A Node.js-specific async time-rotating file sink driver.\n * @since 2.0.0\n */\ndeclare const nodeAsyncTimeDriver: AsyncTimeRotatingFileSinkDriver<number | void>;\n/**\n * Get a file sink.\n *\n * Note that this function is unavailable in the browser.\n *\n * @param path A path to the file to write to.\n * @param options The options for the sink.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed. If `nonBlocking` is enabled,\n *          returns a sink that also implements {@link AsyncDisposable}.\n */\ndeclare function getFileSink(path: string, options?: FileSinkOptions): Sink & Disposable;\ndeclare function getFileSink(path: string, options: FileSinkOptions & {\n  nonBlocking: true;\n}): Sink & AsyncDisposable;\n/**\n * Get a rotating file sink.\n *\n * This sink writes log records to a file, and rotates the file when it reaches\n * the `maxSize`.  The rotated files are named with the original file name\n * followed by a dot and a number, starting from 1.  The number is incremented\n * for each rotation, and the maximum number of files to keep is `maxFiles`.\n *\n * Note that this function is unavailable in the browser.\n *\n * @param path A path to the file to write to.\n * @param options The options for the sink and the file driver.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed. If `nonBlocking` is enabled,\n *          returns a sink that also implements {@link AsyncDisposable}.\n */\ndeclare function getRotatingFileSink(path: string, options?: RotatingFileSinkOptions): Sink & Disposable;\ndeclare function getRotatingFileSink(path: string, options: RotatingFileSinkOptions & {\n  nonBlocking: true;\n}): Sink & AsyncDisposable;\n/**\n * Get a time-rotating file sink.\n *\n * This sink writes log records to a file in a directory, rotating to a new\n * file based on time intervals.  The filename is generated based on the\n * current date/time and the configured interval.\n *\n * Note that this function is unavailable in the browser.\n *\n * @param options The options for the sink.\n * @returns A sink that writes to the file.  The sink is also a disposable\n *          object that closes the file when disposed. If `nonBlocking` is\n *          enabled, returns a sink that also implements {@link AsyncDisposable}.\n * @since 2.0.0\n */\ndeclare function getTimeRotatingFileSink(options: TimeRotatingFileSinkOptions): Sink & Disposable;\ndeclare function getTimeRotatingFileSink(options: TimeRotatingFileSinkOptions & {\n  nonBlocking: true;\n}): Sink & AsyncDisposable;\n//# sourceMappingURL=filesink.node.d.ts.map\n//#endregion\nexport { getFileSink, getRotatingFileSink, getTimeRotatingFileSink, nodeAsyncDriver, nodeAsyncTimeDriver, nodeDriver, nodeTimeDriver };\n//# sourceMappingURL=filesink.node.d.ts.map"],"mappings":";;;;;;;;;AA2D0B;AAAA;;;;;AAgBuE;AAAA;iBAvChFY,WAAAA,CAwCuB,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAxCaX,eAwCb,CAAA,EAxC+BM,IAwC/B,GAxCsCM,UAwCtC;iBAvCvBD,WAAAA,CAuCiCN,IAAAA,EAAAA,MAAAA,EAAAA,OAAAA,EAvCEL,eAuCFK,GAAAA;EAA2B,WAEzEC,EAAAA,IAAAA;CAAI,CAAA,EAvCJA,IAuCOO,GAvCAA,eAuCAA;AAAe;;;;;;;;;;;;;;;;iBAtBTC,mBAAAA,yBAA4CZ,0BAA0BI,OAAOM;iBAC7EE,mBAAAA,wBAA2CZ;;IAExDI,OAAOO;;;;;;;;;;;;;;;;iBAgBME,uBAAAA,UAAiCV,8BAA8BC,OAAOM;iBACtEG,uBAAAA,UAAiCV;;IAE9CC,OAAOO"}

package/dist/dist/timefilesink.d.cts

@@ -0,0 +1,41 @@
+import { FileSinkOptions } from "./filesink.base.cjs";
+
+//#region dist/timefilesink.d.ts
+
+//#region src/timefilesink.d.ts
+/**
+ * The rotation interval for time-based file sinks.
+ */
+type TimeRotationInterval = "hourly" | "daily" | "weekly";
+/**
+ * Options for the {@link getBaseTimeRotatingFileSink} function.
+ */
+interface TimeRotatingFileSinkOptions extends Omit<FileSinkOptions, "lazy"> {
+  /**
+   * The directory to write log files to.
+   */
+  directory: string;
+  /**
+   * A function that generates the filename for the log file based on the date.
+   * Default depends on `interval`:
+   * - `"daily"`: `YYYY-MM-DD.log` (e.g., `2025-01-15.log`)
+   * - `"hourly"`: `YYYY-MM-DD-HH.log` (e.g., `2025-01-15-09.log`)
+   * - `"weekly"`: `YYYY-WW.log` (e.g., `2025-W03.log`)
+   */
+  filename?: (date: Date) => string;
+  /**
+   * The rotation interval.  Defaults to `"daily"`.
+   */
+  interval?: TimeRotationInterval;
+  /**
+   * The maximum age of log files in milliseconds.  Files older than this
+   * will be deleted.  If not specified, old files are not deleted.
+   */
+  maxAgeMs?: number;
+}
+/**
+ * A platform-specific time-rotating file sink driver.
+ */
+//#endregion
+export { TimeRotatingFileSinkOptions };
+//# sourceMappingURL=timefilesink.d.cts.map

package/dist/dist/timefilesink.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timefilesink.d.cts","names":["AsyncFileSinkDriver","FileSinkDriver","FileSinkOptions","Sink","TimeRotationInterval","TimeRotatingFileSinkOptions","Date","Omit","TimeRotatingFileSinkDriver","TFile","AsyncTimeRotatingFileSinkDriver"],"sources":["../timefilesink.d.ts"],"sourcesContent":["import { AsyncFileSinkDriver, FileSinkDriver, FileSinkOptions } from \"./filesink.base.js\";\nimport { Sink } from \"@logtape/logtape\";\n\n//#region src/timefilesink.d.ts\n\n/**\n * The rotation interval for time-based file sinks.\n */\ntype TimeRotationInterval = \"hourly\" | \"daily\" | \"weekly\";\n/**\n * Options for the {@link getBaseTimeRotatingFileSink} function.\n */\ninterface TimeRotatingFileSinkOptions extends Omit<FileSinkOptions, \"lazy\"> {\n  /**\n   * The directory to write log files to.\n   */\n  directory: string;\n  /**\n   * A function that generates the filename for the log file based on the date.\n   * Default depends on `interval`:\n   * - `\"daily\"`: `YYYY-MM-DD.log` (e.g., `2025-01-15.log`)\n   * - `\"hourly\"`: `YYYY-MM-DD-HH.log` (e.g., `2025-01-15-09.log`)\n   * - `\"weekly\"`: `YYYY-WW.log` (e.g., `2025-W03.log`)\n   */\n  filename?: (date: Date) => string;\n  /**\n   * The rotation interval.  Defaults to `\"daily\"`.\n   */\n  interval?: TimeRotationInterval;\n  /**\n   * The maximum age of log files in milliseconds.  Files older than this\n   * will be deleted.  If not specified, old files are not deleted.\n   */\n  maxAgeMs?: number;\n}\n/**\n * A platform-specific time-rotating file sink driver.\n */\ninterface TimeRotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {\n  /**\n   * Read the contents of a directory.\n   * @param path A path to the directory.\n   * @returns An array of filenames in the directory.\n   */\n  readdirSync(path: string): string[];\n  /**\n   * Delete a file.\n   * @param path A path to the file to delete.\n   */\n  unlinkSync(path: string): void;\n  /**\n   * Create a directory if it doesn't exist.\n   * @param path A path to the directory to create.\n   * @param options Options for directory creation.\n   */\n  mkdirSync(path: string, options?: {\n    recursive?: boolean;\n  }): void;\n  /**\n   * Join path segments.\n   * @param paths Path segments to join.\n   * @returns The joined path.\n   */\n  joinPath(...paths: string[]): string;\n}\n/**\n * A platform-specific async time-rotating file sink driver.\n * @since 2.0.0\n */\ninterface AsyncTimeRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile> {\n  /**\n   * Read the contents of a directory.\n   * @param path A path to the directory.\n   * @returns An array of filenames in the directory.\n   */\n  readdirSync(path: string): string[];\n  /**\n   * Delete a file.\n   * @param path A path to the file to delete.\n   */\n  unlinkSync(path: string): void;\n  /**\n   * Create a directory if it doesn't exist.\n   * @param path A path to the directory to create.\n   * @param options Options for directory creation.\n   */\n  mkdirSync(path: string, options?: {\n    recursive?: boolean;\n  }): void;\n  /**\n   * Join path segments.\n   * @param paths Path segments to join.\n   * @returns The joined path.\n   */\n  joinPath(...paths: string[]): string;\n}\n/**\n * Get the ISO week number of a date.\n * @param date The date to get the week number of.\n * @returns The ISO week number (1-53).\n */\n//#endregion\nexport { AsyncTimeRotatingFileSinkDriver, TimeRotatingFileSinkDriver, TimeRotatingFileSinkOptions, TimeRotationInterval };\n//# sourceMappingURL=timefilesink.d.ts.map"],"mappings":";;;;AACwC;;;;KAOnCI,oBAAAA,GAoBQA,QAAAA,GAAAA,OAAAA,GAAAA,QAAAA;;AAhBqC;;UAAxCC,2BAAAA,SAAoCE,KAAKL;;;;;;;;;;;;oBAY/BI;;;;aAIPF"}

package/dist/filesink.base.cjs

@@ -2,6 +2,9 @@ const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
 
 //#region src/filesink.base.ts
+function isMetaLoggerRecord(record) {
+	return record.category.length === 2 && record.category[0] === "logtape" && record.category[1] === "meta";
+}
 /**
 * Adaptive flush strategy that dynamically adjusts buffer thresholds
 * based on recent flush patterns for optimal performance.
@@ -13,8 +16,10 @@ var AdaptiveFlushStrategy = class {
 	avgFlushInterval;
 	maxHistorySize = 10;
 	baseThreshold;
+	baseInterval;
 	constructor(baseThreshold, baseInterval) {
 		this.baseThreshold = baseThreshold;
+		this.baseInterval = baseInterval;
 		this.avgFlushSize = baseThreshold;
 		this.avgFlushInterval = baseInterval;
 	}
@@ -53,7 +58,8 @@ var AdaptiveFlushStrategy = class {
 		return Math.max(Math.min(4096, this.baseThreshold / 2), Math.min(64 * 1024, this.baseThreshold * adaptiveFactor));
 	}
 	calculateAdaptiveInterval() {
-		if (this.avgFlushInterval <= 0) return 0;
+		if (this.baseInterval <= 0) return 0;
+		if (this.avgFlushInterval <= 0) return this.baseInterval;
 		if (this.recentFlushTimes.length < 3) return this.avgFlushInterval;
 		const variance = this.calculateVariance(this.recentFlushTimes);
 		const stabilityFactor = Math.min(2, Math.max(.5, 1e3 / variance));
@@ -203,18 +209,22 @@ function getBaseFileSink(path, options) {
 		}
 		const sink = (record) => {
 			if (fd == null) fd = options.openSync(path);
-			if (byteBuffer.isEmpty() && bufferSize === 8192) {
-				const formattedRecord$1 = formatter(record);
-				const encodedRecord$1 = encoder.encode(formattedRecord$1);
-				if (encodedRecord$1.length < 200) {
-					options.writeSync(fd, encodedRecord$1);
+			let formattedRecord;
+			let encodedRecord;
+			if (byteBuffer.isEmpty()) {
+				formattedRecord = formatter(record);
+				encodedRecord = encoder.encode(formattedRecord);
+				if (encodedRecord.length < 200) {
+					options.writeSync(fd, encodedRecord);
 					options.flushSync(fd);
-					lastFlushTimestamp = Date.now();
+					const currentTime = Date.now();
+					adaptiveStrategy.recordFlush(encodedRecord.length, currentTime - lastFlushTimestamp);
+					lastFlushTimestamp = currentTime;
 					return;
 				}
 			}
-			const formattedRecord = formatter(record);
-			const encodedRecord = encoder.encode(formattedRecord);
+			formattedRecord ??= formatter(record);
+			encodedRecord ??= encoder.encode(formattedRecord);
 			byteBuffer.append(encodedRecord);
 			if (bufferSize <= 0) flushBuffer$1();
 			else {
@@ -236,24 +246,53 @@ function getBaseFileSink(path, options) {
 	let disposed = false;
 	let activeFlush = null;
 	let flushTimer = null;
+	let bufferedNonMetaRecord = false;
+	function reportFlushError(error) {
+		try {
+			(0, __logtape_logtape.getLogger)(["logtape", "meta"]).warn("Non-blocking file sink flush failed for {path}: {error}", {
+				error,
+				path
+			});
+		} catch {}
+	}
 	async function flushBuffer() {
 		if (fd == null || byteBuffer.isEmpty()) return;
 		const flushSize = byteBuffer.size();
 		const currentTime = Date.now();
 		const timeSinceLastFlush = currentTime - lastFlushTimestamp;
 		const chunks = byteBuffer.flush();
+		const suppressErrorReport = !bufferedNonMetaRecord;
+		bufferedNonMetaRecord = false;
 		try {
 			if (asyncOptions.writeMany && chunks.length > 1) await asyncOptions.writeMany(fd, chunks);
 			else for (const chunk of chunks) asyncOptions.writeSync(fd, chunk);
 			await asyncOptions.flush(fd);
 			adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);
 			lastFlushTimestamp = currentTime;
-		} catch {}
+		} catch (error) {
+			if (!suppressErrorReport) reportFlushError(error);
+		}
 	}
 	function scheduleFlush() {
 		if (activeFlush || disposed) return;
 		activeFlush = flushBuffer().finally(() => {
 			activeFlush = null;
+			if (!disposed && !byteBuffer.isEmpty()) scheduleFlush();
+		});
+	}
+	function scheduleDirectFlush(flushSize, suppressErrorReport) {
+		if (activeFlush || disposed || fd == null) return;
+		const flushFd = fd;
+		const startedAt = Date.now();
+		const timeSinceLastFlush = startedAt - lastFlushTimestamp;
+		activeFlush = Promise.resolve().then(() => asyncOptions.flush(flushFd)).then(() => {
+			adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);
+			lastFlushTimestamp = Date.now();
+		}).catch((error) => {
+			if (!suppressErrorReport) reportFlushError(error);
+		}).finally(() => {
+			activeFlush = null;
+			if (!disposed && !byteBuffer.isEmpty()) scheduleFlush();
 		});
 	}
 	function startFlushTimer() {
@@ -265,19 +304,21 @@ function getBaseFileSink(path, options) {
 	const nonBlockingSink = (record) => {
 		if (disposed) return;
 		if (fd == null) fd = asyncOptions.openSync(path);
-		if (byteBuffer.isEmpty() && !activeFlush && bufferSize === 8192) {
-			const formattedRecord$1 = formatter(record);
-			const encodedRecord$1 = encoder.encode(formattedRecord$1);
-			if (encodedRecord$1.length < 200) {
-				asyncOptions.writeSync(fd, encodedRecord$1);
-				scheduleFlush();
-				lastFlushTimestamp = Date.now();
+		let formattedRecord;
+		let encodedRecord;
+		if (byteBuffer.isEmpty() && !activeFlush) {
+			formattedRecord = formatter(record);
+			encodedRecord = encoder.encode(formattedRecord);
+			if (encodedRecord.length < 200) {
+				asyncOptions.writeSync(fd, encodedRecord);
+				scheduleDirectFlush(encodedRecord.length, isMetaLoggerRecord(record));
 				return;
 			}
 		}
-		const formattedRecord = formatter(record);
-		const encodedRecord = encoder.encode(formattedRecord);
+		formattedRecord ??= formatter(record);
+		encodedRecord ??= encoder.encode(formattedRecord);
 		byteBuffer.append(encodedRecord);
+		bufferedNonMetaRecord ||= !isMetaLoggerRecord(record);
 		if (bufferSize <= 0) scheduleFlush();
 		else {
 			const timeSinceLastFlush = record.timestamp - lastFlushTimestamp;
@@ -292,6 +333,7 @@ function getBaseFileSink(path, options) {
 			clearInterval(flushTimer);
 			flushTimer = null;
 		}
+		if (activeFlush !== null) await activeFlush;
 		await flushBuffer();
 		if (fd !== null) try {
 			await asyncOptions.close(fd);
@@ -300,6 +342,11 @@ function getBaseFileSink(path, options) {
 	};
 	return nonBlockingSink;
 }
+function isFileNotFoundError(error) {
+	if (!(error instanceof Error)) return false;
+	const errorWithCode = error;
+	return errorWithCode.code === "ENOENT" || error.name === "NotFound";
+}
 function getBaseRotatingFileSink(path, options) {
 	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
@@ -307,6 +354,7 @@ function getBaseRotatingFileSink(path, options) {
 	const maxFiles = options.maxFiles ?? 5;
 	const bufferSize = options.bufferSize ?? 1024 * 8;
 	const flushInterval = options.flushInterval ?? 5e3;
+	if (maxFiles <= 0 && options.unlinkSync == null) throw new TypeError("maxFiles <= 0 requires unlinkSync support.");
 	let offset = 0;
 	try {
 		const stat = options.statSync(path);
@@ -319,6 +367,27 @@ function getBaseRotatingFileSink(path, options) {
 		return offset + bytes.length > maxSize;
 	}
 	function performRollover() {
+		if (maxFiles <= 0) {
+			const unlinkSync = options.unlinkSync;
+			if (unlinkSync == null) return;
+			options.closeSync(fd);
+			try {
+				unlinkSync(path);
+			} catch (error) {
+				if (!isFileNotFoundError(error)) {
+					try {
+						offset = options.statSync(path).size;
+					} catch {
+						offset = 0;
+					}
+					fd = options.openSync(path);
+					throw error;
+				}
+			}
+			offset = 0;
+			fd = options.openSync(path);
+			return;
+		}
 		options.closeSync(fd);
 		for (let i = maxFiles - 1; i > 0; i--) {
 			const oldPath = `${path}.${i}`;
@@ -359,10 +428,21 @@ function getBaseRotatingFileSink(path, options) {
 	let disposed = false;
 	let activeFlush = null;
 	let flushTimer = null;
+	let bufferedNonMetaRecord = false;
+	function reportFlushError(error) {
+		try {
+			(0, __logtape_logtape.getLogger)(["logtape", "meta"]).warn("Non-blocking rotating file sink flush failed for {path}: {error}", {
+				error,
+				path
+			});
+		} catch {}
+	}
 	async function flushBuffer() {
 		if (buffer.length === 0) return;
 		const data = buffer;
 		buffer = "";
+		const suppressErrorReport = !bufferedNonMetaRecord;
+		bufferedNonMetaRecord = false;
 		try {
 			const bytes = encoder.encode(data);
 			if (shouldRollover(bytes)) performRollover();
@@ -370,7 +450,9 @@ function getBaseRotatingFileSink(path, options) {
 			await asyncOptions.flush(fd);
 			offset += bytes.length;
 			lastFlushTimestamp = Date.now();
-		} catch {}
+		} catch (error) {
+			if (!suppressErrorReport) reportFlushError(error);
+		}
 	}
 	function scheduleFlush() {
 		if (activeFlush || disposed) return;
@@ -387,6 +469,7 @@ function getBaseRotatingFileSink(path, options) {
 	const nonBlockingSink = (record) => {
 		if (disposed) return;
 		buffer += formatter(record);
+		bufferedNonMetaRecord ||= !isMetaLoggerRecord(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
 		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
@@ -398,6 +481,7 @@ function getBaseRotatingFileSink(path, options) {
 			clearInterval(flushTimer);
 			flushTimer = null;
 		}
+		if (activeFlush !== null) await activeFlush;
 		await flushBuffer();
 		try {
 			await asyncOptions.close(fd);

package/dist/filesink.base.d.cts

@@ -136,6 +136,11 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
    * @param newPath A path to be renamed to.
    */
   renameSync(oldPath: string, newPath: string): void;
+  /**
+   * Delete a file.
+   * @param path A path to the file to delete.
+   */
+  unlinkSync?(path: string): void;
 }
 /**
  * A platform-specific async rotating file sink driver.
@@ -156,6 +161,11 @@ interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile>
    * @param newPath A path to be renamed to.
    */
   renameSync(oldPath: string, newPath: string): void;
+  /**
+   * Delete a file.
+   * @param path A path to the file to delete.
+   */
+  unlinkSync?(path: string): void;
 }
 /**
  * Get a platform-independent rotating file sink.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../src/filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAqQA;AAuCiB,UAvCA,eAAA,SAAwB,iBAuCV,CAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;;;AAoBnB;AAQrB;;EAAoC,UAA+B,CAAA,EAAA,MAAA;EAAK;;;;;;;EAmB7C,aAnByB,CAAA,EAAA,MAAA;EAAc;AAgQlE;;;;AAAqD;AAerD;;EAAuC,WAA+B,CAAA,EAAA,OAAA;;AAAD;AAoBrE;;;AACU,UA5UO,cA4UP,CAAA,KAAA,CAAA,CAAA;EAAmB;;;;0BAvUH;;;;;;gBAOV,cAAc;;;;;;;qBAQT,eAAe;;;;;gBAMpB;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;;;iBAOlD,eAAe,eAAe;;;;;YAMnC,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA6OH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;UAoBrD,2CACP,oBAAoB"}
+{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../src/filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAgRA;AAuCiB,UAvCA,eAAA,SAAwB,iBAuCV,CAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;;;AAoBnB;AAQrB;;EAAoC,UAA+B,CAAA,EAAA,MAAA;EAAK;;;;;;;EAmB7C,aAnByB,CAAA,EAAA,MAAA;EAAc;AAiTlE;;;;AAAqD;AAerD;;EAAuC,WAA+B,CAAA,EAAA,OAAA;;AAAD;AA0BrE;;;AACU,UAnYO,cAmYP,CAAA,KAAA,CAAA,CAAA;EAAmB;;;;0BA9XH;;;;;;gBAOV,cAAc;;;;;;;qBAQT,eAAe;;;;;gBAMpB;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;;;iBAOlD,eAAe,eAAe;;;;;YAMnC,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA8RH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;UA0BrD,2CACP,oBAAoB"}

package/dist/filesink.base.d.ts

@@ -136,6 +136,11 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
    * @param newPath A path to be renamed to.
    */
   renameSync(oldPath: string, newPath: string): void;
+  /**
+   * Delete a file.
+   * @param path A path to the file to delete.
+   */
+  unlinkSync?(path: string): void;
 }
 /**
  * A platform-specific async rotating file sink driver.
@@ -156,6 +161,11 @@ interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile>
    * @param newPath A path to be renamed to.
    */
   renameSync(oldPath: string, newPath: string): void;
+  /**
+   * Delete a file.
+   * @param path A path to the file to delete.
+   */
+  unlinkSync?(path: string): void;
 }
 /**
  * Get a platform-independent rotating file sink.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../src/filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAqQA;AAuCiB,UAvCA,eAAA,SAAwB,iBAuCV,CAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;;;AAoBnB;AAQrB;;EAAoC,UAA+B,CAAA,EAAA,MAAA;EAAK;;;;;;;EAmB7C,aAnByB,CAAA,EAAA,MAAA;EAAc;AAgQlE;;;;AAAqD;AAerD;;EAAuC,WAA+B,CAAA,EAAA,OAAA;;AAAD;AAoBrE;;;AACU,UA5UO,cA4UP,CAAA,KAAA,CAAA,CAAA;EAAmB;;;;0BAvUH;;;;;;gBAOV,cAAc;;;;;;;qBAQT,eAAe;;;;;gBAMpB;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;;;iBAOlD,eAAe,eAAe;;;;;YAMnC,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA6OH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;UAoBrD,2CACP,oBAAoB"}
+{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../src/filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAgRA;AAuCiB,UAvCA,eAAA,SAAwB,iBAuCV,CAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;;;AAoBnB;AAQrB;;EAAoC,UAA+B,CAAA,EAAA,MAAA;EAAK;;;;;;;EAmB7C,aAnByB,CAAA,EAAA,MAAA;EAAc;AAiTlE;;;;AAAqD;AAerD;;EAAuC,WAA+B,CAAA,EAAA,OAAA;;AAAD;AA0BrE;;;AACU,UAnYO,cAmYP,CAAA,KAAA,CAAA,CAAA;EAAmB;;;;0BA9XH;;;;;;gBAOV,cAAc;;;;;;;qBAQT,eAAe;;;;;gBAMpB;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;;;iBAOlD,eAAe,eAAe;;;;;YAMnC,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA8RH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;UA0BrD,2CACP,oBAAoB"}