@push.rocks/smartrust 1.1.2 → 1.2.1

package/changelog.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 2026-02-12 - 1.2.1 - fix(rust-binary-locator)
+auto-fix missing execute permission for located Rust binaries
+
+- If a located binary exists but lacks the execute bit, attempt to chmod it to 0o755 and treat it as executable.
+- Logs an info message when the auto-fix is applied: 'Auto-fixed missing execute permission on: <filePath>'.
+- Addresses cases where npm/pnpm installs remove the execute permission from bundled binaries.
+
+## 2026-02-11 - 1.2.0 - feat(rustbridge)
+add streaming responses and robust large-payload/backpressure handling to RustBridge
+
+- Introduce StreamingResponse type and export it (for-await-of iterator + .result promise)
+- Add sendCommandStreaming API to send streaming commands and receive chunks + final result
+- Implement buffer-based stdout newline scanner to handle large messages and avoid readline limits
+- Add backpressure-aware writeToStdin to wait for drain when writing large outbound payloads
+- Add maxPayloadSize option and enforce outbound/inbound size checks to prevent OOMs
+- Add streamTimeoutMs (inactivity timeout) and reset timeout on each received chunk
+- Improve stderr handling (cross-chunk buffering and trimmed emits)
+- Update mock test binary and extensive tests for streaming, large payloads, concurrency, and error cases
+- Add TypeScript types for streaming commands (TStreamingCommandKeys, TExtractChunk, IManagementStreamChunk)
+
 ## 2026-02-10 - 1.1.2 - fix(rust-binary-locator)
 use import.meta.resolve and url.fileURLToPath to locate bundled Rust binary in ESM environments
 

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartrust',
-    version: '1.1.2',
+    version: '1.2.1',
     description: 'a bridge between JS engines and rust'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHNDQUFzQztDQUNwRCxDQUFBIn0=

package/dist_ts/classes.rustbinarylocator.js

