@e-mc/core 0.11.8 → 0.12.0

package/index.js

@@ -1,24 +1,20 @@
 "use strict";
-var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-exports.Module = exports.Permission = exports.AbortComponent = exports.ClientDb = exports.Client = exports.Host = void 0;
+var _a;
+exports.Module = exports.Permission = exports.AbortComponent = exports.WorkerChannel = exports.WorkerGroup = exports.ClientDb = exports.Client = exports.Host = void 0;
 const path = require("node:path");
 const fs = require("node:fs");
+const os = require("node:os");
 const pm = require("picomatch");
 const ipaddr = require("ipaddr.js");
+const EventEmitter = require("node:events");
+const node_worker_threads_1 = require("node:worker_threads");
+const node_url_1 = require("node:url");
 const types_1 = require("@e-mc/types");
 const module_1 = require("@e-mc/module");
 exports.Module = module_1;
-const kConfig = Symbol('config');
-const kQueued = Symbol('queued');
-const kAbortHandler = Symbol('abortHandler');
-const kFreeze = Symbol('freeze');
-const kDone = Symbol('done');
-const kLogState = Symbol('logState');
-const kCacheDir = Symbol('cacheDir');
-const kDiskRead = Symbol('diskRead');
-const kDiskWrite = Symbol('diskWrite');
-const kUncRead = Symbol('uncRead');
-const kUncWrite = Symbol('uncWrite');
+const kHost = Symbol.for('host:constructor');
+const kClient = Symbol.for('client:constructor');
+const kClientDb = Symbol.for('clientdb:constructor');
 const CACHE_USER = {};
 const CACHE_SOURCE = {};
 const CACHE_SESSION = Object.create(null);
