@e-mc/file-manager 0.9.9 → 0.10.1

package/index.js

@@ -1,14 +1,13 @@
 "use strict";
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
 const path = require("path");
 const fs = require("fs");
 const stream = require("stream");
 const pm = require("picomatch");
+const diff = require("diff");
 const chalk = require("chalk");
-const util_1 = require("@e-mc/request/util");
-const asset_1 = require("@e-mc/document/asset");
-const util_2 = require("@e-mc/document/util");
-const types_1 = require("@e-mc/types");
+const stripansi = require("strip-ansi");
+const url_1 = require("url");
 const core_1 = require("@e-mc/core");
 const request_1 = require("@e-mc/request");
 const document_1 = require("@e-mc/document");
@@ -17,6 +16,10 @@ const image_1 = require("@e-mc/image");
 const watch_1 = require("@e-mc/watch");
 const compress_1 = require("@e-mc/compress");
 const cloud_1 = require("@e-mc/cloud");
+const types_1 = require("@e-mc/types");
+const asset_1 = require("@e-mc/document/asset");
+const util_1 = require("@e-mc/document/util");
+const util_2 = require("@e-mc/request/util");
 const kBaseDirectory = Symbol('baseDirectory');
 const kIncremental = Symbol('incremental');
 const kRestarting = Symbol('restarting');
@@ -31,10 +34,11 @@ const kQueuedTasks = Symbol('queuedTasks');
 const kScheduler = Symbol('scheduler');
 const kProcessTimeout = Symbol('processTimeout');
 const kDownloadStats = Symbol('downloadStats');
+const kDiffSource = Symbol('diffSource');
 const kReplaceMap = Symbol('replaceMap');
-const PLATFORM_WIN32 = process.platform === 'win32';
 const PROCESS_STDOUT = process.stdout;
