@naturalcycles/nodejs-lib 15.130.1 → 15.132.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;
     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

@@ -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/index.d.ts

@@ -1,4 +1,3 @@
-export * from './buffer/buffer.util.js';
 export * from './diff/tableDiff.js';
 export * from './infra/process.util.js';
 export * from './log/log.util.js';

package/dist/index.js

@@ -1,4 +1,3 @@
-export * from './buffer/buffer.util.js';
 export * from './diff/tableDiff.js';
 export * from './infra/process.util.js';
 export * from './log/log.util.js';

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

@@ -10,13 +10,10 @@ 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) {

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

@@ -1,7 +1,7 @@
 import type { Transform } from 'node:stream';
 import type { ReadableStream as WebReadableStream } from 'node:stream/web';
 import type { ZlibOptions, ZstdOptions } from 'node:zlib';
-import type { AbortableAsyncMapper, AbortableMapper, AsyncIndexedMapper, AsyncPredicate, END, IndexedMapper, Integer, NonNegativeInteger, PositiveInteger, Predicate, SKIP } from '@naturalcycles/js-lib/types';
+import type { AbortableAsyncMapper, AbortableMapper, AsyncIndexedMapper, AsyncPredicate, END, IndexedMapper, Integer, NonEmptyArray, NonNegativeInteger, PositiveInteger, Predicate, SKIP } from '@naturalcycles/js-lib/types';
 import type { ReadableTyped, TransformOptions, TransformTyped, WritableTyped } from './stream.model.js';
 import type { TransformLogProgressOptions } from './transform/transformLogProgress.js';
 import type { TransformMapOptions } from './transform/transformMap.js';
@@ -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;
@@ -58,7 +57,7 @@ export declare class Pipeline<T = unknown> {
      * less clean than `.take()` on the source.
      */
     limit(limit: NonNegativeInteger | undefined): this;
-    chunk(chunkSize: PositiveInteger, opt?: TransformOptions): Pipeline<T[]>;
+    chunk(chunkSize: PositiveInteger, opt?: TransformOptions): Pipeline<NonEmptyArray<T>>;
     flatten<TO>(this: Pipeline<readonly TO[]>): Pipeline<TO>;
     flattenIfNeeded(): Pipeline<T extends readonly (infer TO)[] ? TO : T>;
     logProgress(opt?: TransformLogProgressOptions): this;
@@ -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/stream/transform/transformChunk.d.ts

@@ -1,4 +1,4 @@
-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';
 /**
  * Similar to RxJS bufferCount(),
@@ -8,4 +8,4 @@ import type { TransformOptions, TransformTyped } from '../stream.model.js';
  * `chunkSize` indicates how many items to include in each chunk.
  * Last chunk will contain the remaining items, possibly less than chunkSize.
  */
-export declare function transformChunk<IN = any>(chunkSize: PositiveInteger, opt?: TransformOptions): TransformTyped<IN, IN[]>;
+export declare function transformChunk<IN = any>(chunkSize: PositiveInteger, opt?: TransformOptions): TransformTyped<IN, NonEmptyArray<IN>>;

package/dist/stream/transform/transformChunk.js

@@ -8,6 +8,7 @@ import { Transform } from 'node:stream';
  * Last chunk will contain the remaining items, possibly less than chunkSize.
  */
 export function transformChunk(chunkSize, opt) {
+    // Only non-empty buffers are emitted
     let buf = [];
     return new Transform({
         objectMode: true,

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.1",
+  "version": "15.132.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@standard-schema/spec": "^1",
@@ -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)
   }
 
@@ -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/index.ts

@@ -1,4 +1,3 @@
-export * from './buffer/buffer.util.js'
 export * from './diff/tableDiff.js'
 export * from './infra/process.util.js'
 export * from './log/log.util.js'

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 => {