@@ -33,9 +29,7 @@ const HOST = {
     QUEUED: 0,
     REJECTED: 0,
     KILLED: 0,
-    CIPHER_ALGORITHM: undefined,
-    CIPHER_KEY: undefined,
-    CIPHER_IV: undefined,
+    CIPHER: null,
     ADMIN_USERS: [],
     ADMIN_PRIVATE: false,
     THREAD_LIMIT: Infinity,
@@ -48,10 +42,20 @@ const HOST = {
     LOG_PROGRESS_QUEUE: new WeakSet(),
     LOG_PROGRESS_PAUSED: new Set()
 };
-const HOST_USERNAME = new WeakMap();
+const WORKER_GROUP = {
+    MAX: (0, types_1.supported)(19, 4) || (0, types_1.supported)(18, 14, true) ? os.availableParallelism() : os.cpus().length,
+    TIMEOUT: Infinity,
+    LOCKED: true
+};
+const WORKER_CHANNEL = {
+    MIN: 0,
+    MAX: Math.max(WORKER_GROUP.MAX / 2, 2),
+    TIMEOUT: 300 * 1000,
+    VERBOSE: true
+};
 let STORE_RESULT_COUNT = 0;
 let PICOMATCH_OPTIONS = { nocase: module_1.PLATFORM_WIN32 };
-let MINIMATCH_OPTIONS = { nocase: module_1.PLATFORM_WIN32, matchBase: true };
+let MINIMATCH_OPTIONS = {};
 let MINIMATCH;
 let PERMISSION;
 function closeHostThread(host) {
@@ -70,7 +74,7 @@ function closeHostThread(host) {
     }
     if (HOST.QUEUE.length > 0 && HOST.DONE.size < HOST.THREAD_LIMIT) {
         const queue = HOST.QUEUE.shift();
-        addHostThread(queue.instance);
+        HOST.DONE.set(queue.instance, HOST.PID++);
         resumeHostQueue(queue);
         HOST.QUEUE.forEach((item, index) => {
             notifyHostQueue(item.instance, index, item.priority, true);
@@ -104,10 +108,6 @@ function resumeHostLog(host) {
         }
     }
 }
-function addHostThread(host) {
-    HOST.DONE.set(host, HOST.PID++);
-    host[kQueued] = false;
-}
 function notifyHostQueue(host, position, priority, broadcast) {
     if (!broadcast || host.broadcastId) {
         host.formatMessage(2, 'QUEUE', ["Thread limit exceeded" + ` (position #${position + 1})`, host.username], 'Priority: ' + priority, { type: 2, ...module_1.LOG_STYLE_WARN });
@@ -156,27 +156,8 @@ function resumeHostQueue(item, aborted) {
         }
     });
 }
-function encryptUsername(data, iv) {
-    return HOST.CIPHER_ALGORITHM && HOST.CIPHER_KEY && (0, types_1.isString)(data) && (0, types_1.encryptUTF8)(HOST.CIPHER_ALGORITHM, HOST.CIPHER_KEY, iv, data) || '';
-}
-function matchPermission(permission, pathname) {
-    const { enabled, value } = permission;
-    return enabled === true && (0, types_1.isString)(pathname) && (value === '**/*' || value === '**' || Permission.match(pathname, value));
-}
-function setPermission(name, pathname, enabled) {
-    if (typeof enabled === 'boolean' && (!this[kFreeze] || this[name].enabled === null) && (!enabled || (pathname = Permission.toPosix(pathname)))) {
-        if (enabled && Array.isArray(pathname)) {
-            switch (pathname.length) {
-                case 1:
-                    pathname = pathname[0];
-                    break;
-                case 0:
-                    enabled = false;
-                    break;
-            }
-        }
-        this[name] = Object.freeze({ enabled, value: enabled ? Object.freeze(pathname) : '' });
-    }
+function encryptText(data, iv) {
+    return HOST.CIPHER && (0, types_1.isString)(data) && (0, types_1.encryptUTF8)(HOST.CIPHER.algorithm, HOST.CIPHER.key, iv, data) || '';
 }
 function clearSourceResult(data) {
     const result = data[1];
@@ -246,25 +227,24 @@ function asPosix(value) {
     return path.normalize(value);
 }
 function parseIp(value, kind) {
-    if (!value) {
-        return '';
-    }
-    try {
-        let ip = ipaddr.parse(value);
-        if (ip.kind() === 'ipv4') {
-            if (kind === 6) {
-                ip = ip.toIPv4MappedAddress();
+    if (value) {
+        try {
+            let ip = ipaddr.parse(value);
+            if (ip.kind() === 'ipv4') {
+                if (kind === 6) {
+                    ip = ip.toIPv4MappedAddress();
+                }
             }
-        }
-        else if (kind === 4) {
-            if (!ip.isIPv4MappedAddress()) {
-                return '';
+            else if (kind === 4) {
+                if (!ip.isIPv4MappedAddress()) {
+                    return '';
+                }
+                ip = ip.toIPv4Address();
             }
-            ip = ip.toIPv4Address();
+            return ip.toNormalizedString();
+        }
+        catch {
         }
-        return ip.toNormalizedString();
-    }
-    catch {
     }
     return '';
 }
@@ -272,6 +252,7 @@ const readable = (value) => (0, types_1.isString)(value) || (0, types_1.isArray)
 const expireTime = (value) => Date.now() + value * 1000;
 const convertSeconds = (value) => typeof value === 'string' && Math.ceil((0, types_1.parseTime)(value) / 1000) || 0;
 class Host extends module_1 {
+    static [kHost] = true;
     static async purgeMemory(percent = 1, limit = 0, parent) {
         return parent ? super.purgeMemory(percent, limit) : 0;
     }
@@ -304,76 +285,101 @@ class Host extends module_1 {
             if (perm.settings) {
                 const { picomatch: pico, minimatch: mini } = perm.settings;
                 if ((0, types_1.isPlainObject)(pico)) {
-                    PICOMATCH_OPTIONS = { nocase: module_1.PLATFORM_WIN32, matchBase: true, ...pico };
+                    PICOMATCH_OPTIONS = { nocase: module_1.PLATFORM_WIN32, ...pico };
                 }
                 if ((0, types_1.isPlainObject)(mini)) {
                     try {
-                        const pkg = require('minimatch');
-                        MINIMATCH = 'minimatch' in pkg ? pkg.minimatch : pkg;
-                        MINIMATCH_OPTIONS = { nocase: module_1.PLATFORM_WIN32, matchBase: true, ...mini };
+                        const { minimatch } = require('minimatch');
+                        MINIMATCH = minimatch;
+                        MINIMATCH_OPTIONS = { nocase: module_1.PLATFORM_WIN32, ...mini };
                     }
                     catch {
                     }
                 }
             }
         }
-        if (proc?.thread) {
-            const { queue, admin } = proc.thread;
-            {
-                let { limit, expires } = proc.thread;
-                if (limit && (limit = Math.floor(+limit)) > 0) {
-                    HOST.THREAD_LIMIT = limit;
-                }
-                if (expires && (expires = (0, types_1.parseTime)(expires)) > 0) {
-                    HOST.THREAD_EXPIRES = expires;
-                }
+        if (proc) {
+            const { cipher, thread } = proc;
+            if (cipher?.iv && cipher.key) {
+                HOST.CIPHER = Object.freeze({ algorithm: cipher.algorithm || 'aes-256-gcm', key: cipher.key, iv: cipher.iv });
             }
-            if (queue) {
-                let { limit, expires, priority } = queue;
-                if (limit !== undefined && (limit = Math.floor(+limit)) >= -1) {
-                    HOST.QUEUE_LIMIT = limit >= 0 ? limit : Infinity;
-                }
-                if (expires && (expires = (0, types_1.parseTime)(expires)) > 0) {
-                    HOST.QUEUE_EXPIRES = expires;
-                }
-                if (priority) {
-                    let { min = -1, max = 0, bypass } = priority;
-                    if ((min = Math.floor(+min)) >= 0) {
-                        HOST.PRIORITY_MIN = min;
-                    }
-                    if ((max = Math.floor(+max)) > 0) {
-                        HOST.PRIORITY_MAX = max;
+            if (thread) {
+                const { queue, admin, worker } = thread;
+                {
+                    let { limit, expires } = thread;
+                    if (limit && (limit = Math.floor(+limit)) > 0) {
+                        HOST.THREAD_LIMIT = limit;
                     }
-                    if (HOST.PRIORITY_MAX < HOST.PRIORITY_MIN) {
-                        HOST.PRIORITY_MAX = HOST.PRIORITY_MIN + 1;
+                    if (expires && (expires = (0, types_1.parseTime)(expires)) > 0) {
+                        HOST.THREAD_EXPIRES = expires;
                     }
-                    if (bypass !== undefined && (bypass = Math.floor(+bypass)) && (bypass < HOST.PRIORITY_MIN || bypass > HOST.PRIORITY_MAX)) {
-                        HOST.PRIORITY_BYPASS = bypass;
+                }
+                if (queue) {
+                    let { limit, expires, priority } = queue;
+                    if (limit !== undefined && (limit = Math.floor(+limit)) >= -1) {
+                        HOST.QUEUE_LIMIT = limit >= 0 ? limit : Infinity;
                     }
-                    else {
-                        bypass = HOST.PRIORITY_BYPASS;
+                    if (expires && (expires = (0, types_1.parseTime)(expires)) > 0) {
+                        HOST.QUEUE_EXPIRES = expires;
                     }
-                    if (bypass !== undefined && bypass >= HOST.PRIORITY_MIN && bypass <= HOST.PRIORITY_MAX) {
-                        HOST.PRIORITY_BYPASS = undefined;
+                    if (priority) {
+                        let { min = -1, max = 0, bypass } = priority;
+                        if ((min = Math.floor(+min)) >= 0) {
+                            HOST.PRIORITY_MIN = min;
+                        }
+                        if ((max = Math.floor(+max)) > 0) {
+                            HOST.PRIORITY_MAX = max;
+                        }
+                        if (HOST.PRIORITY_MAX < HOST.PRIORITY_MIN) {
+                            HOST.PRIORITY_MAX = HOST.PRIORITY_MIN + 1;
+                        }
+                        if (bypass !== undefined && (bypass = Math.floor(+bypass)) && (bypass < HOST.PRIORITY_MIN || bypass > HOST.PRIORITY_MAX)) {
+                            HOST.PRIORITY_BYPASS = bypass;
+                        }
+                        else {
+                            bypass = HOST.PRIORITY_BYPASS;
+                        }
+                        if (bypass !== undefined && bypass >= HOST.PRIORITY_MIN && bypass <= HOST.PRIORITY_MAX) {
+                            HOST.PRIORITY_BYPASS = undefined;
+                        }
                     }
                 }
-            }
-            if (admin) {
-                const cipher = proc.cipher;
-                if ((0, types_1.isArray)(admin.users) && (0, types_1.isPlainObject)(cipher) && (HOST.CIPHER_KEY = cipher.key) && (HOST.CIPHER_IV = cipher.iv)) {
-                    const algorithm = cipher.algorithm || 'aes-256-gcm';
-                    HOST.ADMIN_USERS = admin.users.map(value => (0, types_1.encryptUTF8)(algorithm, HOST.CIPHER_KEY, HOST.CIPHER_IV, value)).filter(value => value);
-                    if (HOST.ADMIN_USERS.length > 0) {
-                        HOST.CIPHER_ALGORITHM = algorithm;
+                if (admin) {
+                    if (HOST.CIPHER && (0, types_1.isArray)(admin.users)) {
+                        const { algorithm, key, iv } = HOST.CIPHER;
+                        HOST.ADMIN_USERS = admin.users.map(value => (0, types_1.encryptUTF8)(algorithm, key, iv, value)).filter(value => value);
                     }
-                    else {
-                        HOST.CIPHER_ALGORITHM = null;
-                        HOST.CIPHER_KEY = null;
-                        HOST.CIPHER_IV = null;
+                    if (typeof admin.private === 'boolean') {
+                        HOST.ADMIN_PRIVATE = admin.private;
                     }
                 }
-                if (typeof admin.private === 'boolean') {
-                    HOST.ADMIN_PRIVATE = admin.private;
+                if (worker) {
+                    let { max = 0, locked, max_expires, channel } = worker;
+                    if ((max = Math.floor(+max)) > 1) {
+                        WORKER_GROUP.MAX = max;
+                    }
+                    if (max_expires && (max_expires = (0, types_1.parseExpires)(max_expires)) > 0) {
+                        WORKER_GROUP.TIMEOUT = WorkerGroup.checkTimeout(max_expires, false);
+                    }
+                    if (typeof locked === 'boolean') {
+                        WORKER_GROUP.LOCKED = locked;
+                    }
+                    if (channel) {
+                        let { min: a = -1, max: b = 0, expires, verbose } = channel;
+                        if ((a = Math.floor(+a)) >= 0) {
+                            WORKER_CHANNEL.MIN = a;
+                        }
+                        if ((b = Math.floor(+b)) >= 0) {
+                            WORKER_CHANNEL.MAX = b;
+                            WORKER_CHANNEL.MIN = Math.min(WORKER_CHANNEL.MIN, b);
+                        }
+                        if (expires && (expires = (0, types_1.parseExpires)(expires)) > 0) {
+                            WORKER_CHANNEL.TIMEOUT = WorkerGroup.checkTimeout(expires, false);
+                        }
+                        if (typeof verbose === 'boolean') {
+                            WORKER_CHANNEL.VERBOSE = verbose;
+                        }
+                    }
                 }
             }
         }
@@ -390,11 +396,15 @@ class Host extends module_1 {
         return permission;
     }
     static isPermission(value) {
-        return value instanceof Permission || (0, types_1.isObject)(value) && !!value[kDiskRead] && !!value[kDiskWrite];
+        return value instanceof Permission || (0, types_1.isObject)(value) && typeof value.diskRead === 'boolean' && typeof value.diskWrite === 'boolean';
     }
     static kill(username, iv, pid) {
+        if (typeof iv === 'boolean' || typeof iv === 'number' || Array.isArray(iv)) {
+            pid = iv;
+            iv = false;
+        }
         let result = 0;
-        if (HOST.ADMIN_USERS.includes(encryptUsername(username, iv))) {
+        if (HOST.ADMIN_USERS.includes(username) || iv && HOST.ADMIN_USERS.includes(encryptText(username, iv))) {
             for (const [host, id] of HOST.DONE) {
                 if (pid === true || id === pid || Array.isArray(pid) && pid.includes(id)) {
                     cancelHostThread(host, 'pid: ' + id.toString());
@@ -413,7 +423,7 @@ class Host extends module_1 {
                 username = undefined;
                 break;
             case 'string':
-                if (!iv || !HOST.ADMIN_USERS.includes(encryptUsername(username, iv))) {
+                if (!(HOST.ADMIN_USERS.includes(username) || iv && HOST.ADMIN_USERS.includes(encryptText(username, iv)))) {
                     username = undefined;
                 }
                 full = true;
@@ -479,27 +489,29 @@ class Host extends module_1 {
     static getPermissionFromSettings() {
         return PERMISSION;
     }
+    restartable = true;
+    modules = new Set();
+    subProcesses = new Set();
+    startTime = Date.now();
+    _threadable = true;
+    _logExclude = false;
+    _logLevel = 0;
+    _logDelayed = null;
+    _usingObjects = new Set();
+    #done = false;
+    #logState = 1;
+    #username = '';
+    #config;
     constructor(config = {}) {
         super();
-        this.restartable = true;
-        this.modules = new Set();
-        this.subProcesses = new Set();
-        this.startTime = Date.now();
-        this._threadable = true;
-        this._logExclude = false;
-        this._logLevel = 0;
-        this._logDelayed = null;
-        this._usingObjects = new Set();
-        this[_a] = false;
-        this[_b] = false;
-        this[_c] = 1;
-        const { broadcastId, log, username, priority } = config;
-        if ((0, types_1.isString)(username)) {
-            HOST_USERNAME.set(this, username);
-        }
-        if (broadcastId) {
-            this.broadcastId = broadcastId;
+        if ((0, types_1.isString)(config.username)) {
+            const cipher = HOST.CIPHER;
+            this.#username = cipher ? (0, types_1.decryptUTF8)(cipher.algorithm, cipher.key, cipher.iv, config.username) || '' : config.username;
+        }
+        if (config.broadcastId) {
+            this.broadcastId = config.broadcastId;
         }
+        const { log, priority } = config;
         let showProgress;
         if ((0, types_1.isPlainObject)(log)) {
             const { enabled, level, exclude, useColor, silent } = log;
@@ -523,7 +535,7 @@ class Host extends module_1 {
         else if (log !== undefined) {
             this.ignoreLog(typeof log === 'boolean' ? !log : log);
         }
-        this[kConfig] = Object.freeze({ ...config });
+        this.#config = Object.freeze({ ...config });
         if (HOST.DONE.size < HOST.THREAD_LIMIT || this.username && typeof priority === 'number' && priority === HOST.PRIORITY_BYPASS) {
             HOST.DONE.set(this, HOST.PID++);
             if (HOST.LOG_PROGRESS) {
@@ -535,7 +547,6 @@ class Host extends module_1 {
             }
         }
         else if (typeof priority === 'number' && priority >= HOST.PRIORITY_MIN && priority <= HOST.PRIORITY_MAX && HOST.QUEUE.length < HOST.QUEUE_LIMIT && typeof this.resumeThread === 'function') {
-            this[kQueued] = true;
             addHostQueue({ instance: this, priority, startTime: Date.now() });
             notifyHostQueue(this, HOST.QUEUE.findIndex(item => item.instance === this), priority);
         }
@@ -546,8 +557,11 @@ class Host extends module_1 {
     restart(...args) { }
     updateProgress(name, ...args) { }
     isFatal(err) {
-        const fatal = this.config.error?.fatal;
-        return fatal ?? super.isFatal(err);
+        if (err instanceof Error) {
+            const fatal = this.config.error?.fatal;
+            return fatal ?? super.isFatal(err);
+        }
+        return false;
     }
     using(...items) {
         const data = this._usingObjects;
@@ -655,11 +669,11 @@ class Host extends module_1 {
             this._logDelayed ||= [];
             HOST.LOG_PROGRESS_PAUSED.add(this);
         }
-        this[kLogState] = 0;
+        this.#logState = 0;
     }
     resumeLog(type) {
         if (!type || this.hasLog(type) || type === 'progress' && !HOST.LOG_PROGRESS) {
-            this[kLogState] = 1;
+            this.#logState = 1;
             const log = this._logDelayed;
             if (log?.length) {
                 const trailing = {};
@@ -723,7 +737,6 @@ class Host extends module_1 {
             }
             if (reject) {
                 HOST.QUEUE.splice(index, 1);
-                addHostThread(this);
                 return false;
             }
             if (Array.isArray(args)) {
@@ -742,10 +755,10 @@ class Host extends module_1 {
         return null;
     }
     get config() {
-        return this[kConfig];
+        return this.#config;
     }
     get username() {
-        return HOST_USERNAME.get(this) || '';
+        return this.#username;
     }
     get ipV4() {
         return parseIp(this.config.remoteIp, 4);
@@ -755,33 +768,34 @@ class Host extends module_1 {
     }
     set done(value) {
         if (value) {
-            this[kDone] = true;
+            this.#done = true;
             closeHostThread(this);
         }
     }
     get done() {
-        return this[kDone] || this.aborted;
+        return this.#done || this.aborted;
     }
     get queued() {
-        return this[kQueued];
+        return !!HOST.QUEUE.find(item => item.instance === this);
     }
     get logState() {
-        return this[kLogState];
+        return this.#logState;
     }
     get errorCount() {
         return Array.from(this.modules).reduce((a, b) => a + b.errors.length, this.errors.length);
     }
 }
 exports.Host = Host;
-_a = kDone, _b = kQueued, _c = kLogState;
 class Client extends module_1 {
+    static [kClient] = true;
     static async purgeMemory(percent = 1, limit = 0, parent) {
         return parent ? super.purgeMemory(percent, limit) : 0;
     }
+    module;
+    _extensions = null;
+    #cacheDir = '';
     constructor(data) {
         super();
-        this._extensions = null;
-        this[_d] = '';
         this.module = (0, types_1.isPlainObject)(data) ? data : {};
     }
     init(...args) {
@@ -827,11 +841,11 @@ class Client extends module_1 {
     }
     set cacheDir(value) {
         if (path.isAbsolute(value) && module_1.isDir(value)) {
-            this[kCacheDir] = value;
+            this.#cacheDir = value;
         }
     }
     get cacheDir() {
-        return this[kCacheDir];
+        return this.#cacheDir;
     }
     get settings() {
         return (this.module.settings ||= {});
@@ -846,8 +860,11 @@ class Client extends module_1 {
     }
 }
 exports.Client = Client;
-_d = kCacheDir;
 class ClientDb extends Client {
+    database;
+    static [kClientDb] = true;
+    static STORE_RESULT_PARTITION_SIZE = 16;
+    static STORE_RESULT_PARTITION_MULT = 2;
     static get TRANSACTION_ACTIVE() {
         return 1;
     }
@@ -880,8 +897,9 @@ class ClientDb extends Client {
                         if ((0, types_1.isPlainObject)(item) && 'enabled' in item) {
                             const key = name + '_' + source;
                             const stored = CACHE_SOURCE[key];
-                            let { enabled, percent = 0, limit = 0, min = 0, max = 0 } = item;
+                            const { enabled, limit = 0, min = 0, max = 0 } = item;
                             if (enabled && limit > 0) {
+                                let percent = item.percent || 0;
                                 if ((0, types_1.isString)(percent)) {
                                     percent = percent.includes('%') ? parseFloat(percent) / 100 : parseFloat(percent);
                                 }
@@ -939,7 +957,7 @@ class ClientDb extends Client {
         return result > 0 ? result : 0;
     }
     static findResult(source, credential, queryString, timeout, sessionKey, renewCache) {
-        const userKey = this.extractUUID(credential) || (0, types_1.hashKey)(this.asString(credential));
+        const userKey = credential ? this.extractUUID(credential) || (0, types_1.hashKey)(this.asString(credential)) : undefined;
         if (!userKey) {
             return;
         }
@@ -968,7 +986,7 @@ class ClientDb extends Client {
                         return result;
                     }
                     try {
-                        return JSON.parse(fs.readFileSync(result, 'utf-8'));
+                        return JSON.parse(fs.readFileSync(result, 'utf8'));
                     }
                     catch {
                     }
@@ -983,6 +1001,9 @@ class ClientDb extends Client {
         }
     }
     static storeResult(source, credential, queryString, result, options, sessionKey, sessionExpires) {
+        if (!credential) {
+            return result;
+        }
         let cache, cacheDir;
         if ((0, types_1.isObject)(sessionKey)) {
             ({ cacheDir, sessionKey, sessionExpires } = sessionKey);
@@ -1115,10 +1136,10 @@ class ClientDb extends Client {
         }
         return source + '_' + (result || this.asString(credential, true));
     }
+    cacheExpires = 600000;
     constructor(data, database = []) {
         super(data);
         this.database = database;
-        this.cacheExpires = 600000;
     }
     init(config) {
         let { cache_dir, session_expires: expires } = this.settings;
@@ -1167,6 +1188,9 @@ class ClientDb extends Client {
         return this.settingsOf(source, 'coerce', component) === true || component === 'options' && this.settingsOf(source, 'coerce') === true;
     }
     getQueryResult(source, credential, queryString, options, renewCache) {
+        if (!credential) {
+            return;
+        }
         let sessionKey, value, exclusiveOf;
         switch (typeof options) {
             case 'boolean':
@@ -1205,12 +1229,12 @@ class ClientDb extends Client {
         if (!Array.isArray(result)) {
             result = result === undefined ? [] : [result];
         }
-        if (!(0, types_1.isString)(queryString)) {
+        if (!credential || !(0, types_1.isString)(queryString)) {
             return result;
         }
         const uuidKey = ClientDb.extractUUID(credential);
         let options;
-        if (ClientDb.enabled("memory.settings.users", this.host?.username)) {
+        if (this.hasPermission('memory')) {
             let value, exclusiveOf;
             if ((0, types_1.isObject)(sessionKey)) {
                 ({ value, sessionKey, exclusiveOf } = sessionKey);
@@ -1291,12 +1315,473 @@ class ClientDb extends Client {
     }
 }
 exports.ClientDb = ClientDb;
-ClientDb.STORE_RESULT_PARTITION_SIZE = 16;
-ClientDb.STORE_RESULT_PARTITION_MULT = 2;
-class AbortComponent {
-    constructor() {
-        this[_e] = new AbortController();
+class WorkerGroup {
+    static checkTimeout(value, active = true) {
+        if (value === Infinity && WORKER_GROUP.TIMEOUT === Infinity) {
+            return active ? module_1.MAX_TIMEOUT : Infinity;
+        }
+        return Math.min(value, WORKER_GROUP.TIMEOUT, module_1.MAX_TIMEOUT);
+    }
+    #max = WORKER_GROUP.MAX;
+    #map = new Map();
+    #workers = [];
+    #locked = WORKER_GROUP.LOCKED;
+    constructor(max = 0, locked) {
+        this.#max = max;
+        if (typeof locked === 'boolean') {
+            this.#locked = locked;
+        }
+    }
+    *[Symbol.iterator]() {
+        for (const worker of this.workers) {
+            yield worker;
+        }
+    }
+    add(name, item, priority = 0) {
+        this.#workers.push([item, Math.max(0, Math.min(100, priority))]);
+        this.#map.set(name, item);
+        if (this.#locked) {
+            item.lock();
+        }
+        item.join(this, name);
+        return this;
+    }
+    delete(name) {
+        let target;
+        if (typeof name === 'string') {
+            target = this.#map.get(name);
+        }
+        else {
+            target = name;
+            name = '';
+            for (const [key, item] of this.#map) {
+                if (item === target) {
+                    name = key;
+                    break;
+                }
+            }
+        }
+        if (name && target) {
+            const index = this.#workers.findIndex(item => item[0] === target);
+            if (index !== -1) {
+                this.#workers.splice(index, 1);
+                this.#map.delete(name);
+                return true;
+            }
+        }
+        return false;
+    }
+    get(name, force = true) {
+        const result = this.#map.get(name);
+        if (result && (this.free(typeof force === 'number' ? force : 1) !== 0 || force === true || result.detached)) {
+            return result;
+        }
+    }
+    free(count = 1) {
+        if (count > 0 && this.sizeOf + count > this.max) {
+            const items = this.#workers.filter(([item]) => !item.detached && item.available > 0);
+            let result = 0;
+            if (items.length > 0) {
+                items.sort((a, b) => {
+                    const p = a[1] - b[1];
+                    if (p === 0) {
+                        const t = Math.trunc(a[0].lastAccessed.getTime() / 1000000) - Math.trunc(b[0].lastAccessed.getTime() / 1000000);
+                        if (t === 0) {
+                            return a[0].frequencyAccessed - b[0].frequencyAccessed;
+                        }
+                        return t;
+                    }
+                    return p;
+                });
+                let j = 1;
+                do {
+                    for (let i = 0; i < items.length; ++i) {
+                        const worker = items[i][0];
+                        const k = worker.drop(1);
+                        result += k;
+                        count -= k;
+                        if (count === 0) {
+                            break;
+                        }
+                        if (j >= worker.available) {
+                            items.splice(i--, 1);
+                        }
+                    }
+                } while (items.length > 0 && ++j);
+            }
+            return result;
+        }
+        return -1;
+    }
+    print(format) {
+        let rows;
+        switch (format) {
+            case 'stats':
+                rows = this.#workers.map(([item, priority]) => ({ Last_Accessed: item.lastAccessed.toISOString().replace('T', ' ').replace(/\.\d+Z$/, ''), Times: item.timesAccessed, Frequency: item.frequencyAccessed, Pending: item.pending, Available: item.available, Errors: item.errors.length, Priority: priority }));
+                break;
+            case 'errors':
+                rows = this.errors;
+                break;
+            default:
+                return;
+        }
+        if (rows.length > 0) {
+            console.table(rows);
+        }
+    }
+    clear() {
+        this.#map.clear();
+        this.#workers.length = 0;
+    }
+    #collectTotal(key) {
+        return this.#workers.reduce((a, b) => a + b[0][key], 0);
+    }
+    set max(value) {
+        if (value > 1) {
+            this.#max = value;
+        }
+    }
+    get max() {
+        return this.#max;
+    }
+    get workers() {
+        return this.#workers.map(item => item[0]);
+    }
+    get pending() {
+        return this.#collectTotal('pending');
+    }
+    get available() {
+        return this.#collectTotal('available');
+    }
+    get errors() {
+        return this.#workers.map(item => item[0].errors).flat().sort((a, b) => a.timeStamp <= b.timeStamp ? -1 : 1);
+    }
+    get size() {
+        return this.#collectTotal('size');
+    }
+    get sizeOf() {
+        return this.#workers.length;
+    }
+}
+exports.WorkerGroup = WorkerGroup;
+class WorkerChannel extends EventEmitter {
+    static create(filename, options, name) {
+        if (typeof options === 'string') {
+            name = options;
+            options = undefined;
+        }
+        let min, max, timeout;
+        if (name) {
+            name = name.replace(/\W+/, '_').toUpperCase() + '_WORKER_';
+            min = process.env[name + 'MIN'];
+            max = process.env[name + 'MAX'];
+            timeout = process.env[name + 'TIMEOUT'];
+        }
+        const result = new WorkerChannel(filename, options, { max: max ? parseInt(max) : undefined, idleTimeout: timeout ? parseInt(timeout) * 1000 : undefined });
+        if (min) {
+            result.min = parseInt(min);
+        }
+        return result;
     }
+    static hasPermission(options) {
+        if ((!options || options.worker) && (!process.permission || process.permission.has('worker'))) {
+            return true;
+        }
+        return false;
+    }
+    #min = WORKER_CHANNEL.MIN;
+    #max = WORKER_CHANNEL.MAX;
+    #idleTimeout = WORKER_CHANNEL.TIMEOUT;
+    #locked = false;
+    #host = null;
+    #label = undefined;
+    #verbose = WORKER_CHANNEL.VERBOSE;
+    #startTime = process.hrtime.bigint();
+    #accessed = [new Date(), 0];
+    #errors = [];
+    #workerData = null;
+    #filename;
+    #options;
+    #workers = [];
+    #pending = new Set();
+    #timeout = new WeakMap();
+    constructor(filename, options = {}, { max = -1, idleTimeout = 0, verbose } = {}) {
+        super();
+        this.#filename = filename instanceof URL ? (0, node_url_1.fileURLToPath)(filename) : options.eval ? filename : path.resolve(filename);
+        if ('workerData' in options) {
+            this.#workerData = options.workerData;
+            options = { ...options };
+            delete options.workerData;
+        }
+        this.#options = Object.freeze(options);
+        this.max = max;
+        this.idleTimeout = idleTimeout;
+        if (typeof verbose === 'boolean') {
+            this.#verbose = verbose;
+        }
+    }
+    *[Symbol.iterator]() {
+        for (const worker of this.workers) {
+            yield worker;
+        }
+    }
+    sendObject(data, transferList, callback, ...returnArgs) {
+        if (!this.detached && this.pending >= this.max) {
+            this.emit('pass', data, transferList);
+            throw Error("Worker queue is full");
+        }
+        const available = this.#workers.find(item => !this.#pending.has(item[0]));
+        let worker, channel;
+        if (available) {
+            [worker, channel] = available;
+            this.#clearTimeout(worker);
+        }
+        else {
+            channel = new node_worker_threads_1.MessageChannel();
+            const options = { ...this.#options, transferList: [channel.port1] };
+            options.workerData = [channel.port1, this.#workerData];
+            worker = new node_worker_threads_1.Worker(this.filename, options);
+            worker
+                .on('exit', exitCode => {
+                const index = this.#findIndex(worker);
+                if (index !== -1) {
+                    this.#workers.splice(index, 1);
+                }
+                this.#clear(worker);
+                this.emit('exit', exitCode);
+            })
+                .on('online', () => {
+                this.emit('online');
+            })
+                .on('message', value => {
+                this.emit('message', value);
+            })
+                .on('messageerror', err => {
+                this.addLog(err);
+                this.emit('messageerror', err);
+            })
+                .on('error', err => {
+                this.addLog(err);
+                this.emit('error', err);
+            });
+            channel.port2.on('close', () => {
+                void worker.terminate();
+            });
+            this.#workers.push([worker, channel]);
+        }
+        this.#pending.add(worker);
+        channel.port2.once('message', (value) => {
+            if (this.detached || this.max > this.size) {
+                void worker.terminate();
+            }
+            else if (this.#clear(worker) && this.size > this.min && this.idleTimeout < Infinity) {
+                this.#timeout.set(worker, setTimeout(() => {
+                    void worker.terminate();
+                }, this.idleTimeout));
+            }
+            if (value != null) {
+                this.emit('data', value);
+            }
+            if (typeof callback === 'function') {
+                callback(value, ...returnArgs);
+            }
+        });
+        this.#accessed[0] = new Date();
+        this.#accessed[1]++;
+        try {
+            worker.postMessage(data, transferList);
+            return worker;
+        }
+        catch (err) {
+            this.#clear(worker);
+            this.addLog(err);
+            this.emit('abort', err);
+            throw err;
+        }
+    }
+    sendBuffer(data, shared = true, callback, ...returnArgs) {
+        try {
+            return this.sendObject(data, shared ? [] : [data.buffer], callback, ...returnArgs);
+        }
+        catch (err) {
+            this.addLog(err);
+            return null;
+        }
+    }
+    async send(data, transferList) {
+        return new Promise((resolve, reject) => {
+            try {
+                this.sendObject(data, transferList, resolve);
+            }
+            catch (err) {
+                this.addLog(err);
+                reject(err);
+            }
+        });
+    }
+    drop(count = 1) {
+        if (!(count > 0) || this.available === 0) {
+            return 0;
+        }
+        const found = [];
+        for (const worker of this.workers) {
+            if (!this.#pending.has(worker)) {
+                found.push(worker);
+                if (--count === 0) {
+                    break;
+                }
+            }
+        }
+        process.nextTick(() => {
+            for (const worker of found) {
+                try {
+                    void worker.terminate();
+                }
+                catch (err) {
+                    this.addLog(err);
+                }
+            }
+        });
+        return found.length;
+    }
+    join(group, label) {
+        this.#host?.delete(this);
+        this.#host = group;
+        this.#label = label;
+    }
+    quit() {
+        this.#host = null;
+        this.#label = undefined;
+    }
+    async kill(count = 1) {
+        if (!(count > 0) || this.available === 0) {
+            return 0;
+        }
+        let result = 0;
+        for (const worker of Array.from(this.#pending)) {
+            try {
+                await worker.terminate();
+                ++result;
+                if (--count === 0) {
+                    break;
+                }
+            }
+            catch (err) {
+                this.addLog(err);
+            }
+        }
+        return result;
+    }
+    lock() {
+        this.#locked = true;
+    }
+    addLog(err, type = types_1.STATUS_TYPE.ERROR) {
+        if (this.#errors.find(item => item.value === err)) {
+            return;
+        }
+        if (this.#verbose) {
+            console.error(err);
+        }
+        this.#errors.push({ timeStamp: new Date(), type, label: this.#label, value: err });
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    #clear(worker) {
+        this.#clearTimeout(worker);
+        this.#findChannel(worker)?.port2.removeAllListeners('message');
+        return this.#pending.delete(worker);
+    }
+    #clearTimeout(worker) {
+        const timeout = this.#timeout.get(worker);
+        if (timeout) {
+            clearTimeout(timeout);
+            this.#timeout.delete(worker);
+        }
+    }
+    #findIndex(worker) {
+        return this.#workers.findIndex(item => item[0] === worker);
+    }
+    #findChannel(worker) {
+        const index = this.#findIndex(worker);
+        if (index !== -1) {
+            return this.#workers[index][1];
+        }
+    }
+    set min(value) {
+        if (this.#locked) {
+            return;
+        }
+        if (value >= 0 && value <= this.max) {
+            this.#min = value;
+        }
+    }
+    get min() {
+        return this.#min;
+    }
+    set max(value) {
+        if (this.#locked) {
+            return;
+        }
+        if (value >= this.min) {
+            this.#max = value;
+            const count = this.size - value;
+            if (count > 0) {
+                void this.drop(count);
+            }
+        }
+        else if (value === 0) {
+            this.#min = 0;
+            this.#max = 0;
+        }
+    }
+    get max() {
+        return this.#max;
+    }
+    set idleTimeout(value) {
+        if (this.#locked) {
+            return;
+        }
+        if (value > 0) {
+            this.#idleTimeout = WorkerGroup.checkTimeout(value, false);
+        }
+    }
+    get idleTimeout() {
+        return this.#idleTimeout;
+    }
+    get filename() {
+        return this.#filename;
+    }
+    get workers() {
+        return this.#workers.map(item => item[0]);
+    }
+    get detached() {
+        return this.max === 0;
+    }
+    get lastAccessed() {
+        return this.#accessed[0];
+    }
+    get timesAccessed() {
+        return this.#accessed[1];
+    }
+    get frequencyAccessed() {
+        return this.timesAccessed === 0 ? 0 : Number(process.hrtime.bigint() - this.#startTime) / this.timesAccessed;
+    }
+    get pending() {
+        return this.#pending.size;
+    }
+    get available() {
+        return this.size - this.pending;
+    }
+    get errors() {
+        return this.#errors;
+    }
+    get size() {
+        return this.#workers.length;
+    }
+}
+exports.WorkerChannel = WorkerChannel;
+class AbortComponent {
     static attach(instance, signal, options) {
         let map = ABORT_LISTENER.get(instance);
         if (!map) {
@@ -1319,25 +1804,25 @@ class AbortComponent {
             map.splice(index, 1);
         }
     }
+    #controller = new AbortController();
     abort(reason) {
         if (!this.aborted) {
-            this[kAbortHandler].abort(reason);
+            this.#controller.abort(reason);
         }
     }
     reset() {
         if (this.aborted) {
-            this[kAbortHandler] = new AbortController();
+            this.#controller = new AbortController();
         }
     }
     get signal() {
-        return this[kAbortHandler].signal;
+        return this.#controller.signal;
     }
     get aborted() {
         return this.signal.aborted;
     }
 }
 exports.AbortComponent = AbortComponent;
-_e = kAbortHandler;
 class Permission {
     static create(settings, parent, freeze) {
         if (this.validate(settings)) {
@@ -1346,7 +1831,7 @@ class Permission {
                 parent = null;
             }
             const { inherit, disk_read, disk_write, unc_read, unc_write } = settings;
-            const result = new Permission(freeze);
+            const result = new _a(freeze);
             if (inherit === false) {
                 parent = null;
             }
@@ -1389,7 +1874,7 @@ class Permission {
         return (0, types_1.isPlainObject)(settings) && (readable(settings.disk_read) || readable(settings.disk_write) || readable(settings.unc_read) || readable(settings.unc_write));
     }
     static clone(permission, freeze) {
-        const result = new Permission(freeze);
+        const result = new _a(freeze);
         if (permission.diskRead) {
             result.setDiskRead(permission.getDiskRead());
         }
@@ -1425,62 +1910,102 @@ class Permission {
         }
         return '';
     }
+    #diskRead = { enabled: null, value: '' };
+    #diskWrite = { enabled: null, value: '' };
+    #uncRead = { enabled: null, value: '' };
+    #uncWrite = { enabled: null, value: '' };
+    #freeze;
     constructor(freeze = false) {
-        this[_f] = { enabled: null, value: '' };
-        this[_g] = { enabled: null, value: '' };
-        this[_h] = { enabled: null, value: '' };
-        this[_j] = { enabled: null, value: '' };
-        this[kFreeze] = freeze;
+        this.#freeze = freeze;
     }
     setDiskRead(pathname = '', enabled = true) {
-        setPermission.call(this, kDiskRead, pathname, enabled);
+        const r = this.#validate(pathname, enabled, this.#diskRead.enabled);
+        if (r) {
+            this.#diskRead = r;
+        }
     }
     setDiskWrite(pathname = '', enabled = true) {
-        setPermission.call(this, kDiskWrite, pathname, enabled);
+        const w = this.#validate(pathname, enabled, this.#diskWrite.enabled);
+        if (w) {
+            this.#diskWrite = w;
+        }
     }
     setUNCRead(pathname = '', enabled = true) {
-        setPermission.call(this, kUncRead, pathname, enabled);
+        const r = this.#validate(pathname, enabled, this.#uncRead.enabled);
+        if (r) {
+            this.#uncRead = r;
+        }
     }
     setUNCWrite(pathname = '', enabled = true) {
-        setPermission.call(this, kUncWrite, pathname, enabled);
+        const w = this.#validate(pathname, enabled, this.#uncWrite.enabled);
+        if (w) {
+            this.#uncWrite = w;
+        }
     }
     getDiskRead() {
-        return this[kDiskRead].value;
+        return this.#diskRead.value;
     }
     getDiskWrite() {
-        return this[kDiskWrite].value;
+        return this.#diskWrite.value;
     }
     getUNCRead() {
-        return this[kUncRead].value;
+        return this.#uncRead.value;
     }
     getUNCWrite() {
-        return this[kUncWrite].value;
+        return this.#uncWrite.value;
     }
     hasDiskRead(pathname) {
-        return matchPermission(this[kDiskRead], pathname);
+        return this.#permitted(this.#diskRead, pathname);
     }
     hasDiskWrite(pathname) {
-        return matchPermission(this[kDiskWrite], pathname);
+        return this.#permitted(this.#diskWrite, pathname);
     }
     hasUNCRead(pathname) {
-        return matchPermission(this[kUncRead], pathname);
+        return this.#permitted(this.#uncRead, pathname);
     }
     hasUNCWrite(pathname) {
-        return matchPermission(this[kUncWrite], pathname);
+        return this.#permitted(this.#uncWrite, pathname);
+    }
+    #validate(pathname, enabled, current) {
+        if (pathname === true) {
+            pathname = '**/*';
+            enabled = true;
+        }
+        else if (pathname === false) {
+            pathname = '';
+            enabled = false;
+        }
+        if ((current === null || !this.#freeze) && (!enabled || (pathname = _a.toPosix(pathname)))) {
+            if (enabled && Array.isArray(pathname)) {
+                switch (pathname.length) {
+                    case 1:
+                        pathname = pathname[0];
+                        break;
+                    case 0:
+                        enabled = false;
+                        break;
+                }
+            }
+            return Object.freeze({ enabled, value: enabled ? Object.freeze(pathname) : '' });
+        }
+    }
+    #permitted(permission, pathname) {
+        const { enabled, value } = permission;
+        return enabled === true && (0, types_1.isString)(pathname) && (value === '**/*' || value === '**' || _a.match(pathname, value));
     }
     get diskRead() {
-        return this[kDiskRead].enabled === true;
+        return this.#diskRead.enabled === true;
     }
     get diskWrite() {
-        return this[kDiskWrite].enabled === true;
+        return this.#diskWrite.enabled === true;
     }
     get uncRead() {
-        return this[kUncRead].enabled === true;
+        return this.#uncRead.enabled === true;
     }
     get uncWrite() {
-        return this[kUncWrite].enabled === true;
+        return this.#uncWrite.enabled === true;
     }
 }
 exports.Permission = Permission;
-_f = kDiskRead, _g = kDiskWrite, _h = kUncRead, _j = kUncWrite;
+_a = Permission;
 PERMISSION = Host.createPermission(true, true);