-const STDOUT_CURSOR = typeof process.stdout.moveCursor === 'function';
+const PROCESS_STDIN = process.stdin;
+const STDOUT_CURSOR = typeof PROCESS_STDOUT.moveCursor === 'function';
 const PROCESS_TIMEOUT = { filemanager: 0, compress: 0 };
 const CACHE_ETAG = {};
 const DISK = {
@@ -58,6 +62,27 @@ const MEMORY = {
     DISK_MIN: Infinity,
     DISK_MAX: 0
 };
+const LOGGER = {
+    TITLE_SEP: '|',
+    TITLE_WIDTH: 6,
+    VALUE_WIDTH: 71,
+    MIN_WIDTH: 0,
+    MESSAGE_WIDTH: 0,
+    STAT_WIDTH: 0,
+    PERCENT_WIDTH: 0,
+    MESSAGE_SEP: ' | ',
+    MESSAGE_SEP_START: 1,
+    PROGRESS_SCROLLBUFFER: 5,
+    PROGRESS_MAXWIDTH: Infinity,
+    PROGRESS_USECOLOR: true,
+    PROGRESS_RAWMODE: false,
+    PROGRESS_TEXTWRAP: 'nowrap',
+    PROGRESS_COLOR: null,
+    PROGRESS_BGCOLOR: null,
+    PROGRESS_BOXCHAR: '■',
+    PROGRESS_SPACER: chalk.blackBright('|'),
+    PROGRESS_COMPLETE: chalk.green('100%')
+};
 let SESSION_ID = 0;
 let SESSION_LIMIT = 1000;
 let ASSET_ID = 0;
@@ -65,7 +90,6 @@ let RECURSION_LIMIT = 10;
 let PROCESS_SUB_LIMIT = Math.max(require('os').cpus().length, 1) * 2;
 let LOG_TIMEELAPSED = true;
 let LOG_TIMEPROCESS = true;
-let LOG_FORMAT = null;
 const HTTP_CLIENT = {
     timeout: 60000,
     connectTimeout: 20 * 1000,
@@ -77,7 +101,7 @@ const HTTP_CLIENT = {
 function applyTimeout(target, options) {
     for (const name in options) {
         const value = parseTimeout(options[name]);
-        if (value !== undefined) {
+        if (value !== -1) {
             target[name] = value;
         }
     }
@@ -89,23 +113,23 @@ function parseTimeout(value) {
     if ((value = (0, types_1.parseTime)(value)) > 0) {
         return value;
     }
+    return -1;
 }
 function withinSizeRange(uri, value, pattern) {
     const match = (pattern || /\(\s*(\d+)\s*(?:,\s*(\d+|\*)\s*)?\)/).exec(value);
     const [minSize, maxSize] = match && !match[1] ? [+match[2], !match[3] || match[3] === '*' ? Infinity : +match[3]] : [0, Infinity];
     if (minSize > 0 || maxSize < Infinity) {
-        const fileSize = (0, util_1.getSize)(uri);
+        const fileSize = (0, util_2.getSize)(uri);
         if (fileSize === 0 || fileSize < minSize || fileSize > maxSize) {
             return false;
         }
     }
     return true;
 }
-function startMessage() {
-    this.formatMessage(128, 'START', [new Date().toLocaleString(), this.assets.length + ' assets'], this.baseDirectory, { ...core_1.Host.LOG_STYLE_SUCCESS });
-}
-function clearAssets() {
-    this.assets.forEach(item => unsetContent(item));
+function clearAssets(host) {
+    for (const item of host.assets) {
+        unsetContent(item);
+    }
 }
 function unsetContent(item) {
     if ('buffer' in item) {
@@ -115,7 +139,7 @@ function unsetContent(item) {
         item.sourceUTF8 = '';
     }
 }
-function bundleTorrent(files, mimeType, encoding) {
+function bundleTorrent(host, files, mimeType, encoding) {
     let output = '';
     for (const file of files) {
         if (core_1.Host.lookupMime(file) === mimeType) {
@@ -123,15 +147,15 @@ function bundleTorrent(files, mimeType, encoding) {
                 output += fs.readFileSync(file, encoding);
             }
             catch (err) {
-                this.writeFail(["Unable to read file", path.basename(file)], err, 32);
+                host.writeFail(["Unable to read file", path.basename(file)], err, 32);
             }
         }
     }
     return output;
 }
-function resetAssets() {
-    this.reset();
-    FileManager.sanitizeAssets(this.assets);
+function resetAssets(host) {
+    host.reset();
+    FileManager.sanitizeAssets(host.assets);
 }
 function recurseDir(output, subDirs, options) {
     const { ignore, sortBy, recursive } = options;
@@ -162,7 +186,7 @@ function recurseDir(output, subDirs, options) {
     }
     return output;
 }
-function checkHash(localUri, output, options, data) {
+function checkHash(host, localUri, output, options, data) {
     let algorithm, digest, value;
     if ((0, types_1.isObject)(options)) {
         ({ algorithm, digest, value } = options);
@@ -172,21 +196,21 @@ function checkHash(localUri, output, options, data) {
     }
     if ((0, types_1.isString)(value)) {
         algorithm || (algorithm = "sha256");
-        if (!data) {
+        if (!data && localUri) {
             try {
                 data = fs.readFileSync(localUri);
             }
             catch (err) {
                 if (output && core_1.Host.isErrorCode(err, 'ENOENT')) {
-                    this.addLog(this.statusType.WARN, algorithm + ' -> ENOENT -> No checksum performed', path.basename(localUri), value);
+                    host.addLog(host.statusType.WARN, algorithm + ': ENOENT -> No checksum performed', path.basename(localUri), value);
                     return true;
                 }
-                this.addLog(this.statusType.WARN, err, path.basename(localUri), value);
+                host.addLog(host.statusType.WARN, err, path.basename(localUri), value);
                 return false;
             }
         }
-        if ((value = value.toLowerCase()) === core_1.Host.asHash(data, { algorithm, digest })) {
-            this.formatMessage(32, algorithm, ["Checksum matched" + (output ? ' (output)' : ''), path.basename(localUri)], value, { ...core_1.Host.LOG_STYLE_INFO, queue: true });
+        if (data && (value = value.toLowerCase()) === core_1.Host.asHash(data, algorithm, digest)) {
+            host.formatMessage(32, algorithm, ["Checksum matched" + (output ? ' (output)' : ''), localUri && path.basename(localUri)], value, { ...core_1.Host.LOG_STYLE_INFO, queue: true });
             return true;
         }
         return false;
@@ -194,7 +218,7 @@ function checkHash(localUri, output, options, data) {
     return true;
 }
 function validatePaths(values, patterns, include, dot) {
-    const items = patterns.map(value => !value.startsWith('*') && /[\\/]/.test(value) ? [core_1.Permission.toPosix(path.resolve(value)), { nocase: PLATFORM_WIN32, dot }] : [value.replace(/(?:^\\|\\+)/g, '/'), { matchBase: true, nocase: PLATFORM_WIN32, dot }]);
+    const items = patterns.map(value => isMatchRoot(value) ? [core_1.Permission.toPosix(path.resolve(value)), { nocase: core_1.Host.PLATFORM_WIN32, dot }] : [sanitizePath(value), { matchBase: true, nocase: core_1.Host.PLATFORM_WIN32, dot }]);
     return values.filter(value => {
         for (const [pattern, options] of items) {
             if (pm.isMatch(core_1.Permission.toPosix(value), pattern, options)) {
@@ -223,130 +247,527 @@ function filterPaths(values, include, exclude, dot) {
     }
     return values;
 }
-function abortedHost() {
-    if (this.finalizeState === 6) {
-        this.restarting = false;
-        this.performFinalize(true);
-        return this.done;
+function abortedHost(host) {
+    if (host.finalizeState === 6) {
+        host.restarting = false;
+        host.performFinalize(true);
+        return host.done;
     }
     return false;
 }
 function formatMinutes(elapsed) {
-    let result = '';
-    if (elapsed >= 3600000) {
-        const h = Math.floor(elapsed / 3600000);
-        elapsed -= h * 3600000;
-        result = h + ':';
+    if (elapsed < 1000) {
+        return elapsed + 'ms';
     }
-    if (elapsed >= 60000) {
-        const m = Math.floor(elapsed / 60000);
-        elapsed -= m * 60000;
-        result += padStart(m, result ? '0' : ' ') + ':';
+    if (elapsed < 60000) {
+        return (elapsed / 1000).toPrecision(3) + 's';
     }
-    else {
-        result += ' 0:';
-    }
-    if (elapsed >= 1000) {
-        const s = Math.floor(elapsed / 1000);
-        result += padStart(s, '0');
-    }
-    else {
-        result += '00';
-    }
-    return result;
+    return (0, types_1.formatTime)(elapsed, ':');
 }
-function observeFile(instance) {
-    instance.on('file:delete', (value, options) => this.delete(value, !!options?.emptyDir));
-    instance.on('file:copy', value => this.add(value));
+function observeFile(host, instance) {
+    instance.on('file:delete', (value, options) => host.delete(value, !!options?.emptyDir));
+    instance.on('file:copy', value => host.add(value));
     instance.on('file:move', (value, options) => {
-        this.add(value);
+        host.add(value);
         const src = options?.outSrc;
         if (src) {
-            this.delete(src);
+            host.delete(src);
         }
     });
     instance.on('dir:remove', value => {
-        if (this.removeCwd(value)) {
-            if (PLATFORM_WIN32) {
-                value = value.toLowerCase();
-            }
+        if (host.removeCwd(value)) {
+            value = matchPathname(value);
             if (!value.endsWith(path.sep)) {
                 value += path.sep;
             }
-            for (const name of this.files) {
-                if ((PLATFORM_WIN32 ? name.toLowerCase() : name).startsWith(value)) {
-                    this.files.delete(name);
+            for (const name of host.files) {
+                if (matchPathname(name).startsWith(value)) {
+                    host.files.delete(name);
                 }
             }
         }
     });
 }
-function collectErrors() {
+function clearModule(instance, items) {
+    const { moduleName, errors } = instance;
+    if (errors.length > 0) {
+        for (const value of errors) {
+            items.push(`[${moduleName}] ` + (core_1.Host.asString(value) || "Unknown"));
+        }
+        errors.length = 0;
+    }
+}
+function collectErrors(host) {
     const result = [];
-    const clearModule = (instance) => {
-        const { moduleName, errors } = instance;
-        if (errors.length) {
-            errors.forEach(value => result.push(`[${moduleName}] ` + (core_1.Host.asString(value) || "Unknown")));
-            errors.length = 0;
-        }
-    };
-    this.modules.forEach(instance => clearModule(instance));
-    this.subProcesses.forEach(instance => clearModule(instance));
-    clearModule(this);
-    if (!this.restarting) {
+    for (const instance of host.modules) {
+        clearModule(instance, result);
+    }
+    for (const instance of host.subProcesses) {
+        clearModule(instance, result);
+    }
+    clearModule(host, result);
+    if (!host.restarting) {
         queueMicrotask(() => {
-            this.flushLog();
-            this.modules.forEach(instance => instance.flushLog());
-            this.subProcesses.forEach(instance => instance.flushLog());
-            this.close();
-            clearAssets.call(this);
+            if (!host.silent) {
+                host.flushLog();
+            }
+            for (const instance of host.modules) {
+                if (!instance.silent) {
+                    instance.flushLog();
+                }
+            }
+            for (const instance of host.subProcesses) {
+                if (!instance.silent) {
+                    instance.flushLog();
+                }
+            }
+            host.close();
+            clearAssets(host);
         });
     }
     else {
-        clearAssets.call(this);
+        clearAssets(host);
     }
     return result;
 }
-function rejectModule(err, type, hint) {
-    this.writeFail(["Handled rejection", this.moduleName + (hint ? ': ' + hint : '')], err, type);
+function setHttpCacheLimit(value, type, disk) {
+    if (value === undefined) {
+        return;
+    }
+    if (typeof value === 'string') {
+        value = (0, types_1.formatSize)(value);
+    }
+    if (value >= 0) {
+        switch (type) {
+            case 1:
+                (disk ? DISK : MEMORY).LIMIT = value;
+                break;
+            case 2:
+                MEMORY.LIMIT_ALL = value;
+                break;
+            case 3:
+                MEMORY.DISK_MIN = value;
+                break;
+            case 4:
+                MEMORY.DISK_MAX = value;
+                break;
+        }
+    }
+    else if (value === -1) {
+        switch (type) {
+            case 3:
+                MEMORY.DISK_MIN = Infinity;
+                break;
+            case 4:
+                MEMORY.DISK_MAX = 0;
+                break;
+        }
+    }
+}
+function rejectModule(instance, err, type, hint) {
+    instance.writeFail(["Handled rejection", instance.moduleName + (hint ? ': ' + hint : '')], err, type);
+}
+function errorAsset(instance, err, localUri, type = 4) {
+    rejectModule(instance, err, type, path.basename(localUri));
+}
+function removeFiles(host, items) {
+    if (items.size > 0) {
+        for (const value of items) {
+            host.deleteFile(value, { emptyDir: true });
+        }
+        items.clear();
+    }
+}
+function createImageInstance(host, mimeMap, mimeType, constructor, ...params) {
+    const instance = new constructor(...params);
+    instance.host = host;
+    instance.init(host.config);
+    observeFile(host, instance);
+    mimeMap.set(mimeType, { constructor, instance, params });
+    return instance;
+}
+function clearQueue(data, attr) {
+    if (attr && data[attr]) {
+        for (const item of data[attr]) {
+            item.invalid = true;
+        }
+        data[attr] = undefined;
+    }
+}
+function hasEtag(item, cacheable, fallback) {
+    if (!cacheable || !(0, types_1.existsFlag)(item.flags)) {
+        return false;
+    }
+    switch (item.incremental) {
+        case false:
+        case "none":
+        case "exists":
+        case "staging":
+            return false;
+        case "etag":
+            return true;
+        default:
+            return fallback;
+    }
+}
+function processHeaders(item, headers, lastModified, mainEtag) {
+    const contentLength = parseInt(headers['content-length']);
+    if (contentLength > 0) {
+        item.contentLength = contentLength;
+    }
+    else if ('contentLength' in item) {
+        item.contentLength = undefined;
+    }
+    const etag = headers.etag;
+    if (etag) {
+        if (mainEtag) {
+            CACHE_ETAG[item.uri] = etag;
+        }
+        return item.etag = etag;
+    }
+    if (lastModified) {
+        return item.lastModified = headers['last-modified'];
+    }
+}
+function errorPermission(host, item) {
+    host.writeFail(["Unable to read file", item.uri], (0, types_1.errorValue)("Operation not permitted", item.uri || "Unknown"), 8192);
+    item.invalid = true;
+}
+function copyDownload(host, item, queued) {
+    const uriMap = new Map();
+    for (const file of queued) {
+        const destUri = file.localUri;
+        let items = uriMap.get(destUri);
+        if (!items) {
+            const pathname = path.dirname(destUri);
+            if (!core_1.Host.createDir(pathname)) {
+                file.invalid = true;
+                continue;
+            }
+            uriMap.set(destUri, items = []);
+        }
+        file.etag = item.etag;
+        file.lastModified = item.lastModified;
+        items.push(file);
+    }
+    const buffer = item.sourceUTF8 || item.buffer;
+    for (const [destUri, items] of uriMap) {
+        try {
+            if (buffer) {
+                fs.writeFileSync(destUri, buffer);
+            }
+            else {
+                fs.copyFileSync(item.localUri, destUri);
+            }
+            for (const queue of items) {
+                host.performAsyncTask();
+                void host.transformAsset(new FileThread(host, queue, 1));
+            }
+        }
+        catch (err) {
+            for (const queue of items) {
+                queue.invalid = true;
+            }
+            host.writeFail([buffer ? "Unable to write buffer" : "Unable to copy file", path.basename(item.localUri)], err, 32);
+        }
+    }
+}
+function setBufferTarget(item, buffer) {
+    if (typeof buffer === 'string') {
+        item.sourceUTF8 = buffer;
+    }
+    else {
+        item.buffer = buffer;
+    }
+}
+function writeBufferCache(host, localUri, buffer, encoding) {
+    fs.writeFileSync(localUri, buffer);
+    host.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
+}
+function nextScheduled(scheduler, pid) {
+    if (pid > 0) {
+        const found = scheduler.status.find(item => item.id === pid);
+        if (found) {
+            found.endTime || (found.endTime = Date.now());
+        }
+    }
+    --scheduler.count;
+    if (scheduler.queue.length > 0) {
+        const params = scheduler.queue.pop();
+        void this.scheduleTask(...params);
+    }
+    else if (scheduler.transform.length > 0) {
+        do {
+            const args = scheduler.transform.shift();
+            void this.transformAsset(args[0], args[1], true);
+        } while (scheduler.transform.length > 0 && scheduler.queue.length === 0);
+    }
+}
+async function doVerifyChecksum(root, from, options, nested) {
+    if ((0, types_1.isObject)(from)) {
+        options = from;
+        from = undefined;
+    }
+    else {
+        options || (options = {});
+    }
+    const { digest, sortBy = 0, recursive = false, ignore = [], include, exclude, verbose = true, joinRoot } = options;
+    const parent = recursive === 1 && typeof verbose !== 'number';
+    let algorithm = options.algorithm;
+    from || (from = checksumFile(algorithm));
+    if (!algorithm) {
+        switch (algorithm = path.extname(from).substring(1).toLowerCase()) {
+            case 'md5':
+            case 'sha1':
+            case 'sha224':
+            case 'sha256':
+            case 'sha384':
+            case 'sha512':
+            case 'ripemd':
+            case 'ripemd-160':
+                break;
+            default:
+                algorithm = undefined;
+                break;
+        }
+    }
+    if (verbose) {
+        (0, types_1.setLogCurrent)(null);
+    }
+    let pass = 0, fail = [], missing = [];
+    try {
+        const filename = path.basename(from);
+        const files = [];
+        from = joinRoot ? path.join(root, filename) : path.resolve(from);
+        recurseDir(files, [root], { ignore: [...ignore, from], sortBy, recursive });
+        const items = fs.readFileSync(from, 'utf-8').split('\n').map(item => {
+            const index = item.indexOf(' ');
+            return [item.substring(0, index), path.join(root, item.substring(index + 1))];
+        });
+        const checked = include || exclude ? filterPaths(items.map(item => item[1]), include, exclude, options.dot) : null;
+        let valid;
+        for (const [previous, pathname] of items) {
+            if (checked !== null && !checked.includes(pathname) || recursive === 1 && path.basename(pathname) === filename) {
+                continue;
+            }
+            if (files.includes(pathname)) {
+                const hash = await FileManager.readHash(pathname, { algorithm, digest });
+                if (hash !== previous) {
+                    fail.push(pathname);
+                }
+                else {
+                    if (verbose) {
+                        process.stdout.write("+" + ' ' + pathname + '\n');
+                    }
+                    ++pass;
+                }
+                valid = true;
+            }
+            else if (!ignore.includes(pathname)) {
+                missing.push(pathname);
+            }
+        }
+        if (parent) {
+            const checksum = files.filter(value => path.basename(value) === filename);
+            if (checksum.length > 0) {
+                const current = items.map(item => item[1]);
+                const tasks = checksum.map(async (pathname) => doVerifyChecksum(path.dirname(pathname), filename, { ...options, ignore: current, joinRoot: true }, true));
+                await Promise.all(tasks).then(group => {
+                    for (const item of group) {
+                        if (item) {
+                            const [f, m, p] = item;
+                            if (f.length > 0) {
+                                fail.push(...f);
+                            }
+                            if (m.length > 0) {
+                                missing.push(...m);
+                            }
+                            pass += p;
+                            valid = true;
+                        }
+                    }
+                });
+            }
+        }
+        if (valid) {
+            options.outPath = from;
+        }
+        else if (options.throwsEmpty) {
+            throw checksumError(algorithm);
+        }
+    }
+    catch (err) {
+        if (options.throwsEmpty) {
+            throw err;
+        }
+        FileManager.writeFail(["Unable to read directory", root], err, 32);
+        return null;
+    }
+    if (parent) {
+        if (fail.length > 0) {
+            fail = Array.from(new Set(fail));
+        }
+        if (missing.length > 0) {
+            missing = Array.from(new Set(missing));
+        }
+    }
+    if (verbose && !nested) {
+        const max = Math.max(...fail.concat(missing).map(item => item.length));
+        writeLog(fail, "-", max);
+        writeLog(missing, "?", max);
+    }
+    return [fail, missing, pass];
+}
+function writeLog(items, symbol, max) {
+    const [bg, fg] = symbol === "-" ? ['\x1b[31m', '\x1b[89m'] : ['\x1b[33m', '\x1b[89m'];
+    items.forEach((value, index) => {
+        process.stdout.write(bg + symbol + ` ${value.padEnd(max)} (${(index + 1).toString()})${fg}\n`);
+    });
+}
+function writeProgressBar(bars, length) {
+    if (bars > 0) {
+        const leading = bars < length ? (--bars, 1) : 0;
+        let result = bars > 0 ? LOGGER.PROGRESS_USECOLOR ? chalk.yellow.bold(LOGGER.PROGRESS_BOXCHAR).repeat(bars) : '#'.repeat(bars) : '';
+        if (leading > 0) {
+            result += chalk.grey(LOGGER.PROGRESS_BOXCHAR.repeat(length - bars));
+        }
+        return result;
+    }
+    return '';
+}
+function formatSegment(endTime, ...values) {
+    if (endTime === -1) {
+        values[0] = chalk.red(values[0]);
+        values[1] = chalk.grey.bold(values[1]);
+        values[2] = chalk.grey.bold(values[2]);
+    }
+    else if (endTime) {
+        values[0] = chalk.yellow.bold(values[0]);
+        values[1] = chalk.cyan.bold(values[1]);
+        values[2] = chalk.cyan(values[2]);
+    }
+    else {
+        values[0] = chalk.yellow(values[0]);
+    }
+    return values;
+}
+function tryPackage(host, target, type) {
+    if ((0, types_1.isString)(target)) {
+        try {
+            return require(target);
+        }
+        catch (err) {
+            host.checkPackage(err, target, ["Unable to load handler", host.moduleName], type);
+        }
+        return null;
+    }
+    return target;
+}
+function setLogMinWidth() {
+    LOGGER.MIN_WIDTH = LOGGER.TITLE_WIDTH + 2 + LOGGER.VALUE_WIDTH + 1;
+    LOGGER.MESSAGE_WIDTH = LOGGER.MIN_WIDTH + LOGGER.MESSAGE_SEP_START;
+    LOGGER.PERCENT_WIDTH = LOGGER.MIN_WIDTH + 8;
+    LOGGER.STAT_WIDTH = LOGGER.PERCENT_WIDTH + 11 + 13;
 }
-const padStart = (value, char) => value > 9 ? value.toString() : char + value;
+const closeResponse = (client) => client?.destroy();
+const isCacheable = (item) => item.initialValue?.cacheable !== false;
+const isMatchRoot = (value) => !value.startsWith('*') && /[\\/]/.test(value);
+const hasIncremental = (value) => value === "etag" || value === "exists";
+const matchPathname = (value) => core_1.Host.PLATFORM_WIN32 ? value.toLowerCase() : value;
+const sanitizePath = (value) => value.replace(/(?:^\\|\\+)/g, '/');
+const equalAddress = (value, other) => value === other || decodeURIComponent(value) === decodeURIComponent(other);
+const formatPercent = (value) => Math.round(value).toString().padStart(3) + '%';
+const checkEOF = (value) => /\n$/.test(value) ? value : value + '\n';
 const checksumFile = (algorithm) => "checksum" + '.' + ((0, types_1.isString)(algorithm) ? algorithm.toLowerCase() : "sha256");
 const checksumError = (algorithm) => new Error("Invalid parameters" + ` (${algorithm || "sha256"})`);
 const isFunction = (value) => typeof value === 'function';
 const ignoreAsset = (item, exists) => item.invalid || (0, types_1.hasBit)(item.flags, 1 | (!exists ? 128 : 0));
+const validateChecksum = (host, item, buffer, localUri = item.localUri) => !item.checksum || checkHash(host, localUri, false, item.checksum, buffer);
+const errorAbsolute = (hint) => (0, types_1.errorValue)("Path is not absolute", hint);
 class Scheduler {
     constructor() {
         this.id = 0;
         this.count = 0;
-        this.length = 0;
+        this.statusHeight = 0;
+        this.scrollHeight = 0;
+        this.pending = 0;
         this.updated = 0;
-        this.titleWidth = 6;
-        this.valueWidth = 71;
         this.limit = PROCESS_SUB_LIMIT;
         this.queue = [];
         this.transform = [];
         this.status = [];
+        this.scroll = [];
         this.logCurrent = null;
-        if (LOG_FORMAT) {
-            this.titleWidth = LOG_FORMAT.title.width;
-            this.valueWidth = LOG_FORMAT.value.width;
-        }
+        this.screenReset = false;
+        this.listener = null;
+        this._columns = -1;
     }
     add(id, url) {
-        const valueWidth = this.valueWidth;
-        if (url.length > valueWidth) {
-            url = url.substring(0, valueWidth - 3) + '...';
+        if (url.length > LOGGER.VALUE_WIDTH) {
+            url = url.substring(0, LOGGER.VALUE_WIDTH - 3) + '...';
         }
         else {
-            url = url.padEnd(valueWidth);
+            url = url.padEnd(LOGGER.VALUE_WIDTH);
         }
         this.status.push(new TaskStatus(id, url));
     }
     reset() {
         this.status = [];
-        this.length = 0;
+        this.scroll = [];
+        this.statusHeight = 0;
+        this.scrollHeight = 0;
         this.logCurrent = null;
+        this._columns = -1;
+        if (this.listener) {
+            PROCESS_STDIN.setRawMode(false);
+            PROCESS_STDIN.removeListener('keypress', this.listener);
+            this.listener = null;
+        }
+    }
+    section(redraw) {
+        if (redraw) {
+            PROCESS_STDOUT.write(chalk.blackBright('-'.repeat(PROCESS_STDOUT.columns)) + '\n');
+        }
+        else {
+            PROCESS_STDOUT.moveCursor(0, 1);
+        }
+    }
+    get barLength() {
+        if (this.rawMode) {
+            if (this._columns === -1) {
+                PROCESS_STDIN.setRawMode(true);
+                this.listener = (ch, key) => {
+                    if (key.ctrl) {
+                        PROCESS_STDIN.setRawMode(false);
+                    }
+                };
+                PROCESS_STDIN.on('keypress', this.listener);
+            }
+            PROCESS_STDIN.pause();
+            PROCESS_STDIN.resume();
+        }
+        const columns = PROCESS_STDOUT.columns;
+        if (columns !== this._columns) {
+            if (this._columns !== -1) {
+                for (const item of this.status) {
+                    item.current = '';
+                    item.finished = '';
+                }
+                this.scroll = [];
+                this.logCurrent = null;
+                PROCESS_STDOUT.write('\x1bc');
+                this.screenReset = true;
+            }
+            this._columns = columns;
+        }
+        const width = columns - LOGGER.STAT_WIDTH;
+        if (width < 0) {
+            return columns >= LOGGER.PERCENT_WIDTH ? 1 : NaN;
+        }
+        return width >= 10 ? Math.max(Math.min(width, LOGGER.PROGRESS_MAXWIDTH), 10) : -1;
+    }
+    get rawMode() {
+        return core_1.Host.PLATFORM_WIN32 && LOGGER.PROGRESS_RAWMODE;
     }
 }
 class TaskStatus {
@@ -359,7 +780,8 @@ class TaskStatus {
         this.startTime = Date.now();
         this.endTime = 0;
         this.dataTime = null;
-        this.output = '';
+        this.current = '';
+        this.finished = '';
     }
 }
 class HttpDiskCache {
@@ -373,10 +795,10 @@ class HttpDiskCache {
         this._excludeExt = [];
         this._includeExt = [];
         this._items = [];
-        this[KEnabled] = enabled;
+        this.enabled = enabled;
     }
     has(uri) {
-        if (!this[KEnabled]) {
+        if (!this.enabled) {
             return false;
         }
         try {
@@ -391,7 +813,7 @@ class HttpDiskCache {
         if (flags === 0) {
             return true;
         }
-        if (flags & 10) {
+        if (flags & (2 | 8)) {
             const ext = path.extname(uri.pathname).substring(1);
             if (ext) {
                 if (flags & 2) {
@@ -404,9 +826,12 @@ class HttpDiskCache {
                 }
             }
         }
-        return flags & 1 ? this._include.includes(uri.origin) : !this._exclude.includes(uri.origin);
+        if ((flags & 1) && !this._include.includes(uri.origin) || (flags & 4) && this._exclude.includes(uri.origin)) {
+            return false;
+        }
+        return true;
     }
-    add(uri, etag, target, { buffer, contentLength = (0, util_1.getSize)(target) } = {}) {
+    add(uri, etag, target, { buffer, contentLength = (0, util_2.getSize)(target) } = {}) {
         let tempDir;
         if (contentLength <= this.limit && (tempDir = this.host.getCacheDir(uri))) {
             const baseDir = path.join(tempDir, etag);
@@ -423,7 +848,9 @@ class HttpDiskCache {
                 }
                 const expires = this.expires;
                 if (expires > 0 && expires < Infinity) {
-                    setTimeout(() => this.clear(target), Math.min(expires, core_1.Host.MAX_TIMEOUT));
+                    setTimeout(() => {
+                        this.clear(target);
+                    }, Math.min(expires, core_1.Host.MAX_TIMEOUT));
                 }
             }
             catch {
@@ -461,7 +888,7 @@ class HttpDiskCache {
             }
         }
         else {
-            this._flags &= ~3;
+            this._flags &= ~(1 | 2);
         }
     }
     get include() {
@@ -483,7 +910,7 @@ class HttpDiskCache {
             }
         }
         else {
-            this._flags &= ~12;
+            this._flags &= ~(4 | 8);
         }
     }
     get exclude() {
@@ -511,7 +938,9 @@ class HttpMemoryCache extends HttpDiskCache {
             }
             this._items.push(MEMORY.CACHE[uri] = [Date.now(), buffer, encoding, contentLength, uri, etag]);
             if (this.expires < Infinity) {
-                setTimeout(() => this.clear(uri), Math.min(this.expires, core_1.Host.MAX_TIMEOUT));
+                setTimeout(() => {
+                    this.clear(uri);
+                }, Math.min(this.expires, core_1.Host.MAX_TIMEOUT));
             }
             ++MEMORY.TOTAL;
             return;
@@ -556,7 +985,7 @@ class HttpMemoryCache extends HttpDiskCache {
         }
     }
     purge(percent, limit) {
-        FileManager.purgeMemory(percent, limit);
+        void FileManager.purgeMemory(percent, limit);
     }
     withinDisk(value) {
         if (typeof value !== 'number') {
@@ -565,6 +994,397 @@ class HttpMemoryCache extends HttpDiskCache {
         return value >= this.toDisk[0] && value <= this.toDisk[1];
     }
 }
+class ProcessGroup {
+    constructor() {
+        this.emptied = [];
+        this.completed = Object.create(null);
+        this.processing = Object.create(null);
+        this.downloading = Object.create(null);
+        this.appending = Object.create(null);
+        this.bundling = Object.create(null);
+        this.originCount = Object.create(null);
+    }
+}
+class ProcessFile {
+    constructor(host, file, localUri, groupData) {
+        this.host = host;
+        this.file = file;
+        this.localUri = localUri;
+        this.groupData = groupData;
+    }
+    createFolder(pathname, emptyDir) {
+        const emptied = this.groupData.emptied;
+        if (!emptied.includes(pathname)) {
+            if (emptyDir && core_1.Host.removeDir(pathname, true)) {
+                emptied.push(pathname);
+            }
+            else if (core_1.Host.createDir(pathname)) {
+                emptied.push(pathname);
+            }
+            else {
+                this.file.invalid = true;
+                this.host.writeFail("Unable to create directory", (0, types_1.errorValue)("Path not found", pathname));
+                return false;
+            }
+        }
+        return true;
+    }
+    queued(pathname, emptyDir, content) {
+        var _p, _q, _r;
+        if (!this.createFolder(pathname, emptyDir)) {
+            return true;
+        }
+        const { host, groupData: group, file, localUri } = this;
+        const { bundleId, bundleIndex = -1 } = file;
+        if (!(0, types_1.isEmpty)(bundleId) && bundleIndex >= 0) {
+            const items = (_p = group.appending)[localUri] || (_p[localUri] = []);
+            (_q = group.bundling)[_r = file.uri] || (_q[_r] = []);
+            if (bundleIndex > 0) {
+                items[bundleIndex - 1] = file;
+                const url = file.url;
+                if (file.fetchType === 1 && (host.cacheToDisk.has(url) || host.cacheToMemory.has(url))) {
+                    const parent = host.assets.find(item => item.bundleIndex === 0 && item.bundleId === bundleId);
+                    if (parent) {
+                        (parent.bundleQueue || (parent.bundleQueue = [])).push(new Promise(resolve => {
+                            host.Request.open(url, { method: 'HEAD', httpVersion: 1 })
+                                .on('response', res => {
+                                if (res.statusCode < 300) {
+                                    processHeaders(file, res.headers, false, false);
+                                }
+                                resolve(file);
+                            })
+                                .on('error', () => {
+                                resolve(file);
+                            })
+                                .on('timeout', () => {
+                                resolve(file);
+                            });
+                        }));
+                    }
+                }
+                return true;
+            }
+        }
+        else if (!content && file.filename) {
+            const previous = group.completed[localUri];
+            if (previous) {
+                if (file.uri === previous.uri) {
+                    file.etag = previous.etag;
+                    file.lastModified = previous.lastModified;
+                }
+                void host.transformAsset(new FileThread(host, file, 1));
+                return true;
+            }
+            const queue = group.processing[localUri];
+            if (queue) {
+                queue.push(file);
+                return true;
+            }
+            group.processing[localUri] = [file];
+        }
+        return false;
+    }
+    received(err, incremental, fetched, binary, checked) {
+        const { host, file } = this;
+        const localUri = this.localUri;
+        if (err) {
+            file.invalid = true;
+            host.completeAsyncTask(err, localUri);
+            return;
+        }
+        if (file.checksum && !checked && !checkHash(host, localUri, false, file.checksum, file.buffer)) {
+            file.invalid = true;
+            host.filesToRemove.add(localUri);
+            host.completeAsyncTask();
+            host.writeFail(["Checksum did not match", path.basename(localUri)], (0, types_1.errorValue)(file.uri || localUri, "Invalid checksum"), { type: 32, queue: true });
+            return;
+        }
+        if (fetched) {
+            host.fetchedAssets.push(file);
+        }
+        else {
+            host.copiedAssets.push(file);
+        }
+        if (binary) {
+            void host.transformAsset(new FileThread(host, file, 1));
+        }
+        else {
+            void this.finalize(incremental);
+        }
+    }
+    async finalize(incremental) {
+        const { host, file, localUri, groupData } = this;
+        const bundleStart = file.bundleIndex === 0 && !(0, types_1.isEmpty)(file.bundleId) ? host.incremental !== "staging" && host[kRecursionLimit] === RECURSION_LIMIT ? 2 : 1 : 0;
+        groupData.completed[localUri] = file;
+        if (bundleStart > 0) {
+            host.setAssetContent(file, host.getUTF8String(file, localUri));
+            let success = true, error, checkEtag = !file.trailingContent && hasEtag(file, bundleStart === 2, incremental === "etag");
+            if (file.bundleQueue) {
+                error = await Promise.all(file.bundleQueue).then(() => null).catch((err) => err);
+                delete file.bundleQueue;
+            }
+            const items = groupData.appending[localUri];
+            if (items) {
+                if (error) {
+                    for (const queue of items) {
+                        queue.invalid = true;
+                    }
+                    success = false;
+                }
+                else {
+                    const tasks = [];
+                    for (const queue of items) {
+                        const encoding = queue.encoding || (queue.encoding = 'utf-8');
+                        const { uri, fetchType: type } = queue;
+                        let tempFile;
+                        if (checkEtag && queue.trailingContent) {
+                            checkEtag = false;
+                        }
+                        const verifyBundle = (value, etag, checked) => {
+                            if (!queue.invalid) {
+                                if (!checked && !validateChecksum(host, queue, value, localUri)) {
+                                    queue.invalid = true;
+                                    return;
+                                }
+                                if (value instanceof Buffer) {
+                                    value = value.toString(encoding);
+                                }
+                                const url = queue.url;
+                                if (etag && host.cacheToMemory.has(url)) {
+                                    host.cacheToMemory.add(url, encodeURIComponent(etag), value, {
+                                        encoding,
+                                        contentLength: queue.contentLength,
+                                        toDisk: !tempFile && isCacheable(queue) ? queue.filename || queue.localUri && path.basename(queue.localUri) : ''
+                                    });
+                                }
+                                host.setAssetContent(queue, value, { localUri, bundleIndex: queue.bundleIndex, bundleReplace: queue.bundleReplace });
+                            }
+                        };
+                        if (queue.content) {
+                            verifyBundle(queue.content);
+                            checkEtag = false;
+                        }
+                        else if (uri) {
+                            if (type === 1 || type === 2) {
+                                const url = queue.url;
+                                const options = {
+                                    url,
+                                    encoding,
+                                    statusMessage: uri + ` (${queue.bundleIndex})`
+                                };
+                                let etag, pipeTo;
+                                if (type === 2) {
+                                    options.socketPath = queue.socketPath;
+                                    options.httpVersion = 1;
+                                }
+                                else if (url) {
+                                    if (etag = queue.etag) {
+                                        const valid = incremental !== false || file.incremental === true;
+                                        const cached = valid && MEMORY.CACHE[uri];
+                                        const etagDir = encodeURIComponent(etag);
+                                        if (cached) {
+                                            if (etagDir === cached[5]) {
+                                                const source = cached[1];
+                                                if (validateChecksum(host, queue, source, localUri)) {
+                                                    verifyBundle(typeof source === 'string' ? source : source.toString(encoding), '', true);
+                                                    host.addDownload(Buffer.byteLength(source, encoding), types_1.DOWNLOAD_TYPE.CACHE);
+                                                    continue;
+                                                }
+                                            }
+                                            else {
+                                                host.cacheToMemory.clear(uri);
+                                            }
+                                        }
+                                        if (host.cacheToDisk.has(url) && isCacheable(queue)) {
+                                            const baseDir = path.join(host.getCacheDir(url), etagDir);
+                                            pipeTo = path.join(baseDir, path.basename(localUri));
+                                            try {
+                                                if (valid && (0, util_2.hasSize)(pipeTo)) {
+                                                    const buffer = fs.readFileSync(pipeTo, { encoding });
+                                                    if (validateChecksum(host, queue, localUri, buffer)) {
+                                                        verifyBundle(buffer, etag, true);
+                                                        host.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
+                                                        continue;
+                                                    }
+                                                }
+                                                if (!fs.existsSync(baseDir)) {
+                                                    fs.mkdirSync(baseDir);
+                                                }
+                                                tempFile = path.join(baseDir, (0, types_1.incrementUUID)());
+                                                options.pipeTo = tempFile;
+                                            }
+                                            catch {
+                                                pipeTo = undefined;
+                                            }
+                                        }
+                                    }
+                                    if ((groupData.originCount[url.origin] || 0) <= 1) {
+                                        options.httpVersion = 1;
+                                    }
+                                    options.connected = (headers) => {
+                                        etag = processHeaders(queue, headers, !!host.Watch, false);
+                                        return true;
+                                    };
+                                }
+                                tasks.push(new Promise((resolve, reject) => {
+                                    void host.scheduleTask(url || uri, options, (data) => {
+                                        if (data) {
+                                            verifyBundle(data, etag);
+                                        }
+                                        else {
+                                            queue.invalid = true;
+                                        }
+                                        const downloaded = groupData.bundling[uri];
+                                        if ((0, types_1.isArray)(downloaded)) {
+                                            if (data && !queue.invalid) {
+                                                if (typeof data === 'string') {
+                                                    queue.sourceUTF8 = data;
+                                                }
+                                                else {
+                                                    queue.buffer = data;
+                                                }
+                                                copyDownload(host, queue, downloaded);
+                                            }
+                                            else {
+                                                for (const item of downloaded) {
+                                                    item.invalid = true;
+                                                }
+                                            }
+                                        }
+                                        if (tempFile && (!pipeTo || core_1.Host.isPath(pipeTo) || !core_1.Host.renameFile(tempFile, pipeTo, false))) {
+                                            queueMicrotask(() => {
+                                                fs.unlink(tempFile, () => { });
+                                            });
+                                        }
+                                        resolve();
+                                    }, (err) => {
+                                        queue.invalid = true;
+                                        if (tempFile) {
+                                            queueMicrotask(() => {
+                                                fs.unlink(tempFile, () => { });
+                                            });
+                                        }
+                                        reject(err);
+                                    }, 1);
+                                }));
+                            }
+                            else if (type) {
+                                const mimeType = queue.mimeType || file.mimeType;
+                                const pathname = host.getTempDir({ uuidDir: true });
+                                if (!pathname || !mimeType) {
+                                    queue.invalid = true;
+                                    tasks.push(Promise.reject(!pathname ? new Error("Unable to create temp directory") : (0, types_1.errorValue)("MIME not found", uri)));
+                                    break;
+                                }
+                                tasks.push(new Promise((resolve, reject) => {
+                                    void host.scheduleTask(queue.url || uri, { pathname, binOpts: queue.binOpts || file.binOpts }, (result) => {
+                                        if (result.length > 0) {
+                                            verifyBundle(bundleTorrent(host, result, mimeType, encoding));
+                                        }
+                                        else {
+                                            queue.invalid = true;
+                                        }
+                                        queueMicrotask(() => {
+                                            core_1.Host.removeDir(pathname);
+                                        });
+                                        resolve();
+                                    }, (err) => {
+                                        queue.invalid = true;
+                                        queueMicrotask(() => {
+                                            core_1.Host.removeDir(pathname);
+                                        });
+                                        reject(err);
+                                    }, 4);
+                                }));
+                            }
+                            else if (host.canRead(uri)) {
+                                tasks.push(fs.promises.readFile(uri, encoding)
+                                    .then(data => {
+                                    verifyBundle(data);
+                                    host.addDownload(Buffer.byteLength(data, encoding), types_1.DOWNLOAD_TYPE.DISK);
+                                })
+                                    .catch(() => {
+                                    queue.invalid = true;
+                                }));
+                            }
+                            else {
+                                checkEtag = false;
+                                errorPermission(host, file);
+                            }
+                        }
+                    }
+                    if (tasks.length > 0) {
+                        success = await Promise.all(tasks)
+                            .then(() => true)
+                            .catch((err) => {
+                            host.writeFail(["Unable to download file", 'bundle: ' + path.basename(localUri)], err, 1024);
+                            return false;
+                        });
+                    }
+                    else if (checkEtag && core_1.Host.isPath(localUri)) {
+                        host.completeAsyncTask();
+                        groupData.appending[localUri] = undefined;
+                        return;
+                    }
+                }
+            }
+            if (success) {
+                if (!host.fetchedAssets.includes(file)) {
+                    host.fetchedAssets.push(file);
+                }
+                void host.transformAsset(new FileThread(host, file, 1));
+            }
+            else {
+                file.invalid = true;
+                unsetContent(file);
+                host.completeAsyncTask(error);
+                queueMicrotask(() => {
+                    host.deleteFile(localUri, { emptyDir: true });
+                });
+            }
+            groupData.appending[localUri] = undefined;
+            return;
+        }
+        const { downloading, processing } = groupData;
+        const uri = file.uri;
+        const processed = processing[localUri];
+        const downloaded = downloading[uri];
+        if ((0, types_1.isArray)(downloaded)) {
+            copyDownload(host, file, downloaded);
+        }
+        if (processed) {
+            for (const item of processed) {
+                if (item !== file) {
+                    if (item.uri === file.uri) {
+                        item.etag = file.etag;
+                        item.lastModified = file.lastModified;
+                    }
+                    host.performAsyncTask();
+                }
+                void host.transformAsset(new FileThread(host, item, 1));
+            }
+            processing[localUri] = undefined;
+        }
+        else {
+            void host.transformAsset(new FileThread(host, file, 1));
+        }
+        if (downloaded) {
+            downloading[uri] = undefined;
+        }
+    }
+    abort(err, preceding) {
+        const { host, file, localUri, groupData } = this;
+        const uri = file.uri;
+        clearQueue(groupData.processing, localUri);
+        clearQueue(groupData.downloading, uri);
+        clearQueue(groupData.appending, localUri);
+        file.invalid = true;
+        if (!preceding) {
+            host.completeAsyncTask();
+        }
+        host.writeFail(["Unable to download file", uri], err, err instanceof Error && err.message.startsWith("Timeout was exceeded") ? 16384 : 1024);
+    }
+}
 class FileThread extends core_1.AbortComponent {
     constructor(host, file, threadCount) {
         super();
@@ -644,15 +1464,15 @@ class FileManager extends core_1.Host {
             return false;
         }
         const { process: proc, download, request, error, logger } = settings;
-        if (proc && (0, types_1.isPlainObject)(proc.thread)) {
-            const limit = (0, util_1.asInt)(proc.thread.sub_limit);
+        if (proc?.thread) {
+            const limit = (0, util_2.asInt)(proc.thread.sub_limit);
             if (limit > 0) {
                 PROCESS_SUB_LIMIT = limit;
             }
         }
         if ((0, types_1.isPlainObject)(request)) {
             let { timeout, disk, buffer, connect } = request;
-            if ((timeout = (0, util_1.fromSeconds)(timeout)) >= 0) {
+            if ((timeout = (0, util_2.fromSeconds)(timeout)) >= 0) {
                 HTTP_CLIENT.timeout = timeout;
             }
             if (disk) {
@@ -667,7 +1487,7 @@ class FileManager extends core_1.Host {
             request_1.loadSettings({ process: settings.process, request, download }, password);
         }
         if (error) {
-            const limit = (0, util_1.asInt)(error.recursion_limit);
+            const limit = (0, util_2.asInt)(error.recursion_limit);
             if (limit >= 0 && limit < Infinity) {
                 RECURSION_LIMIT = limit;
             }
@@ -680,16 +1500,63 @@ class FileManager extends core_1.Host {
             else if (id && (id = +id) > 0) {
                 SESSION_LIMIT = Math.pow(10, id);
             }
+            if (logger.progress) {
+                let { scroll_buffer, max_width, use_color, text_wrap, color, bg_color, raw_mode, box_char } = logger.progress;
+                if ((scroll_buffer = (0, util_2.asInt)(scroll_buffer)) >= 0 && scroll_buffer <= 16) {
+                    LOGGER.PROGRESS_SCROLLBUFFER = scroll_buffer;
+                }
+                if (max_width === 'auto' || max_width === '100%') {
+                    LOGGER.PROGRESS_MAXWIDTH = Infinity;
+                }
+                else if ((max_width = (0, util_2.asInt)(max_width)) >= 10) {
+                    LOGGER.PROGRESS_MAXWIDTH = max_width;
+                }
+                if (typeof use_color === 'boolean') {
+                    LOGGER.PROGRESS_USECOLOR = use_color;
+                }
+                switch (text_wrap) {
+                    case 'ellipsis':
+                    case 'nowrap':
+                    case 'ellipsis-end':
+                    case 'nowrap-end':
+                        LOGGER.PROGRESS_TEXTWRAP = text_wrap;
+                        break;
+                }
+                if ((0, types_1.isString)(color)) {
+                    LOGGER.PROGRESS_COLOR = color;
+                }
+                if ((0, types_1.isString)(bg_color)) {
+                    LOGGER.PROGRESS_BGCOLOR = bg_color;
+                }
+                if ((0, types_1.isString)(box_char) && box_char.length === 1) {
+                    LOGGER.PROGRESS_BOXCHAR = box_char;
+                }
+                if (typeof raw_mode === 'boolean') {
+                    LOGGER.PROGRESS_RAWMODE = raw_mode;
+                    if (raw_mode && core_1.Host.PLATFORM_WIN32) {
+                        require('readline').emitKeypressEvents(PROCESS_STDIN);
+                    }
+                }
+            }
         }
-        LOG_FORMAT = this.LOG_FORMAT;
+        const { title, value, message } = this.LOG_FORMAT;
+        LOGGER.TITLE_WIDTH = title.width;
+        LOGGER.TITLE_SEP = title.braces;
+        LOGGER.VALUE_WIDTH = value.width;
+        const [L, R] = message.braces;
+        const Lch = L.trim();
+        const Rch = R.trim();
+        LOGGER.MESSAGE_SEP = Lch.length + Rch.length === 1 ? ` ${Rch + Lch} ` : (R ? R[0] === ' ' ? R : ' ' + R.trimEnd() : '') + (L ? L[L.length - 1] === ' ' ? L : L.trimStart() + ' ' : '');
+        LOGGER.MESSAGE_SEP_START = Lch.trimEnd().length;
         LOG_TIMEELAPSED = this.hasLogType(128);
         LOG_TIMEPROCESS = this.hasLogType(256);
+        setLogMinWidth();
         return true;
     }
     static sanitizeAssets(assets, exclusions = []) {
-        assets.forEach(item => {
+        for (const item of assets) {
             if ((0, types_1.ignoreFlag)(item.flags)) {
-                return;
+                continue;
             }
             const initialValue = item.initialValue;
             for (const attr in initialValue) {
@@ -725,7 +1592,7 @@ class FileManager extends core_1.Host {
                         break;
                 }
             }
-        });
+        }
         return assets;
     }
     static async writeChecksum(root, to, options) {
@@ -748,13 +1615,13 @@ class FileManager extends core_1.Host {
                 if (recursive === 1 && path.basename(pathname) === filename) {
                     continue;
                 }
-                const current = await this.readHash(pathname, { algorithm, digest }) + ' ' + (path.sep === '\\' ? pathname.replace(/(?:^\\|\\+)/g, '/') : pathname).substring(root.length).replace(/^\//, '');
+                const current = await this.readHash(pathname, { algorithm, digest }) + ' ' + (path.sep === '\\' ? sanitizePath(pathname) : pathname).substring(root.length).replace(/^\//, '');
                 if (verbose) {
                     process.stdout.write(current + '\n');
                 }
                 output.push(current);
             }
-            if (output.length) {
+            if (output.length > 0) {
                 fs.writeFileSync(to, output.join('\n'), 'utf-8');
                 options.outPath = to;
             }
@@ -777,118 +1644,7 @@ class FileManager extends core_1.Host {
         return result;
     }
     static async verifyChecksum(root, from, options) {
-        if ((0, types_1.isObject)(from)) {
-            options = from;
-            from = undefined;
-        }
-        else {
-            options || (options = {});
-        }
-        const { digest, sortBy = 0, recursive = false, ignore = [], include, exclude, verbose = true, joinRoot } = options;
-        const parent = recursive === 1 && typeof verbose !== 'number';
-        let algorithm = options.algorithm;
-        from || (from = checksumFile(algorithm));
-        if (!algorithm) {
-            switch (algorithm = path.extname(from).substring(1).toLowerCase()) {
-                case 'md5':
-                case 'sha1':
-                case 'sha224':
-                case 'sha256':
-                case 'sha384':
-                case 'sha512':
-                    break;
-                default:
-                    algorithm = undefined;
-                    break;
-            }
-        }
-        let pass = 0, fail = [], missing = [];
-        try {
-            const filename = path.basename(from);
-            const files = [];
-            from = joinRoot ? path.join(root, filename) : path.resolve(from);
-            recurseDir(files, [root], { ignore: [...ignore, from], sortBy, recursive });
-            const items = fs.readFileSync(from, 'utf-8').split('\n').map(item => {
-                const index = item.indexOf(' ');
-                return [item.substring(0, index), path.join(root, item.substring(index + 1))];
-            });
-            const checked = include || exclude ? filterPaths(items.map(item => item[1]), include, exclude, options.dot) : null;
-            let valid;
-            for (const [previous, pathname] of items) {
-                if (checked !== null && !checked.includes(pathname) || recursive === 1 && path.basename(pathname) === filename) {
-                    continue;
-                }
-                if (files.includes(pathname)) {
-                    const hash = await this.readHash(pathname, { algorithm, digest });
-                    if (hash !== previous) {
-                        fail.push(pathname);
-                    }
-                    else {
-                        if (verbose) {
-                            process.stdout.write("+" + ' ' + pathname + '\n');
-                        }
-                        ++pass;
-                    }
-                    valid = true;
-                }
-                else if (!ignore.includes(pathname)) {
-                    missing.push(pathname);
-                }
-            }
-            if (parent) {
-                const nested = files.filter(value => path.basename(value) === filename);
-                if (nested.length) {
-                    const current = items.map(item => item[1]);
-                    const tasks = nested.map(async (pathname) => this.verifyChecksum(path.dirname(pathname), filename, { ...options, ignore: current, joinRoot: true, verbose: (verbose ? 1 : 0) }));
-                    await Promise.all(tasks).then(group => {
-                        for (const item of group) {
-                            if (item) {
-                                const [f, m, p] = item;
-                                if (f.length) {
-                                    fail.push(...f);
-                                }
-                                if (m.length) {
-                                    missing.push(...m);
-                                }
-                                pass += p;
-                                valid = true;
-                            }
-                        }
-                    });
-                }
-            }
-            if (valid) {
-                options.outPath = from;
-            }
-            else if (options.throwsEmpty) {
-                throw checksumError(algorithm);
-            }
-        }
-        catch (err) {
-            if (options.throwsEmpty) {
-                throw err;
-            }
-            this.writeFail(["Unable to read directory", root], err, 32);
-            return null;
-        }
-        if (parent) {
-            if (fail.length) {
-                fail = Array.from(new Set(fail));
-            }
-            if (missing.length) {
-                missing = Array.from(new Set(missing));
-            }
-        }
-        if (verbose === true) {
-            const max = Math.max(...fail.concat(missing).map(item => item.length));
-            const writeLog = (items, symbol) => {
-                const [bg, fg] = symbol === "-" ? ['\x1b[31m', '\x1b[89m'] : ['\x1b[33m', '\x1b[89m'];
-                items.forEach((value, index) => process.stdout.write(bg + symbol + ` ${value.padEnd(max)} (${(index + 1).toString()})${fg}\n`));
-            };
-            writeLog(fail, "-");
-            writeLog(missing, "?");
-        }
-        return [fail, missing, pass];
+        return doVerifyChecksum(root, from, options, false);
     }
     static createFileThread(host, file) {
         return new FileThread(host, file, 0);
@@ -896,7 +1652,7 @@ class FileManager extends core_1.Host {
     static setTimeout(options) {
         applyTimeout(PROCESS_TIMEOUT, options);
     }
-    static defineHttpCache({ enabled, expires, limit, limit_all, include, exclude, to_disk, purge_amount }, disk) {
+    static defineHttpCache({ enabled, expires, limit, limit_all, include, exclude, to_disk, purge_amount }, disk = false) {
         const cache = disk ? DISK : MEMORY;
         if (typeof enabled === 'boolean') {
             cache.ENABLED = enabled;
@@ -904,70 +1660,37 @@ class FileManager extends core_1.Host {
         cache.EXPIRES = expires ? (0, types_1.parseExpires)(expires) : 0;
         cache.INCLUDE = (0, types_1.isArray)(include) ? include.slice(0) : [];
         cache.EXCLUDE = (0, types_1.isArray)(exclude) ? exclude.slice(0) : [];
-        const setLimit = (value, type) => {
-            if (value !== undefined) {
-                if (typeof value === 'string') {
-                    value = (0, types_1.formatSize)(value);
-                }
-                if (value >= 0) {
-                    switch (type) {
-                        case 1:
-                            (disk ? DISK : MEMORY).LIMIT = value;
-                            break;
-                        case 2:
-                            MEMORY.LIMIT_ALL = value;
-                            break;
-                        case 3:
-                            MEMORY.DISK_MIN = value;
-                            break;
-                        case 4:
-                            MEMORY.DISK_MAX = value;
-                            break;
-                    }
-                }
-                else if (value === -1) {
-                    switch (type) {
-                        case 3:
-                            MEMORY.DISK_MIN = Infinity;
-                            break;
-                        case 4:
-                            MEMORY.DISK_MAX = 0;
-                            break;
-                    }
-                }
-            }
-        };
-        setLimit(limit, 1);
+        setHttpCacheLimit(limit, 1, disk);
         if (disk) {
             return;
         }
-        setLimit(limit_all, 2);
+        setHttpCacheLimit(limit_all, 2, disk);
         if (to_disk) {
             let limit_disk;
             if (Array.isArray(to_disk)) {
                 [to_disk, limit_disk] = to_disk;
             }
-            setLimit(to_disk, 3);
-            setLimit(limit_disk, 4);
+            setHttpCacheLimit(to_disk, 3, disk);
+            setHttpCacheLimit(limit_disk, 4, disk);
         }
-        if ((purge_amount = (0, util_1.asFloat)(purge_amount)) > 0) {
+        if ((purge_amount = (0, util_2.asFloat)(purge_amount)) > 0) {
             MEMORY.PURGE = Math.min(purge_amount, 1);
         }
     }
     static defineHttpConnect({ timeout, retry_wait, retry_after, retry_limit, redirect_limit }) {
-        if ((timeout = (0, util_1.fromSeconds)(timeout)) >= 0) {
+        if ((timeout = (0, util_2.fromSeconds)(timeout)) >= 0) {
             HTTP_CLIENT.connectTimeout = timeout;
         }
-        if ((retry_wait = (0, util_1.fromSeconds)(retry_wait)) >= 0) {
+        if ((retry_wait = (0, util_2.fromSeconds)(retry_wait)) >= 0) {
             HTTP_CLIENT.retryWait = Math.min(retry_wait, 600 * 1000);
         }
-        if ((retry_after = (0, util_1.fromSeconds)(retry_after)) >= 0) {
+        if ((retry_after = (0, util_2.fromSeconds)(retry_after)) >= 0) {
             HTTP_CLIENT.retryAfter = Math.min(retry_after, this.MAX_TIMEOUT);
         }
-        if ((retry_limit = (0, util_1.asInt)(retry_limit)) >= 0) {
+        if ((retry_limit = (0, util_2.asInt)(retry_limit)) >= 0) {
             HTTP_CLIENT.retryLimit = retry_limit;
         }
-        if ((redirect_limit = (0, util_1.asInt)(redirect_limit)) >= 0) {
+        if ((redirect_limit = (0, util_2.asInt)(redirect_limit)) >= 0) {
             HTTP_CLIENT.redirectLimit = redirect_limit;
         }
     }
@@ -1003,9 +1726,10 @@ class FileManager extends core_1.Host {
         this[_g] = null;
         this[_h] = RECURSION_LIMIT;
         this[_j] = new Scheduler();
-        this[_k] = {};
-        this[_l] = [[0, 0], [0, 0], [0, 0]];
+        this[_k] = [[0, 0], [0, 0], [0, 0]];
+        this[_l] = null;
         this[_m] = {};
+        this[_o] = null;
         if (isFunction(permission)) {
             postFinalize = permission;
             permission = undefined;
@@ -1055,15 +1779,26 @@ class FileManager extends core_1.Host {
         }
         this.cacheToDisk = new HttpDiskCache(this, DISK.ENABLED);
         this.cacheToMemory = new HttpMemoryCache(this, MEMORY.ENABLED);
-        if (MEMORY.INCLUDE.length) {
+        if (MEMORY.INCLUDE.length > 0) {
             this.cacheToMemory.include = MEMORY.INCLUDE;
         }
-        else if (MEMORY.EXCLUDE.length) {
+        if (MEMORY.EXCLUDE.length > 0) {
             this.cacheToMemory.exclude = MEMORY.EXCLUDE;
         }
         if (threads) {
             this.setTaskLimit(threads);
         }
+        if ((0, types_1.isPlainObject)(config.log) && (0, types_1.isArray)(config.log.showDiff) && this.incremental !== "staging") {
+            this[kDiffSource] = [
+                config.log.showDiff.map(item => {
+                    if (!(0, types_1.hasGlob)(item)) {
+                        return item;
+                    }
+                    return isMatchRoot(item) ? pm(core_1.Permission.toPosix(item), { nocase: core_1.Host.PLATFORM_WIN32 }) : pm(sanitizePath(item), { matchBase: true, nocase: core_1.Host.PLATFORM_WIN32 });
+                }),
+                {}
+            ];
+        }
         const request = new request_1();
         request.host = this;
         this.Request = request;
@@ -1073,11 +1808,11 @@ class FileManager extends core_1.Host {
         else {
             request.init(config).apply({ client: HTTP_CLIENT });
             if (!this.queued) {
-                startMessage.call(this);
+                this.startMessage();
             }
         }
     }
-    *[(_b = Symbol.toStringTag, _c = kRestarting, _d = kDelayed, _e = kCleared, _f = kFinalizedState, _g = KTimerMain, _h = kRecursionLimit, _j = kScheduler, _k = kProcessTimeout, _l = kDownloadStats, _m = kReplaceMap, Symbol.iterator)]() {
+    *[(_b = Symbol.toStringTag, _c = kRestarting, _d = kDelayed, _e = kCleared, _f = kFinalizedState, _g = KTimerMain, _h = kRecursionLimit, _j = kScheduler, _k = kDownloadStats, _l = kReplaceMap, _m = kProcessTimeout, _o = kDiffSource, Symbol.iterator)]() {
         for (const file of this.files) {
             yield file;
         }
@@ -1183,7 +1918,7 @@ class FileManager extends core_1.Host {
                 for (const { instance } of this.Document) {
                     instance.restart();
                 }
-                startMessage.call(this);
+                this.startMessage();
                 this.processAssets(emptyDir);
             }
             else {
@@ -1205,7 +1940,7 @@ class FileManager extends core_1.Host {
                     const instance = new cloud_1(args[0], args[1]);
                     instance.host = this;
                     instance.init(this.config);
-                    observeFile.call(this, instance);
+                    observeFile(this, instance);
                     return this.Cloud = instance;
                 }
             }
@@ -1230,16 +1965,20 @@ class FileManager extends core_1.Host {
         this.contentToReplace.clear();
         this.processing.length = 0;
         this.Request.reset();
-        this.modules.forEach(instance => instance.reset());
+        for (const instance of this.modules) {
+            instance.reset();
+        }
         this.emptyDir.clear();
         if (!this.restarting) {
             this.close();
             this._pendingResult = null;
         }
-        clearAssets.call(this);
+        clearAssets(this);
         this.cleared = false;
         this[kDelayed] = 0;
         this[kScheduler] = new Scheduler();
+        this[kDownloadStats] = [[0, 0], [0, 0], [0, 0]];
+        this.clearStorage();
         this.finalizeState = 0;
         return true;
     }
@@ -1253,8 +1992,12 @@ class FileManager extends core_1.Host {
                 if (options.all) {
                     value = path.resolve(value);
                     (options.id ? [this.assets.find(item => item.id === options.id)].filter(item => item) : this.assets.filter(item => item.localUri === value)).forEach(asset => {
-                        asset.transforms?.forEach(file => this.deleteFile(file, emptyDir));
-                        asset.descendants?.forEach(file => this.deleteFile(file, emptyDir));
+                        asset.transforms?.forEach(file => {
+                            this.deleteFile(file, emptyDir);
+                        });
+                        asset.descendants?.forEach(file => {
+                            this.deleteFile(file, emptyDir);
+                        });
                     });
                 }
             }
@@ -1270,89 +2013,62 @@ class FileManager extends core_1.Host {
             return;
         }
         this.finalizeState = 5;
-        startMessage.call(this);
+        this.startMessage();
         this.processAssets(...options.args);
     }
     install(name, ...args) {
         if (this.aborted) {
             return;
         }
-        let target = args.shift();
+        let Target = args.shift();
         switch (name) {
             case 'document':
-                if ((0, types_1.isString)(target)) {
-                    try {
-                        target = require(target);
-                    }
-                    catch (err) {
-                        this.checkPackage(err, target, ["Unable to load handler", this.moduleName], 4);
-                    }
-                }
-                if (isFunction(target) && target.prototype instanceof document_1) {
-                    const instance = new target(...args);
+                if (isFunction(Target = tryPackage(this, Target, 4)) && Target.prototype instanceof document_1) {
+                    const instance = new Target(...args);
                     instance.host = this;
                     instance.init(this.getDocumentAssets(instance), this.config);
-                    observeFile.call(this, instance);
-                    this.Document.push({ instance, constructor: target, params: args });
+                    observeFile(this, instance);
+                    this.Document.push({ instance, constructor: Target, params: args });
                     return instance;
                 }
                 break;
             case 'task':
-                if ((0, types_1.isString)(target)) {
-                    try {
-                        target = require(target);
-                    }
-                    catch (err) {
-                        this.checkPackage(err, target, ["Unable to load handler", this.moduleName], 4);
-                    }
-                }
-                if (isFunction(target) && target.prototype instanceof task_1 && (0, types_1.isPlainObject)(args[0])) {
-                    const instance = new target(...args);
+                if (isFunction(Target = tryPackage(this, Target, 4)) && Target.prototype instanceof task_1 && (0, types_1.isPlainObject)(args[0])) {
+                    const instance = new Target(...args);
                     instance.host = this;
                     instance.init(this.config);
-                    observeFile.call(this, instance);
-                    this.Task.push({ instance, constructor: target, params: args });
+                    observeFile(this, instance);
+                    this.Task.push({ instance, constructor: Target, params: args });
                     return instance;
                 }
                 break;
             case 'cloud': {
                 const database = this.dataSourceItems.filter(item => item.source === 'cloud');
                 let instance;
-                if ((0, types_1.isString)(target)) {
+                if ((0, types_1.isString)(Target)) {
                     const module = args.shift();
                     if ((0, types_1.isObject)(module)) {
-                        if (target === "@e-mc/cloud") {
+                        if (Target === "@e-mc/cloud") {
                             instance = new cloud_1(module, database);
                         }
-                        else {
-                            try {
-                                const Handler = require(target);
-                                if (isFunction(Handler) && Handler.prototype instanceof core_1.ClientDb) {
-                                    instance = new Handler(module, database);
-                                }
-                                else {
-                                    throw (0, types_1.errorMessage)(this.moduleName, "Not a Cloud constructor", target);
-                                }
-                            }
-                            catch (err) {
-                                this.checkPackage(err, target, ["Unable to load handler", this.moduleName], 64);
-                            }
+                        else if (isFunction(Target = tryPackage(this, Target, 64)) && Target.prototype instanceof core_1.ClientDb) {
+                            instance = new Target(module, database);
                         }
                     }
                 }
-                else if ((0, types_1.isObject)(target)) {
-                    instance = new cloud_1(target, database);
+                else if ((0, types_1.isObject)(Target)) {
+                    instance = new cloud_1(Target, database);
                 }
                 if (instance) {
                     instance.host = this;
                     instance.init(this.config);
-                    observeFile.call(this, instance);
+                    observeFile(this, instance);
                     return this.Cloud = instance;
                 }
                 break;
             }
             case 'watch': {
-                const instance = (0, types_1.isObject)(target) ? new watch_1(target) : new watch_1({ interval: target, port: args[0], secure: { port: args[1] }, extensions: args[2] });
+                const instance = (0, types_1.isObject)(Target) ? new watch_1(Target) : new watch_1({ interval: Target, port: args[0], secure: { port: args[1] }, extensions: args[2] });
                 instance.host = this;
                 instance.init(this.config);
                 instance.whenModified = (assets, sanitize, postFinalize) => {
@@ -1395,7 +2111,7 @@ class FileManager extends core_1.Host {
                             }
                             mimeMap.set(mimeType, constructor);
                         }
-                        if (mimeMap.size) {
+                        if (mimeMap.size > 0) {
                             manager.install('image', mimeMap, ...params);
                         }
                     }
@@ -1417,47 +2133,29 @@ class FileManager extends core_1.Host {
                     return manager;
                 };
                 return this.Watch = instance;
-            }
-            case 'image': {
-                const createInstance = (mimeMap, mimeType, constructor, ...params) => {
-                    const instance = new constructor(...params);
-                    instance.host = this;
-                    instance.init(this.config);
-                    observeFile.call(this, instance);
-                    mimeMap.set(mimeType, { constructor, instance, params });
-                    return instance;
-                };
-                if (target instanceof Map) {
+            }
+            case 'image': {
+                if (Target instanceof Map) {
                     const mimeMap = new Map();
-                    for (const [mimeType, constructor] of target) {
+                    for (const [mimeType, constructor] of Target) {
                         if (constructor.prototype instanceof image_1) {
-                            createInstance(mimeMap, mimeType, constructor, args[0]);
+                            createImageInstance(this, mimeMap, mimeType, constructor, args[0]);
                         }
                     }
-                    if (mimeMap.size) {
+                    if (mimeMap.size > 0) {
                         this.Image = mimeMap;
                     }
                 }
-                else {
-                    if ((0, types_1.isString)(target)) {
-                        try {
-                            target = require(target);
-                        }
-                        catch (err) {
-                            this.checkPackage(err, target, ["Unable to load handler", this.moduleName], 2048);
-                        }
-                    }
-                    if (isFunction(target) && target.prototype instanceof image_1) {
-                        return createInstance(this.Image ?? (this.Image = new Map()), 'handler', target, ...args);
-                    }
+                else if (isFunction(Target = tryPackage(this, Target, 2048)) && Target.prototype instanceof image_1) {
+                    return createImageInstance(this, this.Image ?? (this.Image = new Map()), 'handler', Target, ...args);
                 }
                 break;
             }
             case 'compress': {
-                const instance = new compress_1(target);
+                const instance = new compress_1(Target);
                 instance.host = this;
                 instance.init();
-                observeFile.call(this, instance);
+                observeFile(this, instance);
                 return this.Compress = instance;
             }
         }
@@ -1487,7 +2185,6 @@ class FileManager extends core_1.Host {
         if (!(0, types_1.isString)(value)) {
             return;
         }
-        const isSame = (a, b) => a === b || decodeURIComponent(a) === decodeURIComponent(b);
         const result = (assets || this.assets).filter(item => {
             const { uri, flags } = item;
             if (uri && (!instance || this.hasDocument(instance, item.document)) && (!item.invalid || assets || (0, types_1.mainFlag)(flags) || (0, types_1.usingFlag)(flags) || (0, types_1.cloneFlag)(flags) || (0, types_1.watchFlag)(flags))) {
@@ -1505,35 +2202,37 @@ class FileManager extends core_1.Host {
                         return true;
                     }
                 }
-                if (isSame(uri, value)) {
+                if (equalAddress(uri, value)) {
                     return true;
                 }
                 const indexA = uri.indexOf('#');
                 const indexB = value.indexOf('#');
                 if (indexA !== -1 || indexB !== -1) {
-                    return isSame(indexA !== -1 ? uri.substring(0, indexA) : uri, indexB !== -1 ? value.substring(0, indexB) : value);
+                    return equalAddress(indexA !== -1 ? uri.substring(0, indexA) : uri, indexB !== -1 ? value.substring(0, indexB) : value);
                 }
             }
             return false;
         });
         if (replaced) {
             const map = this[kReplaceMap];
-            const target = pathname || core_1.Host.toPosix(value);
-            const found = [];
-            for (const relative in map) {
-                const item = map[relative];
-                if (origin && item.url && item.url.origin !== origin) {
-                    continue;
-                }
-                if (path.basename(relative) === path.basename(target) && path.dirname(target).endsWith(path.dirname(relative))) {
-                    found.push([item, relative]);
+            if (map) {
+                const target = pathname || core_1.Host.toPosix(value);
+                const found = [];
+                for (const relative in map) {
+                    const item = map[relative];
+                    if (origin && item.url && item.url.origin !== origin) {
+                        continue;
+                    }
+                    if (path.basename(relative) === path.basename(target) && path.dirname(target).endsWith(path.dirname(relative))) {
+                        found.push([item, relative]);
+                    }
                 }
-            }
-            if (found.length) {
-                if (result.length === 0) {
-                    return found.sort((a, b) => b[1].length - a[1].length)[0][0];
+                if (found.length > 0) {
+                    if (result.length === 0) {
+                        return found.sort((a, b) => b[1].length - a[1].length)[0][0];
+                    }
+                    result.push(...found.map(item => item[0]));
                 }
-                result.push(...found.map(item => item[0]));
             }
         }
         return result.sort((a, b) => {
@@ -1566,7 +2265,7 @@ class FileManager extends core_1.Host {
     removeCwd(value) {
         if (typeof value === 'string') {
             let baseDir = this.baseDirectory + path.sep, leading = value.substring(0, baseDir.length);
-            if (PLATFORM_WIN32) {
+            if (core_1.Host.PLATFORM_WIN32) {
                 baseDir = baseDir.toLowerCase();
                 leading = leading.toLowerCase();
             }
@@ -1621,7 +2320,7 @@ class FileManager extends core_1.Host {
                 if (localUri && !this.assets.find(item => item.localUri === localUri && !item.invalid)) {
                     this.filesToRemove.add(localUri);
                 }
-                this[kReplaceMap][core_1.Host.joinPath(file.pathname, file.filename)] = file;
+                (this[kReplaceMap] || (this[kReplaceMap] = {}))[core_1.Host.joinPath(file.pathname, file.filename)] = file;
             }
         }
         unsetContent(file);
@@ -1691,7 +2390,8 @@ class FileManager extends core_1.Host {
             this.finalizeState = 1;
             this.finalize()
                 .then(() => {
-                const errors = collectErrors.call(this);
+                this.diffMessage();
+                const errors = collectErrors(this);
                 const files = Array.from(this.files).sort((a, b) => {
                     const sep = path.sep;
                     if (a.includes(sep) && !b.includes(sep)) {
@@ -1702,9 +2402,7 @@ class FileManager extends core_1.Host {
                     }
                     return a < b ? -1 : 1;
                 });
-                if (LOG_TIMEELAPSED) {
-                    this.writeTimeElapsed('END', this.baseDirectory, this.startTime, errors.length > 0 ? { failed: true, ...core_1.Host.LOG_STYLE_FAIL } : { ...core_1.Host.LOG_STYLE_SUCCESS });
-                }
+                this.endMessage(errors);
                 this.resetState();
                 const log = this.config.log;
                 let useNumeric, showSize;
@@ -1712,19 +2410,46 @@ class FileManager extends core_1.Host {
                     ({ useNumeric, showSize } = log);
                 }
                 const items = showSize === false ? files : files.map(name => {
-                    const size = (0, util_1.getSize)(path.join(this.baseDirectory, name));
+                    const size = (0, util_2.getSize)(path.join(this.baseDirectory, name));
                     return { name, size: useNumeric ? size : (0, types_1.formatSize)(size) };
                 });
                 this.emit('end', items, errors, this.collectLog());
                 this.done = true;
             })
-                .catch((err) => this.abortFinalize(err));
+                .catch((err) => {
+                this.abortFinalize(err);
+            });
         }
     }
     hasDocument(instance, document) {
         const moduleName = instance.moduleName;
         return document === moduleName || Array.isArray(document) && document.includes(moduleName);
     }
+    checkFilename(file, pathname = '') {
+        let filename = file.filename;
+        if (filename) {
+            if (!pathname) {
+                pathname = file.pathname || '';
+            }
+            const assets = this.assets;
+            let target = matchPathname(path.join(pathname, filename)), modified;
+            for (let i = 0, j = 1, length = assets.length; i < length; ++i) {
+                const item = assets[i];
+                if (item !== file && item.filename && target === matchPathname(path.join(item.pathname || '', item.filename))) {
+                    const ext = path.extname(filename);
+                    filename = path.basename(filename, ext) + '_' + j + ext;
+                    target = matchPathname(path.join(pathname, filename));
+                    modified = true;
+                    i = -1;
+                    ++j;
+                }
+            }
+            if (modified) {
+                return file.filename = filename;
+            }
+        }
+        return '';
+    }
     setLocalUri(file, replace) {
         let uri = file.uri, type;
         if (uri && !file.url && !file.content && !file.base64 && !file.dataView) {
@@ -1737,13 +2462,12 @@ class FileManager extends core_1.Host {
                     file.uri = file.url.toString();
                 }
                 catch (err) {
-                    this.writeFail(['Unable to parse URL', uri], err, 1024);
+                    this.writeFail(["Unable to resolve file", uri], err, { type: 1024, fatal: !!file.document });
                     return { pathname: '', localUri: '' };
                 }
             }
             else {
                 try {
-                    const errorAbsolute = (value) => (0, types_1.errorValue)("Path is not absolute", value);
                     if (!(file.uri = core_1.Host.resolveFile(uri))) {
                         throw errorAbsolute(uri);
                     }
@@ -1760,12 +2484,15 @@ class FileManager extends core_1.Host {
                     }
                 }
                 catch (err) {
-                    this.writeFail(['Unable to resolve file location', uri], err, 32);
+                    this.writeFail(['Unable to resolve file location', uri], err, { type: 32, fatal: !!file.document });
                     return { pathname: '', localUri: '' };
                 }
             }
         }
         const url = file.url;
+        if (file.pathname) {
+            file.pathname = core_1.Host.toPosix(file.pathname);
+        }
         if (url) {
             if (url.protocol.startsWith('http')) {
                 type = 1;
@@ -1776,12 +2503,32 @@ class FileManager extends core_1.Host {
             else if (core_1.Host.isFile(url, 's/ftp')) {
                 type = 3;
             }
+            let filename = file.filename;
+            if (!filename && !file.document && type !== 4) {
+                filename = url.pathname.split('/').pop();
+                if (filename.includes('.')) {
+                    const mimeType = file.mimeType || core_1.Host.lookupMime(filename);
+                    if (mimeType) {
+                        file.filename = filename;
+                        file.mimeType = mimeType;
+                        this.checkFilename(file);
+                    }
+                }
+                else if (file.mimeType && filename) {
+                    const ext = core_1.Host.lookupMime(file.mimeType, true);
+                    if (ext) {
+                        filename += '.' + ext;
+                        file.filename = filename;
+                        this.checkFilename(file);
+                    }
+                }
+            }
         }
         file.fetchType = type;
         if (file.document) {
             for (const { instance } of this.Document) {
-                if (this.hasDocument(instance, file.document)) {
-                    instance.setLocalUri?.(file, replace);
+                if (instance.setLocalUri && this.hasDocument(instance, file.document)) {
+                    instance.setLocalUri(file, replace);
                 }
             }
         }
@@ -1869,7 +2616,7 @@ class FileManager extends core_1.Host {
         return this.getTempDir({ pathname: url.hostname + '_' + (url.port || (url.protocol === 'https:' ? '443' : '80')), moduleDir: true, createDir });
     }
     setAssetContent(file, content, options) {
-        let trailing = (0, util_2.concatString)(file.trailingContent);
+        let trailing = (0, util_1.concatString)(file.trailingContent);
         if (file.document) {
             for (const { instance } of this.Document) {
                 if (instance.resolveUri && this.hasDocument(instance, file.document)) {
@@ -1912,8 +2659,8 @@ class FileManager extends core_1.Host {
             return content;
         }
         let replacing, newline;
-        const getSeparator = (value) => newline || (newline = (0, util_2.getNewline)(value));
-        if (content && (replacing = this.contentToReplace.get(localUri)) && replacing.length) {
+        const getSeparator = (value) => newline || (newline = (0, util_1.getNewline)(value));
+        if (content && (replacing = this.contentToReplace.get(localUri)) && replacing.length > 0) {
             for (let i = 0, value, match; i < replacing.length; ++i) {
                 if ((0, types_1.isString)(value = appending[i])) {
                     if (replacing[i] && (match = new RegExp(replacing[i], 'i').exec(content))) {
@@ -1944,7 +2691,7 @@ class FileManager extends core_1.Host {
         const localUri = file.localUri;
         if (buffer && localUri) {
             try {
-                this.writeFile(localUri, buffer, { ...options, throwsPermission: true });
+                void this.writeFile(localUri, buffer, { ...options, throwsPermission: true });
                 return file.buffer = buffer;
             }
             catch (err) {
@@ -2079,8 +2826,10 @@ class FileManager extends core_1.Host {
                             tasks.push(instance.tryFile(file.buffer || localUri, output, options).then(() => {
                                 const outFile = options.outFile;
                                 if (outFile) {
-                                    if (condition?.includes('%') && (0, util_1.getSize)(outFile) >= (0, util_1.getSize)(localUri)) {
-                                        queueMicrotask(() => this.deleteFile(outFile));
+                                    if (condition?.includes('%') && (0, util_2.getSize)(outFile) >= (0, util_2.getSize)(localUri)) {
+                                        queueMicrotask(() => {
+                                            this.deleteFile(outFile);
+                                        });
                                     }
                                     else {
                                         this.add(outFile, file, types_1.FILE_TYPE.COMPRESSED);
@@ -2097,7 +2846,7 @@ class FileManager extends core_1.Host {
                     }
                 }
             }
-            if (tasks.length) {
+            if (tasks.length > 0) {
                 return Promise.all(tasks);
             }
         }
@@ -2109,7 +2858,7 @@ class FileManager extends core_1.Host {
         if (!this.aborted) {
             if (!override) {
                 const processTask = this[kScheduler];
-                if (processTask.queue.length) {
+                if (processTask.queue.length > 0) {
                     processTask.transform.push([data, parent]);
                     return false;
                 }
@@ -2120,7 +2869,6 @@ class FileManager extends core_1.Host {
                 file.mimeType = mimeType;
                 data.mimeType = mimeType;
             }
-            const errorAsset = (instance, err, type = 4) => rejectModule.call(instance, err, type, path.basename(localUri));
             if (file.tasks) {
                 const taskName = [];
                 let handler;
@@ -2132,12 +2880,16 @@ class FileManager extends core_1.Host {
                                 if (this.openThread(instance, data, this.getProcessTimeout(handler))) {
                                     instance.using(data)
                                         .finally(() => this.closeThread(instance, data))
-                                        .catch((err) => errorAsset(instance, err));
+                                        .catch((err) => {
+                                        errorAsset(instance, err, localUri);
+                                    });
                                 }
                             }
                             else if (!this.aborted) {
                                 this.addProcessTimeout(instance, file, this.getProcessTimeout(handler));
-                                await instance.using(data).catch((err) => errorAsset(instance, err));
+                                await instance.using(data).catch((err) => {
+                                    errorAsset(instance, err, localUri);
+                                });
                             }
                             taskName.push(moduleName);
                         }
@@ -2155,12 +2907,16 @@ class FileManager extends core_1.Host {
                                     if (this.openThread(instance, data, this.getProcessTimeout(handler))) {
                                         instance.using(data, command)
                                             .finally(() => this.closeThread(instance, data))
-                                            .catch((err) => errorAsset(instance, err, 2048));
+                                            .catch((err) => {
+                                            errorAsset(instance, err, localUri, 2048);
+                                        });
                                     }
                                 }
                                 else if (!this.aborted) {
                                     this.addProcessTimeout(instance, file, this.getProcessTimeout(handler));
-                                    await instance.using(data, command).catch((err) => errorAsset(instance, err, 2048));
+                                    await instance.using(data, command).catch((err) => {
+                                        errorAsset(instance, err, localUri, 2048);
+                                    });
                                 }
                             }
                         }
@@ -2175,12 +2931,16 @@ class FileManager extends core_1.Host {
                             if (this.openThread(instance, data, this.getProcessTimeout(handler))) {
                                 instance.using(data)
                                     .finally(() => this.closeThread(instance, data))
-                                    .catch((err) => errorAsset(instance, err));
+                                    .catch((err) => {
+                                    errorAsset(instance, err, localUri);
+                                });
                             }
                         }
                         else if (!this.aborted) {
                             this.addProcessTimeout(instance, file, this.getProcessTimeout(handler));
-                            await instance.using(data).catch((err) => errorAsset(instance, err));
+                            await instance.using(data).catch((err) => {
+                                errorAsset(instance, err, localUri);
+                            });
                         }
                     }
                 }
@@ -2227,7 +2987,7 @@ class FileManager extends core_1.Host {
             if (index !== -1) {
                 this.processing.splice(index, 1);
             }
-            data.queuedTasks.forEach(task => {
+            for (const task of data.queuedTasks) {
                 try {
                     task();
                 }
@@ -2235,7 +2995,7 @@ class FileManager extends core_1.Host {
                     this.writeFail(["Unable to perform task", path.basename(this.getLocalUri(data))], err);
                 }
                 this.removeAsyncTask();
-            });
+            }
             this.performFinalize();
             return true;
         }
@@ -2284,7 +3044,7 @@ class FileManager extends core_1.Host {
             result = value;
         }
         else if (typeof value === 'string') {
-            if ((result = (0, util_1.byteLength)(value, encoding)) === 0) {
+            if ((result = (0, util_2.byteLength)(value, encoding)) === 0) {
                 return 0;
             }
         }
@@ -2347,18 +3107,21 @@ class FileManager extends core_1.Host {
             return callback;
         };
         if (this.aborted) {
+            this.clearStorage();
             const pending = this._pendingResult;
             if (pending) {
-                queueMicrotask(() => abortedHost.call(this));
+                queueMicrotask(() => {
+                    abortedHost(this);
+                });
                 this._pendingResult = null;
                 return pending;
             }
             return new Promise(resolve => {
                 this.on('end', listener(resolve));
                 queueMicrotask(() => {
-                    if (!abortedHost.call(this)) {
+                    if (!abortedHost(this)) {
                         this.restarting = false;
-                        this.emit('end', [], collectErrors.call(this), this.collectLog());
+                        this.emit('end', [], collectErrors(this), this.collectLog());
                         this.done = true;
                     }
                 });
@@ -2378,7 +3141,7 @@ class FileManager extends core_1.Host {
                 }
                 this.finalizeState = 0;
             case 2:
-                resetAssets.call(this);
+                resetAssets(this);
                 break;
         }
         return this._pendingResult || (this._pendingResult = new Promise((resolve, reject) => {
@@ -2392,9 +3155,10 @@ class FileManager extends core_1.Host {
             }
         }));
     }
-    processAssets(emptyDir, targeted) {
+    processAssets(emptyDir = false, targeted) {
+        var _p;
         if (this.aborted) {
-            abortedHost.call(this);
+            abortedHost(this);
             return;
         }
         if (this.finalizeState === 5) {
@@ -2402,561 +3166,127 @@ class FileManager extends core_1.Host {
         }
         else if (this._pendingResult) {
             return;
-        }
-        if (!this.canWrite(this.baseDirectory, { ownPermissionOnly: true })) {
-            this.writeFail("Unsupported access", new Error(this.baseDirectory), 8192);
-            this.cleared = true;
-            if (this.queued) {
-                this.joinQueue({ reject: true });
-            }
-            return;
-        }
-        switch (this.finalizeState) {
-            case 0:
-                if (this.delayed === 0 && !this.cleared) {
-                    break;
-                }
-            case 1:
-            case 3:
-            case 4:
-                return;
-            case 2:
-                resetAssets.call(this);
-                break;
-        }
-        if (this.queued) {
-            const length = arguments.length;
-            const args = new Array(length);
-            for (let i = 0; i < length; ++i) {
-                args[i] = arguments[i];
-            }
-            if (this.joinQueue({ args })) {
-                this.finalizeState = 4;
-                return;
-            }
-        }
-        if (targeted) {
-            this.using(true, ...targeted);
-        }
-        this.clearProcessTimeout();
-        this[KTimerMain] = setInterval(() => {
-            const { processing, processTimeout, finalizeState } = this;
-            if (finalizeState === 4) {
-                return;
-            }
-            const currentTime = Date.now();
-            let aborted;
-            for (let i = 0; i < processing.length; ++i) {
-                const data = processing[i];
-                const file = data.file;
-                const processModule = file.processModule;
-                let expired = processTimeout > 0 && currentTime - data.startTime >= processTimeout, moduleName;
-                if (processModule && !expired) {
-                    for (const name in processModule) {
-                        const { startTime, timeout } = processModule[name];
-                        if (timeout > 0 && currentTime - startTime >= timeout) {
-                            moduleName = name;
-                            expired = true;
-                            break;
-                        }
-                    }
-                }
-                if (expired || data.aborted) {
-                    let threadCount = data.threadCount + data.queuedTasks.length;
-                    while (threadCount-- > 0) {
-                        this.removeAsyncTask();
-                    }
-                    file.invalid = true;
-                    const localUri = file.localUri;
-                    if (expired) {
-                        data.abort(new Error("Timeout was exceeded"));
-                        if (localUri) {
-                            this.deleteFile(localUri, { id: file.id, emptyDir: true, all: true });
-                        }
-                    }
-                    (moduleName && this.find(moduleName) || this).formatFail(16384, "FAIL!", ["Unable to process file", moduleName || 'main'], (0, types_1.errorValue)(expired ? "Timeout was exceeded" : "Aborted", localUri), { queue: false, startTime: data.startTime });
-                    processing.splice(i--, 1);
-                    aborted = true;
-                }
-            }
-            if (this.processing.length === 0 && this.aborted) {
-                this.performFinalize(true);
-            }
-            else if (aborted) {
-                this.performFinalize();
-            }
-        }, types_1.THRESHOLD.FILEMANAGER_INTERVAL);
-        const { assets, cacheToDisk, cacheToMemory, fetchedAssets, Watch: watch } = this;
-        const downloadable = new Map();
-        const completed = Object.create(null);
-        const processing = Object.create(null);
-        const downloading = Object.create(null);
-        const appending = Object.create(null);
-        const bundling = Object.create(null);
-        const originCount = Object.create(null);
-        const emptied = [this.baseDirectory];
-        const staging = this[kIncremental] === "staging";
-        const incremental = this.config.incremental;
-        const isCacheable = (file) => file.initialValue?.cacheable !== false;
-        const hasIncremental = (value) => value === "etag" || value === "exists";
-        let cacheable = false, cacheOpen = false, cacheEtag = false;
-        if (!staging) {
-            cacheable = this[kRecursionLimit] === RECURSION_LIMIT;
-            if (cacheable) {
-                if (cacheOpen = hasIncremental(incremental)) {
-                    this[kIncremental] = incremental;
-                }
-                cacheEtag = incremental === "etag";
-            }
-            else {
-                this[kIncremental] = "none";
-            }
-        }
-        const targeting = this._usingObjects.size > 0;
-        const hasEtag = (file) => {
-            if (!cacheable || !(0, types_1.existsFlag)(file.flags)) {
-                return false;
-            }
-            switch (file.incremental) {
-                case false:
-                case "none":
-                case "exists":
-                case "staging":
-                    return false;
-                case "etag":
-                    return true;
-                default:
-                    return cacheEtag;
-            }
-        };
-        const applyHeaders = (file, headers, lastModified, mainEtag) => {
-            let contentLength = headers['content-length'];
-            if ((contentLength = parseInt(contentLength)) > 0) {
-                file.contentLength = contentLength;
-            }
-            else {
-                contentLength = 0;
-            }
-            const etag = headers.etag;
-            if (etag) {
-                if (mainEtag) {
-                    CACHE_ETAG[file.uri] = etag;
-                }
-                return file.etag = etag;
-            }
-            if (lastModified && watch) {
-                return file.lastModified = headers['last-modified'];
-            }
-        };
-        const checkQueue = (file, localUri, pathname, content) => {
-            var _o;
-            if (!createFolder(file, pathname)) {
-                return true;
-            }
-            const { bundleId, bundleIndex = -1 } = file;
-            if (!(0, types_1.isEmpty)(bundleId) && bundleIndex >= 0) {
-                const items = appending[localUri] || (appending[localUri] = []);
-                bundling[_o = file.uri] || (bundling[_o] = []);
-                if (bundleIndex > 0) {
-                    items[bundleIndex - 1] = file;
-                    let url, parent;
-                    if (file.fetchType === 1 && (cacheToDisk.has(url = file.url) || cacheToMemory.has(url)) && (parent = assets.find(item => item.bundleIndex === 0 && item.bundleId === bundleId))) {
-                        (parent.bundleQueue || (parent.bundleQueue = [])).push(new Promise(resolve => {
-                            this.Request.open(url, { method: 'HEAD', httpVersion: 1 })
-                                .on('response', res => {
-                                if (res.statusCode < 300) {
-                                    applyHeaders(file, res.headers);
-                                }
-                                resolve(file);
-                            })
-                                .on('error', () => resolve(file))
-                                .on('timeout', () => resolve(file));
-                        }));
-                    }
-                    return true;
-                }
-            }
-            else if (!content && file.filename) {
-                const previous = completed[localUri];
-                if (previous) {
-                    if (file.uri === previous.uri) {
-                        file.etag = previous.etag;
-                        file.lastModified = previous.lastModified;
-                    }
-                    this.transformAsset(new FileThread(this, file, 1));
-                    return true;
-                }
-                const queue = processing[localUri];
-                if (queue) {
-                    queue.push(file);
-                    return true;
-                }
-                processing[localUri] = [file];
-            }
-            return false;
-        };
-        const copyDownload = (file, queued) => {
-            const uriMap = new Map();
-            for (const item of queued) {
-                const destUri = item.localUri;
-                let items = uriMap.get(destUri);
-                if (!items) {
-                    const pathname = path.dirname(destUri);
-                    if (!core_1.Host.createDir(pathname)) {
-                        item.invalid = true;
-                        continue;
-                    }
-                    uriMap.set(destUri, items = []);
-                }
-                item.etag = file.etag;
-                item.lastModified = file.lastModified;
-                items.push(item);
-            }
-            const buffer = file.sourceUTF8 || file.buffer;
-            for (const [destUri, items] of uriMap) {
-                try {
-                    if (buffer) {
-                        fs.writeFileSync(destUri, buffer);
-                    }
-                    else {
-                        fs.copyFileSync(file.localUri, destUri);
-                    }
-                    for (const queue of items) {
-                        this.performAsyncTask();
-                        this.transformAsset(new FileThread(this, queue, 1));
-                    }
-                }
-                catch (err) {
-                    items.forEach(queue => queue.invalid = true);
-                    this.writeFail([buffer ? "Unable to write buffer" : "Unable to copy file", path.basename(file.localUri)], err, 32);
-                }
-            }
-        };
-        const processQueue = async (file, localUri) => {
-            completed[localUri] = file;
-            if (file.bundleIndex === 0 && !(0, types_1.isEmpty)(file.bundleId)) {
-                this.setAssetContent(file, this.getUTF8String(file, localUri));
-                const bundleQueue = file.bundleQueue;
-                let success = true, error, checkEtag = !file.trailingContent && hasEtag(file);
-                if (bundleQueue) {
-                    error = await Promise.all(bundleQueue).then(() => null).catch((err) => err);
-                    delete file.bundleQueue;
-                }
-                const items = appending[localUri];
-                if (items) {
-                    if (error) {
-                        items.forEach(queue => queue.invalid = true);
-                        success = false;
-                    }
-                    else {
-                        const tasks = [];
-                        for (const queue of items) {
-                            const encoding = queue.encoding || (queue.encoding = 'utf-8');
-                            const { uri, fetchType: type } = queue;
-                            let tempFile;
-                            if (checkEtag && queue.trailingContent) {
-                                checkEtag = false;
-                            }
-                            const checksumValid = (buffer) => !queue.checksum || checkHash.call(this, queue.localUri || localUri, false, queue.checksum, buffer);
-                            const verifyBundle = (value, etag, checked) => {
-                                if (!queue.invalid) {
-                                    if (!checked && !checksumValid(value)) {
-                                        queue.invalid = true;
-                                        return;
-                                    }
-                                    if (value instanceof Buffer) {
-                                        value = value.toString(encoding);
-                                    }
-                                    const url = queue.url;
-                                    if (etag && cacheToMemory.has(url)) {
-                                        cacheToMemory.add(url, encodeURIComponent(etag), value, {
-                                            encoding,
-                                            contentLength: queue.contentLength,
-                                            toDisk: !tempFile && isCacheable(queue) ? queue.filename || queue.localUri && path.basename(queue.localUri) : ''
-                                        });
-                                    }
-                                    this.setAssetContent(queue, value, { localUri, bundleIndex: queue.bundleIndex, bundleReplace: queue.bundleReplace });
-                                }
-                            };
-                            if (queue.content) {
-                                verifyBundle(queue.content);
-                                checkEtag = false;
-                            }
-                            else if (uri) {
-                                if (type === 1 || type === 2) {
-                                    const url = queue.url;
-                                    const options = {
-                                        url,
-                                        encoding,
-                                        statusMessage: uri + ` (${queue.bundleIndex})`
-                                    };
-                                    let etag, pipeTo;
-                                    if (type === 2) {
-                                        options.socketPath = queue.socketPath;
-                                        options.httpVersion = 1;
-                                    }
-                                    else if (url) {
-                                        if (etag = queue.etag) {
-                                            const valid = incremental !== false || file.incremental === true;
-                                            const cached = valid && MEMORY.CACHE[uri];
-                                            const etagDir = encodeURIComponent(etag);
-                                            if (cached) {
-                                                if (etagDir === cached[5]) {
-                                                    const source = cached[1];
-                                                    if (checksumValid(source)) {
-                                                        verifyBundle(typeof source === 'string' ? source : source.toString(encoding), '', true);
-                                                        this.addDownload(Buffer.byteLength(source, encoding), types_1.DOWNLOAD_TYPE.CACHE);
-                                                        continue;
-                                                    }
-                                                }
-                                                else {
-                                                    cacheToMemory.clear(uri);
-                                                }
-                                            }
-                                            if (cacheToDisk.has(url) && isCacheable(queue)) {
-                                                const baseDir = path.join(this.getCacheDir(url), etagDir);
-                                                pipeTo = path.join(baseDir, path.basename(localUri));
-                                                try {
-                                                    if (valid && (0, util_1.hasSize)(pipeTo)) {
-                                                        const buffer = fs.readFileSync(pipeTo, { encoding });
-                                                        if (checksumValid(buffer)) {
-                                                            verifyBundle(buffer, etag, true);
-                                                            this.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
-                                                            continue;
-                                                        }
-                                                    }
-                                                    if (!fs.existsSync(baseDir)) {
-                                                        fs.mkdirSync(baseDir);
-                                                    }
-                                                    tempFile = path.join(baseDir, (0, types_1.incrementUUID)());
-                                                    options.pipeTo = tempFile;
-                                                }
-                                                catch {
-                                                    pipeTo = undefined;
-                                                }
-                                            }
-                                        }
-                                        if ((originCount[url.origin] || 0) <= 1) {
-                                            options.httpVersion = 1;
-                                        }
-                                        options.connected = (headers) => {
-                                            etag = applyHeaders(queue, headers, true);
-                                            return true;
-                                        };
-                                    }
-                                    tasks.push(new Promise((resolve, reject) => {
-                                        this.scheduleTask(url || uri, options, (data) => {
-                                            if (data) {
-                                                verifyBundle(data, etag);
-                                            }
-                                            else {
-                                                queue.invalid = true;
-                                            }
-                                            const downloaded = bundling[uri];
-                                            if ((0, types_1.isArray)(downloaded)) {
-                                                if (data && !queue.invalid) {
-                                                    if (typeof data === 'string') {
-                                                        queue.sourceUTF8 = data;
-                                                    }
-                                                    else {
-                                                        queue.buffer = data;
-                                                    }
-                                                    copyDownload(queue, downloaded);
-                                                }
-                                                else {
-                                                    downloaded.forEach(item => item.invalid = true);
-                                                }
-                                            }
-                                            if (tempFile && (!pipeTo || core_1.Host.isPath(pipeTo) || !core_1.Host.renameFile(tempFile, pipeTo, false))) {
-                                                queueMicrotask(() => fs.unlink(tempFile, () => { }));
-                                            }
-                                            resolve();
-                                        }, (err) => {
-                                            queue.invalid = true;
-                                            if (tempFile) {
-                                                queueMicrotask(() => fs.unlink(tempFile, () => { }));
-                                            }
-                                            reject(err);
-                                        }, 1);
-                                    }));
-                                }
-                                else if (type) {
-                                    const mimeType = queue.mimeType || file.mimeType;
-                                    const pathname = this.getTempDir({ uuidDir: true });
-                                    if (!pathname || !mimeType) {
-                                        queue.invalid = true;
-                                        tasks.push(Promise.reject(!pathname ? new Error("Unable to create temp directory") : (0, types_1.errorValue)("MIME not found", uri)));
-                                        break;
-                                    }
-                                    tasks.push(new Promise((resolve, reject) => {
-                                        this.scheduleTask(queue.url || uri, { pathname, binOpts: queue.binOpts || file.binOpts }, (result) => {
-                                            if (result.length) {
-                                                verifyBundle(bundleTorrent.call(this, result, mimeType, encoding));
-                                            }
-                                            else {
-                                                queue.invalid = true;
-                                            }
-                                            queueMicrotask(() => core_1.Host.removeDir(pathname));
-                                            resolve();
-                                        }, (err) => {
-                                            queue.invalid = true;
-                                            queueMicrotask(() => core_1.Host.removeDir(pathname));
-                                            reject(err);
-                                        }, 4);
-                                    }));
-                                }
-                                else if (this.canRead(uri)) {
-                                    tasks.push(fs.promises.readFile(uri, encoding)
-                                        .then(data => {
-                                        verifyBundle(data);
-                                        this.addDownload(Buffer.byteLength(data, encoding), types_1.DOWNLOAD_TYPE.DISK);
-                                    })
-                                        .catch(() => {
-                                        queue.invalid = true;
-                                    }));
-                                }
-                                else {
-                                    checkEtag = false;
-                                    errorPermission(file);
-                                }
-                            }
-                        }
-                        if (tasks.length) {
-                            success = await Promise.all(tasks)
-                                .then(() => true)
-                                .catch((err) => {
-                                this.writeFail(["Unable to download file", 'bundle: ' + path.basename(localUri)], err, 1024);
-                                return false;
-                            });
-                        }
-                        else if (checkEtag && core_1.Host.isPath(localUri)) {
-                            this.completeAsyncTask();
-                            appending[localUri] = undefined;
-                            return;
+        }
+        if (!this.canWrite(this.baseDirectory, { ownPermissionOnly: true })) {
+            this.writeFail("Unsupported access", new Error(this.baseDirectory), 8192);
+            this.cleared = true;
+            if (this.queued) {
+                this.joinQueue({ reject: true });
+            }
+            return;
+        }
+        switch (this.finalizeState) {
+            case 0:
+                if (this.delayed === 0 && !this.cleared) {
+                    break;
+                }
+            case 1:
+            case 3:
+            case 4:
+                return;
+            case 2:
+                resetAssets(this);
+                break;
+        }
+        if (this.queued) {
+            const length = arguments.length;
+            const args = new Array(length);
+            for (let i = 0; i < length; ++i) {
+                args[i] = arguments[i];
+            }
+            if (this.joinQueue({ args })) {
+                this.finalizeState = 4;
+                return;
+            }
+        }
+        if (targeted) {
+            this.using(true, ...targeted);
+        }
+        this.clearProcessTimeout();
+        this[KTimerMain] = setInterval(() => {
+            if (this.finalizeState === 4) {
+                return;
+            }
+            const { processing, processTimeout } = this;
+            const currentTime = Date.now();
+            let aborted;
+            for (let i = 0; i < processing.length; ++i) {
+                const data = processing[i];
+                const file = data.file;
+                const processModule = file.processModule;
+                let expired = processTimeout > 0 && currentTime - data.startTime >= processTimeout, moduleName;
+                if (processModule && !expired) {
+                    for (const name in processModule) {
+                        const { startTime, timeout } = processModule[name];
+                        if (timeout > 0 && currentTime - startTime >= timeout) {
+                            moduleName = name;
+                            expired = true;
+                            break;
                         }
                     }
                 }
-                if (success) {
-                    if (!fetchedAssets.includes(file)) {
-                        fetchedAssets.push(file);
+                if (expired || data.aborted) {
+                    let threadCount = data.threadCount + data.queuedTasks.length;
+                    while (threadCount-- > 0) {
+                        this.removeAsyncTask();
                     }
-                    this.transformAsset(new FileThread(this, file, 1));
-                }
-                else {
                     file.invalid = true;
-                    unsetContent(file);
-                    this.completeAsyncTask(error);
-                    queueMicrotask(() => this.deleteFile(localUri, { emptyDir: true }));
-                }
-                appending[localUri] = undefined;
-                return;
-            }
-            const uri = file.uri;
-            const processed = processing[localUri];
-            const downloaded = downloading[uri];
-            if ((0, types_1.isArray)(downloaded)) {
-                copyDownload(file, downloaded);
-            }
-            if (processed) {
-                for (const item of processed) {
-                    if (item !== file) {
-                        if (item.uri === file.uri) {
-                            item.etag = file.etag;
-                            item.lastModified = file.lastModified;
+                    const localUri = file.localUri;
+                    if (expired) {
+                        data.abort(new Error("Timeout was exceeded"));
+                        if (localUri) {
+                            this.deleteFile(localUri, { id: file.id, emptyDir: true, all: true });
                         }
-                        this.performAsyncTask();
                     }
-                    this.transformAsset(new FileThread(this, item, 1));
+                    (moduleName && this.find(moduleName) || this).formatFail(16384, "FAIL!", ["Unable to process file", moduleName || 'main'], (0, types_1.errorValue)(expired ? "Timeout was exceeded" : "Aborted", localUri), { queue: false, startTime: data.startTime });
+                    processing.splice(i--, 1);
+                    aborted = true;
                 }
-                processing[localUri] = undefined;
-            }
-            else {
-                this.transformAsset(new FileThread(this, file, 1));
             }
-            downloading[uri] = undefined;
-        };
-        const clearQueue = (data, attr) => {
-            if (attr && data[attr]) {
-                data[attr].forEach(item => item.invalid = true);
-                data[attr] = undefined;
+            if (this.processing.length === 0 && this.aborted) {
+                this.performFinalize(true);
             }
-        };
-        const errorRequest = (file, localUri, err, preceding) => {
-            const uri = file.uri;
-            clearQueue(processing, localUri);
-            clearQueue(downloading, uri);
-            clearQueue(appending, localUri);
-            file.invalid = true;
-            if (!preceding) {
-                this.completeAsyncTask();
+            else if (aborted) {
+                this.performFinalize();
             }
-            this.writeFail(["Unable to download file", uri], err, err instanceof Error && err.message.startsWith("Timeout was exceeded") ? 16384 : 1024);
-        };
-        const errorPermission = (file) => {
-            this.writeFail(["Unable to read file", file.uri], (0, types_1.errorValue)("Operation not permitted", file.uri || "Unknown"), 8192);
-            file.invalid = true;
-        };
-        const createFolder = (file, pathname) => {
-            if (!emptied.includes(pathname)) {
-                if (emptyDir && core_1.Host.removeDir(pathname, true)) {
-                    emptied.push(pathname);
-                }
-                else if (core_1.Host.createDir(pathname)) {
-                    emptied.push(pathname);
-                }
-                else {
-                    file.invalid = true;
-                    this.writeFail("Unable to create directory", (0, types_1.errorValue)("Path not found", pathname));
-                    return false;
+        }, types_1.THRESHOLD.FILEMANAGER_INTERVAL);
+        const { assets, cacheToDisk, cacheToMemory, fetchedAssets } = this;
+        const downloadable = new Map();
+        const staging = this[kIncremental] === "staging";
+        const incremental = this.config.incremental;
+        const checkDest = (src, localUri) => staging || !(0, util_2.hasSameStat)(src, localUri);
+        let cacheable = false, cacheOpen = false, cacheEtag = false;
+        if (!staging) {
+            cacheable = this[kRecursionLimit] === RECURSION_LIMIT;
+            if (cacheable) {
+                if (cacheOpen = hasIncremental(incremental)) {
+                    this[kIncremental] = incremental;
                 }
-            }
-            return true;
-        };
-        const fileReceived = (item, localUri, err, fetched, binary, checked) => {
-            if (err) {
-                item.invalid = true;
-                this.completeAsyncTask(err, localUri);
-                return;
-            }
-            if (item.checksum && !checked && !checkHash.call(this, localUri, false, item.checksum, item.buffer)) {
-                item.invalid = true;
-                this.filesToRemove.add(localUri);
-                this.completeAsyncTask();
-                this.writeFail(["Checksum did not match", path.basename(localUri)], (0, types_1.errorValue)(item.uri || localUri, "Invalid checksum"), { type: 32, queue: true });
-                return;
-            }
-            if (fetched) {
-                fetchedAssets.push(item);
-            }
-            else {
-                this.copiedAssets.push(item);
-            }
-            if (binary) {
-                this.transformAsset(new FileThread(this, item, 1));
+                cacheEtag = incremental === "etag";
             }
             else {
-                processQueue(item, localUri);
+                this[kIncremental] = "none";
             }
-        };
+        }
+        const targeting = this._usingObjects.size > 0;
+        const groupData = new ProcessGroup();
         const imported = assets.filter(item => item.imported && (0, types_1.isArray)(item.imported));
         for (let item of assets) {
             if (item.invalid || (0, types_1.ignoreFlag)(item.flags)) {
                 continue;
             }
-            let { filename, uri } = item;
-            if (!filename) {
-                if (!(uri && core_1.Host.isFile(uri, 'torrent'))) {
+            let download = this.setLocalUri(item), uri = item.uri;
+            if (!item.filename) {
+                if (item.fetchType !== 4) {
                     item.invalid = true;
                     continue;
                 }
                 item.filename = '';
             }
             if (targeting && !this.contains(item, (other) => (0, asset_1.isEqual)(item, other))) {
-                this.setLocalUri(item);
                 item.invalid = true;
                 continue;
             }
-            let download = this.setLocalUri(item);
             const localUri = download.localUri;
             if (!localUri) {
                 item.invalid = true;
@@ -2977,7 +3307,7 @@ class FileManager extends core_1.Host {
                     item.incremental = undefined;
                 }
             }
-            if (valid && filename) {
+            if (valid && item.filename) {
                 const etag = (cacheEtag && type !== "exists" || type === "etag") && !!uri;
                 if (etag && imported.some(file => file.imported.includes(uri))) {
                     item.incremental = "none";
@@ -2993,7 +3323,7 @@ class FileManager extends core_1.Host {
                         }
                         return false;
                     };
-                    if ((!etag || item.fetchType === 1 && ((0, types_1.isEmpty)(bundleId) || bundleIndex <= 0)) && (!watch || !item.watch || setBuffer(item))) {
+                    if ((!etag || item.fetchType === 1 && ((0, types_1.isEmpty)(bundleId) || bundleIndex <= 0)) && (!this.Watch || !item.watch || setBuffer(item))) {
                         let childBundle, childDownload;
                         if (!(0, types_1.isEmpty)(bundleId) && bundleIndex > 0) {
                             const target = assets.find(parent => parent.bundleIndex === 0 && parent.bundleId === bundleId);
@@ -3029,7 +3359,7 @@ class FileManager extends core_1.Host {
                             setBuffer(item);
                         }
                         const checksumOutput = item.checksumOutput;
-                        if (core_1.Host.isPath(localUri) && (!checksumOutput || checkHash.call(this, localUri, true, checksumOutput))) {
+                        if (core_1.Host.isPath(localUri) && (!checksumOutput || checkHash(this, localUri, true, checksumOutput))) {
                             item.flags |= 128;
                             if (!etag || item.fetchType !== 1 || checksumOutput) {
                                 if (bundleIndex === 0 && !(0, types_1.isEmpty)(bundleId)) {
@@ -3047,14 +3377,15 @@ class FileManager extends core_1.Host {
                         else if (cached) {
                             try {
                                 const buffer = cached[1];
-                                if (!item.checksum || checkHash.call(this, localUri, false, item.checksum, buffer)) {
+                                if (!item.checksum || checkHash(this, localUri, false, item.checksum, buffer)) {
                                     fs.writeFileSync(localUri, buffer);
                                     if (item.willChange && Buffer.isBuffer(buffer)) {
                                         item.buffer = buffer;
                                     }
-                                    if (!(checksumOutput && (0, types_1.isEmpty)(bundleId) && checkHash.call(this, localUri, true, checksumOutput, buffer))) {
+                                    if (!(checksumOutput && (0, types_1.isEmpty)(bundleId) && checkHash(this, localUri, true, checksumOutput, buffer))) {
                                         this.performAsyncTask();
-                                        fileReceived(item, localUri, null, true, false, true);
+                                        const target = new ProcessFile(this, item, localUri, groupData);
+                                        target.received(null, incremental, true, false, true);
                                     }
                                     continue;
                                 }
@@ -3082,6 +3413,10 @@ class FileManager extends core_1.Host {
             }
             downloadable.set(item, download);
         }
+        const { downloading, bundling, originCount } = groupData;
+        const watching = !!this.Watch;
+        const processTask = this[kScheduler];
+        const diffSource = this[kDiffSource];
         if (downloadable.size > 1 && this.Request.httpVersion !== 1) {
             for (const { url } of downloadable.keys()) {
                 if (url?.protocol === 'https:') {
@@ -3095,47 +3430,61 @@ class FileManager extends core_1.Host {
                 break;
             }
             const { pathname, localUri } = download;
+            const target = new ProcessFile(this, item, localUri, groupData);
+            if (diffSource && core_1.Host.isPath(localUri, true) && diffSource[0].some(pattern => typeof pattern === 'string' ? pattern === item.mimeType || pattern === item.mimeType?.split('/')[1] : pattern(localUri))) {
+                try {
+                    const encoding = image_1.isBinary(item.mimeType) ? 'base64' : item.encoding || 'utf-8';
+                    (_p = diffSource[1])[localUri] || (_p[localUri] = [fs.readFileSync(localUri, encoding), encoding]);
+                }
+                catch (err) {
+                    this.formatMessage(32, "WARN!", ["Unable to read file", path.basename(localUri)], err, { ...core_1.Host.LOG_STYLE_WARN });
+                }
+            }
             if (item.content) {
-                if (!checkQueue(item, localUri, pathname, true)) {
+                if (!target.queued(pathname, emptyDir, true)) {
                     const content = item.content;
                     item.sourceUTF8 = content;
                     this.performAsyncTask();
-                    fs.writeFile(localUri, content, item.encoding || (item.encoding = 'utf-8'), err => fileReceived(item, localUri, err));
+                    fs.writeFile(localUri, content, item.encoding || (item.encoding = 'utf-8'), err => {
+                        target.received(err, incremental);
+                    });
                 }
                 continue;
             }
             if (item.dataView) {
-                if (createFolder(item, pathname)) {
+                if (target.createFolder(pathname, emptyDir)) {
                     this.performAsyncTask();
                     const dataView = item.dataView;
                     fs.writeFile(localUri, dataView, err => {
                         if (!err) {
                             item.buffer = Buffer.isBuffer(dataView) ? dataView : Buffer.from(dataView.buffer);
                         }
-                        fileReceived(item, localUri, err, false, true);
+                        target.received(err, incremental, false, true);
                     });
                 }
                 continue;
             }
             if (item.base64) {
-                if (createFolder(item, pathname)) {
+                if (target.createFolder(pathname, emptyDir)) {
                     this.performAsyncTask();
-                    fs.writeFile(localUri, item.base64, 'base64', err => fileReceived(item, localUri, err, false, true));
+                    fs.writeFile(localUri, item.base64, 'base64', err => {
+                        target.received(err, incremental, false, true);
+                    });
                 }
                 continue;
             }
             const uri = item.uri;
             if (!uri) {
                 if (item.buffer) {
-                    if (createFolder(item, pathname)) {
+                    if (target.createFolder(pathname, emptyDir)) {
                         this.performAsyncTask();
-                        this.scheduleTask(localUri, item.buffer, () => {
-                            fileReceived(item, localUri, null, false, true);
+                        void this.scheduleTask(localUri, item.buffer, () => {
+                            target.received(null, incremental, false, true);
                         }, (err) => {
-                            fileReceived(item, localUri, err);
+                            target.received(err);
                         }).then(code => {
                             if (code === -1) {
-                                fileReceived(item, localUri, (0, types_1.errorValue)("Not able to read buffer", path.basename(localUri)));
+                                target.received((0, types_1.errorValue)("Not able to read buffer", path.basename(localUri)));
                             }
                         });
                     }
@@ -3144,7 +3493,6 @@ class FileManager extends core_1.Host {
                 item.invalid = true;
                 continue;
             }
-            const checkDest = (src) => staging || !(0, util_1.hasSameStat)(src, localUri);
             const type = item.fetchType || 0;
             const bundleMain = item.bundleIndex === 0 && !(0, types_1.isEmpty)(item.bundleId);
             if (type === 1 || type === 2) {
@@ -3152,15 +3500,15 @@ class FileManager extends core_1.Host {
                 if (bundling[uri] && (0, types_1.isEmpty)(item.bundleId)) {
                     bundling[uri].push(item);
                 }
-                else if ((checkEtag = hasEtag(item)) || !checkQueue(item, localUri, pathname)) {
-                    if (type !== 1 && !checkDest(uri)) {
-                        fileReceived(item, localUri, null);
+                else if ((checkEtag = hasEtag(item, cacheable, cacheEtag)) || !target.queued(pathname, emptyDir, false)) {
+                    if (type === 2 && !checkDest(uri, localUri)) {
+                        target.received(null, incremental);
                     }
                     else if (!checkEtag && downloading[uri]) {
                         downloading[uri].push(item);
                     }
-                    else if (type !== 1 && !this.canRead(uri)) {
-                        errorPermission(item);
+                    else if (type === 2 && !this.canRead(uri)) {
+                        errorPermission(this, item);
                     }
                     else {
                         if (!checkEtag) {
@@ -3173,12 +3521,11 @@ class FileManager extends core_1.Host {
                             cacheBuffer = cacheToMemory.has(url);
                             mainEtag = (0, types_1.mainFlag)(item.flags) && (cacheEtag || item.incremental === "etag");
                         }
-                        const closeResponse = () => client?.destroy();
                         const downloadUri = (request, etagDir) => {
                             if (checkEtag) {
                                 item.flags &= ~128;
                             }
-                            closeResponse();
+                            closeResponse(client);
                             const location = request.url.toString();
                             request.encoding = encoding;
                             request.pipeTo = localUri;
@@ -3187,7 +3534,7 @@ class FileManager extends core_1.Host {
                                 request.method = 'GET';
                                 request.httpVersion = (originCount[request.url.origin] || 0) <= 1 ? 1 : undefined;
                                 request.connected = headers => {
-                                    applyHeaders(item, headers, true, mainEtag);
+                                    processHeaders(item, headers, watching, mainEtag);
                                     return item.willChange || !!etagDir && (cacheDir || !item.contentLength || cacheToMemory.within(item.contentLength)) || this.hasLog('progress');
                                 };
                             }
@@ -3196,14 +3543,14 @@ class FileManager extends core_1.Host {
                                 request.method = undefined;
                                 request.httpVersion = 1;
                             }
-                            this.scheduleTask(request.url, request, (data) => {
+                            void this.scheduleTask(request.url, request, (data) => {
                                 if (typeof data === 'string') {
                                     item.sourceUTF8 = data;
                                 }
                                 else if (data) {
                                     item.buffer = data;
                                 }
-                                fileReceived(item, localUri, null, type === 1);
+                                target.received(null, incremental, type === 1);
                                 if (etagDir) {
                                     queueMicrotask(() => {
                                         if (cacheBuffer && data) {
@@ -3215,7 +3562,7 @@ class FileManager extends core_1.Host {
                                     });
                                 }
                             }, (err) => {
-                                errorRequest(item, localUri, err);
+                                target.abort(err);
                             }, 1);
                         };
                         this.performAsyncTask();
@@ -3224,13 +3571,15 @@ class FileManager extends core_1.Host {
                             (function checkHeaders(href) {
                                 const request = this.Request;
                                 try {
-                                    const target = request.opts(href, { method: 'HEAD', httpVersion: 1 });
-                                    (client = request.open(href, target))
+                                    ++processTask.pending;
+                                    const opts = request.opts(href, { method: 'HEAD', httpVersion: 1 });
+                                    (client = request.open(href, opts))
                                         .on('response', res => {
+                                        --processTask.pending;
                                         const statusCode = res.statusCode;
                                         if (statusCode < 300) {
-                                            const etag = applyHeaders(item, res.headers, false, mainEtag);
-                                            let etagDir = '', tempDir;
+                                            const etag = processHeaders(item, res.headers, false, mainEtag);
+                                            let etagDir = null, tempDir;
                                             if (etag) {
                                                 if (cacheDir || mainEtag) {
                                                     tempDir = this.getCacheDir(href);
@@ -3242,13 +3591,13 @@ class FileManager extends core_1.Host {
                                                     let buffer;
                                                     if (cached) {
                                                         if (etagDir === cached[5] && (!encoding || encoding === cached[2])) {
-                                                            if (item.checksum && !checkHash.call(this, localUri, false, item.checksum, cached[1])) {
+                                                            if (item.checksum && !checkHash(this, localUri, false, item.checksum, cached[1])) {
                                                                 tempDir = undefined;
                                                             }
                                                             else {
                                                                 if (checkEtag) {
                                                                     this.completeAsyncTask(null, localUri);
-                                                                    closeResponse();
+                                                                    closeResponse(client);
                                                                     return;
                                                                 }
                                                                 buffer = cached[1];
@@ -3262,68 +3611,56 @@ class FileManager extends core_1.Host {
                                                         }
                                                     }
                                                     try {
-                                                        const setBuffer = () => {
-                                                            if (typeof buffer === 'string') {
-                                                                item.sourceUTF8 = buffer;
-                                                            }
-                                                            else if (buffer) {
-                                                                item.buffer = buffer;
-                                                            }
-                                                        };
                                                         let pipeAs;
-                                                        if (tempDir && (0, util_1.hasSize)(pipeAs = path.join(tempDir, etagDir, path.basename(localUri)))) {
+                                                        if (tempDir && (0, util_2.hasSize)(pipeAs = path.join(tempDir, etagDir, path.basename(localUri)))) {
                                                             if (!checkEtag) {
                                                                 if (cacheBuffer && !buffer) {
                                                                     buffer = fs.readFileSync(pipeAs, encoding);
-                                                                    if (item.checksum && !checkHash.call(this, localUri, false, item.checksum, buffer)) {
-                                                                        downloadUri(target, etagDir);
+                                                                    if (item.checksum && !checkHash(this, localUri, false, item.checksum, buffer)) {
+                                                                        downloadUri(opts, etagDir);
                                                                         return;
                                                                     }
                                                                     if (cacheToMemory.within(item.contentLength = Buffer.byteLength(buffer, encoding))) {
                                                                         cacheToMemory.add(location, etagDir, buffer, { encoding, contentLength: item.contentLength, tempFile: pipeAs });
                                                                     }
                                                                 }
-                                                                if (checkDest(pipeAs)) {
-                                                                    const writeBuffer = () => {
-                                                                        fs.writeFileSync(localUri, buffer);
-                                                                        this.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
-                                                                    };
+                                                                if (checkDest(pipeAs, localUri)) {
                                                                     if (buffer) {
-                                                                        writeBuffer();
+                                                                        writeBufferCache(this, localUri, buffer, encoding);
                                                                     }
                                                                     else if (item.checksum) {
                                                                         buffer = fs.readFileSync(pipeAs, encoding);
-                                                                        if (!checkHash.call(this, localUri, false, item.checksum, buffer)) {
-                                                                            downloadUri(target, etagDir);
+                                                                        if (!checkHash(this, localUri, false, item.checksum, buffer)) {
+                                                                            downloadUri(opts, etagDir);
                                                                             return;
                                                                         }
-                                                                        writeBuffer();
+                                                                        writeBufferCache(this, localUri, buffer, encoding);
                                                                     }
                                                                     else {
                                                                         fs.copyFileSync(pipeAs, localUri);
                                                                         this.addDownload(pipeAs, types_1.DOWNLOAD_TYPE.CACHE);
                                                                     }
                                                                 }
-                                                                if (item.willChange) {
-                                                                    setBuffer();
+                                                                if (item.willChange && buffer) {
+                                                                    setBufferTarget(item, buffer);
                                                                 }
-                                                                fileReceived(item, localUri, null, true, false, true);
+                                                                target.received(null, incremental, true, false, true);
                                                             }
                                                             else {
                                                                 this.completeAsyncTask(null, localUri);
                                                             }
-                                                            closeResponse();
+                                                            closeResponse(client);
                                                             return;
                                                         }
                                                         if (buffer) {
-                                                            setBuffer();
+                                                            setBufferTarget(item, buffer);
                                                             fs.writeFileSync(localUri, buffer);
                                                             this.addDownload(Buffer.byteLength(buffer, encoding), types_1.DOWNLOAD_TYPE.CACHE);
                                                             if (checkEtag) {
                                                                 item.flags &= ~128;
                                                             }
-                                                            fileReceived(item, localUri, null, true, false, true);
-                                                            closeResponse();
+                                                            target.received(null, incremental, true, false, true);
+                                                            closeResponse(client);
                                                             if (pipeAs) {
                                                                 fs.writeFile(pipeAs, buffer, () => { });
                                                             }
@@ -3334,10 +3671,10 @@ class FileManager extends core_1.Host {
                                                     }
                                                 }
                                             }
-                                            downloadUri(target, etagDir);
+                                            downloadUri(opts, etagDir);
                                         }
                                         else if (statusCode < 400) {
-                                            closeResponse();
+                                            closeResponse(client);
                                             const location = res.headers.location;
                                             if (location && ++redirects <= HTTP_CLIENT.redirectLimit) {
                                                 try {
@@ -3347,29 +3684,32 @@ class FileManager extends core_1.Host {
                                                 catch {
                                                 }
                                             }
-                                            errorRequest(item, localUri, (0, types_1.errorMessage)(statusCode, 'Exceeded redirect limit', url.toString()));
+                                            target.abort((0, types_1.errorMessage)(statusCode, "Exceeded redirect limit", url.toString()));
                                         }
                                         else {
-                                            downloadUri(target, null);
+                                            downloadUri(opts, null);
                                         }
                                     })
                                         .on('error', err => {
+                                        --processTask.pending;
                                         if (!client.destroyed) {
-                                            if ((0, util_1.checkRetryable)(err)) {
-                                                downloadUri(target, null);
+                                            if ((0, util_2.checkRetryable)(err)) {
+                                                downloadUri(opts, null);
                                             }
                                             else {
-                                                errorRequest(item, localUri, err);
+                                                target.abort(err);
                                             }
                                         }
                                     })
                                         .on('timeout', () => {
+                                        --processTask.pending;
                                         if (!client.destroyed) {
-                                            downloadUri(target, null);
+                                            downloadUri(opts, null);
                                         }
                                     });
                                 }
                                 catch {
+                                    --processTask.pending;
                                     downloadUri(request.opts(href), null);
                                 }
                             }).bind(this)(url);
@@ -3380,30 +3720,30 @@ class FileManager extends core_1.Host {
                     }
                 }
             }
-            else if (type) {
+            else if (type === 3 || type === 4) {
                 if (bundleMain && !item.mimeType) {
-                    errorRequest(item, localUri, (0, types_1.errorValue)("MIME not found", uri), true);
+                    target.abort((0, types_1.errorValue)("MIME not found", uri), true);
                 }
-                else if (!checkQueue(item, localUri, pathname)) {
+                else if (!target.queued(pathname, emptyDir, false)) {
                     if (downloading[uri]) {
                         downloading[uri].push(item);
                         continue;
                     }
                     downloading[uri] = [];
                     this.performAsyncTask();
-                    this.scheduleTask(item.url || uri, { pathname, binOpts: item.binOpts }, (result) => {
+                    void this.scheduleTask(item.url || uri, { pathname, binOpts: item.binOpts }, (result) => {
                         if (result.length === 0) {
-                            errorRequest(item, localUri, (0, types_1.errorValue)("No files were successfully downloaded", uri));
+                            target.abort((0, types_1.errorValue)("No files were successfully downloaded", uri));
                         }
                         else if (bundleMain) {
                             const encoding = item.encoding || (item.encoding = 'utf-8');
-                            fs.writeFile(localUri, bundleTorrent.call(this, result, item.mimeType, encoding), encoding, err => {
+                            fs.writeFile(localUri, bundleTorrent(this, result, item.mimeType, encoding), encoding, err => {
                                 if (!err) {
                                     fetchedAssets.push(item);
-                                    processQueue(item, localUri);
+                                    void target.finalize(incremental);
                                 }
                                 else {
-                                    errorRequest(item, localUri, err);
+                                    target.abort(err);
                                 }
                             });
                         }
@@ -3428,44 +3768,44 @@ class FileManager extends core_1.Host {
                             }
                             if (found) {
                                 fetchedAssets.push(item);
-                                processQueue(item, localUri);
+                                void target.finalize(incremental);
                             }
                             else {
                                 item.filename = '';
                                 item.localUri = '';
                                 item.mimeType = '';
-                                clearQueue(processing, localUri);
+                                clearQueue(groupData.processing, localUri);
                                 clearQueue(downloading, uri);
                                 this.completeAsyncTask();
                             }
                         }
                     }, (err) => {
-                        errorRequest(item, localUri, err);
+                        target.abort(err);
                     }, 4);
                 }
             }
             else if (!this.canRead(uri)) {
-                errorPermission(item);
+                errorPermission(this, item);
             }
-            else if (!checkQueue(item, localUri, pathname)) {
+            else if (!target.queued(pathname, emptyDir, false)) {
                 this.performAsyncTask();
-                if (checkDest(uri)) {
+                if (checkDest(uri, localUri)) {
                     fs.copyFile(uri, localUri, err => {
                         if (!err) {
                             this.addDownload(localUri, types_1.DOWNLOAD_TYPE.DISK);
                         }
-                        fileReceived(item, localUri, err);
+                        target.received(err);
                     });
                 }
                 else {
-                    fileReceived(item, localUri, null);
+                    target.received(null, incremental);
                 }
             }
         }
         this.cleared = true;
     }
     updateProgress(name, ...args) {
-        if (name === 'request' && STDOUT_CURSOR) {
+        if (name === 'request' && this.hasLog('progress') && STDOUT_CURSOR) {
             const processTask = this[kScheduler];
             const status = processTask.status;
             const id = args[0];
@@ -3491,39 +3831,76 @@ class FileManager extends core_1.Host {
             else if (processTask.updated + 100 > currentTime) {
                 return;
             }
-            const length = status.length;
             const logCurrent = (0, types_1.getLogCurrent)();
-            const formatSegment = (endTime, value) => endTime ? value : chalk.bgGray.black(value);
-            let redraw = processTask.logCurrent !== logCurrent;
-            if (redraw || length > processTask.length) {
-                this.pauseLog();
+            const statusHeight = status.length;
+            const barLength = processTask.barLength;
+            const barIncrement = 100 / barLength;
+            const initial = processTask.logCurrent !== logCurrent;
+            let redraw = false, scrollHeight = 0, logDelayed;
+            if ((logDelayed = core_1.Host.getLogDelayed()) && logDelayed.length > 0) {
+                logDelayed = logDelayed.filter(item => typeof item[4].progressBar !== 'boolean');
+                scrollHeight = Math.min(logDelayed.length, LOGGER.PROGRESS_SCROLLBUFFER);
+            }
+            else {
+                logDelayed = null;
+            }
+            if (initial || statusHeight > processTask.statusHeight || scrollHeight > processTask.scrollHeight) {
+                if (this.logState !== 0) {
+                    this.pauseLog('progress');
+                }
+                if (!initial) {
+                    PROCESS_STDOUT.write('\n'.repeat(statusHeight + scrollHeight - processTask.statusHeight - processTask.scrollHeight));
+                }
+                processTask.statusHeight = statusHeight;
+                processTask.scrollHeight = scrollHeight;
                 processTask.logCurrent = logCurrent;
-                PROCESS_STDOUT.write('\n'.repeat(redraw ? length : length - processTask.length));
-                processTask.length = length;
                 redraw = true;
             }
-            PROCESS_STDOUT.moveCursor(0, -length);
+            if (initial) {
+                processTask.section(true);
+            }
+            else {
+                PROCESS_STDOUT.moveCursor(0, -(statusHeight + 1 + 1 + (scrollHeight > 0 ? 1 + scrollHeight : 0)));
+            }
             processTask.updated = currentTime;
-            const titleWidth = processTask.titleWidth;
-            let finished = true;
-            for (let i = 0; i < length; ++i) {
-                const item = status[i];
-                const { receivedBytes, endTime } = item;
-                if (!endTime) {
-                    finished = false;
-                }
-                if (!redraw && item.previousBytes === receivedBytes) {
-                    PROCESS_STDOUT.moveCursor(0, 1);
-                    continue;
+            const summary = new TaskStatus(-1, chalk.bold(`${statusHeight} requests`.padEnd(LOGGER.VALUE_WIDTH)));
+            const spacer = LOGGER.PROGRESS_SPACER;
+            let finished = processTask.pending === 0;
+            for (let i = 0; i <= statusHeight; ++i) {
+                const item = i === statusHeight ? summary : status[i];
+                let { receivedBytes, endTime } = item;
+                if (i === statusHeight) {
+                    processTask.section(redraw);
+                    if (finished) {
+                        endTime = 1;
+                    }
                 }
-                if (item.output) {
-                    PROCESS_STDOUT.clearLine(0);
-                    PROCESS_STDOUT.write(item.output);
-                    continue;
+                else {
+                    if (!endTime) {
+                        finished = false;
+                    }
+                    if (i === 0) {
+                        summary.dataTime = item.dataTime;
+                        summary.startTime = item.startTime;
+                    }
+                    summary.receivedBytes += receivedBytes;
+                    summary.totalBytes += item.totalBytes;
+                    if (item.previousBytes === receivedBytes) {
+                        if (!redraw) {
+                            PROCESS_STDOUT.moveCursor(0, 1);
+                            continue;
+                        }
+                        const value = item.finished || item.current;
+                        if (value) {
+                            PROCESS_STDOUT.clearLine(0);
+                            PROCESS_STDOUT.write(value);
+                            continue;
+                        }
+                    }
+                    item.previousBytes = receivedBytes;
                 }
                 let percent = 0, bars = 0;
-                item.previousBytes = receivedBytes;
-                if (endTime) {
+                if (endTime > 0) {
                     if (receivedBytes === item.totalBytes) {
                         bars = -1;
                     }
@@ -3531,34 +3908,126 @@ class FileManager extends core_1.Host {
                 else if (receivedBytes > item.totalBytes) {
                     item.totalBytes = receivedBytes;
                     percent = 99;
-                    bars = 24;
+                    bars = barIncrement > 0 ? barLength - 1 : NaN;
                 }
                 else {
                     percent = (receivedBytes / item.totalBytes) * 100;
-                    bars = Math.trunc(percent / 4);
+                    bars = barIncrement > 0 ? Math.round(percent / barIncrement) : NaN;
                 }
                 const diffTime = currentTime - item.startTime;
-                const time = formatSegment(endTime, formatMinutes(diffTime).padStart(titleWidth));
-                const size = formatSegment(endTime, (0, types_1.formatSize)(receivedBytes, { unit: receivedBytes < 1048576 ? 'KB' : receivedBytes < 1073741824 ? 'MB' : 'GB', unitSeparator: ' ', fixedDecimals: true, decimalPlaces: 2 }).padStart(9));
-                const speed = formatSegment(endTime, (0, util_1.getTransferRate)(receivedBytes, item.dataTime ? (0, types_1.convertTime)(process.hrtime(item.dataTime), false) * 1000 : diffTime, ' ').padStart(10));
-                let output = time + ` ${chalk.blackBright(':')} ${endTime && bars !== -1 ? chalk.bgBlack.gray(item.url) : item.url}| ${size} |`;
-                if (!isNaN(percent)) {
-                    output += speed + ` |${bars === -1 ? chalk.bgBlack.green.bold('>'.repeat(25)) : (bars > 0 ? chalk.yellow('>'.repeat(bars)) : '') + (25 - bars > 0 ? chalk.gray((endTime ? '#' : '-').repeat(25 - bars)) : '')}| ` + (endTime ? bars === -1 ? chalk.bold('100%') : chalk.red('ERR!') : Math.trunc(percent).toString().padStart(3) + '%');
+                const unit = receivedBytes < 1048576 ? 'KB' : receivedBytes < 1073741824 ? 'MB' : 'GB';
+                const [time, size, speed] = formatSegment(endTime > 0 ? bars === 0 ? -1 : endTime : 0, formatMinutes(diffTime).padStart(LOGGER.TITLE_WIDTH), (0, types_1.formatSize)(receivedBytes, { unit, unitSeparator: ' ', fixedDecimals: true, decimalPlaces: unit === 'KB' ? 0 : unit === 'MB' ? 1 : 2 }).padStart(8), (0, util_2.getTransferRate)(receivedBytes, item.dataTime ? (0, types_1.convertTime)(process.hrtime(item.dataTime), false) * 1000 : diffTime, ' ').padStart(10));
+                let output = time + ` ${chalk.blackBright(LOGGER.TITLE_SEP)} ` + (endTime > 0 && bars === 0 ? chalk.grey(item.url) : item.url) + spacer;
+                if (barLength === 1) {
+                    output += ` ${endTime > 0 ? bars === 0 ? chalk.red('ERR!') : LOGGER.PROGRESS_COMPLETE : formatPercent(percent)} ` + spacer;
+                }
+                else if (!isNaN(barLength)) {
+                    output += ` ${size} ` + spacer;
+                    if (endTime > 0) {
+                        output += ` ${speed} ${spacer} ${bars === 0 ? chalk.red('ERR!') : LOGGER.PROGRESS_COMPLETE} ` + spacer;
+                    }
+                    else if (!isNaN(percent)) {
+                        output += ` ${speed} ${spacer} ${formatPercent(percent)} ` + spacer;
+                        if (bars >= 0) {
+                            output += writeProgressBar(bars, barLength);
+                        }
+                    }
                 }
                 output += '\n';
+                if (!LOGGER.PROGRESS_USECOLOR) {
+                    output = stripansi(output);
+                }
                 PROCESS_STDOUT.clearLine(0);
                 PROCESS_STDOUT.write(output);
-                if (endTime) {
-                    item.output = output;
+                if (endTime > 0) {
+                    item.finished = output;
+                }
+                else {
+                    item.current = output;
+                }
+            }
+            const cleared = finished && this.cleared;
+            if (logDelayed) {
+                processTask.section(redraw);
+                const { PROGRESS_COLOR: color, PROGRESS_BGCOLOR: bgColor, PROGRESS_USECOLOR: useColor, PROGRESS_TEXTWRAP: messageTextWrap } = LOGGER;
+                const scroll = processTask.scroll;
+                let start = 0, end = 0, output, last;
+                if (cleared) {
+                    logDelayed = this._logDelayed;
+                    end = Math.min(logDelayed.length, scrollHeight);
+                }
+                else {
+                    [start, end] = [Math.max(0, logDelayed.length - scrollHeight), logDelayed.length];
+                }
+                for (let i = 0; start < end; ++i, ++start) {
+                    let item = logDelayed[start];
+                    if (cleared) {
+                        last = item;
+                    }
+                    else {
+                        if (!redraw && scroll[i] === item) {
+                            PROCESS_STDOUT.moveCursor(0, 1);
+                            continue;
+                        }
+                        const options = { ...item[4], messageTextWrap, broadcastId: '' };
+                        if (!useColor) {
+                            options.useColor = false;
+                        }
+                        else if (color || bgColor) {
+                            options.useColor = true;
+                            if (color) {
+                                options.titleColor = color;
+                                options.valueColor = color;
+                                options.hintColor = color;
+                                options.messageColor = color;
+                            }
+                            if (bgColor) {
+                                options.titleBgColor = bgColor;
+                                options.valueBgColor = bgColor;
+                                options.hintBgColor = bgColor;
+                                options.messageBgColor = bgColor;
+                            }
+                        }
+                        scroll[i] = item;
+                        item = item.slice(0);
+                        item[4] = options;
+                    }
+                    PROCESS_STDOUT.clearLine(0);
+                    core_1.Host.formatMessage(...item);
+                    output = true;
+                }
+                if (last) {
+                    if (end < scrollHeight) {
+                        for (let i = end; i < scrollHeight; ++i) {
+                            PROCESS_STDOUT.clearLine(0);
+                            PROCESS_STDOUT.moveCursor(0, 1);
+                        }
+                        PROCESS_STDOUT.moveCursor(0, end - scrollHeight);
+                    }
+                    const index = logDelayed.findIndex(item => item === last);
+                    if (index !== -1) {
+                        logDelayed.splice(0, index + 1);
+                    }
+                }
+                else if (output) {
+                    processTask.logCurrent = (0, types_1.getLogCurrent)();
                 }
             }
-            if (finished) {
-                this.resumeLog();
+            if (cleared) {
+                this.resumeLog('progress');
                 processTask.reset();
             }
+            else if (initial) {
+                if (processTask.screenReset) {
+                    processTask.screenReset = false;
+                }
+                else {
+                    PROCESS_STDOUT.write('\n');
+                }
+            }
         }
     }
-    scheduleTask(url, data, thenCallback, catchCallback, priority = 0) {
+    async scheduleTask(url, data, thenCallback, catchCallback, priority = 0) {
         if (typeof thenCallback === 'number') {
             priority = thenCallback;
             thenCallback = undefined;
@@ -3569,25 +4038,6 @@ class FileManager extends core_1.Host {
             scheduler.queue.sort((a, b) => b[4] - a[4]);
             return Promise.resolve(0);
         }
-        const nextTask = (pid) => {
-            if (pid > 0) {
-                const found = scheduler.status.find(item => item.id === pid);
-                if (found) {
-                    found.endTime || (found.endTime = Date.now());
-                }
-            }
-            --scheduler.count;
-            if (scheduler.queue.length) {
-                const params = scheduler.queue.pop();
-                this.scheduleTask(...params);
-            }
-            else if (scheduler.transform.length) {
-                do {
-                    const args = scheduler.transform.shift();
-                    this.transformAsset(args[0], args[1], true);
-                } while (scheduler.transform.length && scheduler.queue.length === 0);
-            }
-        };
         let id = 0, target;
         if ((0, types_1.isPlainObject)(data)) {
             ++scheduler.count;
@@ -3595,7 +4045,7 @@ class FileManager extends core_1.Host {
                 target = this.fetchFiles(url, data);
             }
             else {
-                if (this.hasLog('progress') && STDOUT_CURSOR) {
+                if (STDOUT_CURSOR && this.hasLog('progress')) {
                     id = ++scheduler.id;
                     data.progressId = id;
                 }
@@ -3608,7 +4058,7 @@ class FileManager extends core_1.Host {
             }
             else {
                 if (data instanceof URL && data.protocol === 'file:') {
-                    data = core_1.Host.resolveFile(data);
+                    data = (0, url_1.fileURLToPath)(data);
                 }
                 if ((0, types_1.isString)(data) && core_1.Host.isPath(data, true) && this.canRead(data)) {
                     data = fs.createReadStream(data);
@@ -3617,19 +4067,19 @@ class FileManager extends core_1.Host {
             if (data instanceof stream.Readable) {
                 ++scheduler.count;
                 target = new Promise((resolve, reject) => {
-                    const writeable = fs.createWriteStream(url);
-                    writeable.on('finish', () => {
+                    const writable = fs.createWriteStream(url);
+                    writable.on('finish', () => {
                         resolve(1);
                     });
-                    writeable.on('error', reject);
+                    writable.on('error', reject);
                     data.on('error', reject);
-                    data.pipe(writeable);
+                    data.pipe(writable);
                 });
             }
         }
         if (target) {
             if (thenCallback) {
-                target.then(thenCallback);
+                void target.then(thenCallback);
             }
             if (catchCallback) {
                 target.catch(catchCallback);
@@ -3637,7 +4087,7 @@ class FileManager extends core_1.Host {
             if (id > 0) {
                 scheduler.add(id, url.toString());
             }
-            return target.finally(nextTask.bind(this, id));
+            return target.finally(nextScheduled.bind(this, scheduler, id));
         }
         return Promise.resolve(-1);
     }
@@ -3648,53 +4098,57 @@ class FileManager extends core_1.Host {
     }
     async finalizeCompress(assets) {
         const compress = this.Compress;
-        if (!(assets.length && compress)) {
+        if (!(assets.length > 0 && compress)) {
             return;
         }
         const tasks = [];
         for (const item of assets) {
-            const localUri = item.localUri;
-            if (!(localUri && image_1.isBinary(item.mimeType))) {
+            if (!image_1.isBinary(item.mimeType)) {
                 continue;
             }
-            const files = [localUri];
+            const files = [[item.localUri, item.mimeType || '']];
             if (item.transforms) {
-                files.push(...item.transforms);
-            }
-            const format = item.mimeType.split('/').pop();
-            for (const file of files) {
-                const output = item.compress.filter(({ condition }) => !condition || withinSizeRange(file, condition));
-                if (!(output.length && this.has(file))) {
-                    continue;
-                }
-                const found = output.filter(value => value.format === format);
-                for (const config of found.length ? found : output) {
-                    const options = {
-                        ...config,
-                        timeout: this[kProcessTimeout].compress ?? PROCESS_TIMEOUT.compress,
-                        proxyUrl: (uri) => {
-                            const proxy = this.Request.proxyOf(uri);
-                            return proxy ? proxy.host.href : '';
-                        }
-                    };
-                    tasks.push(compress.tryImage(item.buffer && files.length === 1 ? item.buffer : file, file, options)
-                        .then(result => {
-                        if (result instanceof Buffer && file === localUri) {
-                            item.buffer = result;
+                files.push(...item.transforms.map(img => [img, core_1.Host.lookupMime(img)]));
+            }
+            tasks.push(new Promise(async (resolve) => {
+                for (const [file, mimeType] of files) {
+                    const ext = mimeType.split('/')[1];
+                    const output = item.compress.filter(({ format, condition }) => (!format || format === ext) && (!condition || withinSizeRange(file, condition)));
+                    if (output.length > 0 && this.has(file)) {
+                        for (let i = 0, length = output.length, buffer = null; i < length; ++i) {
+                            const options = output[i];
+                            options.mimeType = mimeType;
+                            options.timeout ?? (options.timeout = this[kProcessTimeout].compress ?? PROCESS_TIMEOUT.compress);
+                            await compress.tryImage(buffer || files.length === 1 && item.buffer || file, file, options)
+                                .then(result => {
+                                if (result) {
+                                    if (file === item.localUri) {
+                                        item.buffer = result instanceof Uint8Array ? Buffer.from(result) : result;
+                                    }
+                                    if (i < length - 1) {
+                                        buffer = Buffer.from(result);
+                                    }
+                                }
+                            })
+                                .catch((err) => {
+                                this.writeFail(["Unable to compress file", path.basename(file)], err, 8);
+                            });
                         }
-                    })
-                        .catch((err) => this.writeFail(["Unable to compress file", path.basename(file)], err, { type: 8, startTime: options.startTime })));
+                    }
                 }
-            }
+                resolve();
+            }));
         }
-        if (tasks.length) {
-            return Promise.all(tasks);
+        if (tasks.length > 0) {
+            await Promise.all(tasks);
         }
     }
     async finalizeDocument() {
         for (const { instance, constructor } of this.Document) {
-            if (constructor.finalize && instance.assets.length) {
-                await constructor.finalize.call(this, instance).catch((err) => rejectModule.call(instance, err, 4));
+            if (constructor.finalize && instance.assets.length > 0) {
+                await constructor.finalize.call(this, instance).catch((err) => {
+                    rejectModule(instance, err, 4);
+                });
                 if (this.aborted) {
                     return;
                 }
@@ -3702,11 +4156,13 @@ class FileManager extends core_1.Host {
         }
     }
     async finalizeTask(assets) {
-        if (assets.length) {
+        if (assets.length > 0) {
             for (const { instance, constructor } of this.Task) {
                 const items = assets.filter(item => item.tasks.find(data => data.handler === instance.moduleName));
-                if (items.length) {
-                    await constructor.finalize.call(this, instance, items).catch((err) => rejectModule.call(instance, err, 4));
+                if (items.length > 0) {
+                    await constructor.finalize.call(this, instance, items).catch((err) => {
+                        rejectModule(instance, err, 4);
+                    });
                     if (this.aborted) {
                         return;
                     }
@@ -3717,11 +4173,36 @@ class FileManager extends core_1.Host {
     async finalizeCloud() {
         const cloud = this.Cloud;
         if (cloud) {
-            return cloud_1.finalize.call(this, cloud).catch((err) => rejectModule.call(cloud, err, 64));
+            await cloud_1.finalize.call(this, cloud).catch((err) => {
+                rejectModule(cloud, err, 64);
+            });
+        }
+    }
+    async finalizeChecksum() {
+        let checksum = this.config.checksum;
+        if (!checksum) {
+            return;
+        }
+        if (typeof checksum === 'boolean' || checksum === 1) {
+            checksum = { recursive: checksum };
+        }
+        else if ((0, types_1.isString)(checksum)) {
+            const items = checksum.split('.');
+            checksum = items.length > 1 ? { algorithm: items[items.length - 1], filename: checksum } : { algorithm: checksum };
+        }
+        if ((0, types_1.isPlainObject)(checksum)) {
+            const baseDirectory = this.baseDirectory;
+            checksum.joinRoot = true;
+            checksum.throwsEmpty = true;
+            const sumTime = LOG_TIMEELAPSED ? process.hrtime() : 0;
+            const files = (await FileManager.writeChecksum(baseDirectory, checksum.filename, checksum));
+            if (sumTime) {
+                this.writeTimeElapsed(checksum.algorithm || "sha256", [baseDirectory, files.length + (files.length === 1 ? ' file' : ' files')], sumTime, { ...core_1.Host.LOG_STYLE_WARN });
+            }
         }
     }
     async finalizeCleanup() {
-        if (this.emptyDir.size) {
+        if (this.emptyDir.size > 0) {
             for (const value of Array.from(this.emptyDir).reverse()) {
                 try {
                     fs.rmdirSync(value);
@@ -3731,8 +4212,10 @@ class FileManager extends core_1.Host {
             }
         }
         for (const { instance, constructor } of this.Document) {
-            if (constructor.cleanup && instance.assets.length) {
-                await constructor.cleanup.call(this, instance).catch((err) => rejectModule.call(instance, err, 4));
+            if (constructor.cleanup && instance.assets.length > 0) {
+                await constructor.cleanup.call(this, instance).catch((err) => {
+                    rejectModule(instance, err, 4);
+                });
             }
         }
     }
@@ -3745,17 +4228,11 @@ class FileManager extends core_1.Host {
         }
         const startTime = process.hrtime();
         const filesToRemove = this.filesToRemove;
-        const removeFiles = () => {
-            if (filesToRemove.size) {
-                filesToRemove.forEach(value => this.deleteFile(value, { emptyDir: true }));
-                filesToRemove.clear();
-            }
-        };
         for (const [file, output] of this.filesToCompare) {
             const localUri = file.localUri;
-            let minFile = localUri, minSize = (0, util_1.getSize)(minFile);
+            let minFile = localUri, minSize = (0, util_2.getSize)(minFile);
             for (const other of output) {
-                const size = (0, util_1.getSize)(other);
+                const size = (0, util_2.getSize)(other);
                 if (minSize === 0 || size > 0 && size < minSize) {
                     filesToRemove.add(minFile);
                     minFile = other;
@@ -3769,12 +4246,16 @@ class FileManager extends core_1.Host {
                 this.replace(file, minFile);
             }
         }
-        removeFiles();
-        await this.finalizeCompress(this.assets.filter(item => item.compress && !ignoreAsset(item))).catch((err) => rejectModule.call(this, err, 8));
+        removeFiles(this, filesToRemove);
+        await this.finalizeCompress(this.assets.filter(item => item.compress && !ignoreAsset(item))).catch((err) => {
+            rejectModule(this, err, 8);
+        });
         if (this.aborted) {
             return (0, types_1.createAbortError)(true);
         }
-        await this.finalizeDocument().catch((err) => rejectModule.call(this, err, 4));
+        await this.finalizeDocument().catch((err) => {
+            rejectModule(this, err, 4);
+        });
         if (this.aborted) {
             return (0, types_1.createAbortError)(true);
         }
@@ -3788,62 +4269,62 @@ class FileManager extends core_1.Host {
                 }
             }
         }
-        removeFiles();
-        await this.finalizeTask(this.taskAssets.filter(item => item.tasks?.find(data => !data.preceding) && item.localUri && this.has(item.localUri) && !ignoreAsset(item))).catch((err) => rejectModule.call(this, err, 4));
+        removeFiles(this, filesToRemove);
+        await this.finalizeTask(this.taskAssets.filter(item => item.tasks?.find(data => !data.preceding) && item.localUri && this.has(item.localUri) && !ignoreAsset(item))).catch((err) => {
+            rejectModule(this, err, 4);
+        });
         if (this.aborted) {
             return (0, types_1.createAbortError)(true);
         }
-        removeFiles();
+        removeFiles(this, filesToRemove);
         for (const item of this.assets) {
             if (item.checksumOutput && !ignoreAsset(item)) {
                 const localUri = item.localUri;
-                if (!filesToRemove.has(localUri) && !checkHash.call(this, localUri, true, item.checksumOutput)) {
+                if (!filesToRemove.has(localUri) && !checkHash(this, localUri, true, item.checksumOutput)) {
                     item.invalid = true;
                     filesToRemove.add(localUri);
                     this.writeFail(["Checksum did not match", path.basename(localUri)], (0, types_1.errorValue)(localUri, "Invalid checksum"), { type: 32, startTime, queue: true });
                 }
             }
         }
-        removeFiles();
-        await this.finalizeCloud().catch((err) => rejectModule.call(this, err, 64));
+        removeFiles(this, filesToRemove);
+        await this.finalizeCloud().catch((err) => {
+            rejectModule(this, err, 64);
+        });
         if (this.aborted) {
             return (0, types_1.createAbortError)(true);
         }
-        removeFiles();
+        removeFiles(this, filesToRemove);
         if (this.Compress) {
             const tasks = [];
-            this.assets.forEach(item => item.compress && !ignoreAsset(item, true) && tasks.push(this.compressFile(item, false)));
-            if (tasks.length) {
+            for (const item of this.assets) {
+                if (item.compress && !ignoreAsset(item, true)) {
+                    tasks.push(this.compressFile(item, false));
+                }
+            }
+            if (tasks.length > 0) {
                 await Promise.allSettled(tasks);
             }
         }
-        let checksum = this.config.checksum;
-        if (checksum) {
-            if (typeof checksum === 'boolean' || checksum === 1) {
-                checksum = { recursive: checksum };
-            }
-            else if ((0, types_1.isString)(checksum)) {
-                const items = checksum.split('.');
-                checksum = items.length > 1 ? { algorithm: items[items.length - 1], filename: checksum } : { algorithm: checksum };
-            }
-            if ((0, types_1.isPlainObject)(checksum)) {
-                const baseDirectory = this.baseDirectory;
-                checksum.joinRoot = true;
-                checksum.throwsEmpty = true;
-                const sumTime = LOG_TIMEELAPSED ? process.hrtime() : 0;
-                try {
-                    const files = (await FileManager.writeChecksum(baseDirectory, checksum.filename, checksum));
-                    if (sumTime) {
-                        this.writeTimeElapsed(checksum.algorithm || "sha256", [baseDirectory, files.length + (files.length === 1 ? ' file' : ' files')], sumTime, { ...core_1.Host.LOG_STYLE_WARN });
-                    }
-                }
-                catch (err) {
-                    this.writeFail(["Unable to read directory", path.basename(baseDirectory)], err, { type: 32, startTime });
-                }
-            }
+        await this.finalizeChecksum().catch((err) => {
+            rejectModule(this, err, 32);
+        });
+        await this.finalizeCleanup().catch((err) => {
+            rejectModule(this, err, 1);
+        });
+        removeFiles(this, filesToRemove);
+        this.closeMessage(startTime);
+        this.Watch?.start(this.assets);
+    }
+    close() {
+        this.Request.close();
+    }
+    startMessage() {
+        if (!this.silent) {
+            this.formatMessage(128, 'START', [new Date().toLocaleString(), this.assets.length + ' assets'], this.baseDirectory, { ...core_1.Host.LOG_STYLE_SUCCESS });
         }
-        await this.finalizeCleanup().catch((err) => rejectModule.call(this, err, 1));
-        removeFiles();
+    }
+    closeMessage(startTime) {
         if (LOG_TIMEELAPSED) {
             const [http, disk, cache] = this[kDownloadStats];
             const errorCount = this.errorCount;
@@ -3867,16 +4348,81 @@ class FileManager extends core_1.Host {
                 const bufferCount = Object.keys(MEMORY.CACHE).length;
                 message.push('BUFFER ' + (bufferCount > 1 ? bufferCount + ' / ' : '') + (0, types_1.formatSize)(MEMORY.SIZE));
             }
-            this.writeTimeElapsed('CLOSE', ['No further modifications', message.length ? ` ${message.join(chalk.blackBright(' )( '))} ` : ''], startTime, { ...core_1.Host.LOG_STYLE_WARN });
+            this.writeTimeElapsed('CLOSE', ['No further modifications', message.length > 0 ? message.join(chalk.blackBright(LOGGER.MESSAGE_SEP)) : ''], startTime, { ...core_1.Host.LOG_STYLE_WARN });
         }
-        this.Watch?.start(this.assets);
     }
-    close() {
-        this.Request.close();
+    diffMessage() {
+        const diffSource = this[kDiffSource]?.[1];
+        if (!diffSource) {
+            return;
+        }
+        const output = [];
+        const addHeader = (pathname, summary) => {
+            output.push(chalk.blackBright('-'.repeat(LOGGER.MESSAGE_WIDTH)), ' ' + (summary === 'deleted' ? chalk.yellow(pathname) : pathname), chalk.blackBright('-'.repeat(LOGGER.MESSAGE_WIDTH - summary.length - 1)) + ' ' + chalk.bold(summary));
+        };
+        let divider = false;
+        for (const pathname in diffSource) {
+            if (core_1.Host.isPath(pathname, true)) {
+                const [content, encoding] = diffSource[pathname];
+                const hunks = diff.structuredPatch('', '', checkEOF(content), checkEOF(fs.readFileSync(pathname, encoding)), '', '', { context: 0 }).hunks;
+                const length = hunks.length;
+                if (length === 0) {
+                    continue;
+                }
+                const lastHunk = hunks[length - 1];
+                const oldMax = lastHunk.oldStart + lastHunk.oldLines;
+                const newMax = lastHunk.newStart + lastHunk.newLines;
+                const posLength = Math.max(Math.max(oldMax, newMax).toString().length, Math.min(oldMax, newMax).toString().length);
+                addHeader(pathname, length + ` hunk${length > 1 ? 's' : ''}`);
+                for (const { lines, oldLines, oldStart, newStart, newLines } of hunks) {
+                    for (let i = 0, j = oldStart, k = oldLines, l = 0, q = lines.length, added = false; i < q && k > 0; ++i) {
+                        const line = lines[i].substring(1);
+                        output.push(` ${chalk[!line && k === 1 ? 'grey' : added ? 'green' : 'red']((j + l++).toString().padStart(posLength))} ${chalk[added ? 'green' : 'red'](line)}`);
+                        if (--k === 0 && !added) {
+                            j = newStart;
+                            k = newLines;
+                            l = 0;
+                            added = true;
+                        }
+                    }
+                }
+                divider = true;
+            }
+            else {
+                addHeader(pathname, 'deleted');
+                divider = false;
+            }
+        }
+        if (output.length > 0) {
+            if (divider) {
+                output.push(chalk.blackBright('-'.repeat(LOGGER.MESSAGE_WIDTH)));
+            }
+            output.push('');
+            if (this.broadcastId && core_1.Host.hasLogType(2)) {
+                core_1.Host.formatMessage(2, '', '', output.join('\n'), { broadcastId: this.broadcastId, rawOutput: true });
+            }
+            else {
+                process.stdout.write(output.join('\n'));
+                (0, types_1.setLogCurrent)(null);
+            }
+        }
+    }
+    endMessage(errors) {
+        if (LOG_TIMEELAPSED) {
+            this.writeTimeElapsed('END', this.baseDirectory, this.startTime, errors.length > 0 ? { failed: true, ...core_1.Host.LOG_STYLE_FAIL } : { ...core_1.Host.LOG_STYLE_SUCCESS });
+        }
+    }
+    clearStorage() {
+        if (this[kDiffSource]) {
+            this[kDiffSource][1] = {};
+        }
+        this.contentToAppend.clear();
+        this.contentToReplace.clear();
     }
     resetState() {
         this.finalizeState = 2;
         this._pendingResult = null;
+        this.clearStorage();
     }
     abortFinalize(err) {
         if (!this.restarting) {
@@ -3886,7 +4432,7 @@ class FileManager extends core_1.Host {
         else {
             this.finalizeState = 4;
         }
-        this.emit('end', [], collectErrors.call(this), this.collectLog());
+        this.emit('end', [], collectErrors(this), this.collectLog());
         if (!this.restarting) {
             this.done = true;
         }
@@ -3928,9 +4474,9 @@ class FileManager extends core_1.Host {
                     const start = Math.max(queue.length - available, 0);
                     const items = queue.slice(start);
                     queue.splice(queue.length - items.length);
-                    items.forEach(params => {
-                        this.scheduleTask(...params);
-                    });
+                    for (const params of items) {
+                        void this.scheduleTask(...params);
+                    }
                 }
             }
         }
@@ -3942,5 +4488,5 @@ class FileManager extends core_1.Host {
         return Array.from(this.modules).reduce((a, b) => a + b.errors.length, this.errors.length);
     }
 }
-
+setLogMinWidth();
 module.exports = FileManager;