@naturalcycles/nodejs-lib 15.130.1 → 15.132.0

package/src/security/crypto.util.ts

@@ -8,7 +8,10 @@ const algorithm = 'aes-256-cbc'
 /**
  * Using aes-256-cbc.
  */
-export function encryptRandomIVBuffer(input: Buffer, secretKeyBuffer: Buffer): Buffer {
+export function encryptRandomIVBuffer(
+  input: Uint8Array,
+  secretKeyBuffer: Uint8Array,
+): Buffer<ArrayBuffer> {
   // sha256 to match aes-256 key length
   const key = sha256AsBuffer(secretKeyBuffer)
 
@@ -22,7 +25,10 @@ export function encryptRandomIVBuffer(input: Buffer, secretKeyBuffer: Buffer): B
 /**
  * Using aes-256-cbc.
  */
-export function decryptRandomIVBuffer(input: Buffer, secretKeyBuffer: Buffer): Buffer {
+export function decryptRandomIVBuffer(
+  input: Uint8Array,
+  secretKeyBuffer: Uint8Array,
+): Buffer<ArrayBuffer> {
   // sha256 to match aes-256 key length
   const key = sha256AsBuffer(secretKeyBuffer)
 
@@ -39,7 +45,10 @@ export function decryptRandomIVBuffer(input: Buffer, secretKeyBuffer: Buffer): B
  * Decrypts all object values (base64 strings).
  * Returns object with decrypted values (utf8 strings).
  */
-export function decryptObject(obj: StringMap<Base64String>, secretKeyBuffer: Buffer): StringMap {
+export function decryptObject(
+  obj: StringMap<Base64String>,
+  secretKeyBuffer: Uint8Array,
+): StringMap {
   const { key, iv } = getCryptoParams(secretKeyBuffer)
 
   const r: StringMap = {}
@@ -54,7 +63,10 @@ export function decryptObject(obj: StringMap<Base64String>, secretKeyBuffer: Buf
  * Encrypts all object values (utf8 strings).
  * Returns object with encrypted values (base64 strings).
  */
-export function encryptObject(obj: StringMap, secretKeyBuffer: Buffer): StringMap<Base64String> {
+export function encryptObject(
+  obj: StringMap,
+  secretKeyBuffer: Uint8Array,
+): StringMap<Base64String> {
   const { key, iv } = getCryptoParams(secretKeyBuffer)
 
   const r: StringMap = {}
@@ -71,7 +83,7 @@ export function encryptObject(obj: StringMap, secretKeyBuffer: Buffer): StringMa
  * Input is base64 string.
  * Output is utf8 string.
  */
-export function decryptString(str: Base64String, secretKeyBuffer: Buffer): string {
+export function decryptString(str: Base64String, secretKeyBuffer: Uint8Array): string {
   const { key, iv } = getCryptoParams(secretKeyBuffer)
   const decipher = crypto.createDecipheriv(algorithm, key, iv)
   return decipher.update(str, 'base64', 'utf8') + decipher.final('utf8')
@@ -83,13 +95,13 @@ export function decryptString(str: Base64String, secretKeyBuffer: Buffer): strin
  * Input is utf8 string.
  * Output is base64 string.
  */
-export function encryptString(str: string, secretKeyBuffer: Buffer): Base64String {
+export function encryptString(str: string, secretKeyBuffer: Uint8Array): Base64String {
   const { key, iv } = getCryptoParams(secretKeyBuffer)
   const cipher = crypto.createCipheriv(algorithm, key, iv)
   return cipher.update(str, 'utf8', 'base64') + cipher.final('base64')
 }
 
-function getCryptoParams(secretKeyBuffer: Buffer): { key: Buffer; iv: Buffer } {
+function getCryptoParams(secretKeyBuffer: Uint8Array): { key: Buffer; iv: Buffer } {
   const key = sha256AsBuffer(secretKeyBuffer)
   const iv = md5AsBuffer(Buffer.concat([secretKeyBuffer, key]))
   return { key, iv }

package/src/security/hash.util.ts

@@ -2,40 +2,45 @@ import type { BinaryToTextEncoding } from 'node:crypto'
 import { hash as cryptoHash } from 'node:crypto'
 import type { Base64String, Base64UrlString } from '@naturalcycles/js-lib/types'
 
-export function md5(s: string | Buffer, outputEncoding: BinaryToTextEncoding = 'hex'): string {
+export function md5(s: string | Uint8Array, outputEncoding: BinaryToTextEncoding = 'hex'): string {
   return hash(s, 'md5', outputEncoding)
 }
 
-export function md5AsBuffer(s: string | Buffer): Buffer {
+export function md5AsBuffer(s: string | Uint8Array): Buffer<ArrayBuffer> {
   return hashAsBuffer(s, 'md5')
 }
 
-export function sha256(s: string | Buffer, outputEncoding: BinaryToTextEncoding = 'hex'): string {
+export function sha256(
+  s: string | Uint8Array,
+  outputEncoding: BinaryToTextEncoding = 'hex',
+): string {
   return hash(s, 'sha256', outputEncoding)
 }
 
-export function sha256AsBuffer(s: string | Buffer): Buffer {
+export function sha256AsBuffer(s: string | Uint8Array): Buffer<ArrayBuffer> {
   return hashAsBuffer(s, 'sha256')
 }
 
 export function hash(
-  s: string | Buffer,
+  s: string | Uint8Array,
   algorithm: string,
   outputEncoding: BinaryToTextEncoding = 'hex',
 ): string {
   return cryptoHash(algorithm, s, outputEncoding)
 }
 
-export function hashAsBuffer(s: string | Buffer, algorithm: string): Buffer {
+export function hashAsBuffer(s: string | Uint8Array, algorithm: string): Buffer<ArrayBuffer> {
   return cryptoHash(algorithm, s, 'buffer')
 }
 
-export function base64(s: string | Buffer): Base64String {
-  return (typeof s === 'string' ? Buffer.from(s) : s).toString('base64')
+export function base64(s: string | Uint8Array): Base64String {
+  if (typeof s === 'string') return Buffer.from(s).toString('base64')
+  return bufferToBase64(s)
 }
 
-export function base64Url(s: string | Buffer): Base64UrlString {
-  return (typeof s === 'string' ? Buffer.from(s) : s).toString('base64url')
+export function base64Url(s: string | Uint8Array): Base64UrlString {
+  if (typeof s === 'string') return Buffer.from(s).toString('base64url')
+  return bufferToBase64Url(s)
 }
 
 export function base64ToString(strBase64: Base64String): string {
@@ -46,11 +51,11 @@ export function base64UrlToString(strBase64Url: Base64UrlString): string {
   return Buffer.from(strBase64Url, 'base64url').toString('utf8')
 }
 
-export function base64ToBuffer(strBase64: Base64String): Buffer {
+export function base64ToBuffer(strBase64: Base64String): Buffer<ArrayBuffer> {
   return Buffer.from(strBase64, 'base64')
 }
 
-export function base64UrlToBuffer(strBase64Url: Base64UrlString): Buffer {
+export function base64UrlToBuffer(strBase64Url: Base64UrlString): Buffer<ArrayBuffer> {
   return Buffer.from(strBase64Url, 'base64url')
 }
 
@@ -62,10 +67,14 @@ export function stringToBase64Url(s: string): Base64UrlString {
   return Buffer.from(s, 'utf8').toString('base64url')
 }
 
-export function bufferToBase64(b: Buffer): Base64String {
-  return b.toString('base64')
+// Buffer#toString is faster than Uint8Array#toBase64 on small inputs (~1.3-1.7x up to ~512 bytes,
+// measured on Node 26), hence the Buffer fast-path. On larger inputs they're on par.
+export function bufferToBase64(b: Uint8Array): Base64String {
+  return Buffer.isBuffer(b) ? b.toString('base64') : b.toBase64()
 }
 
-export function bufferToBase64Url(b: Buffer): Base64UrlString {
-  return b.toString('base64url')
+export function bufferToBase64Url(b: Uint8Array): Base64UrlString {
+  return Buffer.isBuffer(b)
+    ? b.toString('base64url')
+    : b.toBase64({ alphabet: 'base64url', omitPadding: true })
 }

package/src/stream/index.ts

@@ -24,7 +24,6 @@ export * from './transform/transformSplit.js'
 export * from './transform/transformTap.js'
 export * from './transform/transformThrottle.js'
 export * from './transform/transformThrottleByRSS.js'
-export * from './transform/transformWarmup.js'
 export * from './transform/worker/baseWorkerClass.js'
 export * from './transform/worker/transformMultiThreaded.js'
 export type * from './transform/worker/transformMultiThreaded.model.js'

package/src/stream/pipeline.ts

@@ -14,6 +14,7 @@ import type {
   END,
   IndexedMapper,
   Integer,
+  NonEmptyArray,
   NonNegativeInteger,
   PositiveInteger,
   Predicate,
@@ -54,8 +55,6 @@ import { transformThrottle } from './transform/transformThrottle.js'
 import type { TransformThrottleOptions } from './transform/transformThrottle.js'
 import { transformThrottleByRSS } from './transform/transformThrottleByRSS.js'
 import type { TransformThrottleByRSSOptions } from './transform/transformThrottleByRSS.js'
-import { transformWarmup } from './transform/transformWarmup.js'
-import type { TransformWarmupOptions } from './transform/transformWarmup.js'
 import { writablePushToArray } from './writable/writablePushToArray.js'
 import { writableVoid } from './writable/writableVoid.js'
 
@@ -164,7 +163,7 @@ export class Pipeline<T = unknown> {
     return this
   }
 
-  chunk(chunkSize: PositiveInteger, opt?: TransformOptions): Pipeline<T[]> {
+  chunk(chunkSize: PositiveInteger, opt?: TransformOptions): Pipeline<NonEmptyArray<T>> {
     this.transforms.push(transformChunk(chunkSize, opt))
     return this as any
   }
@@ -257,14 +256,6 @@ export class Pipeline<T = unknown> {
     return this
   }
 
-  /**
-   * @experimental to be removed after transformMap2 is stable
-   */
-  warmup(opt: TransformWarmupOptions): this {
-    this.transforms.push(transformWarmup(opt))
-    return this
-  }
-
   transform<TO>(transform: TransformTyped<T, TO>): Pipeline<TO> {
     this.transforms.push(transform)
     return this as any

package/src/stream/transform/transformChunk.ts

@@ -1,5 +1,5 @@
 import { Transform } from 'node:stream'
-import type { PositiveInteger } from '@naturalcycles/js-lib/types'
+import type { NonEmptyArray, PositiveInteger } from '@naturalcycles/js-lib/types'
 import type { TransformOptions, TransformTyped } from '../stream.model.js'
 
 /**
@@ -13,7 +13,8 @@ import type { TransformOptions, TransformTyped } from '../stream.model.js'
 export function transformChunk<IN = any>(
   chunkSize: PositiveInteger,
   opt?: TransformOptions,
-): TransformTyped<IN, IN[]> {
+): TransformTyped<IN, NonEmptyArray<IN>> {
+  // Only non-empty buffers are emitted
   let buf: IN[] = []
 
   return new Transform({

package/src/validation/timezones.ts

@@ -1,4 +1,5 @@
 import { _uniq } from '@naturalcycles/js-lib/array'
+import { Intl2 } from '@naturalcycles/js-lib/intl'
 import type { IANATimezone } from '@naturalcycles/js-lib/types'
 
 // List extracted from Wikipedia (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
@@ -603,8 +604,7 @@ const TIMEZONES_FROM_WIKI = [
   'Zulu',
 ] as IANATimezone[]
 
-// oxlint-disable-next-line no-restricted-globals
-const TIMEZONES_FROM_JS = Intl.supportedValuesOf('timeZone') as IANATimezone[]
+const TIMEZONES_FROM_JS = Intl2.getSupportedTimezones()
 
 /**
  * A complicated merge of timezones from the underlying Javascript engine

package/src/zip/zip2.ts

@@ -16,11 +16,11 @@ const zstdCompressAsync = promisify(zlib.zstdCompress.bind(zlib))
 const zstdDecompressAsync = promisify(zlib.zstdDecompress.bind(zlib))
 
 class Zip2 {
-  async decompressZstdOrInflateToString(buf: Buffer): Promise<string> {
+  async decompressZstdOrInflateToString(buf: Uint8Array): Promise<string> {
     return (await this.decompressZstdOrInflate(buf)).toString()
   }
 
-  decompressZstdOrInflateToStringSync(buf: Buffer): string {
+  decompressZstdOrInflateToStringSync(buf: Uint8Array): string {
     return this.decompressZstdOrInflateSync(buf).toString()
   }
 
@@ -28,14 +28,14 @@ class Zip2 {
    * Detects if Buffer is zstd-compressed.
    * Otherwise attempts to Inflate.
    */
-  async decompressZstdOrInflate(buf: Buffer): Promise<Buffer<ArrayBuffer>> {
+  async decompressZstdOrInflate(buf: Uint8Array): Promise<Buffer<ArrayBuffer>> {
     if (this.isZstdBuffer(buf)) {
       return await zstdDecompressAsync(buf)
     }
     return await inflateAsync(buf)
   }
 
-  decompressZstdOrInflateSync(buf: Buffer): Buffer<ArrayBuffer> {
+  decompressZstdOrInflateSync(buf: Uint8Array): Buffer<ArrayBuffer> {
     if (this.isZstdBuffer(buf)) {
       return zlib.zstdDecompressSync(buf)
     }
@@ -46,7 +46,10 @@ class Zip2 {
    * deflateBuffer uses `deflate`.
    * It's 9 bytes shorter than `gzip`.
    */
-  async deflate(input: string | Buffer, options: ZlibOptions = {}): Promise<Buffer<ArrayBuffer>> {
+  async deflate(
+    input: string | Uint8Array,
+    options: ZlibOptions = {},
+  ): Promise<Buffer<ArrayBuffer>> {
     return await deflateAsync(input, options)
   }
 
@@ -54,23 +57,23 @@ class Zip2 {
    * deflateSync uses `deflate`.
    * It's 9 bytes shorter than `gzip`.
    */
-  deflateSync(input: string | Buffer, options?: ZlibOptions): Buffer<ArrayBuffer> {
+  deflateSync(input: string | Uint8Array, options?: ZlibOptions): Buffer<ArrayBuffer> {
     return zlib.deflateSync(input, options)
   }
 
-  async inflate(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer<ArrayBuffer>> {
+  async inflate(buf: Uint8Array, options: ZlibOptions = {}): Promise<Buffer<ArrayBuffer>> {
     return await inflateAsync(buf, options)
   }
 
-  inflateSync(buf: Buffer, options: ZlibOptions = {}): Buffer<ArrayBuffer> {
+  inflateSync(buf: Uint8Array, options: ZlibOptions = {}): Buffer<ArrayBuffer> {
     return zlib.inflateSync(buf, options)
   }
 
-  async inflateToString(buf: Buffer, options?: ZlibOptions): Promise<string> {
+  async inflateToString(buf: Uint8Array, options?: ZlibOptions): Promise<string> {
     return (await this.inflate(buf, options)).toString()
   }
 
-  inflateToStringSync(buf: Buffer, options?: ZlibOptions): string {
+  inflateToStringSync(buf: Uint8Array, options?: ZlibOptions): string {
     return zlib.inflateSync(buf, options).toString()
   }
 
@@ -78,7 +81,7 @@ class Zip2 {
    * gzipBuffer uses `gzip`
    * It's 9 bytes longer than `deflate`.
    */
-  async gzip(input: string | Buffer, options: ZlibOptions = {}): Promise<Buffer<ArrayBuffer>> {
+  async gzip(input: string | Uint8Array, options: ZlibOptions = {}): Promise<Buffer<ArrayBuffer>> {
     return await gzipAsync(input, options)
   }
 
@@ -86,28 +89,28 @@ class Zip2 {
    * gzipBuffer uses `gzip`
    * It's 9 bytes longer than `deflate`.
    */
-  gzipSync(input: string | Buffer, options: ZlibOptions = {}): Buffer<ArrayBuffer> {
+  gzipSync(input: string | Uint8Array, options: ZlibOptions = {}): Buffer<ArrayBuffer> {
     return zlib.gzipSync(input, options)
   }
 
-  async gunzip(buf: Buffer, options: ZlibOptions = {}): Promise<Buffer<ArrayBuffer>> {
+  async gunzip(buf: Uint8Array, options: ZlibOptions = {}): Promise<Buffer<ArrayBuffer>> {
     return await gunzipAsync(buf, options)
   }
 
-  gunzipSync(buf: Buffer, options: ZlibOptions = {}): Buffer<ArrayBuffer> {
+  gunzipSync(buf: Uint8Array, options: ZlibOptions = {}): Buffer<ArrayBuffer> {
     return zlib.gunzipSync(buf, options)
   }
 
-  async gunzipToString(buf: Buffer, options?: ZlibOptions): Promise<string> {
+  async gunzipToString(buf: Uint8Array, options?: ZlibOptions): Promise<string> {
     return (await this.gunzip(buf, options)).toString()
   }
 
-  gunzipToStringSync(buf: Buffer, options?: ZlibOptions): string {
+  gunzipToStringSync(buf: Uint8Array, options?: ZlibOptions): string {
     return zlib.gunzipSync(buf, options).toString()
   }
 
   async zstdCompress(
-    input: Buffer | string,
+    input: Uint8Array | string,
     level?: Integer, // defaults to 3
     options: ZstdOptions = {},
   ): Promise<Buffer<ArrayBuffer>> {
@@ -115,7 +118,7 @@ class Zip2 {
   }
 
   zstdCompressSync(
-    input: Buffer | string,
+    input: Uint8Array | string,
     level?: Integer, // defaults to 3
     options: ZstdOptions = {},
   ): Buffer<ArrayBuffer> {
@@ -134,33 +137,34 @@ class Zip2 {
     }
   }
 
-  async zstdDecompressToString(input: Buffer, options: ZstdOptions = {}): Promise<string> {
+  async zstdDecompressToString(input: Uint8Array, options: ZstdOptions = {}): Promise<string> {
     return (await zstdDecompressAsync(input, options)).toString()
   }
 
   /**
    * Warning! It leaks memory severely. Prefer sync.
    */
-  async zstdDecompress(input: Buffer, options: ZstdOptions = {}): Promise<Buffer<ArrayBuffer>> {
+  async zstdDecompress(input: Uint8Array, options: ZstdOptions = {}): Promise<Buffer<ArrayBuffer>> {
     return await zstdDecompressAsync(input, options)
   }
 
   /**
    * Warning! It leaks memory severely. Prefer sync.
    */
-  zstdDecompressToStringSync(input: Buffer, options: ZstdOptions = {}): string {
+  zstdDecompressToStringSync(input: Uint8Array, options: ZstdOptions = {}): string {
     return zlib.zstdDecompressSync(input, options).toString()
   }
 
-  zstdDecompressSync(input: Buffer, options: ZstdOptions = {}): Buffer<ArrayBuffer> {
+  zstdDecompressSync(input: Uint8Array, options: ZstdOptions = {}): Buffer<ArrayBuffer> {
     return zlib.zstdDecompressSync(input, options)
   }
 
-  isZstdBuffer(input: Buffer): boolean {
-    return input.readUInt32LE(0) === ZSTD_MAGIC_NUMBER
+  isZstdBuffer(input: Uint8Array): boolean {
+    // zstd magic number 0xFD2FB528, stored little-endian
+    return input[0] === 0x28 && input[1] === 0xb5 && input[2] === 0x2f && input[3] === 0xfd
   }
 
-  isGzipBuffer(input: Buffer): boolean {
+  isGzipBuffer(input: Uint8Array): boolean {
     return input[0] === 0x1f && input[1] === 0x8b
   }
 
@@ -211,11 +215,9 @@ class Zip2 {
    *
    * For large archives or streamed inputs prefer {@link createZip} / {@link ZipWriter}.
    */
-  async createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer> {
+  async createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer<ArrayBuffer>> {
     return await createZipBuffer(entries)
   }
 }
 
 export const zip2 = new Zip2()
-
-const ZSTD_MAGIC_NUMBER = 0xfd2fb528

package/src/zip/zipWriter.ts

@@ -62,7 +62,7 @@ const deflateRawAsync = promisify(zlib.deflateRaw.bind(zlib))
  *
  * Each input path may be a file (added directly) or a directory (walked
  * recursively; all nested files are added). By default an entry's name is its
- * path relative to its input's parent directory, so `zipFiles(['./photos'], 'out.zip')`
+ * path relative to its input's parent directory, so `zipPaths(['./photos'], 'out.zip')`
  * stores entries under `photos/...`. Override the base via {@link ZipPathsOptions.baseDir}.
  *
  * Files discovered by walking a directory are added in deterministic (sorted)
@@ -105,7 +105,7 @@ export async function zipPaths(
  *
  * For large archives or streamed inputs prefer {@link createZip} / {@link ZipWriter}.
  */
-export async function createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer> {
+export async function createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer<ArrayBuffer>> {
   const chunks: Buffer[] = []
   const sink = new Writable({
     write(chunk: Buffer, _enc, cb) {
@@ -176,7 +176,11 @@ export class ZipWriter implements AsyncDisposable {
    * Add an in-memory buffer as a file entry.
    * The CRC-32 and sizes are computed up front and written inline (no data descriptor).
    */
-  async addBuffer(data: Buffer, fileName: string, opt: ZipWriterEntryOptions = {}): Promise<void> {
+  async addBuffer(
+    data: Uint8Array,
+    fileName: string,
+    opt: ZipWriterEntryOptions = {},
+  ): Promise<void> {
     this.assertWritable()
     const entry = this.createEntry(fileName, false, opt)
     entry.crc32 = zlib.crc32(data)
@@ -325,7 +329,7 @@ export class ZipWriter implements AsyncDisposable {
   }
 
   /** Write an entry whose CRC and sizes are already known: header, name, data, no descriptor. */
-  private async writeKnownEntry(entry: WriteEntry, data: Buffer): Promise<void> {
+  private async writeKnownEntry(entry: WriteEntry, data: Uint8Array): Promise<void> {
     entry.relativeOffsetOfLocalHeader = this.offset
     await this.write(buildLocalFileHeader(entry))
     await this.write(entry.nameBuf)
@@ -389,7 +393,7 @@ export class ZipWriter implements AsyncDisposable {
   }
 
   /** Write a buffer to the output, tracking the byte offset and respecting backpressure. */
-  private async write(buf: Buffer): Promise<void> {
+  private async write(buf: Uint8Array): Promise<void> {
     if (this.streamError) throw this.streamError
     if (buf.length === 0) return
     this.offset += buf.length

package/dist/buffer/buffer.util.d.ts

@@ -1,4 +0,0 @@
-/**
- * Same as _chunk, but for Buffer.
- */
-export declare function _chunkBuffer(buf: Buffer, size: number): Buffer[];

package/dist/buffer/buffer.util.js

@@ -1,10 +0,0 @@
-/**
- * Same as _chunk, but for Buffer.
- */
-export function _chunkBuffer(buf, size) {
-    const out = [];
-    for (let i = 0; i < buf.length; i += size) {
-        out.push(buf.subarray(i, i + size));
-    }
-    return out;
-}

package/dist/stream/transform/transformWarmup.d.ts

@@ -1,24 +0,0 @@
-import type { NumberOfSeconds, PositiveInteger } from '@naturalcycles/js-lib/types';
-import type { TransformOptions, TransformTyped } from '../stream.model.js';
-export interface TransformWarmupOptions extends TransformOptions {
-    /**
-     * Target concurrency after warmup completes.
-     */
-    concurrency: PositiveInteger;
-    /**
-     * Time in seconds to gradually increase concurrency from 1 to `concurrency`.
-     * Set to 0 to disable warmup (pass-through mode from the start).
-     */
-    warmupSeconds: NumberOfSeconds;
-}
-/**
- * Transform that gradually increases concurrency from 1 to the configured maximum
- * over a warmup period. Useful for scenarios where you want to avoid overwhelming
- * a system at startup (e.g., database connections, API rate limits).
- *
- * During warmup: limits concurrent items based on elapsed time.
- * After warmup: passes items through immediately with zero overhead.
- *
- * @experimental
- */
-export declare function transformWarmup<T>(opt: TransformWarmupOptions): TransformTyped<T, T>;

package/dist/stream/transform/transformWarmup.js

@@ -1,79 +0,0 @@
-import { Transform } from 'node:stream';
-import { createCommonLoggerAtLevel } from '@naturalcycles/js-lib/log';
-import { pDefer } from '@naturalcycles/js-lib/promise/pDefer.js';
-/**
- * Transform that gradually increases concurrency from 1 to the configured maximum
- * over a warmup period. Useful for scenarios where you want to avoid overwhelming
- * a system at startup (e.g., database connections, API rate limits).
- *
- * During warmup: limits concurrent items based on elapsed time.
- * After warmup: passes items through immediately with zero overhead.
- *
- * @experimental
- */
-export function transformWarmup(opt) {
-    const { concurrency, warmupSeconds, objectMode = true, highWaterMark = 1 } = opt;
-    const warmupMs = warmupSeconds * 1000;
-    const logger = createCommonLoggerAtLevel(opt.logger, opt.logLevel);
-    let startTime = 0;
-    let warmupComplete = warmupSeconds <= 0 || concurrency <= 1;
-    let inFlight = 0;
-    const waiters = [];
-    return new Transform({
-        objectMode,
-        highWaterMark,
-        async transform(item, _, cb) {
-            // Initialize start time on first item
-            if (startTime === 0) {
-                startTime = Date.now();
-            }
-            // Fast-path: after warmup, just pass through with zero overhead
-            if (warmupComplete) {
-                cb(null, item);
-                return;
-            }
-            const currentConcurrency = getCurrentConcurrency();
-            if (inFlight < currentConcurrency) {
-                // Have room, proceed immediately
-                inFlight++;
-                logger.debug(`inFlight++ ${inFlight}/${currentConcurrency}, waiters ${waiters.length}`);
-            }
-            else {
-                // Wait for a slot
-                const waiter = pDefer();
-                waiters.push(waiter);
-                logger.debug(`inFlight ${inFlight}/${currentConcurrency}, waiters++ ${waiters.length}`);
-                await waiter;
-                logger.debug(`waiter resolved, inFlight ${inFlight}/${getCurrentConcurrency()}`);
-            }
-            // Push the item
-            cb(null, item);
-            // Release slot on next microtask - essential for concurrency control.
-            // Without this, the slot would be freed immediately and items would
-            // flow through without any limiting effect.
-            queueMicrotask(release);
-        },
-    });
-    function getCurrentConcurrency() {
-        if (warmupComplete)
-            return concurrency;
-        const elapsed = Date.now() - startTime;
-        if (elapsed >= warmupMs) {
-            warmupComplete = true;
-            logger.debug('warmup complete');
-            return concurrency;
-        }
-        // Linear interpolation from 1 to concurrency
-        const progress = elapsed / warmupMs;
-        return Math.max(1, Math.floor(1 + (concurrency - 1) * progress));
-    }
-    function release() {
-        inFlight--;
-        // Wake up waiters based on current concurrency (may have increased)
-        const currentConcurrency = getCurrentConcurrency();
-        while (waiters.length && inFlight < currentConcurrency) {
-            inFlight++;
-            waiters.shift().resolve();
-        }
-    }
-}

package/src/buffer/buffer.util.ts

@@ -1,12 +0,0 @@
-/**
- * Same as _chunk, but for Buffer.
- */
-export function _chunkBuffer(buf: Buffer, size: number): Buffer[] {
-  const out: Buffer[] = []
-
-  for (let i = 0; i < buf.length; i += size) {
-    out.push(buf.subarray(i, i + size))
-  }
-
-  return out
-}