@logtape/file 1.1.0-dev.321 → 1.1.0-dev.323

package/deno.json

@@ -1,10 +1,10 @@
 {
   "name": "@logtape/file",
-  "version": "1.1.0-dev.321+fda84317",
+  "version": "1.1.0-dev.323+146f8194",
   "license": "MIT",
-  "exports": "./mod.ts",
+  "exports": "./src/mod.ts",
   "imports": {
-    "#filesink": "./filesink.jsr.ts"
+    "#filesink": "./src/filesink.jsr.ts"
   },
   "exclude": [
     "coverage/",

package/dist/filesink.base.cjs

@@ -1,7 +1,7 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
 
-//#region filesink.base.ts
+//#region src/filesink.base.ts
 /**
 * Adaptive flush strategy that dynamically adjusts buffer thresholds
 * based on recent flush patterns for optimal performance.

package/dist/filesink.base.d.cts

@@ -1,6 +1,6 @@
 import { Sink, StreamSinkOptions } from "@logtape/logtape";
 
-//#region filesink.base.d.ts
+//#region src/filesink.base.d.ts
 
 /**
  * Options for the {@link getBaseFileSink} function.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAqQA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;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;CAAK;AAAN;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":";;;;;;AAqQA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;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;CAAK;AAAN;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"}

package/dist/filesink.base.d.ts

@@ -1,6 +1,6 @@
 import { Sink, StreamSinkOptions } from "@logtape/logtape";
 
-//#region filesink.base.d.ts
+//#region src/filesink.base.d.ts
 
 /**
  * Options for the {@link getBaseFileSink} function.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAqQA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;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;CAAK;AAAN;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":";;;;;;AAqQA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;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;CAAK;AAAN;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"}

package/dist/filesink.base.js

@@ -1,6 +1,6 @@
 import { defaultTextFormatter } from "@logtape/logtape";
 
-//#region filesink.base.ts
+//#region src/filesink.base.ts
 /**
 * Adaptive flush strategy that dynamically adjusts buffer thresholds
 * based on recent flush patterns for optimal performance.

package/dist/filesink.base.js.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.js","names":["baseThreshold: number","baseInterval: number","size: number","timeSinceLastFlush: number","currentSize: number","values: number[]","buffer: Uint8Array","bufferPool: BufferPool","data: Uint8Array","path: string","options:\n    & FileSinkOptions\n    & (FileSinkDriver<TFile> | AsyncFileSinkDriver<TFile>)","lastFlushTimestamp: number","flushBuffer","sink: Sink & Disposable","record: LogRecord","formattedRecord","encodedRecord","activeFlush: Promise<void> | null","flushTimer: ReturnType<typeof setInterval> | null","nonBlockingSink: Sink & AsyncDisposable","options:\n    & RotatingFileSinkOptions\n    & (RotatingFileSinkDriver<TFile> | AsyncRotatingFileSinkDriver<TFile>)","offset: number","buffer: string","bytes: Uint8Array"],"sources":["../filesink.base.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type StreamSinkOptions,\n} from \"@logtape/logtape\";\n\n/**\n * Adaptive flush strategy that dynamically adjusts buffer thresholds\n * based on recent flush patterns for optimal performance.\n */\nclass AdaptiveFlushStrategy {\n  private recentFlushSizes: number[] = [];\n  private recentFlushTimes: number[] = [];\n  private avgFlushSize: number;\n  private avgFlushInterval: number;\n  private readonly maxHistorySize = 10;\n  private readonly baseThreshold: number;\n\n  constructor(baseThreshold: number, baseInterval: number) {\n    this.baseThreshold = baseThreshold;\n    this.avgFlushSize = baseThreshold;\n    this.avgFlushInterval = baseInterval;\n  }\n\n  /**\n   * Record a flush event for pattern analysis.\n   * @param size The size of data flushed in bytes.\n   * @param timeSinceLastFlush Time since last flush in milliseconds.\n   */\n  recordFlush(size: number, timeSinceLastFlush: number): void {\n    this.recentFlushSizes.push(size);\n    this.recentFlushTimes.push(timeSinceLastFlush);\n\n    // Keep only recent history\n    if (this.recentFlushSizes.length > this.maxHistorySize) {\n      this.recentFlushSizes.shift();\n      this.recentFlushTimes.shift();\n    }\n\n    // Update averages\n    this.updateAverages();\n  }\n\n  /**\n   * Determine if buffer should be flushed based on adaptive strategy.\n   * @param currentSize Current buffer size in bytes.\n   * @param timeSinceLastFlush Time since last flush in milliseconds.\n   * @returns True if buffer should be flushed.\n   */\n  shouldFlush(currentSize: number, timeSinceLastFlush: number): boolean {\n    const adaptiveThreshold = this.calculateAdaptiveThreshold();\n    const adaptiveInterval = this.calculateAdaptiveInterval();\n\n    return currentSize >= adaptiveThreshold ||\n      (adaptiveInterval > 0 && timeSinceLastFlush >= adaptiveInterval);\n  }\n\n  private updateAverages(): void {\n    if (this.recentFlushSizes.length === 0) return;\n\n    this.avgFlushSize =\n      this.recentFlushSizes.reduce((sum, size) => sum + size, 0) /\n      this.recentFlushSizes.length;\n\n    this.avgFlushInterval =\n      this.recentFlushTimes.reduce((sum, time) => sum + time, 0) /\n      this.recentFlushTimes.length;\n  }\n\n  private calculateAdaptiveThreshold(): number {\n    // Adjust threshold based on recent patterns\n    // Higher average flush sizes suggest larger batches are beneficial\n    const adaptiveFactor = Math.min(\n      2.0,\n      Math.max(0.5, this.avgFlushSize / this.baseThreshold),\n    );\n\n    return Math.max(\n      Math.min(4096, this.baseThreshold / 2),\n      Math.min(64 * 1024, this.baseThreshold * adaptiveFactor),\n    );\n  }\n\n  private calculateAdaptiveInterval(): number {\n    // If base interval is 0, time-based flushing is disabled\n    if (this.avgFlushInterval <= 0) return 0;\n\n    // Adjust interval based on recent flush frequency\n    // More frequent flushes suggest lower latency is preferred\n    if (this.recentFlushTimes.length < 3) return this.avgFlushInterval;\n\n    const variance = this.calculateVariance(this.recentFlushTimes);\n    const stabilityFactor = Math.min(2.0, Math.max(0.5, 1000 / variance));\n\n    return Math.max(\n      1000,\n      Math.min(10000, this.avgFlushInterval * stabilityFactor),\n    );\n  }\n\n  private calculateVariance(values: number[]): number {\n    if (values.length < 2) return 1000; // Default variance\n\n    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;\n    const squaredDiffs = values.map((val) => Math.pow(val - mean, 2));\n    return squaredDiffs.reduce((sum, diff) => sum + diff, 0) / values.length;\n  }\n}\n\n/**\n * Memory pool for reusing Uint8Array buffers to minimize GC pressure.\n * Maintains a pool of pre-allocated buffers for efficient reuse.\n */\nclass BufferPool {\n  private pool: Uint8Array[] = [];\n  private readonly maxPoolSize = 50; // Keep a reasonable pool size\n  private readonly maxBufferSize = 64 * 1024; // Don't pool very large buffers\n\n  /**\n   * Acquire a buffer from the pool or create a new one.\n   * @param size The minimum size needed for the buffer.\n   * @returns A Uint8Array that can be used for encoding.\n   */\n  acquire(size: number): Uint8Array {\n    // Don't pool very large buffers to avoid memory waste\n    if (size > this.maxBufferSize) {\n      return new Uint8Array(size);\n    }\n\n    // Try to find a suitable buffer from the pool\n    for (let i = this.pool.length - 1; i >= 0; i--) {\n      const buffer = this.pool[i];\n      if (buffer.length >= size) {\n        // Remove from pool and return\n        this.pool.splice(i, 1);\n        return buffer.subarray(0, size);\n      }\n    }\n\n    // No suitable buffer found, create a new one\n    // Create slightly larger buffer to improve reuse chances\n    const actualSize = Math.max(size, 1024); // Minimum 1KB\n    return new Uint8Array(actualSize);\n  }\n\n  /**\n   * Return a buffer to the pool for future reuse.\n   * @param buffer The buffer to return to the pool.\n   */\n  release(buffer: Uint8Array): void {\n    // Don't pool if we're at capacity or buffer is too large\n    if (\n      this.pool.length >= this.maxPoolSize || buffer.length > this.maxBufferSize\n    ) {\n      return;\n    }\n\n    // Don't pool very small buffers as they're cheap to allocate\n    if (buffer.length < 256) {\n      return;\n    }\n\n    // Add to pool for reuse\n    this.pool.push(buffer);\n  }\n\n  /**\n   * Clear the pool to free memory. Useful for cleanup.\n   */\n  clear(): void {\n    this.pool.length = 0;\n  }\n\n  /**\n   * Get current pool statistics for monitoring.\n   * @returns Object with pool size and buffer count.\n   */\n  getStats(): { poolSize: number; totalBuffers: number } {\n    return {\n      poolSize: this.pool.reduce((sum, buf) => sum + buf.length, 0),\n      totalBuffers: this.pool.length,\n    };\n  }\n}\n\n/**\n * High-performance byte buffer for batching log records.\n * Eliminates string concatenation overhead by storing pre-encoded bytes.\n * Uses memory pooling to reduce GC pressure.\n */\nclass ByteRingBuffer {\n  private buffers: Uint8Array[] = [];\n  private totalSize: number = 0;\n  private bufferPool: BufferPool;\n\n  constructor(bufferPool: BufferPool) {\n    this.bufferPool = bufferPool;\n  }\n\n  /**\n   * Append pre-encoded log record bytes to the buffer.\n   * @param data The encoded log record as bytes.\n   */\n  append(data: Uint8Array): void {\n    this.buffers.push(data);\n    this.totalSize += data.length;\n  }\n\n  /**\n   * Get the current total size of buffered data in bytes.\n   * @returns The total size in bytes.\n   */\n  size(): number {\n    return this.totalSize;\n  }\n\n  /**\n   * Get the number of buffered records.\n   * @returns The number of records in the buffer.\n   */\n  count(): number {\n    return this.buffers.length;\n  }\n\n  /**\n   * Flush all buffered data and return it as an array of byte arrays.\n   * This clears the internal buffer and returns used buffers to the pool.\n   * @returns Array of buffered byte arrays ready for writev() operations.\n   */\n  flush(): Uint8Array[] {\n    const result = [...this.buffers];\n    this.clear();\n    return result;\n  }\n\n  /**\n   * Clear the buffer without returning data.\n   * Returns buffers to the pool for reuse.\n   */\n  clear(): void {\n    // Return buffers to pool for reuse\n    for (const buffer of this.buffers) {\n      this.bufferPool.release(buffer);\n    }\n    this.buffers.length = 0;\n    this.totalSize = 0;\n  }\n\n  /**\n   * Check if the buffer is empty.\n   * @returns True if the buffer contains no data.\n   */\n  isEmpty(): boolean {\n    return this.buffers.length === 0;\n  }\n}\n\n/**\n * Options for the {@link getBaseFileSink} function.\n */\nexport type FileSinkOptions = StreamSinkOptions & {\n  /**\n   * If `true`, the file is not opened until the first write.  Defaults to `false`.\n   */\n  lazy?: boolean;\n\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  /**\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  /**\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/**\n * A platform-specific file sink driver.\n * @template TFile The type of the file descriptor.\n */\nexport interface 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  /**\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  /**\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  /**\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  /**\n   * Close the file.\n   * @param fd The file descriptor.\n   */\n  closeSync(fd: TFile): void;\n}\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 */\nexport interface 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  /**\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  /**\n   * Asynchronously close the file.\n   * @param fd The file descriptor.\n   */\n  close(fd: TFile): Promise<void>;\n}\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 */\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options: FileSinkOptions & FileSinkDriver<TFile>,\n): Sink & Disposable;\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options: FileSinkOptions & AsyncFileSinkDriver<TFile>,\n): Sink & AsyncDisposable;\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options:\n    & FileSinkOptions\n    & (FileSinkDriver<TFile> | AsyncFileSinkDriver<TFile>),\n): Sink & (Disposable | AsyncDisposable) {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 bytes\n  const flushInterval = options.flushInterval ?? 5000; // Default flush interval of 5 seconds\n  let fd = options.lazy ? null : options.openSync(path);\n\n  // Initialize memory pool and buffer systems\n  const bufferPool = new BufferPool();\n  const byteBuffer = new ByteRingBuffer(bufferPool);\n  const adaptiveStrategy = new AdaptiveFlushStrategy(bufferSize, flushInterval);\n  let lastFlushTimestamp: number = Date.now();\n\n  if (!options.nonBlocking) {\n    // Blocking mode implementation\n    // deno-lint-ignore no-inner-declarations\n    function flushBuffer(): void {\n      if (fd == null || byteBuffer.isEmpty()) return;\n\n      const flushSize = byteBuffer.size();\n      const currentTime = Date.now();\n      const timeSinceLastFlush = currentTime - lastFlushTimestamp;\n\n      const chunks = byteBuffer.flush();\n      if (options.writeManySync && chunks.length > 1) {\n        // Use batch write if available\n        options.writeManySync(fd, chunks);\n      } else {\n        // Fallback to individual writes\n        for (const chunk of chunks) {\n          options.writeSync(fd, chunk);\n        }\n      }\n      options.flushSync(fd);\n\n      // Record flush for adaptive strategy\n      adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);\n      lastFlushTimestamp = currentTime;\n    }\n\n    const sink: Sink & Disposable = (record: LogRecord) => {\n      if (fd == null) fd = options.openSync(path);\n\n      // ULTRA FAST PATH: Direct write when buffer is empty and using default buffer settings\n      if (byteBuffer.isEmpty() && bufferSize === 8192) {\n        // Inline everything for maximum speed - avoid all function calls\n        const formattedRecord = formatter(record);\n        const encodedRecord = encoder.encode(formattedRecord);\n\n        // Only use fast path for typical log sizes to avoid breaking edge cases\n        if (encodedRecord.length < 200) {\n          // Write directly for small logs - no complex buffering logic\n          options.writeSync(fd, encodedRecord);\n          options.flushSync(fd);\n          lastFlushTimestamp = Date.now();\n          return;\n        }\n      }\n\n      // STANDARD PATH: Complex logic for edge cases\n      const formattedRecord = formatter(record);\n      const encodedRecord = encoder.encode(formattedRecord);\n      byteBuffer.append(encodedRecord);\n\n      // Check for immediate flush conditions\n      if (bufferSize <= 0) {\n        // No buffering - flush immediately\n        flushBuffer();\n      } else {\n        // Use adaptive strategy for intelligent flushing\n        const timeSinceLastFlush = record.timestamp - lastFlushTimestamp;\n        const shouldFlush = adaptiveStrategy.shouldFlush(\n          byteBuffer.size(),\n          timeSinceLastFlush,\n        );\n\n        if (shouldFlush) {\n          flushBuffer();\n        }\n      }\n    };\n    sink[Symbol.dispose] = () => {\n      if (fd !== null) {\n        flushBuffer();\n        options.closeSync(fd);\n      }\n      // Clean up buffer pool\n      bufferPool.clear();\n    };\n    return sink;\n  }\n\n  // Non-blocking mode implementation\n  const asyncOptions = options as AsyncFileSinkDriver<TFile>;\n  let disposed = false;\n  let activeFlush: Promise<void> | null = null;\n  let flushTimer: ReturnType<typeof setInterval> | null = null;\n\n  async function flushBuffer(): Promise<void> {\n    if (fd == null || byteBuffer.isEmpty()) return;\n\n    const flushSize = byteBuffer.size();\n    const currentTime = Date.now();\n    const timeSinceLastFlush = currentTime - lastFlushTimestamp;\n\n    const chunks = byteBuffer.flush();\n    try {\n      if (asyncOptions.writeMany && chunks.length > 1) {\n        // Use async batch write if available\n        await asyncOptions.writeMany(fd, chunks);\n      } else {\n        // Fallback to individual writes\n        for (const chunk of chunks) {\n          asyncOptions.writeSync(fd, chunk);\n        }\n      }\n      await asyncOptions.flush(fd);\n\n      // Record flush for adaptive strategy\n      adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);\n      lastFlushTimestamp = currentTime;\n    } catch {\n      // Silently ignore errors in non-blocking mode\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (activeFlush || disposed) return;\n\n    activeFlush = flushBuffer().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    if (fd == null) fd = asyncOptions.openSync(path);\n\n    // ULTRA FAST PATH: Direct write when buffer is empty and using default buffer settings\n    if (byteBuffer.isEmpty() && !activeFlush && bufferSize === 8192) {\n      // Inline everything for maximum speed - avoid all function calls\n      const formattedRecord = formatter(record);\n      const encodedRecord = encoder.encode(formattedRecord);\n\n      // Only use fast path for typical log sizes to avoid breaking edge cases\n      if (encodedRecord.length < 200) {\n        // Write directly for small logs - no complex buffering logic\n        asyncOptions.writeSync(fd, encodedRecord);\n        scheduleFlush(); // Async flush\n        lastFlushTimestamp = Date.now();\n        return;\n      }\n    }\n\n    // STANDARD PATH: Complex logic for edge cases\n    const formattedRecord = formatter(record);\n    const encodedRecord = encoder.encode(formattedRecord);\n    byteBuffer.append(encodedRecord);\n\n    // Check for immediate flush conditions\n    if (bufferSize <= 0) {\n      // No buffering - flush immediately\n      scheduleFlush();\n    } else {\n      // Use adaptive strategy for intelligent flushing\n      const timeSinceLastFlush = record.timestamp - lastFlushTimestamp;\n      const shouldFlush = adaptiveStrategy.shouldFlush(\n        byteBuffer.size(),\n        timeSinceLastFlush,\n      );\n\n      if (shouldFlush) {\n        scheduleFlush();\n      } else if (flushTimer === null && flushInterval > 0) {\n        startFlushTimer();\n      }\n    }\n  };\n\n  nonBlockingSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearInterval(flushTimer);\n      flushTimer = null;\n    }\n    await flushBuffer();\n    if (fd !== null) {\n      try {\n        await asyncOptions.close(fd);\n      } catch {\n        // Writer might already be closed or errored\n      }\n    }\n    // Clean up buffer pool\n    bufferPool.clear();\n  };\n\n  return nonBlockingSink;\n}\n\n/**\n * Options for the {@link getBaseRotatingFileSink} function.\n */\nexport interface 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  /**\n   * The maximum number of files to keep.  5 by default.\n   */\n  maxFiles?: number;\n}\n\n/**\n * A platform-specific rotating file sink driver.\n */\nexport interface 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): { 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\n/**\n * A platform-specific async rotating file sink driver.\n * @since 1.0.0\n */\nexport interface AsyncRotatingFileSinkDriver<TFile>\n  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): { 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\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 */\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options: RotatingFileSinkOptions & RotatingFileSinkDriver<TFile>,\n): Sink & Disposable;\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options: RotatingFileSinkOptions & AsyncRotatingFileSinkDriver<TFile>,\n): Sink & AsyncDisposable;\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options:\n    & RotatingFileSinkOptions\n    & (RotatingFileSinkDriver<TFile> | AsyncRotatingFileSinkDriver<TFile>),\n): Sink & (Disposable | AsyncDisposable) {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const maxSize = options.maxSize ?? 1024 * 1024;\n  const maxFiles = options.maxFiles ?? 5;\n  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 chars\n  const flushInterval = options.flushInterval ?? 5000; // Default flush interval of 5 seconds\n  let offset: number = 0;\n  try {\n    const stat = options.statSync(path);\n    offset = stat.size;\n  } catch {\n    // Continue as the offset is already 0.\n  }\n  let fd = options.openSync(path);\n  let lastFlushTimestamp: number = Date.now();\n  let buffer: string = \"\";\n\n  function shouldRollover(bytes: Uint8Array): boolean {\n    return offset + bytes.length > maxSize;\n  }\n  function performRollover(): void {\n    options.closeSync(fd);\n    for (let i = maxFiles - 1; i > 0; i--) {\n      const oldPath = `${path}.${i}`;\n      const newPath = `${path}.${i + 1}`;\n      try {\n        options.renameSync(oldPath, newPath);\n      } catch (_) {\n        // Continue if the file does not exist.\n      }\n    }\n    options.renameSync(path, `${path}.1`);\n    offset = 0;\n    fd = options.openSync(path);\n  }\n\n  if (!options.nonBlocking) {\n    // Blocking mode implementation\n    // deno-lint-ignore no-inner-declarations\n    function flushBuffer(): void {\n      if (buffer.length > 0) {\n        const bytes = encoder.encode(buffer);\n        buffer = \"\";\n        if (shouldRollover(bytes)) performRollover();\n        options.writeSync(fd, bytes);\n        options.flushSync(fd);\n        offset += bytes.length;\n        lastFlushTimestamp = Date.now();\n      }\n    }\n\n    const sink: Sink & Disposable = (record: LogRecord) => {\n      buffer += formatter(record);\n\n      const shouldFlushBySize = buffer.length >= bufferSize;\n      const shouldFlushByTime = flushInterval > 0 &&\n        (record.timestamp - lastFlushTimestamp) >= flushInterval;\n\n      if (shouldFlushBySize || shouldFlushByTime) {\n        flushBuffer();\n      }\n    };\n    sink[Symbol.dispose] = () => {\n      flushBuffer();\n      options.closeSync(fd);\n    };\n    return sink;\n  }\n\n  // Non-blocking mode implementation\n  const asyncOptions = options as AsyncRotatingFileSinkDriver<TFile>;\n  let disposed = false;\n  let activeFlush: Promise<void> | null = null;\n  let flushTimer: ReturnType<typeof setInterval> | null = null;\n\n  async function flushBuffer(): Promise<void> {\n    if (buffer.length === 0) return;\n\n    const data = buffer;\n    buffer = \"\";\n    try {\n      const bytes = encoder.encode(data);\n      if (shouldRollover(bytes)) performRollover();\n      asyncOptions.writeSync(fd, bytes);\n      await asyncOptions.flush(fd);\n      offset += bytes.length;\n      lastFlushTimestamp = Date.now();\n    } catch {\n      // Silently ignore errors in non-blocking mode\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (activeFlush || disposed) return;\n\n    activeFlush = flushBuffer().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    buffer += formatter(record);\n\n    const shouldFlushBySize = buffer.length >= bufferSize;\n    const shouldFlushByTime = flushInterval > 0 &&\n      (record.timestamp - lastFlushTimestamp) >= flushInterval;\n\n    if (shouldFlushBySize || shouldFlushByTime) {\n      scheduleFlush();\n    } else if (flushTimer === null && flushInterval > 0) {\n      startFlushTimer();\n    }\n  };\n\n  nonBlockingSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearInterval(flushTimer);\n      flushTimer = null;\n    }\n    await flushBuffer();\n    try {\n      await asyncOptions.close(fd);\n    } catch {\n      // Writer might already be closed or errored\n    }\n  };\n\n  return nonBlockingSink;\n}\n"],"mappings":"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"}
+{"version":3,"file":"filesink.base.js","names":["baseThreshold: number","baseInterval: number","size: number","timeSinceLastFlush: number","currentSize: number","values: number[]","buffer: Uint8Array","bufferPool: BufferPool","data: Uint8Array","path: string","options:\n    & FileSinkOptions\n    & (FileSinkDriver<TFile> | AsyncFileSinkDriver<TFile>)","lastFlushTimestamp: number","flushBuffer","sink: Sink & Disposable","record: LogRecord","formattedRecord","encodedRecord","activeFlush: Promise<void> | null","flushTimer: ReturnType<typeof setInterval> | null","nonBlockingSink: Sink & AsyncDisposable","options:\n    & RotatingFileSinkOptions\n    & (RotatingFileSinkDriver<TFile> | AsyncRotatingFileSinkDriver<TFile>)","offset: number","buffer: string","bytes: Uint8Array"],"sources":["../src/filesink.base.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type StreamSinkOptions,\n} from \"@logtape/logtape\";\n\n/**\n * Adaptive flush strategy that dynamically adjusts buffer thresholds\n * based on recent flush patterns for optimal performance.\n */\nclass AdaptiveFlushStrategy {\n  private recentFlushSizes: number[] = [];\n  private recentFlushTimes: number[] = [];\n  private avgFlushSize: number;\n  private avgFlushInterval: number;\n  private readonly maxHistorySize = 10;\n  private readonly baseThreshold: number;\n\n  constructor(baseThreshold: number, baseInterval: number) {\n    this.baseThreshold = baseThreshold;\n    this.avgFlushSize = baseThreshold;\n    this.avgFlushInterval = baseInterval;\n  }\n\n  /**\n   * Record a flush event for pattern analysis.\n   * @param size The size of data flushed in bytes.\n   * @param timeSinceLastFlush Time since last flush in milliseconds.\n   */\n  recordFlush(size: number, timeSinceLastFlush: number): void {\n    this.recentFlushSizes.push(size);\n    this.recentFlushTimes.push(timeSinceLastFlush);\n\n    // Keep only recent history\n    if (this.recentFlushSizes.length > this.maxHistorySize) {\n      this.recentFlushSizes.shift();\n      this.recentFlushTimes.shift();\n    }\n\n    // Update averages\n    this.updateAverages();\n  }\n\n  /**\n   * Determine if buffer should be flushed based on adaptive strategy.\n   * @param currentSize Current buffer size in bytes.\n   * @param timeSinceLastFlush Time since last flush in milliseconds.\n   * @returns True if buffer should be flushed.\n   */\n  shouldFlush(currentSize: number, timeSinceLastFlush: number): boolean {\n    const adaptiveThreshold = this.calculateAdaptiveThreshold();\n    const adaptiveInterval = this.calculateAdaptiveInterval();\n\n    return currentSize >= adaptiveThreshold ||\n      (adaptiveInterval > 0 && timeSinceLastFlush >= adaptiveInterval);\n  }\n\n  private updateAverages(): void {\n    if (this.recentFlushSizes.length === 0) return;\n\n    this.avgFlushSize =\n      this.recentFlushSizes.reduce((sum, size) => sum + size, 0) /\n      this.recentFlushSizes.length;\n\n    this.avgFlushInterval =\n      this.recentFlushTimes.reduce((sum, time) => sum + time, 0) /\n      this.recentFlushTimes.length;\n  }\n\n  private calculateAdaptiveThreshold(): number {\n    // Adjust threshold based on recent patterns\n    // Higher average flush sizes suggest larger batches are beneficial\n    const adaptiveFactor = Math.min(\n      2.0,\n      Math.max(0.5, this.avgFlushSize / this.baseThreshold),\n    );\n\n    return Math.max(\n      Math.min(4096, this.baseThreshold / 2),\n      Math.min(64 * 1024, this.baseThreshold * adaptiveFactor),\n    );\n  }\n\n  private calculateAdaptiveInterval(): number {\n    // If base interval is 0, time-based flushing is disabled\n    if (this.avgFlushInterval <= 0) return 0;\n\n    // Adjust interval based on recent flush frequency\n    // More frequent flushes suggest lower latency is preferred\n    if (this.recentFlushTimes.length < 3) return this.avgFlushInterval;\n\n    const variance = this.calculateVariance(this.recentFlushTimes);\n    const stabilityFactor = Math.min(2.0, Math.max(0.5, 1000 / variance));\n\n    return Math.max(\n      1000,\n      Math.min(10000, this.avgFlushInterval * stabilityFactor),\n    );\n  }\n\n  private calculateVariance(values: number[]): number {\n    if (values.length < 2) return 1000; // Default variance\n\n    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;\n    const squaredDiffs = values.map((val) => Math.pow(val - mean, 2));\n    return squaredDiffs.reduce((sum, diff) => sum + diff, 0) / values.length;\n  }\n}\n\n/**\n * Memory pool for reusing Uint8Array buffers to minimize GC pressure.\n * Maintains a pool of pre-allocated buffers for efficient reuse.\n */\nclass BufferPool {\n  private pool: Uint8Array[] = [];\n  private readonly maxPoolSize = 50; // Keep a reasonable pool size\n  private readonly maxBufferSize = 64 * 1024; // Don't pool very large buffers\n\n  /**\n   * Acquire a buffer from the pool or create a new one.\n   * @param size The minimum size needed for the buffer.\n   * @returns A Uint8Array that can be used for encoding.\n   */\n  acquire(size: number): Uint8Array {\n    // Don't pool very large buffers to avoid memory waste\n    if (size > this.maxBufferSize) {\n      return new Uint8Array(size);\n    }\n\n    // Try to find a suitable buffer from the pool\n    for (let i = this.pool.length - 1; i >= 0; i--) {\n      const buffer = this.pool[i];\n      if (buffer.length >= size) {\n        // Remove from pool and return\n        this.pool.splice(i, 1);\n        return buffer.subarray(0, size);\n      }\n    }\n\n    // No suitable buffer found, create a new one\n    // Create slightly larger buffer to improve reuse chances\n    const actualSize = Math.max(size, 1024); // Minimum 1KB\n    return new Uint8Array(actualSize);\n  }\n\n  /**\n   * Return a buffer to the pool for future reuse.\n   * @param buffer The buffer to return to the pool.\n   */\n  release(buffer: Uint8Array): void {\n    // Don't pool if we're at capacity or buffer is too large\n    if (\n      this.pool.length >= this.maxPoolSize || buffer.length > this.maxBufferSize\n    ) {\n      return;\n    }\n\n    // Don't pool very small buffers as they're cheap to allocate\n    if (buffer.length < 256) {\n      return;\n    }\n\n    // Add to pool for reuse\n    this.pool.push(buffer);\n  }\n\n  /**\n   * Clear the pool to free memory. Useful for cleanup.\n   */\n  clear(): void {\n    this.pool.length = 0;\n  }\n\n  /**\n   * Get current pool statistics for monitoring.\n   * @returns Object with pool size and buffer count.\n   */\n  getStats(): { poolSize: number; totalBuffers: number } {\n    return {\n      poolSize: this.pool.reduce((sum, buf) => sum + buf.length, 0),\n      totalBuffers: this.pool.length,\n    };\n  }\n}\n\n/**\n * High-performance byte buffer for batching log records.\n * Eliminates string concatenation overhead by storing pre-encoded bytes.\n * Uses memory pooling to reduce GC pressure.\n */\nclass ByteRingBuffer {\n  private buffers: Uint8Array[] = [];\n  private totalSize: number = 0;\n  private bufferPool: BufferPool;\n\n  constructor(bufferPool: BufferPool) {\n    this.bufferPool = bufferPool;\n  }\n\n  /**\n   * Append pre-encoded log record bytes to the buffer.\n   * @param data The encoded log record as bytes.\n   */\n  append(data: Uint8Array): void {\n    this.buffers.push(data);\n    this.totalSize += data.length;\n  }\n\n  /**\n   * Get the current total size of buffered data in bytes.\n   * @returns The total size in bytes.\n   */\n  size(): number {\n    return this.totalSize;\n  }\n\n  /**\n   * Get the number of buffered records.\n   * @returns The number of records in the buffer.\n   */\n  count(): number {\n    return this.buffers.length;\n  }\n\n  /**\n   * Flush all buffered data and return it as an array of byte arrays.\n   * This clears the internal buffer and returns used buffers to the pool.\n   * @returns Array of buffered byte arrays ready for writev() operations.\n   */\n  flush(): Uint8Array[] {\n    const result = [...this.buffers];\n    this.clear();\n    return result;\n  }\n\n  /**\n   * Clear the buffer without returning data.\n   * Returns buffers to the pool for reuse.\n   */\n  clear(): void {\n    // Return buffers to pool for reuse\n    for (const buffer of this.buffers) {\n      this.bufferPool.release(buffer);\n    }\n    this.buffers.length = 0;\n    this.totalSize = 0;\n  }\n\n  /**\n   * Check if the buffer is empty.\n   * @returns True if the buffer contains no data.\n   */\n  isEmpty(): boolean {\n    return this.buffers.length === 0;\n  }\n}\n\n/**\n * Options for the {@link getBaseFileSink} function.\n */\nexport type FileSinkOptions = StreamSinkOptions & {\n  /**\n   * If `true`, the file is not opened until the first write.  Defaults to `false`.\n   */\n  lazy?: boolean;\n\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  /**\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  /**\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/**\n * A platform-specific file sink driver.\n * @template TFile The type of the file descriptor.\n */\nexport interface 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  /**\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  /**\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  /**\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  /**\n   * Close the file.\n   * @param fd The file descriptor.\n   */\n  closeSync(fd: TFile): void;\n}\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 */\nexport interface 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  /**\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  /**\n   * Asynchronously close the file.\n   * @param fd The file descriptor.\n   */\n  close(fd: TFile): Promise<void>;\n}\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 */\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options: FileSinkOptions & FileSinkDriver<TFile>,\n): Sink & Disposable;\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options: FileSinkOptions & AsyncFileSinkDriver<TFile>,\n): Sink & AsyncDisposable;\nexport function getBaseFileSink<TFile>(\n  path: string,\n  options:\n    & FileSinkOptions\n    & (FileSinkDriver<TFile> | AsyncFileSinkDriver<TFile>),\n): Sink & (Disposable | AsyncDisposable) {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 bytes\n  const flushInterval = options.flushInterval ?? 5000; // Default flush interval of 5 seconds\n  let fd = options.lazy ? null : options.openSync(path);\n\n  // Initialize memory pool and buffer systems\n  const bufferPool = new BufferPool();\n  const byteBuffer = new ByteRingBuffer(bufferPool);\n  const adaptiveStrategy = new AdaptiveFlushStrategy(bufferSize, flushInterval);\n  let lastFlushTimestamp: number = Date.now();\n\n  if (!options.nonBlocking) {\n    // Blocking mode implementation\n    // deno-lint-ignore no-inner-declarations\n    function flushBuffer(): void {\n      if (fd == null || byteBuffer.isEmpty()) return;\n\n      const flushSize = byteBuffer.size();\n      const currentTime = Date.now();\n      const timeSinceLastFlush = currentTime - lastFlushTimestamp;\n\n      const chunks = byteBuffer.flush();\n      if (options.writeManySync && chunks.length > 1) {\n        // Use batch write if available\n        options.writeManySync(fd, chunks);\n      } else {\n        // Fallback to individual writes\n        for (const chunk of chunks) {\n          options.writeSync(fd, chunk);\n        }\n      }\n      options.flushSync(fd);\n\n      // Record flush for adaptive strategy\n      adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);\n      lastFlushTimestamp = currentTime;\n    }\n\n    const sink: Sink & Disposable = (record: LogRecord) => {\n      if (fd == null) fd = options.openSync(path);\n\n      // ULTRA FAST PATH: Direct write when buffer is empty and using default buffer settings\n      if (byteBuffer.isEmpty() && bufferSize === 8192) {\n        // Inline everything for maximum speed - avoid all function calls\n        const formattedRecord = formatter(record);\n        const encodedRecord = encoder.encode(formattedRecord);\n\n        // Only use fast path for typical log sizes to avoid breaking edge cases\n        if (encodedRecord.length < 200) {\n          // Write directly for small logs - no complex buffering logic\n          options.writeSync(fd, encodedRecord);\n          options.flushSync(fd);\n          lastFlushTimestamp = Date.now();\n          return;\n        }\n      }\n\n      // STANDARD PATH: Complex logic for edge cases\n      const formattedRecord = formatter(record);\n      const encodedRecord = encoder.encode(formattedRecord);\n      byteBuffer.append(encodedRecord);\n\n      // Check for immediate flush conditions\n      if (bufferSize <= 0) {\n        // No buffering - flush immediately\n        flushBuffer();\n      } else {\n        // Use adaptive strategy for intelligent flushing\n        const timeSinceLastFlush = record.timestamp - lastFlushTimestamp;\n        const shouldFlush = adaptiveStrategy.shouldFlush(\n          byteBuffer.size(),\n          timeSinceLastFlush,\n        );\n\n        if (shouldFlush) {\n          flushBuffer();\n        }\n      }\n    };\n    sink[Symbol.dispose] = () => {\n      if (fd !== null) {\n        flushBuffer();\n        options.closeSync(fd);\n      }\n      // Clean up buffer pool\n      bufferPool.clear();\n    };\n    return sink;\n  }\n\n  // Non-blocking mode implementation\n  const asyncOptions = options as AsyncFileSinkDriver<TFile>;\n  let disposed = false;\n  let activeFlush: Promise<void> | null = null;\n  let flushTimer: ReturnType<typeof setInterval> | null = null;\n\n  async function flushBuffer(): Promise<void> {\n    if (fd == null || byteBuffer.isEmpty()) return;\n\n    const flushSize = byteBuffer.size();\n    const currentTime = Date.now();\n    const timeSinceLastFlush = currentTime - lastFlushTimestamp;\n\n    const chunks = byteBuffer.flush();\n    try {\n      if (asyncOptions.writeMany && chunks.length > 1) {\n        // Use async batch write if available\n        await asyncOptions.writeMany(fd, chunks);\n      } else {\n        // Fallback to individual writes\n        for (const chunk of chunks) {\n          asyncOptions.writeSync(fd, chunk);\n        }\n      }\n      await asyncOptions.flush(fd);\n\n      // Record flush for adaptive strategy\n      adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);\n      lastFlushTimestamp = currentTime;\n    } catch {\n      // Silently ignore errors in non-blocking mode\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (activeFlush || disposed) return;\n\n    activeFlush = flushBuffer().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    if (fd == null) fd = asyncOptions.openSync(path);\n\n    // ULTRA FAST PATH: Direct write when buffer is empty and using default buffer settings\n    if (byteBuffer.isEmpty() && !activeFlush && bufferSize === 8192) {\n      // Inline everything for maximum speed - avoid all function calls\n      const formattedRecord = formatter(record);\n      const encodedRecord = encoder.encode(formattedRecord);\n\n      // Only use fast path for typical log sizes to avoid breaking edge cases\n      if (encodedRecord.length < 200) {\n        // Write directly for small logs - no complex buffering logic\n        asyncOptions.writeSync(fd, encodedRecord);\n        scheduleFlush(); // Async flush\n        lastFlushTimestamp = Date.now();\n        return;\n      }\n    }\n\n    // STANDARD PATH: Complex logic for edge cases\n    const formattedRecord = formatter(record);\n    const encodedRecord = encoder.encode(formattedRecord);\n    byteBuffer.append(encodedRecord);\n\n    // Check for immediate flush conditions\n    if (bufferSize <= 0) {\n      // No buffering - flush immediately\n      scheduleFlush();\n    } else {\n      // Use adaptive strategy for intelligent flushing\n      const timeSinceLastFlush = record.timestamp - lastFlushTimestamp;\n      const shouldFlush = adaptiveStrategy.shouldFlush(\n        byteBuffer.size(),\n        timeSinceLastFlush,\n      );\n\n      if (shouldFlush) {\n        scheduleFlush();\n      } else if (flushTimer === null && flushInterval > 0) {\n        startFlushTimer();\n      }\n    }\n  };\n\n  nonBlockingSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearInterval(flushTimer);\n      flushTimer = null;\n    }\n    await flushBuffer();\n    if (fd !== null) {\n      try {\n        await asyncOptions.close(fd);\n      } catch {\n        // Writer might already be closed or errored\n      }\n    }\n    // Clean up buffer pool\n    bufferPool.clear();\n  };\n\n  return nonBlockingSink;\n}\n\n/**\n * Options for the {@link getBaseRotatingFileSink} function.\n */\nexport interface 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  /**\n   * The maximum number of files to keep.  5 by default.\n   */\n  maxFiles?: number;\n}\n\n/**\n * A platform-specific rotating file sink driver.\n */\nexport interface 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): { 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\n/**\n * A platform-specific async rotating file sink driver.\n * @since 1.0.0\n */\nexport interface AsyncRotatingFileSinkDriver<TFile>\n  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): { 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\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 */\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options: RotatingFileSinkOptions & RotatingFileSinkDriver<TFile>,\n): Sink & Disposable;\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options: RotatingFileSinkOptions & AsyncRotatingFileSinkDriver<TFile>,\n): Sink & AsyncDisposable;\nexport function getBaseRotatingFileSink<TFile>(\n  path: string,\n  options:\n    & RotatingFileSinkOptions\n    & (RotatingFileSinkDriver<TFile> | AsyncRotatingFileSinkDriver<TFile>),\n): Sink & (Disposable | AsyncDisposable) {\n  const formatter = options.formatter ?? defaultTextFormatter;\n  const encoder = options.encoder ?? new TextEncoder();\n  const maxSize = options.maxSize ?? 1024 * 1024;\n  const maxFiles = options.maxFiles ?? 5;\n  const bufferSize = options.bufferSize ?? 1024 * 8; // Default buffer size of 8192 chars\n  const flushInterval = options.flushInterval ?? 5000; // Default flush interval of 5 seconds\n  let offset: number = 0;\n  try {\n    const stat = options.statSync(path);\n    offset = stat.size;\n  } catch {\n    // Continue as the offset is already 0.\n  }\n  let fd = options.openSync(path);\n  let lastFlushTimestamp: number = Date.now();\n  let buffer: string = \"\";\n\n  function shouldRollover(bytes: Uint8Array): boolean {\n    return offset + bytes.length > maxSize;\n  }\n  function performRollover(): void {\n    options.closeSync(fd);\n    for (let i = maxFiles - 1; i > 0; i--) {\n      const oldPath = `${path}.${i}`;\n      const newPath = `${path}.${i + 1}`;\n      try {\n        options.renameSync(oldPath, newPath);\n      } catch (_) {\n        // Continue if the file does not exist.\n      }\n    }\n    options.renameSync(path, `${path}.1`);\n    offset = 0;\n    fd = options.openSync(path);\n  }\n\n  if (!options.nonBlocking) {\n    // Blocking mode implementation\n    // deno-lint-ignore no-inner-declarations\n    function flushBuffer(): void {\n      if (buffer.length > 0) {\n        const bytes = encoder.encode(buffer);\n        buffer = \"\";\n        if (shouldRollover(bytes)) performRollover();\n        options.writeSync(fd, bytes);\n        options.flushSync(fd);\n        offset += bytes.length;\n        lastFlushTimestamp = Date.now();\n      }\n    }\n\n    const sink: Sink & Disposable = (record: LogRecord) => {\n      buffer += formatter(record);\n\n      const shouldFlushBySize = buffer.length >= bufferSize;\n      const shouldFlushByTime = flushInterval > 0 &&\n        (record.timestamp - lastFlushTimestamp) >= flushInterval;\n\n      if (shouldFlushBySize || shouldFlushByTime) {\n        flushBuffer();\n      }\n    };\n    sink[Symbol.dispose] = () => {\n      flushBuffer();\n      options.closeSync(fd);\n    };\n    return sink;\n  }\n\n  // Non-blocking mode implementation\n  const asyncOptions = options as AsyncRotatingFileSinkDriver<TFile>;\n  let disposed = false;\n  let activeFlush: Promise<void> | null = null;\n  let flushTimer: ReturnType<typeof setInterval> | null = null;\n\n  async function flushBuffer(): Promise<void> {\n    if (buffer.length === 0) return;\n\n    const data = buffer;\n    buffer = \"\";\n    try {\n      const bytes = encoder.encode(data);\n      if (shouldRollover(bytes)) performRollover();\n      asyncOptions.writeSync(fd, bytes);\n      await asyncOptions.flush(fd);\n      offset += bytes.length;\n      lastFlushTimestamp = Date.now();\n    } catch {\n      // Silently ignore errors in non-blocking mode\n    }\n  }\n\n  function scheduleFlush(): void {\n    if (activeFlush || disposed) return;\n\n    activeFlush = flushBuffer().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    buffer += formatter(record);\n\n    const shouldFlushBySize = buffer.length >= bufferSize;\n    const shouldFlushByTime = flushInterval > 0 &&\n      (record.timestamp - lastFlushTimestamp) >= flushInterval;\n\n    if (shouldFlushBySize || shouldFlushByTime) {\n      scheduleFlush();\n    } else if (flushTimer === null && flushInterval > 0) {\n      startFlushTimer();\n    }\n  };\n\n  nonBlockingSink[Symbol.asyncDispose] = async () => {\n    disposed = true;\n    if (flushTimer !== null) {\n      clearInterval(flushTimer);\n      flushTimer = null;\n    }\n    await flushBuffer();\n    try {\n      await asyncOptions.close(fd);\n    } catch {\n      // Writer might already be closed or errored\n    }\n  };\n\n  return nonBlockingSink;\n}\n"],"mappings":"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"}

package/dist/filesink.deno.cjs

@@ -1,6 +1,6 @@
 const require_filesink_base = require('./filesink.base.cjs');
 
-//#region filesink.deno.ts
+//#region src/filesink.deno.ts
 /**
 * A Deno-specific file sink driver.
 */

package/dist/filesink.deno.d.cts

@@ -1,7 +1,7 @@
 import { AsyncRotatingFileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions } from "./filesink.base.cjs";
 import { Sink } from "@logtape/logtape";
 
-//#region filesink.deno.d.ts
+//#region src/filesink.deno.d.ts
 
 /**
  * A Deno-specific file sink driver.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.deno.d.cts","names":[],"sources":["../filesink.deno.ts"],"sourcesContent":[],"mappings":";;;;;;;AAaA;AAsBC,cAtBY,UAsBZ,EAtBwB,sBAsBxB,CAtB+C,IAAA,CAAK,MAsBpD,CAAA;;;AAtB8C;AA4B/C;AAeC,cAfY,eAeZ,EAf6B,2BAe7B,CAfyD,IAAA,CAAK,MAe9D,CAAA;;;AAfwD;AA4BzD;;;;;AAGoB;AACpB;;AAEW,iBANK,WAAA,CAML,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAJC,eAID,CAAA,EAHR,IAGQ,GAHD,UAGC;AACR,iBAHa,WAAA,CAGb,IAAA,EAAA,MAAA,EAAA,OAAA,EADQ,eACR,GAAA;EAAI,WAAG,EAAA,IAAA;AAAe,CAAA,CAAA,EAAtB,IAAsB,GAAf,eAAe;AA2BzB;;;;;AAGoB;AACpB;;;;;AAGyB;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}
+{"version":3,"file":"filesink.deno.d.cts","names":[],"sources":["../src/filesink.deno.ts"],"sourcesContent":[],"mappings":";;;;;;;AAaA;AAsBC,cAtBY,UAsBZ,EAtBwB,sBAsBxB,CAtB+C,IAAA,CAAK,MAsBpD,CAAA;;;AAtB8C;AA4B/C;AAeC,cAfY,eAeZ,EAf6B,2BAe7B,CAfyD,IAAA,CAAK,MAe9D,CAAA;;;AAfwD;AA4BzD;;;;;AAGoB;AACpB;;AAEW,iBANK,WAAA,CAML,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAJC,eAID,CAAA,EAHR,IAGQ,GAHD,UAGC;AACR,iBAHa,WAAA,CAGb,IAAA,EAAA,MAAA,EAAA,OAAA,EADQ,eACR,GAAA;EAAI,WAAG,EAAA,IAAA;AAAe,CAAA,CAAA,EAAtB,IAAsB,GAAf,eAAe;AA2BzB;;;;;AAGoB;AACpB;;;;;AAGyB;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}

package/dist/filesink.deno.d.ts

@@ -1,7 +1,7 @@
 import { AsyncRotatingFileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions } from "./filesink.base.js";
 import { Sink } from "@logtape/logtape";
 
-//#region filesink.deno.d.ts
+//#region src/filesink.deno.d.ts
 
 /**
  * A Deno-specific file sink driver.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.deno.d.ts","names":[],"sources":["../filesink.deno.ts"],"sourcesContent":[],"mappings":";;;;;;;AAaA;AAsBC,cAtBY,UAsBZ,EAtBwB,sBAsBxB,CAtB+C,IAAA,CAAK,MAsBpD,CAAA;;;AAtB8C;AA4B/C;AAeC,cAfY,eAeZ,EAf6B,2BAe7B,CAfyD,IAAA,CAAK,MAe9D,CAAA;;;AAfwD;AA4BzD;;;;;AAGoB;AACpB;;AAEW,iBANK,WAAA,CAML,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAJC,eAID,CAAA,EAHR,IAGQ,GAHD,UAGC;AACR,iBAHa,WAAA,CAGb,IAAA,EAAA,MAAA,EAAA,OAAA,EADQ,eACR,GAAA;EAAI,WAAG,EAAA,IAAA;AAAe,CAAA,CAAA,EAAtB,IAAsB,GAAf,eAAe;AA2BzB;;;;;AAGoB;AACpB;;;;;AAGyB;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}
+{"version":3,"file":"filesink.deno.d.ts","names":[],"sources":["../src/filesink.deno.ts"],"sourcesContent":[],"mappings":";;;;;;;AAaA;AAsBC,cAtBY,UAsBZ,EAtBwB,sBAsBxB,CAtB+C,IAAA,CAAK,MAsBpD,CAAA;;;AAtB8C;AA4B/C;AAeC,cAfY,eAeZ,EAf6B,2BAe7B,CAfyD,IAAA,CAAK,MAe9D,CAAA;;;AAfwD;AA4BzD;;;;;AAGoB;AACpB;;AAEW,iBANK,WAAA,CAML,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAJC,eAID,CAAA,EAHR,IAGQ,GAHD,UAGC;AACR,iBAHa,WAAA,CAGb,IAAA,EAAA,MAAA,EAAA,OAAA,EADQ,eACR,GAAA;EAAI,WAAG,EAAA,IAAA;AAAe,CAAA,CAAA,EAAtB,IAAsB,GAAf,eAAe;AA2BzB;;;;;AAGoB;AACpB;;;;;AAGyB;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}

package/dist/filesink.deno.js

@@ -1,6 +1,6 @@
 import { getBaseFileSink, getBaseRotatingFileSink } from "./filesink.base.js";
 
-//#region filesink.deno.ts
+//#region src/filesink.deno.ts
 /**
 * A Deno-specific file sink driver.
 */

package/dist/filesink.deno.js.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.deno.js","names":["denoDriver: RotatingFileSinkDriver<Deno.FsFile>","path: string","fd: Deno.FsFile","chunks: Uint8Array[]","denoAsyncDriver: AsyncRotatingFileSinkDriver<Deno.FsFile>","options: FileSinkOptions","options: RotatingFileSinkOptions"],"sources":["../filesink.deno.ts"],"sourcesContent":["import type { Sink } from \"@logtape/logtape\";\nimport {\n  type AsyncRotatingFileSinkDriver,\n  type FileSinkOptions,\n  getBaseFileSink,\n  getBaseRotatingFileSink,\n  type RotatingFileSinkDriver,\n  type RotatingFileSinkOptions,\n} from \"./filesink.base.ts\";\n\n/**\n * A Deno-specific file sink driver.\n */\nexport const denoDriver: RotatingFileSinkDriver<Deno.FsFile> = {\n  openSync(path: string) {\n    return Deno.openSync(path, { create: true, append: true });\n  },\n  writeSync(fd, chunk) {\n    fd.writeSync(chunk);\n  },\n  writeManySync(fd: Deno.FsFile, chunks: Uint8Array[]): void {\n    // Deno doesn't have writev, but we can optimize by writing all chunks\n    // then doing a single sync operation\n    for (const chunk of chunks) {\n      fd.writeSync(chunk);\n    }\n  },\n  flushSync(fd) {\n    fd.syncSync();\n  },\n  closeSync(fd) {\n    fd.close();\n  },\n  statSync: globalThis?.Deno.statSync,\n  renameSync: globalThis?.Deno.renameSync,\n};\n\n/**\n * A Deno-specific async file sink driver.\n * @since 1.0.0\n */\nexport const denoAsyncDriver: AsyncRotatingFileSinkDriver<Deno.FsFile> = {\n  ...denoDriver,\n  async writeMany(fd: Deno.FsFile, chunks: Uint8Array[]): Promise<void> {\n    // Deno doesn't have async writev, but we can write all chunks\n    // then do a single async sync\n    for (const chunk of chunks) {\n      await fd.write(chunk);\n    }\n  },\n  async flush(fd) {\n    await fd.sync();\n  },\n  close(fd) {\n    return Promise.resolve(fd.close());\n  },\n};\n\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 */\nexport function getFileSink(\n  path: string,\n  options?: FileSinkOptions,\n): Sink & Disposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseFileSink(path, { ...options, ...denoAsyncDriver });\n  }\n  return getBaseFileSink(path, { ...options, ...denoDriver });\n}\n\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 */\nexport function getRotatingFileSink(\n  path: string,\n  options?: RotatingFileSinkOptions,\n): Sink & Disposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseRotatingFileSink(path, { ...options, ...denoAsyncDriver });\n  }\n  return getBaseRotatingFileSink(path, { ...options, ...denoDriver });\n}\n\n// cSpell: ignore filesink\n"],"mappings":";;;;;;AAaA,MAAaA,aAAkD;CAC7D,SAASC,MAAc;AACrB,SAAO,KAAK,SAAS,MAAM;GAAE,QAAQ;GAAM,QAAQ;EAAM,EAAC;CAC3D;CACD,UAAU,IAAI,OAAO;AACnB,KAAG,UAAU,MAAM;CACpB;CACD,cAAcC,IAAiBC,QAA4B;AAGzD,OAAK,MAAM,SAAS,OAClB,IAAG,UAAU,MAAM;CAEtB;CACD,UAAU,IAAI;AACZ,KAAG,UAAU;CACd;CACD,UAAU,IAAI;AACZ,KAAG,OAAO;CACX;CACD,UAAU,YAAY,KAAK;CAC3B,YAAY,YAAY,KAAK;AAC9B;;;;;AAMD,MAAaC,kBAA4D;CACvE,GAAG;CACH,MAAM,UAAUF,IAAiBC,QAAqC;AAGpE,OAAK,MAAM,SAAS,OAClB,OAAM,GAAG,MAAM,MAAM;CAExB;CACD,MAAM,MAAM,IAAI;AACd,QAAM,GAAG,MAAM;CAChB;CACD,MAAM,IAAI;AACR,SAAO,QAAQ,QAAQ,GAAG,OAAO,CAAC;CACnC;AACF;AAqBD,SAAgB,YACdF,MACAI,UAA2B,CAAE,GACU;AACvC,KAAI,QAAQ,YACV,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAElE,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AAC5D;AA0BD,SAAgB,oBACdJ,MACAK,UAAmC,CAAE,GACE;AACvC,KAAI,QAAQ,YACV,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAE1E,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AACpE"}
+{"version":3,"file":"filesink.deno.js","names":["denoDriver: RotatingFileSinkDriver<Deno.FsFile>","path: string","fd: Deno.FsFile","chunks: Uint8Array[]","denoAsyncDriver: AsyncRotatingFileSinkDriver<Deno.FsFile>","options: FileSinkOptions","options: RotatingFileSinkOptions"],"sources":["../src/filesink.deno.ts"],"sourcesContent":["import type { Sink } from \"@logtape/logtape\";\nimport {\n  type AsyncRotatingFileSinkDriver,\n  type FileSinkOptions,\n  getBaseFileSink,\n  getBaseRotatingFileSink,\n  type RotatingFileSinkDriver,\n  type RotatingFileSinkOptions,\n} from \"./filesink.base.ts\";\n\n/**\n * A Deno-specific file sink driver.\n */\nexport const denoDriver: RotatingFileSinkDriver<Deno.FsFile> = {\n  openSync(path: string) {\n    return Deno.openSync(path, { create: true, append: true });\n  },\n  writeSync(fd, chunk) {\n    fd.writeSync(chunk);\n  },\n  writeManySync(fd: Deno.FsFile, chunks: Uint8Array[]): void {\n    // Deno doesn't have writev, but we can optimize by writing all chunks\n    // then doing a single sync operation\n    for (const chunk of chunks) {\n      fd.writeSync(chunk);\n    }\n  },\n  flushSync(fd) {\n    fd.syncSync();\n  },\n  closeSync(fd) {\n    fd.close();\n  },\n  statSync: globalThis?.Deno.statSync,\n  renameSync: globalThis?.Deno.renameSync,\n};\n\n/**\n * A Deno-specific async file sink driver.\n * @since 1.0.0\n */\nexport const denoAsyncDriver: AsyncRotatingFileSinkDriver<Deno.FsFile> = {\n  ...denoDriver,\n  async writeMany(fd: Deno.FsFile, chunks: Uint8Array[]): Promise<void> {\n    // Deno doesn't have async writev, but we can write all chunks\n    // then do a single async sync\n    for (const chunk of chunks) {\n      await fd.write(chunk);\n    }\n  },\n  async flush(fd) {\n    await fd.sync();\n  },\n  close(fd) {\n    return Promise.resolve(fd.close());\n  },\n};\n\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 */\nexport function getFileSink(\n  path: string,\n  options?: FileSinkOptions,\n): Sink & Disposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseFileSink(path, { ...options, ...denoAsyncDriver });\n  }\n  return getBaseFileSink(path, { ...options, ...denoDriver });\n}\n\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 */\nexport function getRotatingFileSink(\n  path: string,\n  options?: RotatingFileSinkOptions,\n): Sink & Disposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseRotatingFileSink(path, { ...options, ...denoAsyncDriver });\n  }\n  return getBaseRotatingFileSink(path, { ...options, ...denoDriver });\n}\n\n// cSpell: ignore filesink\n"],"mappings":";;;;;;AAaA,MAAaA,aAAkD;CAC7D,SAASC,MAAc;AACrB,SAAO,KAAK,SAAS,MAAM;GAAE,QAAQ;GAAM,QAAQ;EAAM,EAAC;CAC3D;CACD,UAAU,IAAI,OAAO;AACnB,KAAG,UAAU,MAAM;CACpB;CACD,cAAcC,IAAiBC,QAA4B;AAGzD,OAAK,MAAM,SAAS,OAClB,IAAG,UAAU,MAAM;CAEtB;CACD,UAAU,IAAI;AACZ,KAAG,UAAU;CACd;CACD,UAAU,IAAI;AACZ,KAAG,OAAO;CACX;CACD,UAAU,YAAY,KAAK;CAC3B,YAAY,YAAY,KAAK;AAC9B;;;;;AAMD,MAAaC,kBAA4D;CACvE,GAAG;CACH,MAAM,UAAUF,IAAiBC,QAAqC;AAGpE,OAAK,MAAM,SAAS,OAClB,OAAM,GAAG,MAAM,MAAM;CAExB;CACD,MAAM,MAAM,IAAI;AACd,QAAM,GAAG,MAAM;CAChB;CACD,MAAM,IAAI;AACR,SAAO,QAAQ,QAAQ,GAAG,OAAO,CAAC;CACnC;AACF;AAqBD,SAAgB,YACdF,MACAI,UAA2B,CAAE,GACU;AACvC,KAAI,QAAQ,YACV,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAElE,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AAC5D;AA0BD,SAAgB,oBACdJ,MACAK,UAAmC,CAAE,GACE;AACvC,KAAI,QAAQ,YACV,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAE1E,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AACpE"}

package/dist/filesink.node.cjs

@@ -3,7 +3,7 @@ const require_filesink_base = require('./filesink.base.cjs');
 const node_fs = require_rolldown_runtime.__toESM(require("node:fs"));
 const node_util = require_rolldown_runtime.__toESM(require("node:util"));
 
-//#region filesink.node.ts
+//#region src/filesink.node.ts
 /**
 * A Node.js-specific file sink driver.
 */

package/dist/filesink.node.d.cts

@@ -1,7 +1,7 @@
 import { AsyncRotatingFileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions } from "./filesink.base.cjs";
 import { Sink } from "@logtape/logtape";
 
-//#region filesink.node.d.ts
+//#region src/filesink.node.d.ts
 
 /**
  * A Node.js-specific file sink driver.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.node.d.cts","names":[],"sources":["../filesink.node.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;AAwBa,cAxBA,UAqCZ,EArCwB,sBAwBK,CAAA,MAA2B,GAAA,IAAA,CAAA;AA0BzD;;;;AAGU,cA7BG,eA6BH,EA7BoB,2BA6BpB,CAAA,MAAA,GAAA,IAAA,CAAA;AAAU;AACpB;;;;;AAGyB;AA2BzB;;;;AAGU,iBArCM,WAAA,CAqCN,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAnCE,eAmCF,CAAA,EAlCP,IAkCO,GAlCA,UAkCA;AAAU,iBAjCJ,WAAA,CAiCI,IAAA,EAAA,MAAA,EAAA,OAAA,EA/BT,eA+BS,GAAA;EACJ,WAAA,EAAA,IAAA;CAAmB,CAAA,EA/BhC,IA+BgC,GA/BzB,eA+ByB;;;;AAGV;;;;;;;;;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}
+{"version":3,"file":"filesink.node.d.cts","names":[],"sources":["../src/filesink.node.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;AAwBa,cAxBA,UAqCZ,EArCwB,sBAwBK,CAAA,MAA2B,GAAA,IAAA,CAAA;AA0BzD;;;;AAGU,cA7BG,eA6BH,EA7BoB,2BA6BpB,CAAA,MAAA,GAAA,IAAA,CAAA;AAAU;AACpB;;;;;AAGyB;AA2BzB;;;;AAGU,iBArCM,WAAA,CAqCN,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAnCE,eAmCF,CAAA,EAlCP,IAkCO,GAlCA,UAkCA;AAAU,iBAjCJ,WAAA,CAiCI,IAAA,EAAA,MAAA,EAAA,OAAA,EA/BT,eA+BS,GAAA;EACJ,WAAA,EAAA,IAAA;CAAmB,CAAA,EA/BhC,IA+BgC,GA/BzB,eA+ByB;;;;AAGV;;;;;;;;;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}

package/dist/filesink.node.d.ts

@@ -1,7 +1,7 @@
 import { AsyncRotatingFileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions } from "./filesink.base.js";
 import { Sink } from "@logtape/logtape";
 
-//#region filesink.node.d.ts
+//#region src/filesink.node.d.ts
 
 /**
  * A Node.js-specific file sink driver.

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

@@ -1 +1 @@
-{"version":3,"file":"filesink.node.d.ts","names":[],"sources":["../filesink.node.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;AAwBa,cAxBA,UAqCZ,EArCwB,sBAwBK,CAAA,MAA2B,GAAA,IAAA,CAAA;AA0BzD;;;;AAGU,cA7BG,eA6BH,EA7BoB,2BA6BpB,CAAA,MAAA,GAAA,IAAA,CAAA;AAAU;AACpB;;;;;AAGyB;AA2BzB;;;;AAGU,iBArCM,WAAA,CAqCN,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAnCE,eAmCF,CAAA,EAlCP,IAkCO,GAlCA,UAkCA;AAAU,iBAjCJ,WAAA,CAiCI,IAAA,EAAA,MAAA,EAAA,OAAA,EA/BT,eA+BS,GAAA;EACJ,WAAA,EAAA,IAAA;CAAmB,CAAA,EA/BhC,IA+BgC,GA/BzB,eA+ByB;;;;AAGV;;;;;;;;;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}
+{"version":3,"file":"filesink.node.d.ts","names":[],"sources":["../src/filesink.node.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;AAwBa,cAxBA,UAqCZ,EArCwB,sBAwBK,CAAA,MAA2B,GAAA,IAAA,CAAA;AA0BzD;;;;AAGU,cA7BG,eA6BH,EA7BoB,2BA6BpB,CAAA,MAAA,GAAA,IAAA,CAAA;AAAU;AACpB;;;;;AAGyB;AA2BzB;;;;AAGU,iBArCM,WAAA,CAqCN,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EAnCE,eAmCF,CAAA,EAlCP,IAkCO,GAlCA,UAkCA;AAAU,iBAjCJ,WAAA,CAiCI,IAAA,EAAA,MAAA,EAAA,OAAA,EA/BT,eA+BS,GAAA;EACJ,WAAA,EAAA,IAAA;CAAmB,CAAA,EA/BhC,IA+BgC,GA/BzB,eA+ByB;;;;AAGV;;;;;;;;;;;;;iBAPT,mBAAA,yBAEJ,0BACT,OAAO;iBACM,mBAAA,wBAEL;;IACR,OAAO"}

package/dist/filesink.node.js

@@ -2,7 +2,7 @@ import { getBaseFileSink, getBaseRotatingFileSink } from "./filesink.base.js";
 import fs from "node:fs";
 import { promisify } from "node:util";
 
-//#region filesink.node.ts
+//#region src/filesink.node.ts
 /**
 * A Node.js-specific file sink driver.
 */

package/dist/filesink.node.js.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.node.js","names":["nodeDriver: RotatingFileSinkDriver<number | void>","path: string","fd: number","chunks: Uint8Array[]","nodeAsyncDriver: AsyncRotatingFileSinkDriver<number | void>","options: FileSinkOptions","options: RotatingFileSinkOptions"],"sources":["../filesink.node.ts"],"sourcesContent":["import type { Sink } from \"@logtape/logtape\";\nimport fs from \"node:fs\";\nimport { promisify } from \"node:util\";\nimport {\n  type AsyncRotatingFileSinkDriver,\n  type FileSinkOptions,\n  getBaseFileSink,\n  getBaseRotatingFileSink,\n  type RotatingFileSinkDriver,\n  type RotatingFileSinkOptions,\n} from \"./filesink.base.ts\";\n\n/**\n * A Node.js-specific file sink driver.\n */\nexport const nodeDriver: RotatingFileSinkDriver<number | void> = {\n  openSync(path: string) {\n    return fs.openSync(path, \"a\");\n  },\n  writeSync: fs.writeSync,\n  writeManySync(fd: number, chunks: Uint8Array[]): void {\n    if (chunks.length === 0) return;\n    if (chunks.length === 1) {\n      fs.writeSync(fd, chunks[0]);\n      return;\n    }\n    // Use writev for multiple chunks\n    fs.writevSync(fd, chunks);\n  },\n  flushSync: fs.fsyncSync,\n  closeSync: fs.closeSync,\n  statSync: fs.statSync,\n  renameSync: fs.renameSync,\n};\n\n/**\n * A Node.js-specific async file sink driver.\n * @since 1.0.0\n */\nexport const nodeAsyncDriver: AsyncRotatingFileSinkDriver<number | void> = {\n  ...nodeDriver,\n  async writeMany(fd: number, chunks: Uint8Array[]): Promise<void> {\n    if (chunks.length === 0) return;\n    if (chunks.length === 1) {\n      await promisify(fs.write)(fd, chunks[0]);\n      return;\n    }\n    // Use async writev for multiple chunks\n    await promisify(fs.writev)(fd, chunks);\n  },\n  flush: promisify(fs.fsync),\n  close: promisify(fs.close),\n};\n\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 */\nexport function getFileSink(\n  path: string,\n  options?: FileSinkOptions,\n): Sink & Disposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseFileSink(path, { ...options, ...nodeAsyncDriver });\n  }\n  return getBaseFileSink(path, { ...options, ...nodeDriver });\n}\n\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 */\nexport function getRotatingFileSink(\n  path: string,\n  options?: RotatingFileSinkOptions,\n): Sink & Disposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseRotatingFileSink(path, { ...options, ...nodeAsyncDriver });\n  }\n  return getBaseRotatingFileSink(path, { ...options, ...nodeDriver });\n}\n\n// cSpell: ignore filesink\n"],"mappings":";;;;;;;;AAeA,MAAaA,aAAoD;CAC/D,SAASC,MAAc;AACrB,SAAO,GAAG,SAAS,MAAM,IAAI;CAC9B;CACD,WAAW,GAAG;CACd,cAAcC,IAAYC,QAA4B;AACpD,MAAI,OAAO,WAAW,EAAG;AACzB,MAAI,OAAO,WAAW,GAAG;AACvB,MAAG,UAAU,IAAI,OAAO,GAAG;AAC3B;EACD;AAED,KAAG,WAAW,IAAI,OAAO;CAC1B;CACD,WAAW,GAAG;CACd,WAAW,GAAG;CACd,UAAU,GAAG;CACb,YAAY,GAAG;AAChB;;;;;AAMD,MAAaC,kBAA8D;CACzE,GAAG;CACH,MAAM,UAAUF,IAAYC,QAAqC;AAC/D,MAAI,OAAO,WAAW,EAAG;AACzB,MAAI,OAAO,WAAW,GAAG;AACvB,SAAM,UAAU,GAAG,MAAM,CAAC,IAAI,OAAO,GAAG;AACxC;EACD;AAED,QAAM,UAAU,GAAG,OAAO,CAAC,IAAI,OAAO;CACvC;CACD,OAAO,UAAU,GAAG,MAAM;CAC1B,OAAO,UAAU,GAAG,MAAM;AAC3B;AAqBD,SAAgB,YACdF,MACAI,UAA2B,CAAE,GACU;AACvC,KAAI,QAAQ,YACV,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAElE,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AAC5D;AA0BD,SAAgB,oBACdJ,MACAK,UAAmC,CAAE,GACE;AACvC,KAAI,QAAQ,YACV,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAE1E,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AACpE"}
+{"version":3,"file":"filesink.node.js","names":["nodeDriver: RotatingFileSinkDriver<number | void>","path: string","fd: number","chunks: Uint8Array[]","nodeAsyncDriver: AsyncRotatingFileSinkDriver<number | void>","options: FileSinkOptions","options: RotatingFileSinkOptions"],"sources":["../src/filesink.node.ts"],"sourcesContent":["import type { Sink } from \"@logtape/logtape\";\nimport fs from \"node:fs\";\nimport { promisify } from \"node:util\";\nimport {\n  type AsyncRotatingFileSinkDriver,\n  type FileSinkOptions,\n  getBaseFileSink,\n  getBaseRotatingFileSink,\n  type RotatingFileSinkDriver,\n  type RotatingFileSinkOptions,\n} from \"./filesink.base.ts\";\n\n/**\n * A Node.js-specific file sink driver.\n */\nexport const nodeDriver: RotatingFileSinkDriver<number | void> = {\n  openSync(path: string) {\n    return fs.openSync(path, \"a\");\n  },\n  writeSync: fs.writeSync,\n  writeManySync(fd: number, chunks: Uint8Array[]): void {\n    if (chunks.length === 0) return;\n    if (chunks.length === 1) {\n      fs.writeSync(fd, chunks[0]);\n      return;\n    }\n    // Use writev for multiple chunks\n    fs.writevSync(fd, chunks);\n  },\n  flushSync: fs.fsyncSync,\n  closeSync: fs.closeSync,\n  statSync: fs.statSync,\n  renameSync: fs.renameSync,\n};\n\n/**\n * A Node.js-specific async file sink driver.\n * @since 1.0.0\n */\nexport const nodeAsyncDriver: AsyncRotatingFileSinkDriver<number | void> = {\n  ...nodeDriver,\n  async writeMany(fd: number, chunks: Uint8Array[]): Promise<void> {\n    if (chunks.length === 0) return;\n    if (chunks.length === 1) {\n      await promisify(fs.write)(fd, chunks[0]);\n      return;\n    }\n    // Use async writev for multiple chunks\n    await promisify(fs.writev)(fd, chunks);\n  },\n  flush: promisify(fs.fsync),\n  close: promisify(fs.close),\n};\n\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 */\nexport function getFileSink(\n  path: string,\n  options?: FileSinkOptions,\n): Sink & Disposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getFileSink(\n  path: string,\n  options: FileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseFileSink(path, { ...options, ...nodeAsyncDriver });\n  }\n  return getBaseFileSink(path, { ...options, ...nodeDriver });\n}\n\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 */\nexport function getRotatingFileSink(\n  path: string,\n  options?: RotatingFileSinkOptions,\n): Sink & Disposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions & { nonBlocking: true },\n): Sink & AsyncDisposable;\nexport function getRotatingFileSink(\n  path: string,\n  options: RotatingFileSinkOptions = {},\n): Sink & (Disposable | AsyncDisposable) {\n  if (options.nonBlocking) {\n    return getBaseRotatingFileSink(path, { ...options, ...nodeAsyncDriver });\n  }\n  return getBaseRotatingFileSink(path, { ...options, ...nodeDriver });\n}\n\n// cSpell: ignore filesink\n"],"mappings":";;;;;;;;AAeA,MAAaA,aAAoD;CAC/D,SAASC,MAAc;AACrB,SAAO,GAAG,SAAS,MAAM,IAAI;CAC9B;CACD,WAAW,GAAG;CACd,cAAcC,IAAYC,QAA4B;AACpD,MAAI,OAAO,WAAW,EAAG;AACzB,MAAI,OAAO,WAAW,GAAG;AACvB,MAAG,UAAU,IAAI,OAAO,GAAG;AAC3B;EACD;AAED,KAAG,WAAW,IAAI,OAAO;CAC1B;CACD,WAAW,GAAG;CACd,WAAW,GAAG;CACd,UAAU,GAAG;CACb,YAAY,GAAG;AAChB;;;;;AAMD,MAAaC,kBAA8D;CACzE,GAAG;CACH,MAAM,UAAUF,IAAYC,QAAqC;AAC/D,MAAI,OAAO,WAAW,EAAG;AACzB,MAAI,OAAO,WAAW,GAAG;AACvB,SAAM,UAAU,GAAG,MAAM,CAAC,IAAI,OAAO,GAAG;AACxC;EACD;AAED,QAAM,UAAU,GAAG,OAAO,CAAC,IAAI,OAAO;CACvC;CACD,OAAO,UAAU,GAAG,MAAM;CAC1B,OAAO,UAAU,GAAG,MAAM;AAC3B;AAqBD,SAAgB,YACdF,MACAI,UAA2B,CAAE,GACU;AACvC,KAAI,QAAQ,YACV,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAElE,QAAO,gBAAgB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AAC5D;AA0BD,SAAgB,oBACdJ,MACAK,UAAmC,CAAE,GACE;AACvC,KAAI,QAAQ,YACV,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAiB,EAAC;AAE1E,QAAO,wBAAwB,MAAM;EAAE,GAAG;EAAS,GAAG;CAAY,EAAC;AACpE"}