@@ -110,7 +110,17 @@ export class RustBinaryLocator {
             return true;
         }
         catch {
-            return false;
+            // File may exist but lack execute bit (common after npm/pnpm install).
+            // Try to make it executable.
+            try {
+                await plugins.fs.promises.access(filePath, plugins.fs.constants.F_OK);
+                await plugins.fs.promises.chmod(filePath, 0o755);
+                this.logger.log('info', `Auto-fixed missing execute permission on: ${filePath}`);
+                return true;
+            }
+            catch {
+                return false;
+            }
         }
     }
     async findInPath(binaryName) {
@@ -124,4 +134,4 @@ export class RustBinaryLocator {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.rustbridge.d.ts

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
-import type { IRustBridgeOptions, TCommandMap } from './interfaces/index.js';
+import { StreamingResponse } from './classes.streamingresponse.js';
+import type { IRustBridgeOptions, TCommandMap, TStreamingCommandKeys, TExtractChunk } from './interfaces/index.js';
 /**
  * Generic bridge between TypeScript and a Rust binary.
  * Communicates via JSON-over-stdin/stdout IPC protocol.
@@ -11,7 +12,8 @@ export declare class RustBridge<TCommands extends TCommandMap = TCommandMap> ext
     private options;
     private logger;
     private childProcess;
-    private readlineInterface;
+    private stdoutBuffer;
+    private stderrRemainder;
     private pendingRequests;
     private requestCounter;
     private isRunning;
@@ -26,6 +28,12 @@ export declare class RustBridge<TCommands extends TCommandMap = TCommandMap> ext
      * Send a typed command to the Rust process and wait for the response.
      */
     sendCommand<K extends string & keyof TCommands>(method: K, params: TCommands[K]['params']): Promise<TCommands[K]['result']>;
+    /**
+     * Send a streaming command to the Rust process.
+     * Returns a StreamingResponse that yields chunks via `for await...of`
+     * and exposes `.result` for the final response.
+     */
+    sendCommandStreaming<K extends string & TStreamingCommandKeys<TCommands>>(method: K, params: TCommands[K]['params']): StreamingResponse<TExtractChunk<TCommands[K]>, TCommands[K]['result']>;
     /**
      * Kill the Rust process and clean up all resources.
      */
@@ -34,6 +42,16 @@ export declare class RustBridge<TCommands extends TCommandMap = TCommandMap> ext
      * Whether the bridge is currently running.
      */
     get running(): boolean;
+    /**
+     * Buffer-based newline scanner for stdout chunks.
+     * Replaces readline to handle large payloads without buffering entire lines in a separate abstraction.
+     */
+    private handleStdoutChunk;
+    /**
+     * Write data to stdin with backpressure support.
+     * Waits for drain if the internal buffer is full.
+     */
+    private writeToStdin;
     private handleLine;
     private cleanup;
 }

package/dist_ts/classes.rustbridge.js

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import { RustBinaryLocator } from './classes.rustbinarylocator.js';
+import { StreamingResponse } from './classes.streamingresponse.js';
 const defaultLogger = {
     log() { },
 };
@@ -14,7 +15,8 @@ export class RustBridge extends plugins.events.EventEmitter {
     options;
     logger;
     childProcess = null;
-    readlineInterface = null;
+    stdoutBuffer = Buffer.alloc(0);
+    stderrRemainder = '';
     pendingRequests = new Map();
     requestCounter = 0;
     isRunning = false;
@@ -27,6 +29,7 @@ export class RustBridge extends plugins.events.EventEmitter {
             requestTimeoutMs: 30000,
             readyTimeoutMs: 10000,
             readyEventName: 'ready',
+            maxPayloadSize: 50 * 1024 * 1024,
             ...options,
         };
         this.locator = new RustBinaryLocator(options, this.logger);
@@ -49,22 +52,32 @@ export class RustBridge extends plugins.events.EventEmitter {
                     stdio: ['pipe', 'pipe', 'pipe'],
                     env,
                 });
-                // Handle stderr
+                // Handle stderr with cross-chunk buffering
                 this.childProcess.stderr?.on('data', (data) => {
-                    const lines = data.toString().split('\n').filter((l) => l.trim());
+                    this.stderrRemainder += data.toString();
+                    const lines = this.stderrRemainder.split('\n');
+                    // Keep the last element (incomplete line) as remainder
+                    this.stderrRemainder = lines.pop();
                     for (const line of lines) {
-                        this.logger.log('debug', `[${this.options.binaryName}] ${line}`);
-                        this.emit('stderr', line);
+                        const trimmed = line.trim();
+                        if (trimmed) {
+                            this.logger.log('debug', `[${this.options.binaryName}] ${trimmed}`);
+                            this.emit('stderr', trimmed);
+                        }
                     }
                 });
-                // Handle stdout via readline for line-delimited JSON
-                this.readlineInterface = plugins.readline.createInterface({ input: this.childProcess.stdout });
-                this.readlineInterface.on('line', (line) => {
-                    this.handleLine(line.trim());
+                // Handle stdout via Buffer-based newline scanner
+                this.childProcess.stdout.on('data', (chunk) => {
+                    this.handleStdoutChunk(chunk);
                 });
                 // Handle process exit
                 this.childProcess.on('exit', (code, signal) => {
                     this.logger.log('info', `Process exited (code=${code}, signal=${signal})`);
+                    // Flush any remaining stderr
+                    if (this.stderrRemainder.trim()) {
+                        this.logger.log('debug', `[${this.options.binaryName}] ${this.stderrRemainder.trim()}`);
+                        this.emit('stderr', this.stderrRemainder.trim());
+                    }
                     this.cleanup();
                     this.emit('exit', code, signal);
                 });
@@ -102,22 +115,62 @@ export class RustBridge extends plugins.events.EventEmitter {
         }
         const id = `req_${++this.requestCounter}`;
         const request = { id, method, params };
+        const json = JSON.stringify(request);
+        // Check outbound payload size
+        const byteLength = Buffer.byteLength(json, 'utf8');
+        if (byteLength > this.options.maxPayloadSize) {
+            throw new Error(`Outbound message exceeds maxPayloadSize (${byteLength} > ${this.options.maxPayloadSize})`);
+        }
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pendingRequests.delete(id);
                 reject(new Error(`Command '${method}' timed out after ${this.options.requestTimeoutMs}ms`));
             }, this.options.requestTimeoutMs);
             this.pendingRequests.set(id, { resolve, reject, timer });
-            const json = JSON.stringify(request) + '\n';
-            this.childProcess.stdin.write(json, (err) => {
-                if (err) {
-                    clearTimeout(timer);
-                    this.pendingRequests.delete(id);
-                    reject(new Error(`Failed to write to stdin: ${err.message}`));
-                }
+            this.writeToStdin(json + '\n').catch((err) => {
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(new Error(`Failed to write to stdin: ${err.message}`));
             });
         });
     }
