simple-zstd 2.0.0 → 2.1.0

package/dist/src/process-queue.js

@@ -1,94 +1,81 @@
 "use strict";
 // This is a generic class for creating a queue of worker processes.
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _ProcessQueue_instances, _ProcessQueue_targetSize, _ProcessQueue_queue, _ProcessQueue_factory, _ProcessQueue_destroy, _ProcessQueue_hitCount, _ProcessQueue_missCount, _ProcessQueue_destroyed, _ProcessQueue_createResource;
 Object.defineProperty(exports, "__esModule", { value: true });
 const debug_1 = __importDefault(require("debug"));
 const debug = (0, debug_1.default)('SimpleZSTDQueue');
 class ProcessQueue {
+    #targetSize;
+    #queue;
+    #factory;
+    #destroy;
+    #hitCount;
+    #missCount;
+    #destroyed;
     constructor(targetSize, factory, destroy) {
-        _ProcessQueue_instances.add(this);
-        _ProcessQueue_targetSize.set(this, void 0);
-        _ProcessQueue_queue.set(this, void 0);
-        _ProcessQueue_factory.set(this, void 0);
-        _ProcessQueue_destroy.set(this, void 0);
-        _ProcessQueue_hitCount.set(this, void 0);
-        _ProcessQueue_missCount.set(this, void 0);
-        _ProcessQueue_destroyed.set(this, void 0);
         debug('constructor', targetSize);
-        __classPrivateFieldSet(this, _ProcessQueue_targetSize, targetSize, "f");
-        __classPrivateFieldSet(this, _ProcessQueue_queue, [], "f");
-        __classPrivateFieldSet(this, _ProcessQueue_factory, factory, "f");
-        __classPrivateFieldSet(this, _ProcessQueue_destroy, destroy, "f");
-        __classPrivateFieldSet(this, _ProcessQueue_hitCount, 0, "f");
-        __classPrivateFieldSet(this, _ProcessQueue_missCount, 0, "f");
-        __classPrivateFieldSet(this, _ProcessQueue_destroyed, false, "f");
+        this.#targetSize = targetSize;
+        this.#queue = [];
+        this.#factory = factory;
+        this.#destroy = destroy;
+        this.#hitCount = 0;
+        this.#missCount = 0;
+        this.#destroyed = false;
         for (let i = 0; i < targetSize || 0; i += 1) {
-            __classPrivateFieldGet(this, _ProcessQueue_instances, "m", _ProcessQueue_createResource).call(this);
+            this.#createResource();
         }
     }
     get hits() {
-        return __classPrivateFieldGet(this, _ProcessQueue_hitCount, "f");
+        return this.#hitCount;
     }
     get misses() {
-        return __classPrivateFieldGet(this, _ProcessQueue_missCount, "f");
+        return this.#missCount;
+    }
+    async #createResource() {
+        debug('createResource?', this.#queue.length);
+        if (this.#destroyed) {
+            debug('createResource skipped - queue destroyed');
+            return;
+        }
+        if (this.#queue.length < this.#targetSize) {
+            debug('createResource call factory');
+            this.#queue.push(this.#factory());
+        }
     }
     async acquire() {
         debug('acquire');
-        const attempt = __classPrivateFieldGet(this, _ProcessQueue_queue, "f").pop();
+        const attempt = this.#queue.pop();
         if (attempt) {
             debug('acquire hit');
-            if (!__classPrivateFieldGet(this, _ProcessQueue_destroyed, "f")) {
+            if (!this.#destroyed) {
                 setImmediate(() => {
                     // Double-check destroyed flag in case it changed
-                    if (!__classPrivateFieldGet(this, _ProcessQueue_destroyed, "f")) {
-                        __classPrivateFieldGet(this, _ProcessQueue_instances, "m", _ProcessQueue_createResource).call(this);
+                    if (!this.#destroyed) {
+                        this.#createResource();
                     }
                 });
             }
-            __classPrivateFieldSet(this, _ProcessQueue_hitCount, __classPrivateFieldGet(this, _ProcessQueue_hitCount, "f") + 1, "f");
+            this.#hitCount += 1;
             return attempt;
         }
         debug('acquire miss');
-        __classPrivateFieldSet(this, _ProcessQueue_missCount, __classPrivateFieldGet(this, _ProcessQueue_missCount, "f") + 1, "f");
-        return __classPrivateFieldGet(this, _ProcessQueue_factory, "f").call(this);
+        this.#missCount += 1;
+        return this.#factory();
     }
     async destroy() {
-        debug('destroy', __classPrivateFieldGet(this, _ProcessQueue_queue, "f").length);
-        __classPrivateFieldSet(this, _ProcessQueue_destroyed, true, "f");
+        debug('destroy', this.#queue.length);
+        this.#destroyed = true;
         const destroyPromises = [];
-        while (__classPrivateFieldGet(this, _ProcessQueue_queue, "f").length > 0) {
-            const p = __classPrivateFieldGet(this, _ProcessQueue_queue, "f").pop();
+        while (this.#queue.length > 0) {
+            const p = this.#queue.pop();
             if (p) {
-                destroyPromises.push(Promise.resolve(__classPrivateFieldGet(this, _ProcessQueue_destroy, "f").call(this, p)));
+                destroyPromises.push(Promise.resolve(this.#destroy(p)));
             }
         }
         await Promise.all(destroyPromises);
     }
 }
-_ProcessQueue_targetSize = new WeakMap(), _ProcessQueue_queue = new WeakMap(), _ProcessQueue_factory = new WeakMap(), _ProcessQueue_destroy = new WeakMap(), _ProcessQueue_hitCount = new WeakMap(), _ProcessQueue_missCount = new WeakMap(), _ProcessQueue_destroyed = new WeakMap(), _ProcessQueue_instances = new WeakSet(), _ProcessQueue_createResource = async function _ProcessQueue_createResource() {
-    debug('createResource?', __classPrivateFieldGet(this, _ProcessQueue_queue, "f").length);
-    if (__classPrivateFieldGet(this, _ProcessQueue_destroyed, "f")) {
-        debug('createResource skipped - queue destroyed');
-        return;
-    }
-    if (__classPrivateFieldGet(this, _ProcessQueue_queue, "f").length < __classPrivateFieldGet(this, _ProcessQueue_targetSize, "f")) {
-        debug('createResource call factory');
-        __classPrivateFieldGet(this, _ProcessQueue_queue, "f").push(__classPrivateFieldGet(this, _ProcessQueue_factory, "f").call(this));
-    }
-};
 exports.default = ProcessQueue;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1xdWV1ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm9jZXNzLXF1ZXVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxvRUFBb0U7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRXBFLGtEQUEwQjtBQUUxQixNQUFNLEtBQUssR0FBRyxJQUFBLGVBQUssRUFBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBRXZDLE1BQXFCLFlBQVk7SUFlL0IsWUFDRSxVQUFrQixFQUNsQixPQUFpQyxFQUNqQyxPQUE4Qzs7UUFqQmhELDJDQUFZO1FBRVosc0NBQWtDO1FBRWxDLHdDQUFtQztRQUVuQyx3Q0FBZ0Q7UUFFaEQseUNBQVU7UUFFViwwQ0FBVztRQUVYLDBDQUFvQjtRQU9sQixLQUFLLENBQUMsYUFBYSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ2pDLHVCQUFBLElBQUksNEJBQWUsVUFBVSxNQUFBLENBQUM7UUFDOUIsdUJBQUEsSUFBSSx1QkFBVSxFQUFFLE1BQUEsQ0FBQztRQUNqQix1QkFBQSxJQUFJLHlCQUFZLE9BQU8sTUFBQSxDQUFDO1FBQ3hCLHVCQUFBLElBQUkseUJBQVksT0FBTyxNQUFBLENBQUM7UUFFeEIsdUJBQUEsSUFBSSwwQkFBYSxDQUFDLE1BQUEsQ0FBQztRQUNuQix1QkFBQSxJQUFJLDJCQUFjLENBQUMsTUFBQSxDQUFDO1FBQ3BCLHVCQUFBLElBQUksMkJBQWMsS0FBSyxNQUFBLENBQUM7UUFFeEIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFVBQVUsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQzVDLHVCQUFBLElBQUksNkRBQWdCLE1BQXBCLElBQUksQ0FBa0IsQ0FBQztRQUN6QixDQUFDO0lBQ0gsQ0FBQztJQUVELElBQUksSUFBSTtRQUNOLE9BQU8sdUJBQUEsSUFBSSw4QkFBVSxDQUFDO0lBQ3hCLENBQUM7SUFFRCxJQUFJLE1BQU07UUFDUixPQUFPLHVCQUFBLElBQUksK0JBQVcsQ0FBQztJQUN6QixDQUFDO0lBY0QsS0FBSyxDQUFDLE9BQU87UUFDWCxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDakIsTUFBTSxPQUFPLEdBQUcsdUJBQUEsSUFBSSwyQkFBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWxDLElBQUksT0FBTyxFQUFFLENBQUM7WUFDWixLQUFLLENBQUMsYUFBYSxDQUFDLENBQUM7WUFDckIsSUFBSSxDQUFDLHVCQUFBLElBQUksK0JBQVcsRUFBRSxDQUFDO2dCQUNyQixZQUFZLENBQUMsR0FBRyxFQUFFO29CQUNoQixpREFBaUQ7b0JBQ2pELElBQUksQ0FBQyx1QkFBQSxJQUFJLCtCQUFXLEVBQUUsQ0FBQzt3QkFDckIsdUJBQUEsSUFBSSw2REFBZ0IsTUFBcEIsSUFBSSxDQUFrQixDQUFDO29CQUN6QixDQUFDO2dCQUNILENBQUMsQ0FBQyxDQUFDO1lBQ0wsQ0FBQztZQUNELGlIQUFrQixDQUFDLE1BQUEsQ0FBQztZQUNwQixPQUFPLE9BQU8sQ0FBQztRQUNqQixDQUFDO1FBRUQsS0FBSyxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQ3RCLG1IQUFtQixDQUFDLE1BQUEsQ0FBQztRQUNyQixPQUFPLHVCQUFBLElBQUksNkJBQVMsTUFBYixJQUFJLENBQVcsQ0FBQztJQUN6QixDQUFDO0lBRUQsS0FBSyxDQUFDLE9BQU87UUFDWCxLQUFLLENBQUMsU0FBUyxFQUFFLHVCQUFBLElBQUksMkJBQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNyQyx1QkFBQSxJQUFJLDJCQUFjLElBQUksTUFBQSxDQUFDO1FBQ3ZCLE1BQU0sZUFBZSxHQUFvQixFQUFFLENBQUM7UUFDNUMsT0FBTyx1QkFBQSxJQUFJLDJCQUFPLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQzlCLE1BQU0sQ0FBQyxHQUFHLHVCQUFBLElBQUksMkJBQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUM1QixJQUFJLENBQUMsRUFBRSxDQUFDO2dCQUNOLGVBQWUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyx1QkFBQSxJQUFJLDZCQUFTLE1BQWIsSUFBSSxFQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUMxRCxDQUFDO1FBQ0gsQ0FBQztRQUNELE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUNyQyxDQUFDO0NBQ0Y7K1ZBL0NDLEtBQUs7SUFDSCxLQUFLLENBQUMsaUJBQWlCLEVBQUUsdUJBQUEsSUFBSSwyQkFBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzdDLElBQUksdUJBQUEsSUFBSSwrQkFBVyxFQUFFLENBQUM7UUFDcEIsS0FBSyxDQUFDLDBDQUEwQyxDQUFDLENBQUM7UUFDbEQsT0FBTztJQUNULENBQUM7SUFDRCxJQUFJLHVCQUFBLElBQUksMkJBQU8sQ0FBQyxNQUFNLEdBQUcsdUJBQUEsSUFBSSxnQ0FBWSxFQUFFLENBQUM7UUFDMUMsS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUM7UUFDckMsdUJBQUEsSUFBSSwyQkFBTyxDQUFDLElBQUksQ0FBQyx1QkFBQSxJQUFJLDZCQUFTLE1BQWIsSUFBSSxDQUFXLENBQUMsQ0FBQztJQUNwQyxDQUFDO0FBQ0gsQ0FBQztrQkFyRGtCLFlBQVkifQ==
+//# sourceMappingURL=process-queue.js.map

package/dist/src/process-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-queue.js","sourceRoot":"","sources":["../../src/process-queue.ts"],"names":[],"mappings":"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"}

package/dist/src/types.d.ts

@@ -17,6 +17,12 @@ export interface DecompressOpts {
     spawnOptions?: SpawnOptions;
     streamOptions?: DuplexOptions;
 }
+export interface CreateDictionaryOpts {
+    trainingFiles: Array<string | Buffer>;
+    maxDictSize?: number;
+    zstdOptions?: string[];
+    spawnOptions?: SpawnOptions;
+}
 export interface PoolOpts {
     compressQueueSize?: number;
     decompressQueueSize?: number;

package/dist/src/types.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9
+//# sourceMappingURL=types.js.map

package/dist/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "simple-zstd",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Node.js interface to the system installed zstd.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "scripts": {
     "build": "tsc",
     "prepublish": "tsc",
-    "lint": "eslint . --ext .ts",
+    "lint": "eslint .",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
-    "test": "timeout --signal=TERM --kill-after=5s 120s node --test --require ts-node/register test/test.ts || true",
-    "test-debug": "DEBUG=SimpleZSTD,SimpleZSTDQueue timeout --signal=TERM --kill-after=5s 120s node --test --require ts-node/register test/test.ts || true",
-    "test-ci": "timeout --signal=TERM --kill-after=5s 120s node --test --require ts-node/register test/test.ts && exit 0 || exit 1",
-    "coverage": "timeout --signal=TERM --kill-after=5s 120s node --test --experimental-test-coverage --require ts-node/register test/test.ts || true"
+    "test": "node --test --require ts-node/register test/**/*.test.ts || true",
+    "test-debug": "DEBUG=SimpleZSTD,SimpleZSTDQueue timeout -t 120s -- node --test --require ts-node/register test/**/*.test.ts || true",
+    "test-ci": "node --test --require ts-node/register test/**/*.test.ts && exit 0 || exit 1",
+    "coverage": "node --test --experimental-test-coverage --require ts-node/register test/**/*.test.ts || true"
   },
   "repository": {
     "type": "git",
@@ -54,15 +54,16 @@
   },
   "homepage": "https://github.com/Stieneee/simple-zstd#readme",
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@release-it/conventional-changelog": "^10.0.1",
     "@types/debug": "^4.1.12",
-    "@types/node": "^24.10.0",
-    "@typescript-eslint/eslint-plugin": "^8.46.3",
-    "@typescript-eslint/parser": "^8.46.3",
-    "eslint": "^9.39.1",
+    "@types/node": "^25.5.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.0",
+    "@typescript-eslint/parser": "^8.57.0",
+    "eslint": "^10.0.3",
     "eslint-config-prettier": "^10.1.8",
-    "globals": "^16.5.0",
-    "prettier": "^3.6.2",
+    "globals": "^17.4.0",
+    "prettier": "^3.8.1",
     "release-it": "^19.0.6",
     "ts-node": "^10.9.1",
     "typescript": "^5.9.3"
@@ -70,7 +71,6 @@
   "dependencies": {
     "debug": "^4.3.4",
     "is-zst": "^1.0.0",
-    "tmp": "^0.2.1",
     "tmp-promise": "^3.0.3"
   },
   "packageManager": "npm@11.6.2"

package/src/index.ts

@@ -1,12 +1,13 @@
 import fs from 'node:fs';
-import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { writeFile, readFile, copyFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { Readable, Duplex, PassThrough } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
-import { execSync } from 'node:child_process';
+import { execSync, execFile } from 'node:child_process';
 
 import isZst from 'is-zst';
-import { file } from 'tmp-promise';
+import { dir } from 'tmp-promise';
 import Debug from 'debug';
 
 const debug = Debug('SimpleZSTD');
@@ -15,14 +16,35 @@ import ProcessQueue from './process-queue';
 import BufferWritable from './buffer-writable';
 import ProcessDuplex from './process-duplex';
 import PeekPassThrough from './peek-transform';
-import { ZSTDOpts, PoolOpts } from './types';
+import { ZSTDOpts, PoolOpts, CreateDictionaryOpts } from './types';
 
 // Export types for consumers
-export type { ZSTDOpts, PoolOpts, CompressOpts, DecompressOpts, DictionaryObject } from './types';
+export type {
+  ZSTDOpts,
+  PoolOpts,
+  CompressOpts,
+  DecompressOpts,
+  DictionaryObject,
+  CreateDictionaryOpts,
+} from './types';
 
 // Dictionary cache to avoid recreating temp files for the same dictionary buffer
 // Map: hash -> { path: string, cleanup: () => void, refCount: number }
-const dictionaryCache = new Map<string, { path: string; cleanup: () => void; refCount: number }>();
+const dictionaryCache = new Map<
+  string,
+  { path: string; cleanup: () => Promise<void>; refCount: number }
+>();
+
+async function createTempDirectory(prefix: string): Promise<{
+  directoryPath: string;
+  cleanup: () => Promise<void>;
+}> {
+  const { path: tempDirectory, cleanup } = await dir({ prefix, unsafeCleanup: true });
+  return {
+    directoryPath: tempDirectory,
+    cleanup: () => Promise.resolve(cleanup()),
+  };
+}
 
 function hashBuffer(buffer: Buffer): string {
   return createHash('sha256').update(buffer).digest('hex');
@@ -51,17 +73,18 @@ async function getCachedDictionaryPath(
   }
 
   debug(`Dictionary cache miss: ${hash.slice(0, 8)}... - creating temp file`);
-  const { path, cleanup: tmpCleanup } = await file({ prefix: 'zstd-dict-' });
-  await writeFile(path, dictionary);
+  const { directoryPath, cleanup: tmpCleanup } = await createTempDirectory('zstd-dict-cache-');
+  const dictionaryPath = path.join(directoryPath, 'dictionary.zstd');
+  await writeFile(dictionaryPath, dictionary);
 
   dictionaryCache.set(hash, {
-    path,
+    path: dictionaryPath,
     cleanup: tmpCleanup,
     refCount: 1,
   });
 
   return {
-    path,
+    path: dictionaryPath,
     cleanup: () => {
       const cached = dictionaryCache.get(hash);
       if (cached) {
@@ -115,7 +138,6 @@ try {
 async function CreateCompressStream(compLevel: number, opts: ZSTDOpts): Promise<Duplex> {
   let lvl = compLevel;
   let zo = opts.zstdOptions || [];
-  let path: string | null = null;
   let cleanup: () => void = () => null;
 
   if (!lvl) lvl = 3;
@@ -126,15 +148,22 @@ async function CreateCompressStream(compLevel: number, opts: ZSTDOpts): Promise<
     zo = [...zo, '-D', `${opts.dictionary.path}`];
   } else if (Buffer.isBuffer(opts.dictionary)) {
     // Use cached dictionary to avoid recreating temp files
-    ({ path, cleanup } = await getCachedDictionaryPath(opts.dictionary));
-    zo = [...zo, '-D', `${path}`];
+    const cached = await getCachedDictionaryPath(opts.dictionary);
+    cleanup = cached.cleanup;
+    zo = [...zo, '-D', cached.path];
   }
 
   let c: Duplex;
 
   try {
     debug(bin, ['-zc', `-${lvl}`, ...zo], opts.spawnOptions, opts.streamOptions);
-    c = new ProcessDuplex(bin, ['-zc', `-${lvl}`, ...zo], opts.spawnOptions, opts.streamOptions);
+    c = new ProcessDuplex({
+      command: bin,
+      args: ['-zc', `-${lvl}`, ...zo],
+      spawnOptions: opts.spawnOptions,
+      streamOptions: opts.streamOptions,
+      nonZeroExitPolicy: true,
+    });
   } catch (err) {
     // cleanup if error;
     cleanup();
@@ -143,11 +172,6 @@ async function CreateCompressStream(compLevel: number, opts: ZSTDOpts): Promise<
 
   c.on('exit', (code: number, signal) => {
     debug('c exit', code, signal);
-    if (code !== 0) {
-      setImmediate(() => {
-        c.destroy(new Error(`zstd exited non zero. code: ${code} signal: ${signal}`));
-      });
-    }
     cleanup();
   });
 
@@ -183,7 +207,6 @@ function CompressBuffer(buffer: Buffer, c: Duplex): Promise<Buffer> {
 async function CreateDecompressStream(opts: ZSTDOpts): Promise<Duplex> {
   // Dictionary
   let zo = opts.zstdOptions || [];
-  let path: string | null = null;
   let cleanup: () => void = () => null;
 
   let terminate = false;
@@ -192,15 +215,22 @@ async function CreateDecompressStream(opts: ZSTDOpts): Promise<Duplex> {
     zo = [...zo, '-D', `${opts.dictionary.path}`];
   } else if (Buffer.isBuffer(opts.dictionary)) {
     // Use cached dictionary to avoid recreating temp files
-    ({ path, cleanup } = await getCachedDictionaryPath(opts.dictionary));
-    zo = [...zo, '-D', `${path}`];
+    const cached = await getCachedDictionaryPath(opts.dictionary);
+    cleanup = cached.cleanup;
+    zo = [...zo, '-D', cached.path];
   }
 
   let d: Duplex;
 
   try {
     debug(bin, ['-dc', ...zo], opts.spawnOptions, opts.streamOptions);
-    d = new ProcessDuplex(bin, ['-dc', ...zo], opts.spawnOptions, opts.streamOptions);
+    d = new ProcessDuplex({
+      command: bin,
+      args: ['-dc', ...zo],
+      spawnOptions: opts.spawnOptions,
+      streamOptions: opts.streamOptions,
+      nonZeroExitPolicy: () => !terminate,
+    });
   } catch (err) {
     // cleanup if error
     cleanup();
@@ -209,11 +239,6 @@ async function CreateDecompressStream(opts: ZSTDOpts): Promise<Duplex> {
 
   d.on('exit', (code: number, signal) => {
     debug('d exit', code, signal);
-    if (code !== 0 && !terminate) {
-      setImmediate(() => {
-        d.destroy(new Error(`zstd exited non zero. code: ${code} signal: ${signal}`));
-      });
-    }
     cleanup();
   });
 
@@ -281,24 +306,138 @@ export function decompress(opts: ZSTDOpts = {}): Promise<Duplex> {
 }
 
 export async function decompressBuffer(buffer: Buffer, opts: ZSTDOpts = {}): Promise<Buffer> {
-  const d = await CreateDecompressStream(opts);
-  return DecompressBuffer(buffer, d);
+  // Preserve "smart decompression" behavior for non-zstd payloads.
+  if (!isZst(buffer)) {
+    return buffer;
+  }
+
+  let zo = opts.zstdOptions || [];
+  let cleanup: () => void = () => null;
+
+  if (opts.dictionary && 'path' in opts.dictionary) {
+    zo = [...zo, '-D', `${opts.dictionary.path}`];
+  } else if (Buffer.isBuffer(opts.dictionary)) {
+    const cachedDictionary = await getCachedDictionaryPath(opts.dictionary);
+    zo = [...zo, '-D', `${cachedDictionary.path}`];
+    cleanup = cachedDictionary.cleanup;
+  }
+
+  const args = ['-dc', ...zo];
+
+  return new Promise((resolve, reject) => {
+    debug(bin, args, opts.spawnOptions);
+    const child = execFile(
+      bin,
+      args,
+      {
+        ...(opts.spawnOptions ?? {}),
+        encoding: 'buffer',
+        maxBuffer: 512 * 1024 * 1024,
+      },
+      (error, stdout, stderr) => {
+        cleanup();
+
+        if (!error) {
+          resolve(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
+          return;
+        }
+
+        const code = typeof error.code === 'number' ? error.code : null;
+        const signal = error.signal ?? null;
+        const stdErrMessage = stderr?.toString().trim();
+        const errorMessage = stdErrMessage
+          ? `zstd decompression failed (code: ${code}, signal: ${signal}): ${stdErrMessage}`
+          : `zstd decompression failed (code: ${code}, signal: ${signal})`;
+
+        reject(new Error(errorMessage));
+      }
+    );
+
+    child.stdin?.end(buffer);
+  });
+}
+
+export async function createDictionary(opts: CreateDictionaryOpts): Promise<Buffer> {
+  if (!Array.isArray(opts.trainingFiles) || opts.trainingFiles.length === 0) {
+    throw new Error('createDictionary requires at least one training file or buffer');
+  }
+
+  const { path: tempRunDirectory, cleanup } = await dir({
+    prefix: 'zstd-dict-create-run-',
+    unsafeCleanup: true,
+  });
+
+  try {
+    const trainingPaths: string[] = [];
+    const outputPath = path.join(tempRunDirectory, 'dictionary.zstd');
+
+    for (const [index, trainingInput] of opts.trainingFiles.entries()) {
+      const stagedTrainingPath = path.join(tempRunDirectory, `training-${index}.bin`);
+
+      if (typeof trainingInput === 'string') {
+        await copyFile(trainingInput, stagedTrainingPath);
+        trainingPaths.push(stagedTrainingPath);
+        continue;
+      }
+
+      if (Buffer.isBuffer(trainingInput)) {
+        await writeFile(stagedTrainingPath, trainingInput);
+        trainingPaths.push(stagedTrainingPath);
+        continue;
+      }
+
+      throw new Error('createDictionary trainingFiles entries must be file paths or Buffers');
+    }
+
+    const args = ['--train', ...trainingPaths, '-o', outputPath];
+
+    if (opts.maxDictSize && opts.maxDictSize > 0) {
+      args.push(`--maxdict=${opts.maxDictSize}`);
+    }
+
+    if (opts.zstdOptions?.length) {
+      args.push(...opts.zstdOptions);
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      debug(bin, args, opts.spawnOptions);
+      execFile(bin, args, opts.spawnOptions ?? {}, (error, _stdout, stderr) => {
+        if (!error) {
+          resolve();
+          return;
+        }
+
+        const code = typeof error.code === 'number' ? error.code : null;
+        const signal = error.signal ?? null;
+        const stdErrMessage = stderr?.toString().trim();
+        const errorMessage = stdErrMessage
+          ? `zstd dictionary training failed (code: ${code}, signal: ${signal}): ${stdErrMessage}`
+          : `zstd dictionary training failed (code: ${code}, signal: ${signal})`;
+
+        reject(new Error(errorMessage));
+      });
+    });
+
+    return readFile(outputPath);
+  } finally {
+    await cleanup();
+  }
 }
 
 // SimpleZSTD Class
 export class SimpleZSTD {
   #compressQueue!: ProcessQueue<Duplex>;
   #decompressQueue!: ProcessQueue<Duplex>;
-  #compressDictCleanup: () => void = () => null;
-  #decompressDictCleanup: () => void = () => null;
+  #compressDictCleanup: () => Promise<void> = async () => undefined;
+  #decompressDictCleanup: () => Promise<void> = async () => undefined;
   #ready;
   #poolOptions?: PoolOpts;
 
   private constructor(poolOptions?: PoolOpts) {
     debug('constructor', poolOptions);
     this.#poolOptions = poolOptions;
-    this.#compressDictCleanup = () => null;
-    this.#decompressDictCleanup = () => null;
+    this.#compressDictCleanup = async () => undefined;
+    this.#decompressDictCleanup = async () => undefined;
 
     this.#ready = new Promise((resolve, reject) => {
       (async () => {
@@ -309,10 +448,13 @@ export class SimpleZSTD {
           if (compressDict && 'path' in compressDict) {
             compressDictPath = compressDict.path;
           } else if (compressDict && Buffer.isBuffer(compressDict)) {
-            const { path, cleanup } = await file({ prefix: 'zstd-dict-' });
+            const { directoryPath, cleanup } = await createTempDirectory(
+              'zstd-dict-pool-compress-'
+            );
+            const dictionaryPath = path.join(directoryPath, 'dictionary.zstd');
             this.#compressDictCleanup = cleanup;
-            await writeFile(path, compressDict);
-            compressDictPath = path;
+            await writeFile(dictionaryPath, compressDict);
+            compressDictPath = dictionaryPath;
           }
 
           // Handle decompress queue dictionary
@@ -321,10 +463,13 @@ export class SimpleZSTD {
           if (decompressDict && 'path' in decompressDict) {
             decompressDictPath = decompressDict.path;
           } else if (decompressDict && Buffer.isBuffer(decompressDict)) {
-            const { path, cleanup } = await file({ prefix: 'zstd-dict-' });
+            const { directoryPath, cleanup } = await createTempDirectory(
+              'zstd-dict-pool-decompress-'
+            );
+            const dictionaryPath = path.join(directoryPath, 'dictionary.zstd');
             this.#decompressDictCleanup = cleanup;
-            await writeFile(path, decompressDict);
-            decompressDictPath = path;
+            await writeFile(dictionaryPath, decompressDict);
+            decompressDictPath = dictionaryPath;
           }
 
           this.#compressQueue = new ProcessQueue(
@@ -381,10 +526,10 @@ export class SimpleZSTD {
       })();
     }).catch((err) => {
       debug('ready error', err);
-      this.#compressDictCleanup();
-      this.#decompressDictCleanup();
-      this.#compressDictCleanup = () => null;
-      this.#decompressDictCleanup = () => null;
+      void this.#compressDictCleanup();
+      void this.#decompressDictCleanup();
+      this.#compressDictCleanup = async () => undefined;
+      this.#decompressDictCleanup = async () => undefined;
     });
   }
 
@@ -414,10 +559,10 @@ export class SimpleZSTD {
 
   async destroy() {
     await Promise.all([this.#compressQueue.destroy(), this.#decompressQueue.destroy()]);
-    this.#compressDictCleanup();
-    this.#decompressDictCleanup();
-    this.#compressDictCleanup = () => null;
-    this.#decompressDictCleanup = () => null;
+    await this.#compressDictCleanup();
+    await this.#decompressDictCleanup();
+    this.#compressDictCleanup = async () => undefined;
+    this.#decompressDictCleanup = async () => undefined;
   }
 
   /**