@naturalcycles/nodejs-lib 15.130.0 → 15.131.0

package/dist/fs/fs2.d.ts

@@ -18,24 +18,24 @@ declare class FS2 {
      * Convenience wrapper that defaults to utf-8 string output.
      */
     readTextAsync(filePath: string): Promise<string>;
-    readBuffer(filePath: string): Buffer;
-    readBufferAsync(filePath: string): Promise<Buffer>;
+    readBuffer(filePath: string): Buffer<ArrayBuffer>;
+    readBufferAsync(filePath: string): Promise<Buffer<ArrayBuffer>>;
     readJson<T = unknown>(filePath: string): T;
     readJsonAsync<T = unknown>(filePath: string): Promise<T>;
-    writeFile(filePath: string, data: string | Buffer, opt?: WriteFileOptions): void;
-    writeFileAsync(filePath: string, data: string | Buffer, opt?: WriteFileOptions): Promise<void>;
+    writeFile(filePath: string, data: string | Uint8Array, opt?: WriteFileOptions): void;
+    writeFileAsync(filePath: string, data: string | Uint8Array, opt?: WriteFileOptions): Promise<void>;
     writePrettyJson(filePath: string, data: any): void;
     writeJson(filePath: string, data: any, opt?: JsonOptions): void;
     writePrettyJsonAsync(filePath: string, data: any): Promise<void>;
     writeJsonAsync(filePath: string, data: any, opt?: JsonOptions): Promise<void>;
-    appendFile(filePath: string, data: string | Buffer): void;
-    appendFileAsync(filePath: string, data: string | Buffer): Promise<void>;
+    appendFile(filePath: string, data: string | Uint8Array): void;
+    appendFileAsync(filePath: string, data: string | Uint8Array): Promise<void>;
     outputPrettyJson(filePath: string, data: any): void;
     outputJson(filePath: string, data: any, opt?: JsonOptions): void;
-    outputPrettyAsync(filePath: string, data: any): Promise<void>;
+    outputPrettyJsonAsync(filePath: string, data: any): Promise<void>;
     outputJsonAsync(filePath: string, data: any, opt?: JsonOptions): Promise<void>;
-    outputFile(filePath: string, data: string | Buffer): void;
-    outputFileAsync(filePath: string, data: string | Buffer): Promise<void>;
+    outputFile(filePath: string, data: string | Uint8Array): void;
+    outputFileAsync(filePath: string, data: string | Uint8Array): Promise<void>;
     pathExists(filePath: string): boolean;
     pathExistsAsync(filePath: string): Promise<boolean>;
     requireFileToExist(filePath: string): void;

package/dist/fs/fs2.js

@@ -88,7 +88,7 @@ class FS2 {
         const str = stringify(data, opt);
         this.outputFile(filePath, str);
     }
-    async outputPrettyAsync(filePath, data) {
+    async outputPrettyJsonAsync(filePath, data) {
         await this.outputJsonAsync(filePath, data, prettyJsonOptions);
     }
     async outputJsonAsync(filePath, data, opt) {
@@ -156,11 +156,9 @@ class FS2 {
         }
         catch (err) {
             // If the stat call above failed because the directory doesn't exist, create it
-            if (err?.code === 'ENOENT') {
-                this.ensureDir(dir);
-                return;
-            }
-            throw err;
+            if (err?.code !== 'ENOENT')
+                throw err;
+            this.ensureDir(dir);
         }
         fs.writeFileSync(filePath, '');
     }
@@ -182,9 +180,9 @@ class FS2 {
         }
         catch (err) {
             // If the stat call above failed because the directory doesn't exist, create it
-            if (err?.code === 'ENOENT')
-                return await this.ensureDirAsync(dir);
-            throw err;
+            if (err?.code !== 'ENOENT')
+                throw err;
+            await this.ensureDirAsync(dir);
         }
         await fsp.writeFile(filePath, '');
     }

package/dist/secret/secrets-decrypt.util.js

@@ -24,7 +24,7 @@ export function secretsDecrypt(dir, file, encKeyBuffer, del = false, jsonMode =
             _assert(!filename.endsWith('.plain.json'), `${path.basename(filename)} MUST NOT end with '.plain.json'`);
             plainFilename = filename.replace('.json', '.plain.json');
             const json = decryptObject(fs2.readJson(filename), encKeyBuffer);
-            fs2.writeJson(plainFilename, json, { spaces: 2 });
+            fs2.writePrettyJson(plainFilename, json);
         }
         else {
             const enc = fs.readFileSync(filename);

package/dist/secret/secrets-encrypt.util.js

@@ -10,20 +10,17 @@ import { encryptObject, encryptRandomIVBuffer } from '../security/crypto.util.js
  * Using provided encKey.
  */
 export function secretsEncrypt(pattern, file, encKeyBuffer, del = false, jsonMode = false) {
-    const patterns = file
-        ? [file]
-        : [
-            ...pattern,
-            `!**/*.enc`, // excluding already encoded
-        ];
-    const filenames = globSync(patterns);
+    // Already encrypted files are filtered out: a `!**/*.enc` pattern only excludes them under the cwd
+    const filenames = file
+        ? globSync([file])
+        : globSync(pattern).filter(filename => !filename.endsWith('.enc'));
     let encFilename;
     filenames.forEach(filename => {
         if (jsonMode) {
             _assert(filename.endsWith('.plain.json'), `${path.basename(filename)} MUST end with '.plain.json'`);
             encFilename = filename.replace('.plain', '');
             const json = encryptObject(fs2.readJson(filename), encKeyBuffer);
-            fs2.writeJson(encFilename, json, { spaces: 2 });
+            fs2.writePrettyJson(encFilename, json);
         }
         else {
             const plain = fs.readFileSync(filename);

package/dist/security/crypto.util.d.ts

@@ -2,35 +2,35 @@ import type { Base64String, StringMap } from '@naturalcycles/js-lib/types';
 /**
  * Using aes-256-cbc.
  */
-export declare function encryptRandomIVBuffer(input: Buffer, secretKeyBuffer: Buffer): Buffer;
+export declare function encryptRandomIVBuffer(input: Uint8Array, secretKeyBuffer: Uint8Array): Buffer<ArrayBuffer>;
 /**
  * Using aes-256-cbc.
  */
-export declare function decryptRandomIVBuffer(input: Buffer, secretKeyBuffer: Buffer): Buffer;
+export declare function decryptRandomIVBuffer(input: Uint8Array, secretKeyBuffer: Uint8Array): Buffer<ArrayBuffer>;
 /**
  * Decrypts all object values (base64 strings).
  * Returns object with decrypted values (utf8 strings).
  */
-export declare function decryptObject(obj: StringMap<Base64String>, secretKeyBuffer: Buffer): StringMap;
+export declare function decryptObject(obj: StringMap<Base64String>, secretKeyBuffer: Uint8Array): StringMap;
 /**
  * Encrypts all object values (utf8 strings).
  * Returns object with encrypted values (base64 strings).
  */
-export declare function encryptObject(obj: StringMap, secretKeyBuffer: Buffer): StringMap<Base64String>;
+export declare function encryptObject(obj: StringMap, secretKeyBuffer: Uint8Array): StringMap<Base64String>;
 /**
  * Using aes-256-cbc.
  *
  * Input is base64 string.
  * Output is utf8 string.
  */
-export declare function decryptString(str: Base64String, secretKeyBuffer: Buffer): string;
+export declare function decryptString(str: Base64String, secretKeyBuffer: Uint8Array): string;
 /**
  * Using aes-256-cbc.
  *
  * Input is utf8 string.
  * Output is base64 string.
  */
-export declare function encryptString(str: string, secretKeyBuffer: Buffer): Base64String;
+export declare function encryptString(str: string, secretKeyBuffer: Uint8Array): Base64String;
 /**
  * Wraps `crypto.timingSafeEqual` and allows it to be used with String inputs:
  *

package/dist/security/hash.util.d.ts

@@ -1,18 +1,18 @@
 import type { BinaryToTextEncoding } from 'node:crypto';
 import type { Base64String, Base64UrlString } from '@naturalcycles/js-lib/types';
-export declare function md5(s: string | Buffer, outputEncoding?: BinaryToTextEncoding): string;
-export declare function md5AsBuffer(s: string | Buffer): Buffer;
-export declare function sha256(s: string | Buffer, outputEncoding?: BinaryToTextEncoding): string;
-export declare function sha256AsBuffer(s: string | Buffer): Buffer;
-export declare function hash(s: string | Buffer, algorithm: string, outputEncoding?: BinaryToTextEncoding): string;
-export declare function hashAsBuffer(s: string | Buffer, algorithm: string): Buffer;
-export declare function base64(s: string | Buffer): Base64String;
-export declare function base64Url(s: string | Buffer): Base64UrlString;
+export declare function md5(s: string | Uint8Array, outputEncoding?: BinaryToTextEncoding): string;
+export declare function md5AsBuffer(s: string | Uint8Array): Buffer<ArrayBuffer>;
+export declare function sha256(s: string | Uint8Array, outputEncoding?: BinaryToTextEncoding): string;
+export declare function sha256AsBuffer(s: string | Uint8Array): Buffer<ArrayBuffer>;
+export declare function hash(s: string | Uint8Array, algorithm: string, outputEncoding?: BinaryToTextEncoding): string;
+export declare function hashAsBuffer(s: string | Uint8Array, algorithm: string): Buffer<ArrayBuffer>;
+export declare function base64(s: string | Uint8Array): Base64String;
+export declare function base64Url(s: string | Uint8Array): Base64UrlString;
 export declare function base64ToString(strBase64: Base64String): string;
 export declare function base64UrlToString(strBase64Url: Base64UrlString): string;
-export declare function base64ToBuffer(strBase64: Base64String): Buffer;
-export declare function base64UrlToBuffer(strBase64Url: Base64UrlString): Buffer;
+export declare function base64ToBuffer(strBase64: Base64String): Buffer<ArrayBuffer>;
+export declare function base64UrlToBuffer(strBase64Url: Base64UrlString): Buffer<ArrayBuffer>;
 export declare function stringToBase64(s: string): Base64String;
 export declare function stringToBase64Url(s: string): Base64UrlString;
-export declare function bufferToBase64(b: Buffer): Base64String;
-export declare function bufferToBase64Url(b: Buffer): Base64UrlString;
+export declare function bufferToBase64(b: Uint8Array): Base64String;
+export declare function bufferToBase64Url(b: Uint8Array): Base64UrlString;

package/dist/security/hash.util.js

@@ -18,10 +18,14 @@ export function hashAsBuffer(s, algorithm) {
     return cryptoHash(algorithm, s, 'buffer');
 }
 export function base64(s) {
-    return (typeof s === 'string' ? Buffer.from(s) : s).toString('base64');
+    if (typeof s === 'string')
+        return Buffer.from(s).toString('base64');
+    return bufferToBase64(s);
 }
 export function base64Url(s) {
-    return (typeof s === 'string' ? Buffer.from(s) : s).toString('base64url');
+    if (typeof s === 'string')
+        return Buffer.from(s).toString('base64url');
+    return bufferToBase64Url(s);
 }
 export function base64ToString(strBase64) {
     return Buffer.from(strBase64, 'base64').toString('utf8');
@@ -41,9 +45,13 @@ export function stringToBase64(s) {
 export function stringToBase64Url(s) {
     return Buffer.from(s, 'utf8').toString('base64url');
 }
+// 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) {
-    return b.toString('base64');
+    return Buffer.isBuffer(b) ? b.toString('base64') : b.toBase64();
 }
 export function bufferToBase64Url(b) {
-    return b.toString('base64url');
+    return Buffer.isBuffer(b)
+        ? b.toString('base64url')
+        : b.toBase64({ alphabet: 'base64url', omitPadding: true });
 }

package/dist/stream/index.d.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/dist/stream/index.js

@@ -23,7 +23,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 * from './writable/writableChunk.js';

package/dist/stream/pipeline.d.ts

@@ -10,7 +10,6 @@ import type { TransformMapSyncOptions } from './transform/transformMapSync.js';
 import type { TransformOffsetOptions } from './transform/transformOffset.js';
 import type { TransformThrottleOptions } from './transform/transformThrottle.js';
 import type { TransformThrottleByRSSOptions } from './transform/transformThrottleByRSS.js';
-import type { TransformWarmupOptions } from './transform/transformWarmup.js';
 export declare class Pipeline<T = unknown> {
     private readonly source;
     private transforms;
@@ -72,10 +71,6 @@ export declare class Pipeline<T = unknown> {
     tapSync(fn: IndexedMapper<T, void>, opt?: TransformOptions): this;
     throttle(opt: TransformThrottleOptions): this;
     throttleByRSS(opt: TransformThrottleByRSSOptions): this;
-    /**
-     * @experimental to be removed after transformMap2 is stable
-     */
-    warmup(opt: TransformWarmupOptions): this;
     transform<TO>(transform: TransformTyped<T, TO>): Pipeline<TO>;
     /**
      * Helper method to add multiple transforms at once.

package/dist/stream/pipeline.js

@@ -25,7 +25,6 @@ import { transformSplitOnNewline } from './transform/transformSplit.js';
 import { transformTap, transformTapSync } from './transform/transformTap.js';
 import { transformThrottle } from './transform/transformThrottle.js';
 import { transformThrottleByRSS } from './transform/transformThrottleByRSS.js';
-import { transformWarmup } from './transform/transformWarmup.js';
 import { writablePushToArray } from './writable/writablePushToArray.js';
 import { writableVoid } from './writable/writableVoid.js';
 export class Pipeline {
@@ -180,13 +179,6 @@ export class Pipeline {
         this.transforms.push(transformThrottleByRSS(opt));
         return this;
     }
-    /**
-     * @experimental to be removed after transformMap2 is stable
-     */
-    warmup(opt) {
-        this.transforms.push(transformWarmup(opt));
-        return this;
-    }
     transform(transform) {
         this.transforms.push(transform);
         return this;

package/dist/validation/timezones.js

@@ -1,4 +1,5 @@
 import { _uniq } from '@naturalcycles/js-lib/array';
+import { Intl2 } from '@naturalcycles/js-lib/intl';
 // List extracted from Wikipedia (https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
 // with the "Factory" value removed as its not working with our toolings
 const TIMEZONES_FROM_WIKI = [
@@ -600,8 +601,7 @@ const TIMEZONES_FROM_WIKI = [
     'WET',
     'Zulu',
 ];
-// oxlint-disable-next-line no-restricted-globals
-const TIMEZONES_FROM_JS = Intl.supportedValuesOf('timeZone');
+const TIMEZONES_FROM_JS = Intl2.getSupportedTimezones();
 /**
  * A complicated merge of timezones from the underlying Javascript engine
  * and a list exported from Wikipedia.

package/dist/zip/zip2.d.ts

@@ -4,59 +4,59 @@ import type { ZipEntry } from './zipReader.js';
 import { ZipWriter } from './zipWriter.js';
 import type { ZipFileEntry, ZipPathsOptions } from './zipWriter.js';
 declare class Zip2 {
-    decompressZstdOrInflateToString(buf: Buffer): Promise<string>;
-    decompressZstdOrInflateToStringSync(buf: Buffer): string;
+    decompressZstdOrInflateToString(buf: Uint8Array): Promise<string>;
+    decompressZstdOrInflateToStringSync(buf: Uint8Array): string;
     /**
      * Detects if Buffer is zstd-compressed.
      * Otherwise attempts to Inflate.
      */
-    decompressZstdOrInflate(buf: Buffer): Promise<Buffer<ArrayBuffer>>;
-    decompressZstdOrInflateSync(buf: Buffer): Buffer<ArrayBuffer>;
+    decompressZstdOrInflate(buf: Uint8Array): Promise<Buffer<ArrayBuffer>>;
+    decompressZstdOrInflateSync(buf: Uint8Array): Buffer<ArrayBuffer>;
     /**
      * deflateBuffer uses `deflate`.
      * It's 9 bytes shorter than `gzip`.
      */
-    deflate(input: string | Buffer, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
+    deflate(input: string | Uint8Array, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
     /**
      * deflateSync uses `deflate`.
      * It's 9 bytes shorter than `gzip`.
      */
-    deflateSync(input: string | Buffer, options?: ZlibOptions): Buffer<ArrayBuffer>;
-    inflate(buf: Buffer, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
-    inflateSync(buf: Buffer, options?: ZlibOptions): Buffer<ArrayBuffer>;
-    inflateToString(buf: Buffer, options?: ZlibOptions): Promise<string>;
-    inflateToStringSync(buf: Buffer, options?: ZlibOptions): string;
+    deflateSync(input: string | Uint8Array, options?: ZlibOptions): Buffer<ArrayBuffer>;
+    inflate(buf: Uint8Array, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
+    inflateSync(buf: Uint8Array, options?: ZlibOptions): Buffer<ArrayBuffer>;
+    inflateToString(buf: Uint8Array, options?: ZlibOptions): Promise<string>;
+    inflateToStringSync(buf: Uint8Array, options?: ZlibOptions): string;
     /**
      * gzipBuffer uses `gzip`
      * It's 9 bytes longer than `deflate`.
      */
-    gzip(input: string | Buffer, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
+    gzip(input: string | Uint8Array, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
     /**
      * gzipBuffer uses `gzip`
      * It's 9 bytes longer than `deflate`.
      */
-    gzipSync(input: string | Buffer, options?: ZlibOptions): Buffer<ArrayBuffer>;
-    gunzip(buf: Buffer, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
-    gunzipSync(buf: Buffer, options?: ZlibOptions): Buffer<ArrayBuffer>;
-    gunzipToString(buf: Buffer, options?: ZlibOptions): Promise<string>;
-    gunzipToStringSync(buf: Buffer, options?: ZlibOptions): string;
-    zstdCompress(input: Buffer | string, level?: Integer, // defaults to 3
+    gzipSync(input: string | Uint8Array, options?: ZlibOptions): Buffer<ArrayBuffer>;
+    gunzip(buf: Uint8Array, options?: ZlibOptions): Promise<Buffer<ArrayBuffer>>;
+    gunzipSync(buf: Uint8Array, options?: ZlibOptions): Buffer<ArrayBuffer>;
+    gunzipToString(buf: Uint8Array, options?: ZlibOptions): Promise<string>;
+    gunzipToStringSync(buf: Uint8Array, options?: ZlibOptions): string;
+    zstdCompress(input: Uint8Array | string, level?: Integer, // defaults to 3
     options?: ZstdOptions): Promise<Buffer<ArrayBuffer>>;
-    zstdCompressSync(input: Buffer | string, level?: Integer, // defaults to 3
+    zstdCompressSync(input: Uint8Array | string, level?: Integer, // defaults to 3
     options?: ZstdOptions): Buffer<ArrayBuffer>;
     zstdLevelToOptions(level: Integer | undefined, opt?: ZstdOptions): ZstdOptions;
-    zstdDecompressToString(input: Buffer, options?: ZstdOptions): Promise<string>;
+    zstdDecompressToString(input: Uint8Array, options?: ZstdOptions): Promise<string>;
     /**
      * Warning! It leaks memory severely. Prefer sync.
      */
-    zstdDecompress(input: Buffer, options?: ZstdOptions): Promise<Buffer<ArrayBuffer>>;
+    zstdDecompress(input: Uint8Array, options?: ZstdOptions): Promise<Buffer<ArrayBuffer>>;
     /**
      * Warning! It leaks memory severely. Prefer sync.
      */
-    zstdDecompressToStringSync(input: Buffer, options?: ZstdOptions): string;
-    zstdDecompressSync(input: Buffer, options?: ZstdOptions): Buffer<ArrayBuffer>;
-    isZstdBuffer(input: Buffer): boolean;
-    isGzipBuffer(input: Buffer): boolean;
+    zstdDecompressToStringSync(input: Uint8Array, options?: ZstdOptions): string;
+    zstdDecompressSync(input: Uint8Array, options?: ZstdOptions): Buffer<ArrayBuffer>;
+    isZstdBuffer(input: Uint8Array): boolean;
+    isGzipBuffer(input: Uint8Array): boolean;
     /**
      * Open a zip file and extract all of its entries into `destDir`, streaming each
      * file to disk. Directories are created as needed.
@@ -90,7 +90,7 @@ declare class Zip2 {
      *
      * For large archives or streamed inputs prefer {@link createZip} / {@link ZipWriter}.
      */
-    createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer>;
+    createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer<ArrayBuffer>>;
 }
 export declare const zip2: Zip2;
 export {};

package/dist/zip/zip2.js

@@ -122,7 +122,8 @@ class Zip2 {
         return zlib.zstdDecompressSync(input, options);
     }
     isZstdBuffer(input) {
-        return input.readUInt32LE(0) === ZSTD_MAGIC_NUMBER;
+        // zstd magic number 0xFD2FB528, stored little-endian
+        return input[0] === 0x28 && input[1] === 0xb5 && input[2] === 0x2f && input[3] === 0xfd;
     }
     isGzipBuffer(input) {
         return input[0] === 0x1f && input[1] === 0x8b;
@@ -177,4 +178,3 @@ class Zip2 {
     }
 }
 export const zip2 = new Zip2();
-const ZSTD_MAGIC_NUMBER = 0xfd2fb528;

package/dist/zip/zipWriter.d.ts

@@ -6,7 +6,7 @@ import type { UnixTimestamp } from '@naturalcycles/js-lib/types';
  *
  * 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)
@@ -25,7 +25,7 @@ export declare function zipPaths(paths: string[], outputZipFilePath: string, opt
  *
  * For large archives or streamed inputs prefer {@link createZip} / {@link ZipWriter}.
  */
-export declare function createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer>;
+export declare function createZipBuffer(entries: ZipFileEntry[]): Promise<Buffer<ArrayBuffer>>;
 /**
  * Options for {@link zipPaths}.
  */
@@ -69,7 +69,7 @@ export declare 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).
      */
-    addBuffer(data: Buffer, fileName: string, opt?: ZipWriterEntryOptions): Promise<void>;
+    addBuffer(data: Uint8Array, fileName: string, opt?: ZipWriterEntryOptions): Promise<void>;
     /**
      * Add a file from disk, streaming its contents. The entry's mtime and mode
      * default to the file's own (override via `opt`). If `fileName` is omitted,

package/dist/zip/zipWriter.js

@@ -38,7 +38,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)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.130.0",
+  "version": "15.131.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@standard-schema/spec": "^1",
@@ -14,7 +14,7 @@
     "yaml": "^2"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "0.0.0",
+    "@naturalcycles/dev-lib": "20.66.0",
     "typescript": "^7"
   },
   "exports": {
@@ -65,7 +65,7 @@
     "directory": "packages/nodejs-lib"
   },
   "engines": {
-    "node": ">=24.10.0"
+    "node": ">=26.12.1"
   },
   "description": "Standard library for Node.js",
   "author": "Natural Cycles Team",

package/src/fs/fs2.ts

@@ -47,11 +47,11 @@ class FS2 {
     return await fsp.readFile(filePath, 'utf8')
   }
 
-  readBuffer(filePath: string): Buffer {
+  readBuffer(filePath: string): Buffer<ArrayBuffer> {
     return fs.readFileSync(filePath)
   }
 
-  async readBufferAsync(filePath: string): Promise<Buffer> {
+  async readBufferAsync(filePath: string): Promise<Buffer<ArrayBuffer>> {
     return await fsp.readFile(filePath)
   }
 
@@ -65,13 +65,13 @@ class FS2 {
     return _jsonParse(str)
   }
 
-  writeFile(filePath: string, data: string | Buffer, opt?: WriteFileOptions): void {
+  writeFile(filePath: string, data: string | Uint8Array, opt?: WriteFileOptions): void {
     fs.writeFileSync(filePath, data, opt)
   }
 
   async writeFileAsync(
     filePath: string,
-    data: string | Buffer,
+    data: string | Uint8Array,
     opt?: WriteFileOptions,
   ): Promise<void> {
     await fsp.writeFile(filePath, data, opt)
@@ -95,11 +95,11 @@ class FS2 {
     await fsp.writeFile(filePath, str)
   }
 
-  appendFile(filePath: string, data: string | Buffer): void {
+  appendFile(filePath: string, data: string | Uint8Array): void {
     fs.appendFileSync(filePath, data)
   }
 
-  async appendFileAsync(filePath: string, data: string | Buffer): Promise<void> {
+  async appendFileAsync(filePath: string, data: string | Uint8Array): Promise<void> {
     await fsp.appendFile(filePath, data)
   }
 
@@ -112,7 +112,7 @@ class FS2 {
     this.outputFile(filePath, str)
   }
 
-  async outputPrettyAsync(filePath: string, data: any): Promise<void> {
+  async outputPrettyJsonAsync(filePath: string, data: any): Promise<void> {
     await this.outputJsonAsync(filePath, data, prettyJsonOptions)
   }
 
@@ -121,7 +121,7 @@ class FS2 {
     await this.outputFileAsync(filePath, str)
   }
 
-  outputFile(filePath: string, data: string | Buffer): void {
+  outputFile(filePath: string, data: string | Uint8Array): void {
     const dirPath = path.dirname(filePath)
     if (!fs.existsSync(dirPath)) {
       this.ensureDir(dirPath)
@@ -130,7 +130,7 @@ class FS2 {
     fs.writeFileSync(filePath, data)
   }
 
-  async outputFileAsync(filePath: string, data: string | Buffer): Promise<void> {
+  async outputFileAsync(filePath: string, data: string | Uint8Array): Promise<void> {
     const dirPath = path.dirname(filePath)
     if (!(await this.pathExistsAsync(dirPath))) {
       await this.ensureDirAsync(dirPath)
@@ -188,11 +188,8 @@ class FS2 {
       }
     } catch (err) {
       // If the stat call above failed because the directory doesn't exist, create it
-      if ((err as any)?.code === 'ENOENT') {
-        this.ensureDir(dir)
-        return
-      }
-      throw err
+      if ((err as any)?.code !== 'ENOENT') throw err
+      this.ensureDir(dir)
     }
 
     fs.writeFileSync(filePath, '')
@@ -214,8 +211,8 @@ class FS2 {
       }
     } catch (err) {
       // If the stat call above failed because the directory doesn't exist, create it
-      if ((err as any)?.code === 'ENOENT') return await this.ensureDirAsync(dir)
-      throw err
+      if ((err as any)?.code !== 'ENOENT') throw err
+      await this.ensureDirAsync(dir)
     }
 
     await fsp.writeFile(filePath, '')

package/src/secret/secrets-decrypt.util.ts

@@ -49,7 +49,7 @@ export function secretsDecrypt(
 
       const json = decryptObject(fs2.readJson(filename), encKeyBuffer)
 
-      fs2.writeJson(plainFilename, json, { spaces: 2 })
+      fs2.writePrettyJson(plainFilename, json)
     } else {
       const enc = fs.readFileSync(filename)
       const plain = decryptRandomIVBuffer(enc, encKeyBuffer)

package/src/secret/secrets-encrypt.util.ts

@@ -25,13 +25,10 @@ export function secretsEncrypt(
   del = false,
   jsonMode = false,
 ): void {
-  const patterns = file
-    ? [file]
-    : [
-        ...pattern,
-        `!**/*.enc`, // excluding already encoded
-      ]
-  const filenames = globSync(patterns)
+  // Already encrypted files are filtered out: a `!**/*.enc` pattern only excludes them under the cwd
+  const filenames = file
+    ? globSync([file])
+    : globSync(pattern).filter(filename => !filename.endsWith('.enc'))
   let encFilename: string
 
   filenames.forEach(filename => {
@@ -44,7 +41,7 @@ export function secretsEncrypt(
 
       const json = encryptObject(fs2.readJson(filename), encKeyBuffer)
 
-      fs2.writeJson(encFilename, json, { spaces: 2 })
+      fs2.writePrettyJson(encFilename, json)
     } else {
       const plain = fs.readFileSync(filename)
       const enc = encryptRandomIVBuffer(plain, encKeyBuffer)

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

@@ -54,8 +54,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'
 
@@ -257,14 +255,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/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/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/stream/transform/transformWarmup.ts

@@ -1,105 +0,0 @@
-import { Transform } from 'node:stream'
-import { createCommonLoggerAtLevel } from '@naturalcycles/js-lib/log'
-import type { DeferredPromise } from '@naturalcycles/js-lib/promise'
-import { pDefer } from '@naturalcycles/js-lib/promise/pDefer.js'
-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 function transformWarmup<T>(opt: TransformWarmupOptions): TransformTyped<T, T> {
-  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: DeferredPromise[] = []
-
-  return new Transform({
-    objectMode,
-    highWaterMark,
-    async transform(item: T, _, 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(): number {
-    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(): void {
-    inFlight--
-    // Wake up waiters based on current concurrency (may have increased)
-    const currentConcurrency = getCurrentConcurrency()
-    while (waiters.length && inFlight < currentConcurrency) {
-      inFlight++
-      waiters.shift()!.resolve()
-    }
-  }
-}