package/dist/streamfilesink.cjs

@@ -3,7 +3,7 @@ const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/log
 const node_fs = require_rolldown_runtime.__toESM(require("node:fs"));
 const node_stream = require_rolldown_runtime.__toESM(require("node:stream"));
 
-//#region streamfilesink.ts
+//#region src/streamfilesink.ts
 /**
 * Create a high-performance stream-based file sink that writes log records to a file.
 *

package/dist/streamfilesink.d.cts

@@ -1,6 +1,6 @@
 import { Sink, TextFormatter } from "@logtape/logtape";
 
-//#region streamfilesink.d.ts
+//#region src/streamfilesink.d.ts
 
 /**
  * Options for the {@link getStreamFileSink} function.

package/dist/streamfilesink.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"streamfilesink.d.cts","names":[],"sources":["../streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}
+{"version":3,"file":"streamfilesink.d.cts","names":[],"sources":["../src/streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}

package/dist/streamfilesink.d.ts

@@ -1,6 +1,6 @@
 import { Sink, TextFormatter } from "@logtape/logtape";
 
-//#region streamfilesink.d.ts
+//#region src/streamfilesink.d.ts
 
 /**
  * Options for the {@link getStreamFileSink} function.

package/dist/streamfilesink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamfilesink.d.ts","names":[],"sources":["../streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}
+{"version":3,"file":"streamfilesink.d.ts","names":[],"sources":["../src/streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}

package/dist/streamfilesink.js

@@ -2,7 +2,7 @@ import { defaultTextFormatter } from "@logtape/logtape";
 import { createWriteStream } from "node:fs";
 import { PassThrough } from "node:stream";
 
-//#region streamfilesink.ts
+//#region src/streamfilesink.ts
 /**
 * Create a high-performance stream-based file sink that writes log records to a file.
 *

package/dist/streamfilesink.js.map

@@ -1 +1 @@
-{"version":3,"file":"streamfilesink.js","names":["path: string","options: StreamFileSinkOptions","sink: Sink & Disposable","record: LogRecord"],"sources":["../streamfilesink.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n} from \"@logtape/logtape\";\nimport { createWriteStream } from \"node:fs\";\nimport { PassThrough } from \"node:stream\";\n\n/**\n * Options for the {@link getStreamFileSink} function.\n *\n * This interface configures the high-performance stream-based file sink that\n * uses Node.js PassThrough streams for optimal I/O performance with automatic\n * backpressure management.\n *\n * @since 1.0.0\n */\nexport interface StreamFileSinkOptions {\n  /**\n   * High water mark for the PassThrough stream buffer in bytes.\n   *\n   * This controls the internal buffer size of the PassThrough stream.\n   * Higher values can improve performance for high-volume logging but use\n   * more memory. Lower values reduce memory usage but may impact performance.\n   *\n   * @default 16384\n   * @since 1.0.0\n   */\n  readonly highWaterMark?: number;\n\n  /**\n   * A custom formatter for log records.\n   *\n   * If not specified, the default text formatter will be used, which formats\n   * records in the standard LogTape format with timestamp, level, category,\n   * and message.\n   *\n   * @default defaultTextFormatter\n   * @since 1.0.0\n   */\n  readonly formatter?: TextFormatter;\n}\n\n/**\n * Create a high-performance stream-based file sink that writes log records to a file.\n *\n * This sink uses Node.js PassThrough streams piped to WriteStreams for optimal\n * I/O performance. It leverages the Node.js stream infrastructure to provide\n * automatic backpressure management, efficient buffering, and asynchronous writes\n * without blocking the main thread.\n *\n * ## Performance Characteristics\n *\n * - **High Performance**: Optimized for high-volume logging scenarios\n * - **Non-blocking**: Uses asynchronous I/O that doesn't block the main thread\n * - **Memory Efficient**: Automatic backpressure prevents memory buildup\n * - **Stream-based**: Leverages Node.js native stream optimizations\n *\n * ## When to Use\n *\n * Use this sink when you need:\n * - High-performance file logging for production applications\n * - Non-blocking I/O behavior for real-time applications\n * - Automatic backpressure handling for high-volume scenarios\n * - Simple file output without complex buffering configuration\n *\n * For more control over buffering behavior, consider using {@link getFileSink}\n * instead, which provides options for buffer size, flush intervals, and\n * non-blocking modes.\n *\n * ## Example\n *\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getStreamFileSink } from \"@logtape/file\";\n *\n * await configure({\n *   sinks: {\n *     file: getStreamFileSink(\"app.log\", {\n *       highWaterMark: 32768  // 32KB buffer for high-volume logging\n *     })\n *   },\n *   loggers: [\n *     { category: [\"myapp\"], sinks: [\"file\"] }\n *   ]\n * });\n * ```\n *\n * @param path The path to the file to write logs to. The file will be created\n *             if it doesn't exist, or appended to if it does exist.\n * @param options Configuration options for the stream-based sink.\n * @returns A sink that writes formatted log records to the specified file.\n *          The returned sink implements `Disposable` for proper resource cleanup.\n *\n * @since 1.0.0\n */\nexport function getStreamFileSink(\n  path: string,\n  options: StreamFileSinkOptions = {},\n): Sink & Disposable {\n  const highWaterMark = options.highWaterMark ?? 16384;\n  const formatter = options.formatter ?? defaultTextFormatter;\n\n  // Create PassThrough stream for optimal performance\n  const passThrough = new PassThrough({\n    highWaterMark,\n    objectMode: false,\n  });\n\n  // Create WriteStream immediately (not lazy)\n  const writeStream = createWriteStream(path, { flags: \"a\" });\n\n  // Pipe PassThrough to WriteStream for automatic backpressure handling\n  passThrough.pipe(writeStream);\n\n  let disposed = false;\n\n  // Stream-based sink function for high performance\n  const sink: Sink & Disposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Direct write to PassThrough stream\n    passThrough.write(formatter(record));\n  };\n\n  // Minimal disposal\n  sink[Symbol.dispose] = () => {\n    if (disposed) return;\n    disposed = true;\n    passThrough.end();\n    writeStream.end();\n  };\n\n  return sink;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,SAAgB,kBACdA,MACAC,UAAiC,CAAE,GAChB;CACnB,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,YAAY,QAAQ,aAAa;CAGvC,MAAM,cAAc,IAAI,YAAY;EAClC;EACA,YAAY;CACb;CAGD,MAAM,cAAc,kBAAkB,MAAM,EAAE,OAAO,IAAK,EAAC;AAG3D,aAAY,KAAK,YAAY;CAE7B,IAAI,WAAW;CAGf,MAAMC,OAA0B,CAACC,WAAsB;AACrD,MAAI,SAAU;AAGd,cAAY,MAAM,UAAU,OAAO,CAAC;CACrC;AAGD,MAAK,OAAO,WAAW,MAAM;AAC3B,MAAI,SAAU;AACd,aAAW;AACX,cAAY,KAAK;AACjB,cAAY,KAAK;CAClB;AAED,QAAO;AACR"}
+{"version":3,"file":"streamfilesink.js","names":["path: string","options: StreamFileSinkOptions","sink: Sink & Disposable","record: LogRecord"],"sources":["../src/streamfilesink.ts"],"sourcesContent":["import {\n  defaultTextFormatter,\n  type LogRecord,\n  type Sink,\n  type TextFormatter,\n} from \"@logtape/logtape\";\nimport { createWriteStream } from \"node:fs\";\nimport { PassThrough } from \"node:stream\";\n\n/**\n * Options for the {@link getStreamFileSink} function.\n *\n * This interface configures the high-performance stream-based file sink that\n * uses Node.js PassThrough streams for optimal I/O performance with automatic\n * backpressure management.\n *\n * @since 1.0.0\n */\nexport interface StreamFileSinkOptions {\n  /**\n   * High water mark for the PassThrough stream buffer in bytes.\n   *\n   * This controls the internal buffer size of the PassThrough stream.\n   * Higher values can improve performance for high-volume logging but use\n   * more memory. Lower values reduce memory usage but may impact performance.\n   *\n   * @default 16384\n   * @since 1.0.0\n   */\n  readonly highWaterMark?: number;\n\n  /**\n   * A custom formatter for log records.\n   *\n   * If not specified, the default text formatter will be used, which formats\n   * records in the standard LogTape format with timestamp, level, category,\n   * and message.\n   *\n   * @default defaultTextFormatter\n   * @since 1.0.0\n   */\n  readonly formatter?: TextFormatter;\n}\n\n/**\n * Create a high-performance stream-based file sink that writes log records to a file.\n *\n * This sink uses Node.js PassThrough streams piped to WriteStreams for optimal\n * I/O performance. It leverages the Node.js stream infrastructure to provide\n * automatic backpressure management, efficient buffering, and asynchronous writes\n * without blocking the main thread.\n *\n * ## Performance Characteristics\n *\n * - **High Performance**: Optimized for high-volume logging scenarios\n * - **Non-blocking**: Uses asynchronous I/O that doesn't block the main thread\n * - **Memory Efficient**: Automatic backpressure prevents memory buildup\n * - **Stream-based**: Leverages Node.js native stream optimizations\n *\n * ## When to Use\n *\n * Use this sink when you need:\n * - High-performance file logging for production applications\n * - Non-blocking I/O behavior for real-time applications\n * - Automatic backpressure handling for high-volume scenarios\n * - Simple file output without complex buffering configuration\n *\n * For more control over buffering behavior, consider using {@link getFileSink}\n * instead, which provides options for buffer size, flush intervals, and\n * non-blocking modes.\n *\n * ## Example\n *\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getStreamFileSink } from \"@logtape/file\";\n *\n * await configure({\n *   sinks: {\n *     file: getStreamFileSink(\"app.log\", {\n *       highWaterMark: 32768  // 32KB buffer for high-volume logging\n *     })\n *   },\n *   loggers: [\n *     { category: [\"myapp\"], sinks: [\"file\"] }\n *   ]\n * });\n * ```\n *\n * @param path The path to the file to write logs to. The file will be created\n *             if it doesn't exist, or appended to if it does exist.\n * @param options Configuration options for the stream-based sink.\n * @returns A sink that writes formatted log records to the specified file.\n *          The returned sink implements `Disposable` for proper resource cleanup.\n *\n * @since 1.0.0\n */\nexport function getStreamFileSink(\n  path: string,\n  options: StreamFileSinkOptions = {},\n): Sink & Disposable {\n  const highWaterMark = options.highWaterMark ?? 16384;\n  const formatter = options.formatter ?? defaultTextFormatter;\n\n  // Create PassThrough stream for optimal performance\n  const passThrough = new PassThrough({\n    highWaterMark,\n    objectMode: false,\n  });\n\n  // Create WriteStream immediately (not lazy)\n  const writeStream = createWriteStream(path, { flags: \"a\" });\n\n  // Pipe PassThrough to WriteStream for automatic backpressure handling\n  passThrough.pipe(writeStream);\n\n  let disposed = false;\n\n  // Stream-based sink function for high performance\n  const sink: Sink & Disposable = (record: LogRecord) => {\n    if (disposed) return;\n\n    // Direct write to PassThrough stream\n    passThrough.write(formatter(record));\n  };\n\n  // Minimal disposal\n  sink[Symbol.dispose] = () => {\n    if (disposed) return;\n    disposed = true;\n    passThrough.end();\n    writeStream.end();\n  };\n\n  return sink;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA,SAAgB,kBACdA,MACAC,UAAiC,CAAE,GAChB;CACnB,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,MAAM,YAAY,QAAQ,aAAa;CAGvC,MAAM,cAAc,IAAI,YAAY;EAClC;EACA,YAAY;CACb;CAGD,MAAM,cAAc,kBAAkB,MAAM,EAAE,OAAO,IAAK,EAAC;AAG3D,aAAY,KAAK,YAAY;CAE7B,IAAI,WAAW;CAGf,MAAMC,OAA0B,CAACC,WAAsB;AACrD,MAAI,SAAU;AAGd,cAAY,MAAM,UAAU,OAAO,CAAC;CACrC;AAGD,MAAK,OAAO,WAAW,MAAM;AAC3B,MAAI,SAAU;AACd,aAAW;AACX,cAAY,KAAK;AACjB,cAAY,KAAK;CAClB;AAED,QAAO;AACR"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.1.0-dev.321+fda84317",
+  "version": "1.1.0-dev.323+146f8194",
   "description": "File sink and rotating file sink for LogTape",
   "keywords": [
     "logging",
@@ -20,7 +20,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dahlia/logtape.git",
-    "directory": "file/"
+    "directory": "packages/file/"
   },
   "bugs": {
     "url": "https://github.com/dahlia/logtape/issues"
@@ -57,7 +57,7 @@
   },
   "sideEffects": false,
   "peerDependencies": {
-    "@logtape/logtape": "1.1.0-dev.321+fda84317"
+    "@logtape/logtape": "1.1.0-dev.323+146f8194"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/{filesink.test.ts → src/filesink.test.ts}

@@ -9,7 +9,13 @@ import { delay } from "@std/async/delay";
 import { join } from "@std/path/join";
 import fs from "node:fs";
 import { tmpdir } from "node:os";
-import { debug, error, fatal, info, warning } from "../logtape/fixtures.ts";
+import {
+  debug,
+  error,
+  fatal,
+  info,
+  warning,
+} from "../../logtape/src/fixtures.ts";
 import { type FileSinkDriver, getBaseFileSink } from "./filesink.base.ts";
 
 const test = suite(import.meta);

package/{streamfilesink.test.ts → src/streamfilesink.test.ts}

@@ -7,7 +7,13 @@ import { delay } from "@std/async/delay";
 import { join } from "@std/path/join";
 import fs from "node:fs";
 import { platform, tmpdir } from "node:os";
-import { debug, error, fatal, info, warning } from "../logtape/fixtures.ts";
+import {
+  debug,
+  error,
+  fatal,
+  info,
+  warning,
+} from "../../logtape/src/fixtures.ts";
 
 const test = suite(import.meta);
 

package/tsdown.config.ts

@@ -1,7 +1,7 @@
 import { defineConfig } from "tsdown";
 
 export default defineConfig({
-  entry: ["mod.ts", "filesink.deno.ts", "filesink.node.ts"],
+  entry: ["src/mod.ts", "src/filesink.deno.ts", "src/filesink.node.ts"],
   dts: {
     sourcemap: true,
   },