+    /**
+     * Send a streaming command to the Rust process.
+     * Returns a StreamingResponse that yields chunks via `for await...of`
+     * and exposes `.result` for the final response.
+     */
+    sendCommandStreaming(method, params) {
+        const streaming = new StreamingResponse();
+        if (!this.childProcess || !this.isRunning) {
+            streaming.fail(new Error(`${this.options.binaryName} bridge is not running`));
+            return streaming;
+        }
+        const id = `req_${++this.requestCounter}`;
+        const request = { id, method, params };
+        const json = JSON.stringify(request);
+        const byteLength = Buffer.byteLength(json, 'utf8');
+        if (byteLength > this.options.maxPayloadSize) {
+            streaming.fail(new Error(`Outbound message exceeds maxPayloadSize (${byteLength} > ${this.options.maxPayloadSize})`));
+            return streaming;
+        }
+        const timeoutMs = this.options.streamTimeoutMs ?? this.options.requestTimeoutMs;
+        const timer = setTimeout(() => {
+            this.pendingRequests.delete(id);
+            streaming.fail(new Error(`Streaming command '${method}' timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        this.pendingRequests.set(id, {
+            resolve: (result) => streaming.finish(result),
+            reject: (error) => streaming.fail(error),
+            timer,
+            streaming,
+        });
+        this.writeToStdin(json + '\n').catch((err) => {
+            clearTimeout(timer);
+            this.pendingRequests.delete(id);
+            streaming.fail(new Error(`Failed to write to stdin: ${err.message}`));
+        });
+        return streaming;
+    }
     /**
      * Kill the Rust process and clean up all resources.
      */
@@ -126,11 +179,9 @@ export class RustBridge extends plugins.events.EventEmitter {
             const proc = this.childProcess;
             this.childProcess = null;
             this.isRunning = false;
-            // Close readline
-            if (this.readlineInterface) {
-                this.readlineInterface.close();
-                this.readlineInterface = null;
-            }
+            // Clear buffers
+            this.stdoutBuffer = Buffer.alloc(0);
+            this.stderrRemainder = '';
             // Reject pending requests
             for (const [, pending] of this.pendingRequests) {
                 clearTimeout(pending.timer);
@@ -180,6 +231,55 @@ export class RustBridge extends plugins.events.EventEmitter {
     get running() {
         return this.isRunning;
     }
+    /**
+     * Buffer-based newline scanner for stdout chunks.
+     * Replaces readline to handle large payloads without buffering entire lines in a separate abstraction.
+     */
+    handleStdoutChunk(chunk) {
+        this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
+        let newlineIndex;
+        while ((newlineIndex = this.stdoutBuffer.indexOf(0x0A)) !== -1) {
+            const lineBuffer = this.stdoutBuffer.subarray(0, newlineIndex);
+            this.stdoutBuffer = this.stdoutBuffer.subarray(newlineIndex + 1);
+            if (lineBuffer.length > this.options.maxPayloadSize) {
+                this.logger.log('error', `Inbound message exceeds maxPayloadSize (${lineBuffer.length} bytes), dropping`);
+                continue;
+            }
+            const line = lineBuffer.toString('utf8').trim();
+            this.handleLine(line);
+        }
+        // If accumulated buffer exceeds maxPayloadSize (sender never sends newline), clear to prevent OOM
+        if (this.stdoutBuffer.length > this.options.maxPayloadSize) {
+            this.logger.log('error', `Stdout buffer exceeded maxPayloadSize (${this.stdoutBuffer.length} bytes) without newline, clearing`);
+            this.stdoutBuffer = Buffer.alloc(0);
+        }
+    }
+    /**
+     * Write data to stdin with backpressure support.
+     * Waits for drain if the internal buffer is full.
+     */
+    writeToStdin(data) {
+        return new Promise((resolve, reject) => {
+            if (!this.childProcess?.stdin) {
+                reject(new Error('stdin not available'));
+                return;
+            }
+            const canContinue = this.childProcess.stdin.write(data, 'utf8', (err) => {
+                if (err) {
+                    reject(err);
+                }
+            });
+            if (canContinue) {
+                resolve();
+            }
+            else {
+                // Wait for drain before resolving
+                this.childProcess.stdin.once('drain', () => {
+                    resolve();
+                });
+            }
+        });
+    }
     handleLine(line) {
         if (!line)
             return;
@@ -197,6 +297,21 @@ export class RustBridge extends plugins.events.EventEmitter {
             this.emit(`management:${event.event}`, event.data);
             return;
         }
+        // Stream chunk (has 'id' + stream === true + 'data')
+        if ('id' in parsed && parsed.stream === true && 'data' in parsed) {
+            const pending = this.pendingRequests.get(parsed.id);
+            if (pending?.streaming) {
+                // Reset inactivity timeout
+                clearTimeout(pending.timer);
+                const timeoutMs = this.options.streamTimeoutMs ?? this.options.requestTimeoutMs;
+                pending.timer = setTimeout(() => {
+                    this.pendingRequests.delete(parsed.id);
+                    pending.reject(new Error(`Streaming command timed out after ${timeoutMs}ms of inactivity`));
+                }, timeoutMs);
+                pending.streaming.pushChunk(parsed.data);
+            }
+            return;
+        }
         // Otherwise it's a response (has 'id' field)
         if ('id' in parsed) {
             const response = parsed;
@@ -216,10 +331,8 @@ export class RustBridge extends plugins.events.EventEmitter {
     cleanup() {
         this.isRunning = false;
         this.childProcess = null;
-        if (this.readlineInterface) {
-            this.readlineInterface.close();
-            this.readlineInterface = null;
-        }
+        this.stdoutBuffer = Buffer.alloc(0);
+        this.stderrRemainder = '';
         // Reject all pending requests
         for (const [, pending] of this.pendingRequests) {
             clearTimeout(pending.timer);
@@ -228,4 +341,4 @@ export class RustBridge extends plugins.events.EventEmitter {
         this.pendingRequests.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rustbridge.js","sourceRoot":"","sources":["../ts/classes.rustbridge.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.rustbridge.js","sourceRoot":"","sources":["../ts/classes.rustbridge.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.streamingresponse.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Represents a streaming response from a Rust bridge command.
+ * Implements AsyncIterable to allow `for await...of` consumption of chunks,
+ * and exposes `.result` for the final response once the stream ends.
+ *
+ * @typeParam TChunk - Type of each streamed chunk
+ * @typeParam TResult - Type of the final result
+ */
+export declare class StreamingResponse<TChunk, TResult> implements AsyncIterable<TChunk> {
+    /** Resolves with the final result when the stream ends successfully. */
+    readonly result: Promise<TResult>;
+    private resolveResult;
+    private rejectResult;
+    /** Buffered chunks not yet consumed by the iterator. */
+    private buffer;
+    /** Waiting consumer resolve callback (when iterator is ahead of producer). */
+    private waiting;
+    /** Waiting consumer reject callback. */
+    private waitingReject;
+    private done;
+    private error;
+    constructor();
+    /**
+     * Push a chunk into the stream. Called internally by RustBridge.
+     */
+    pushChunk(chunk: TChunk): void;
+    /**
+     * End the stream successfully with a final result. Called internally by RustBridge.
+     */
+    finish(result: TResult): void;
+    /**
+     * End the stream with an error. Called internally by RustBridge.
+     */
+    fail(error: Error): void;
+    [Symbol.asyncIterator](): AsyncIterator<TChunk>;
+}

package/dist_ts/classes.streamingresponse.js

@@ -0,0 +1,102 @@
+/**
+ * Represents a streaming response from a Rust bridge command.
+ * Implements AsyncIterable to allow `for await...of` consumption of chunks,
+ * and exposes `.result` for the final response once the stream ends.
+ *
+ * @typeParam TChunk - Type of each streamed chunk
+ * @typeParam TResult - Type of the final result
+ */
+export class StreamingResponse {
+    /** Resolves with the final result when the stream ends successfully. */
+    result;
+    resolveResult;
+    rejectResult;
+    /** Buffered chunks not yet consumed by the iterator. */
+    buffer = [];
+    /** Waiting consumer resolve callback (when iterator is ahead of producer). */
+    waiting = null;
+    /** Waiting consumer reject callback. */
+    waitingReject = null;
+    done = false;
+    error = null;
+    constructor() {
+        this.result = new Promise((resolve, reject) => {
+            this.resolveResult = resolve;
+            this.rejectResult = reject;
+        });
+    }
+    /**
+     * Push a chunk into the stream. Called internally by RustBridge.
+     */
+    pushChunk(chunk) {
+        if (this.done)
+            return;
+        if (this.waiting) {
+            // A consumer is waiting — deliver immediately
+            const resolve = this.waiting;
+            this.waiting = null;
+            this.waitingReject = null;
+            resolve({ value: chunk, done: false });
+        }
+        else {
+            // No consumer waiting — buffer the chunk
+            this.buffer.push(chunk);
+        }
+    }
+    /**
+     * End the stream successfully with a final result. Called internally by RustBridge.
+     */
+    finish(result) {
+        if (this.done)
+            return;
+        this.done = true;
+        this.resolveResult(result);
+        // If a consumer is waiting, signal end of iteration
+        if (this.waiting) {
+            const resolve = this.waiting;
+            this.waiting = null;
+            this.waitingReject = null;
+            resolve({ value: undefined, done: true });
+        }
+    }
+    /**
+     * End the stream with an error. Called internally by RustBridge.
+     */
+    fail(error) {
+        if (this.done)
+            return;
+        this.done = true;
+        this.error = error;
+        this.rejectResult(error);
+        // If a consumer is waiting, reject it
+        if (this.waitingReject) {
+            const reject = this.waitingReject;
+            this.waiting = null;
+            this.waitingReject = null;
+            reject(error);
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                // If there are buffered chunks, deliver one
+                if (this.buffer.length > 0) {
+                    return Promise.resolve({ value: this.buffer.shift(), done: false });
+                }
+                // If the stream is done, signal end
+                if (this.done) {
+                    if (this.error) {
+                        return Promise.reject(this.error);
+                    }
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                // No buffered chunks and not done — wait for the next push
+                return new Promise((resolve, reject) => {
+                    this.waiting = resolve;
+                    this.waitingReject = reject;
+                });
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -1,3 +1,4 @@
 export { RustBridge } from './classes.rustbridge.js';
 export { RustBinaryLocator } from './classes.rustbinarylocator.js';
+export { StreamingResponse } from './classes.streamingresponse.js';
 export * from './interfaces/index.js';

package/dist_ts/index.js

@@ -1,4 +1,5 @@
 export { RustBridge } from './classes.rustbridge.js';
 export { RustBinaryLocator } from './classes.rustbinarylocator.js';
+export { StreamingResponse } from './classes.streamingresponse.js';
 export * from './interfaces/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsY0FBYyx1QkFBdUIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsY0FBYyx1QkFBdUIsQ0FBQyJ9

package/dist_ts/interfaces/config.d.ts

@@ -37,4 +37,9 @@ export interface IRustBridgeOptions extends IBinaryLocatorOptions {
     readyEventName?: string;
     /** Optional logger instance */
     logger?: IRustBridgeLogger;
+    /** Maximum message size in bytes (default: 50MB). Messages exceeding this are rejected. */
+    maxPayloadSize?: number;
+    /** Inactivity timeout for streaming commands in ms (default: same as requestTimeoutMs).
+     *  Resets on each chunk received. */
+    streamTimeoutMs?: number;
 }

package/dist_ts/interfaces/ipc.d.ts

@@ -34,3 +34,26 @@ export interface ICommandDefinition<TParams = any, TResult = any> {
  * Used to type-safe the bridge's sendCommand method.
  */
 export type TCommandMap = Record<string, ICommandDefinition>;
+/**
+ * Stream chunk message received from the Rust binary during a streaming command.
+ */
+export interface IManagementStreamChunk {
+    id: string;
+    stream: true;
+    data: any;
+}
+/**
+ * Extract keys from a command map whose definitions include a `chunk` field,
+ * indicating they support streaming responses.
+ */
+export type TStreamingCommandKeys<TCommands extends TCommandMap> = {
+    [K in keyof TCommands]: TCommands[K] extends {
+        chunk: any;
+    } ? K : never;
+}[keyof TCommands];
+/**
+ * Extract the chunk type from a command definition that has a `chunk` field.
+ */
+export type TExtractChunk<TDef> = TDef extends {
+    chunk: infer C;
+} ? C : never;

package/dist_ts/plugins.d.ts

@@ -1,9 +1,8 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import * as childProcess from 'child_process';
-import * as readline from 'readline';
 import * as events from 'events';
 import * as url from 'url';
-export { path, fs, childProcess, readline, events, url };
+export { path, fs, childProcess, events, url };
 import * as smartpath from '@push.rocks/smartpath';
 export { smartpath };