@e-mc/request 0.8.20 → 0.8.22

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2024 An Pham
+Copyright 2023 An Pham
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -9,7 +9,7 @@
 
 ## Interface
 
-- https://www.unpkg.com/@e-mc/types@0.8.20/lib/index.d.ts
+- https://www.unpkg.com/@e-mc/types@0.8.22/lib/index.d.ts
 
 ```typescript
 import type { IModule, ModuleConstructor } from "./index";
@@ -82,9 +82,9 @@ interface RequestConstructor extends ModuleConstructor {
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.8.20/lib/http.d.ts
-- https://www.unpkg.com/@e-mc/types@0.8.20/lib/request.d.ts
-- https://www.unpkg.com/@e-mc/types@0.8.20/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.8.22/lib/http.d.ts
+- https://www.unpkg.com/@e-mc/types@0.8.22/lib/request.d.ts
+- https://www.unpkg.com/@e-mc/types@0.8.22/lib/settings.d.ts
 
 ## LICENSE
 

package/http/adapter/index.js

@@ -0,0 +1,561 @@
+"use strict";
+const fs = require("node:fs");
+const http2 = require("node:http2");
+const yaml = require("js-yaml");
+const types_1 = require("@e-mc/types");
+const module_1 = require("@e-mc/module");
+const util_1 = require("@e-mc/request/util");
+const kOutStream = Symbol('outStream');
+const kOptions = Symbol('options');
+let LOG_TIMEFORMAT = 'readable';
+class HttpAdapter {
+    instance;
+    state;
+    uri;
+    static isUnsupported(value) {
+        return value === 421 || value === 505;
+    }
+    static isDowngrade(err) {
+        return err instanceof Error && (err.code === 'ERR_HTTP2_ERROR' || this.isUnsupported(Math.abs(err.errno)));
+    }
+    static wasAborted(err) {
+        return err instanceof Error && err.message.startsWith("Aborted");
+    }
+    static isConnectionError(err) {
+        switch (err instanceof Error && err.code) {
+            case 'ETIMEDOUT':
+            case 'ECONNRESET':
+                return true;
+            default:
+                return false;
+        }
+    }
+    static defineHostConfig({ settings }) {
+        const time_format = settings?.time_format;
+        switch (time_format) {
+            case 'readable':
+            case 'relative':
+            case 'none':
+                LOG_TIMEFORMAT = time_format;
+                break;
+        }
+    }
+    contentLength = 0;
+    retries = 0;
+    redirects = 0;
+    closed = false;
+    aborted = false;
+    timeout = null;
+    dataTime = null;
+    delayTime = undefined;
+    opts;
+    client;
+    resolve;
+    reject;
+    startTime;
+    [kOutStream] = null;
+    [kOptions];
+    constructor(instance, state, uri, options) {
+        this.instance = instance;
+        this.state = state;
+        this.uri = uri;
+        this[kOptions] = options;
+        this.startTime = state.log ? process.hrtime.bigint() : BigInt(0);
+        this.setOpts();
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+            this.init();
+        });
+    }
+    init() {
+        this.aborted = false;
+        this.setWriteStream();
+        this.client = this.instance.open(this.uri, this.opts);
+        if (this.opts.httpVersion === 2) {
+            this.client
+                .on('response', (headers, flags) => {
+                if (this.destroyed) {
+                    return;
+                }
+                const statusCode = headers[':status'];
+                if (statusCode < 300) {
+                    this.acceptResponse(headers);
+                }
+                else if (statusCode < 400) {
+                    this.redirectResponse(statusCode, headers.location);
+                }
+                else if (statusCode === 401 ||
+                    statusCode === 402 ||
+                    statusCode === 403 ||
+                    statusCode === 404 ||
+                    statusCode === 407 ||
+                    statusCode === 410) {
+                    this.terminate(this.formatStatus(statusCode));
+                }
+                else if (this.isRetry(statusCode)) {
+                    this.retryResponse(statusCode, headers['retry-after']);
+                }
+                else if (HttpAdapter.isUnsupported(statusCode)) {
+                    this.retryDownload(true, this.formatNgFlags(http2.constants.NGHTTP2_PROTOCOL_ERROR, statusCode));
+                }
+                else {
+                    switch (flags) {
+                        case http2.constants.NGHTTP2_PROTOCOL_ERROR:
+                        case http2.constants.NGHTTP2_INADEQUATE_SECURITY:
+                        case http2.constants.NGHTTP2_HTTP_1_1_REQUIRED:
+                            this.retryDownload(true, this.formatNgFlags(flags, statusCode, headers.location));
+                            break;
+                        default:
+                            this.retryDownload(false, this.formatStatus(statusCode));
+                            break;
+                    }
+                }
+            })
+                .on('unknownProtocol', () => {
+                if (this.aborted) {
+                    return;
+                }
+                this.retryDownload(true, 'Unknown protocol (HTTP/2)');
+            })
+                .on('aborted', () => {
+                this.aborted = true;
+                this.terminate((0, types_1.createAbortError)());
+            })
+                .on('error', async (err) => {
+                if (this.aborted) {
+                    return;
+                }
+                if (HttpAdapter.wasAborted(err)) {
+                    this.errorResponse(err);
+                }
+                else {
+                    switch (!HttpAdapter.isDowngrade(err) && await this.host.hasProtocol(2)) {
+                        case 1:
+                            this.errorResponse(err);
+                            break;
+                        case 2:
+                            this.retryDownload(false, err);
+                            break;
+                        default:
+                            this.retryDownload(true, err);
+                            break;
+                    }
+                }
+            });
+        }
+        else {
+            this.client
+                .on('response', res => {
+                if (this.destroyed) {
+                    return;
+                }
+                const statusCode = res.statusCode;
+                if (statusCode < 300) {
+                    this.acceptResponse(res.headers);
+                }
+                else if (statusCode < 400) {
+                    this.redirectResponse(statusCode, res.headers.location);
+                }
+                else if (this.isRetry(statusCode)) {
+                    this.retryResponse(statusCode, res.headers['retry-after']);
+                }
+                else {
+                    this.terminate(this.formatStatus(statusCode));
+                }
+            })
+                .on('abort', () => {
+                this.aborted = true;
+                this.terminate((0, types_1.createAbortError)());
+            })
+                .on('error', err => {
+                if (this.aborted) {
+                    return;
+                }
+                this.errorResponse(err);
+            });
+        }
+        this.client.on('timeout', () => {
+            if (this.aborted) {
+                return;
+            }
+            if (++this.retries <= this.retryLimit) {
+                this.abortResponse();
+                this.retryTimeout();
+            }
+            else {
+                this.terminate(this.formatStatus(408));
+            }
+        });
+    }
+    setOpts(uri) {
+        if (uri) {
+            this.uri = uri;
+        }
+        this.opts = this.instance.opts(this.uri, this[kOptions]);
+    }
+    setWriteStream() {
+        const pipeTo = this.pipeTo;
+        if (typeof pipeTo === 'string') {
+            try {
+                this.outStream = fs.createWriteStream(pipeTo, { emitClose: false, highWaterMark: this.host.streamSize });
+            }
+            catch (err) {
+                this.terminate(err);
+            }
+        }
+        else if (pipeTo) {
+            this.outStream = pipeTo;
+        }
+    }
+    retryDownload(downgrade, message) {
+        if (this.aborted) {
+            return;
+        }
+        this.abortResponse();
+        if (downgrade) {
+            const host = this.host;
+            host.failed(2);
+            if (host.version > 1) {
+                if (this.state.verbose) {
+                    this.instance.formatMessage(1024, 'HTTP2', ["Unsupported protocol", host.origin], message, { failed: true });
+                }
+                host.version = 1;
+            }
+        }
+        this.opts.httpVersion = 1;
+        this.init();
+    }
+    acceptResponse(headers) {
+        const opts = this.opts;
+        if ('outHeaders' in opts) {
+            opts.outHeaders = headers;
+        }
+        if ('outFilename' in opts) {
+            opts.outFilename = (0, util_1.parseHeader)(headers, 'content-disposition');
+        }
+        const pipeline = this.pipeTo ? !(0, types_1.isString)(this.pipeTo) : false;
+        const enabled = opts.connected?.call(this.client, headers) !== false && !pipeline;
+        const maxBufferSize = opts.maxBufferSize ? (0, types_1.alignSize)(opts.maxBufferSize) : 0;
+        this.contentLength = parseInt(headers['content-length'] || '0');
+        const updating = opts.progressId !== undefined && !!this.instance.host && this.contentLength > 0;
+        const readTimeout = this.instance.readTimeout;
+        let log = this.state.log, buffer = null, dataLength = 0;
+        this.client.once('readable', () => {
+            if (readTimeout > 0) {
+                this.timeout = setTimeout(() => {
+                    this.terminate((0, types_1.errorValue)("Timeout was exceeded", this.uri.toString()));
+                }, readTimeout);
+            }
+            if (log) {
+                switch (this.instance.settings?.time_format || LOG_TIMEFORMAT) {
+                    case 'readable':
+                        this.delayTime = process.hrtime.bigint() - this.startTime;
+                        break;
+                    case 'relative':
+                        this.delayTime = Date.now() - this.instance.startTime;
+                        break;
+                    case 'none':
+                        if (!this.silent) {
+                            log = false;
+                        }
+                        break;
+                }
+            }
+            this.dataTime = process.hrtime.bigint();
+            if (updating) {
+                this.updateProgress(0, 0);
+            }
+        });
+        if (enabled) {
+            const encoding = opts.encoding;
+            this.client.on('data', (chunk) => {
+                if (buffer) {
+                    if (typeof buffer === 'string') {
+                        buffer += typeof chunk === 'string' ? chunk : chunk.toString(encoding);
+                    }
+                    else if (Array.isArray(buffer)) {
+                        buffer.push(typeof chunk === 'string' ? Buffer.from(chunk, encoding) : chunk);
+                    }
+                    else {
+                        buffer = Buffer.concat([buffer, typeof chunk === 'string' ? Buffer.from(chunk, encoding) : chunk]);
+                    }
+                }
+                else {
+                    buffer = typeof chunk === 'string' ? chunk : [chunk];
+                }
+                if (updating) {
+                    dataLength += Buffer.byteLength(chunk, encoding);
+                    this.updateProgress(dataLength, this.contentLength);
+                }
+                if (maxBufferSize > 0) {
+                    if (!updating) {
+                        dataLength += Buffer.byteLength(chunk, encoding);
+                    }
+                    if (dataLength > maxBufferSize) {
+                        this.terminate((0, types_1.errorValue)("Size limit was exceeded", this.uri.toString()));
+                    }
+                }
+            });
+        }
+        this.client.once('end', () => {
+            if (this.closed || this.aborted) {
+                return;
+            }
+            this.close();
+            const encoding = opts.encoding;
+            let result;
+            if (buffer) {
+                if (Array.isArray(buffer)) {
+                    buffer = Buffer.concat(buffer);
+                    if (encoding) {
+                        buffer = buffer.toString(encoding);
+                    }
+                }
+                dataLength = Buffer.byteLength(buffer, encoding);
+                if (updating) {
+                    this.updateProgress(dataLength, dataLength);
+                }
+                if (typeof buffer === 'string') {
+                    if (buffer.startsWith('\uFEFF') && encoding !== 'utf16le' && encoding !== 'utf-16le') {
+                        buffer = buffer.substring(1);
+                    }
+                    if (opts.outFormat) {
+                        const { out: format, parser } = opts.outFormat;
+                        let packageName;
+                        try {
+                            switch (format) {
+                                case 'yaml':
+                                    result = yaml.load(buffer, parser);
+                                    break;
+                                case 'json5':
+                                    result = require(packageName = 'json5').parse(buffer);
+                                    break;
+                                case 'xml':
+                                    result = new (require(packageName = 'fast-xml-parser').XMLParser)(parser).parse(buffer);
+                                    break;
+                                case 'toml':
+                                    result = require(packageName = 'toml').parse(buffer);
+                                    break;
+                                default:
+                                    result = JSON.parse(buffer);
+                                    break;
+                            }
+                            if (!(0, types_1.isObject)(result)) {
+                                result = null;
+                            }
+                        }
+                        catch (err) {
+                            if (this.state.verbose && !(packageName && this.instance.checkPackage(err, packageName))) {
+                                this.instance.writeFail(["Unable to parse URI response", format], err, 1024);
+                            }
+                            result = null;
+                        }
+                    }
+                }
+                if (result === undefined) {
+                    result = buffer;
+                }
+            }
+            else {
+                if (updating) {
+                    this.updateProgress(0, this.contentLength);
+                }
+                if (enabled && this.instance.readExpect === 'always') {
+                    this.terminate("No data received");
+                    return;
+                }
+                result = encoding && !pipeline ? '' : null;
+            }
+            this.endResponse(result, dataLength, log);
+        });
+        this.host.success(this.httpVersion);
+    }
+    updateProgress(dataLength, contentLength) {
+        const { host, moduleName } = this.instance;
+        host.updateProgress(moduleName, this.opts.progressId, dataLength, contentLength, this.dataTime);
+    }
+    endResponse(result, dataLength = 0, logging = this.state.log) {
+        if (logging) {
+            const messageUnit = this.dataTime && dataLength > 0 ? (0, util_1.getTransferRate)(dataLength, (0, types_1.convertTime)(process.hrtime.bigint() - this.dataTime, false) * 1000) : undefined;
+            this.instance.writeTimeProcess('HTTP' + this.httpVersion, this.opts.statusMessage || this.uri.toString(), this.startTime, {
+                type: 1024,
+                queue: !!this.instance.host,
+                titleBgColor: !result ? 'bgBlue' : undefined,
+                messageUnit,
+                messageUnitMinWidth: 9,
+                delayTime: this.delayTime,
+                bypassLog: module_1.hasLogType(32768)
+            });
+        }
+        this.resolve(result);
+    }
+    redirectResponse(statusCode, location) {
+        if (location) {
+            if (this.opts.followRedirect === false) {
+                this.terminate(this.formatStatus(statusCode, "Follow redirect was disabled"));
+            }
+            else if (++this.redirects <= this.redirectLimit) {
+                this.abortResponse();
+                this.setOpts((0, util_1.fromURL)(this.opts.url, location));
+                this.init();
+            }
+            else {
+                this.terminate(this.formatStatus(statusCode, "Exceeded redirect limit"));
+            }
+        }
+        else {
+            this.terminate(this.formatStatus(statusCode, "Missing redirect location"));
+        }
+    }
+    abortResponse() {
+        if (this.closed) {
+            return;
+        }
+        this.aborted = true;
+        this.client.destroy();
+        this.instance.reset(this);
+        this.cleanup();
+    }
+    errorResponse(err) {
+        if (HttpAdapter.wasAborted(err)) {
+            this.terminate(err);
+        }
+        else if ((0, util_1.checkRetryable)(err) && ++this.retries <= this.retryLimit) {
+            this.abortResponse();
+            if (HttpAdapter.isConnectionError(err)) {
+                this.retryTimeout();
+            }
+            else {
+                setTimeout(() => {
+                    this.init();
+                }, this.retryWait);
+            }
+        }
+        else {
+            this.host.error(this.httpVersion);
+            this.terminate(err);
+        }
+    }
+    retryResponse(statusCode, retryAfter) {
+        this.abortResponse();
+        if (retryAfter && this.retryAfter > 0) {
+            let offset = +retryAfter || new Date(retryAfter);
+            if (offset instanceof Date) {
+                offset = Math.max(0, offset.getTime() - Date.now());
+            }
+            else {
+                offset *= 1000;
+            }
+            if (offset > 0) {
+                if (offset <= this.retryAfter) {
+                    this.sendWarning(`Retry After (${retryAfter})`);
+                    setTimeout(() => {
+                        this.init();
+                    }, offset);
+                }
+                else {
+                    this.terminate(this.formatStatus(statusCode));
+                }
+                return;
+            }
+        }
+        this.sendWarning(this.formatRetry((0, util_1.fromStatusCode)(statusCode)));
+        if ((0, util_1.isRetryable)(statusCode, true)) {
+            setImmediate(this.init.bind(this));
+        }
+        else {
+            setTimeout(() => {
+                this.init();
+            }, this.retryWait);
+        }
+    }
+    isRetry(value) {
+        return (0, util_1.isRetryable)(value) && ++this.retries <= this.retryLimit;
+    }
+    retryTimeout() {
+        this.sendWarning(this.formatRetry("HTTP connection timeout"));
+        this.init();
+    }
+    terminate(err) {
+        if (this.closed) {
+            return;
+        }
+        this.cleanup();
+        this.close();
+        this.reject(typeof err === 'string' ? new Error(err) : err);
+    }
+    sendWarning(message) {
+        if (this.state.verbose) {
+            const { host, url } = this.opts;
+            this.instance.formatMessage(1024, 'HTTP' + this.httpVersion, [message, host.origin], url.toString(), { ...module_1.LOG_STYLE_WARN });
+        }
+    }
+    formatStatus(value, hint) {
+        return value + ': ' + (hint || (0, util_1.fromStatusCode)(value)) + ` (${this.uri.toString()})`;
+    }
+    close() {
+        this.closed = true;
+        this.instance.reset(this);
+        if (this.aborted && !this.client.aborted) {
+            this.abortController?.abort();
+        }
+    }
+    cleanup() {
+        if ((0, types_1.isString)(this.pipeTo) && this.outStream) {
+            (0, util_1.cleanupStream)(this.outStream, this.pipeTo);
+            this.outStream = null;
+        }
+    }
+    formatNgFlags(value, statusCode, location) {
+        return location ? `Using HTTP 1.1 for URL redirect (${location})` : this.formatStatus(statusCode, value ? 'NGHTTP2 Error ' + value : '');
+    }
+    formatRetry(message) {
+        return `${message} (${this.retries} / ${this.retryLimit})`;
+    }
+    set abortController(value) {
+        this.opts.outAbort = value;
+    }
+    get abortController() {
+        return this.opts.outAbort || null;
+    }
+    set outStream(value) {
+        this[kOutStream] = value;
+        if (value) {
+            this.opts.outStream = value;
+        }
+    }
+    get outStream() {
+        return this[kOutStream];
+    }
+    get destroyed() {
+        return this.client.destroyed || this.httpVersion === 2 && this.client.aborted;
+    }
+    get host() {
+        return this.opts.host;
+    }
+    get httpVersion() {
+        return this.opts.httpVersion;
+    }
+    get pipeTo() {
+        return this.opts.pipeTo;
+    }
+    get silent() {
+        return this.opts.silent === false;
+    }
+    get retryLimit() {
+        return this.state.config.retryLimit;
+    }
+    get retryWait() {
+        return this.state.config.retryWait;
+    }
+    get retryAfter() {
+        return this.state.config.retryAfter;
+    }
+    get redirectLimit() {
+        return this.state.config.redirectLimit;
+    }
+}
+module.exports = HttpAdapter;

package/index.js

@@ -316,8 +316,8 @@ function decompressEncoding(value, chunkSize) {
             break;
     }
 }
-function abortHeaders(href, request, options) {
-    const reason = (0, types_1.errorValue)("Aborted by client", href);
+function abortHeaders(href, request, options, statusCode = '') {
+    const reason = (0, types_1.errorMessage)(statusCode, "Aborted by client", href);
     const outAbort = options.outAbort;
     if (outAbort) {
         outAbort.abort(reason);
@@ -1061,13 +1061,13 @@ class Request extends module_1.default {
                 return Promise.reject(err);
             }
         }
-        let pathname, headers, binOpts, silent;
+        let pathname, headers, binOpts, signal, silent;
         if (options) {
             if (typeof options === 'string') {
                 pathname = options;
             }
             else {
-                ({ pathname, headers, binOpts, silent } = options);
+                ({ pathname, headers, binOpts, signal, silent } = options);
                 if ((0, types_1.isArray)(binOpts)) {
                     let next = false;
                     binOpts = binOpts.filter(opt => !((0, types_1.isString)(opt) && /^-[a-z][\S\s]*$/i.test(opt.trim()))).map((opt) => {
@@ -1371,7 +1371,13 @@ class Request extends module_1.default {
                         }
                         for (const item of ARIA2.PID_QUEUE) {
                             try {
-                                process.kill(item[0], 0);
+                                if (pid === item[0] && (signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+                                    process.kill(item[0]);
+                                    closeTorrent(item[0]);
+                                }
+                                else {
+                                    process.kill(item[0], 0);
+                                }
                             }
                             catch {
                                 closeTorrent(item[0]);
@@ -1686,6 +1692,9 @@ class Request extends module_1.default {
             const ac = new AbortController();
             this[kDownloading].add(options.outAbort = ac);
             stream.addAbortSignal(ac.signal, request);
+            if (options.signal) {
+                stream.addAbortSignal(options.signal, request);
+            }
             this.signal.addEventListener('abort', () => ac.abort(new Error("Aborted by process")), { once: true });
         }
         if (posting) {
@@ -1898,7 +1907,7 @@ class Request extends module_1.default {
                     }
                     const client = this.open(href, request);
                     const { host, url, encoding, outFormat } = request;
-                    let buffer, aborted;
+                    let buffer, aborted = false;
                     ({ httpVersion, outAbort } = request);
                     const isAborted = () => client.destroyed || httpVersion === 2 && client.aborted;
                     const isRetry = (value) => (0, util_1.isRetryable)(value) && ++retries <= this._config.retryLimit;
@@ -1914,14 +1923,11 @@ class Request extends module_1.default {
                         if (timeout) {
                             clearTimeout(timeout);
                         }
-                        buffer = null;
-                        aborted = true;
                         if (outAbort) {
-                            if (!client.aborted) {
-                                outAbort.abort();
-                            }
                             this[kDownloading].delete(outAbort);
                         }
+                        buffer = null;
+                        aborted = true;
                         client.destroy();
                     };
                     const retryTimeout = () => {
@@ -1946,7 +1952,6 @@ class Request extends module_1.default {
                                 var _o;
                                 if (readTimeout > 0) {
                                     timeout = setTimeout(() => {
-                                        abortResponse();
                                         throwError((0, types_1.errorValue)("Timeout was exceeded", href.toString()));
                                     }, readTimeout);
                                 }
@@ -2070,9 +2075,9 @@ class Request extends module_1.default {
                         host.success(httpVersion);
                     };
                     const redirectResponse = (statusCode, location) => {
-                        abortResponse();
                         if (location) {
                             if (++redirects <= this._config.redirectLimit) {
+                                abortResponse();
                                 downloadUri.call(this, Request.fromURL(url, location));
                             }
                             else {
@@ -2084,11 +2089,11 @@ class Request extends module_1.default {
                         }
                     };
                     const errorResponse = (err) => {
-                        abortResponse();
                         if (wasAborted(err)) {
                             throwError(err);
                         }
                         else if ((0, util_1.checkRetryable)(err) && ++retries <= this._config.retryLimit) {
+                            abortResponse();
                             if (isConnectionTimeout(err)) {
                                 retryTimeout();
                             }
@@ -2233,7 +2238,6 @@ class Request extends module_1.default {
                                 retryResponse(statusCode, res.headers['retry-after']);
                             }
                             else {
-                                abortResponse();
                                 throwError(formatStatus(statusCode));
                             }
                         })
@@ -2251,8 +2255,8 @@ class Request extends module_1.default {
                         if (aborted) {
                             return;
                         }
-                        abortResponse();
                         if (++retries <= this._config.retryLimit) {
+                            abortResponse();
                             retryTimeout();
                         }
                         else {
@@ -2294,7 +2298,7 @@ class Request extends module_1.default {
             for (const callback of called) {
                 try {
                     if (callback(code, headers, url) === true) {
-                        abortHeaders.call(this, href, request, options);
+                        abortHeaders.call(this, href, request, options, code);
                         return false;
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/request",
-  "version": "0.8.20",
+  "version": "0.8.22",
   "description": "Request constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,8 +20,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.8.20",
-    "@e-mc/types": "0.8.20",
+    "@e-mc/module": "0.8.22",
+    "@e-mc/types": "0.8.22",
     "combined-stream": "^1.0.8",
     "js-yaml": "^4.1.0",
     "picomatch": "^3.0.1",