@e-mc/core 0.13.6 → 0.13.7

package/README.md

@@ -9,7 +9,7 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.13.6/lib/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.13.7/lib/index.d.ts)
 
 ```typescript
 import type { DataSource, LogStatus, WorkerAction } from "./squared";
@@ -74,6 +74,7 @@ interface HostConstructor extends ModuleConstructor {
     getThreadCount(full: true): ThreadCountStat;
     getThreadCount(username: string, iv?: BinaryLike): ThreadCountStat;
     getThreadCount(username?: string | boolean, iv?: BinaryLike): number;
+    parseIp(value: unknown, kind?: "ipv4" | "ipv6"): string;
     getPermissionFromSettings(freeze?: boolean): IPermission;
     readonly prototype: IHost;
     new(config?: HostInitConfig): IHost;
@@ -102,11 +103,11 @@ interface IClientDb extends IClient<IHost, ClientModule<ClientDbSettings>> {
     hasCache(source: string, sessionKey?: string): boolean;
     hasCoerce(source: string, component: keyof DbCoerceSettings, uuidKey: string | undefined): boolean;
     hasCoerce(source: string, component: keyof DbCoerceSettings, credential?: unknown): boolean;
+    getQueryResult(source: string, credential: unknown, queryString: string, options: CacheOptions): QueryResult | undefined;
     getQueryResult(source: string, credential: unknown, queryString: string, renewCache: boolean): QueryResult | undefined;
     getQueryResult(source: string, credential: unknown, queryString: string, sessionKey?: string, renewCache?: boolean): QueryResult | undefined;
-    getQueryResult(source: string, credential: unknown, queryString: string, options?: CacheOptions, renewCache?: boolean): QueryResult | undefined;
+    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, options: CacheOptions): QueryResult;
     setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, sessionKey?: string): QueryResult;
-    setQueryResult(source: string, credential: unknown, queryString: string, result: unknown, options?: CacheOptions): QueryResult;
     getCacheResult(source: string, credential: unknown, queryString: string, cacheValue: CacheOptions, ignoreCache?: unknown): QueryResult | undefined;
     applyState(items: DataSource | DataSource[], value: number, as?: boolean): void;
     commit(items?: DataSource[]): Promise<boolean>;
@@ -130,7 +131,8 @@ interface ClientDbConstructor extends ClientConstructor<IHost, ClientModule> {
     loadSettings(settings: Pick<Settings, "process" | "memory">, password?: string): boolean;
     getTimeout(value: number | string | TimeoutAction | undefined): number;
     convertTime(value: number | string): number;
-    findResult(source: string, credential: unknown, queryString: string, timeout: number, sessionKey?: string | boolean, renewCache?: boolean): QueryResult | undefined;
+    findResult(source: string, credential: unknown, queryString: string, timeout: number, renewCache: boolean): QueryResult | undefined;
+    findResult(source: string, credential: unknown, queryString: string, timeout: number, sessionKey?: string, renewCache?: boolean): QueryResult | undefined;
     storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, options: StoreResultOptions): QueryResult;
     /** @deprecated */
     storeResult(source: string, credential: unknown, queryString: string, result: QueryResult, sessionKey: string, sessionExpires: number): QueryResult;
@@ -322,13 +324,13 @@ NOTE: **@e-mc/core** is mostly a collection of abstract base classes which canno
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/squared.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/core.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/db.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/dom.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/logger.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/node.d.ts
-- https://www.unpkg.com/@e-mc/types@0.13.6/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.7/lib/squared.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.7/lib/core.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.7/lib/db.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.7/lib/dom.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.7/lib/logger.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.7/lib/node.d.ts
+- https://www.unpkg.com/@e-mc/types@0.13.7/lib/settings.d.ts
 
 * https://www.npmjs.com/package/@types/node
 

package/index.js

@@ -19,15 +19,8 @@ const CACHE_SOURCE = Object.create(null);
 const CACHE_SESSION = Object.create(null);
 const ABORT_LISTENER = new WeakMap();
 const HOST = {
-    DONE: new Map(),
-    QUEUE: [],
     QUEUE_LIMIT: Infinity,
     QUEUE_EXPIRES: 86400000,
-    PID: 1,
-    CLOSED: 0,
-    QUEUED: 0,
-    REJECTED: 0,
-    KILLED: 0,
     CIPHER: null,
     ADMIN_USERS: [],
     ADMIN_PRIVATE: false,
@@ -35,11 +28,7 @@ const HOST = {
     THREAD_EXPIRES: 86400000,
     PRIORITY_MIN: 0,
     PRIORITY_MAX: 100,
-    PRIORITY_BYPASS: undefined,
-    LOG_PROGRESS: null,
-    LOG_DELAYED: [],
-    LOG_PROGRESS_QUEUE: new WeakSet(),
-    LOG_PROGRESS_PAUSED: new Set()
+    PRIORITY_BYPASS: undefined
 };
 const WORKER_GROUP = {
     MAX: module_1.availableParallelism(),
@@ -49,119 +38,23 @@ const WORKER_GROUP = {
 const WORKER_CHANNEL = {
     MIN: 0,
     MAX: Math.max(WORKER_GROUP.MAX / 2, 2),
-    TIMEOUT: 300 * 1000,
+    TIMEOUT: 5 * 60000,
     VERBOSE: true
 };
+const GC = {
+    EXPIRES: 600,
+    EXPIRES_LIMIT: 2592000,
+    EXPIRES_DEFAULT: false,
+    INTERVAL: 60000
+};
 let STORE_RESULT_COUNT = 0;
 let PICOMATCH_OPTIONS = { nocase: module_1.PLATFORM_WIN32 };
 let MINIMATCH_OPTIONS = {};
 let MINIMATCH;
 let PERMISSION;
-function closeHostThread(host) {
-    HOST.DONE.delete(host);
-    resumeHostLog(host);
-    ++HOST.CLOSED;
-    const current = Date.now();
-    for (let i = 0; i < HOST.QUEUE.length; ++i) {
-        const item = HOST.QUEUE[i];
-        const { instance, startTime } = item;
-        if (startTime + HOST.QUEUE_EXPIRES <= current) {
-            cancelHostThread(instance, 'expired: ' + (0, types_1.formatTime)(startTime, true));
-            HOST.QUEUE.splice(i--, 1);
-            resumeHostQueue(item, true);
-        }
-    }
-    if (HOST.QUEUE.length > 0 && HOST.DONE.size < HOST.THREAD_LIMIT) {
-        const queue = HOST.QUEUE.shift();
-        HOST.DONE.set(queue.instance, HOST.PID++);
-        resumeHostQueue(queue);
-        HOST.QUEUE.forEach((item, index) => {
-            notifyHostQueue(item.instance, index, item.priority, true);
-        });
-    }
-}
-function cancelHostThread(host, hint, rejected) {
-    host.writeFail(["Transaction was cancelled", host.username], (0, types_1.errorValue)("Thread was killed", hint), { type: 2, fatal: true });
-    host.abort();
-    resetHostLog(host);
-    if (rejected) {
-        ++HOST.REJECTED;
-    }
-    else {
-        ++HOST.KILLED;
-    }
-}
-function resetHostLog(host) {
-    if (HOST.LOG_PROGRESS === host) {
-        HOST.LOG_PROGRESS = null;
-        HOST.LOG_DELAYED.length = 0;
-    }
-    HOST.LOG_PROGRESS_QUEUE.delete(host);
-    HOST.LOG_PROGRESS_PAUSED.delete(host);
-}
-function resumeHostLog(host) {
-    resetHostLog(host);
-    if (!HOST.LOG_PROGRESS) {
-        for (const item of HOST.LOG_PROGRESS_PAUSED) {
-            item.resumeLog('progress');
-        }
-    }
-}
-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 });
-    }
-}
-function addHostQueue(item) {
-    HOST.QUEUE.push(item);
-    HOST.QUEUE.sort((a, b) => {
-        const au = a.instance.username;
-        const bu = b.instance.username;
-        if (au && !bu) {
-            return -1;
-        }
-        if (!au && bu) {
-            return 1;
-        }
-        return a.priority - b.priority;
-    });
-}
-function resumeHostQueue(item, aborted) {
-    if (!item.joined) {
-        return;
-    }
-    const { instance, args = [], startTime } = item;
-    if (!aborted) {
-        if (HOST.LOG_PROGRESS) {
-            instance.pauseLog('progress');
-        }
-        else if (HOST.LOG_PROGRESS_QUEUE.has(instance)) {
-            HOST.LOG_PROGRESS = instance;
-            instance.resumeLog('progress');
-            for (const host of HOST.DONE.keys()) {
-                if (host !== instance) {
-                    host.pauseLog('progress');
-                }
-            }
-        }
-        HOST.LOG_PROGRESS_QUEUE.delete(instance);
-        instance.writeTimeElapsed('JOIN', ['Thread restarting...', HOST.THREAD_LIMIT > 1 ? 'Availability: ' + HOST.DONE.size + ' / ' + HOST.THREAD_LIMIT : ''], startTime, { type: 2, ...module_1.LOG_STYLE_WARN });
-    }
-    queueMicrotask(() => {
-        try {
-            instance.resumeThread({ args, startTime, aborted });
-        }
-        catch {
-        }
-    });
-}
 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 getSettingsValue(options, name, component) {
-    const result = options[name];
-    return component ? (0, types_1.isObject)(result) ? result[component] : undefined : result;
-}
 function isInvalidRange(result, range) {
     const [lower, upper = 0] = range;
     return Array.isArray(result) && (result.length <= lower || upper > 0 && result.length > upper);
@@ -173,30 +66,8 @@ function asPosix(value) {
     }
     return path.normalize(value);
 }
-function parseIp(value, kind) {
-    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 '';
-                }
-                ip = ip.toIPv4Address();
-            }
-            return ip.toNormalizedString();
-        }
-        catch {
-        }
-    }
-    return '';
-}
 const readable = (value) => (0, types_1.isString)(value) || (0, types_1.isArray)(value);
-const expireTime = (value) => Date.now() + value * 1000;
+const expireTime = (value) => Date.now() + Math.min(Math.trunc(value * 1000), GC.EXPIRES_LIMIT);
 const convertSeconds = (value) => typeof value === 'string' && Math.ceil((0, types_1.parseTime)(value) / 1000) || 0;
 class DbLRU {
     static get(source) {
@@ -215,28 +86,38 @@ class DbLRU {
         }
         return false;
     }
-    items = [];
     config = null;
+    items = [];
     refresh(percent) {
         const { items, config } = this;
         let result = 0;
         if (config && items.length >= config.limit || percent) {
             percent = Math.min(1, percent ?? config.percent);
+            const length = items.length;
             if (percent === 1) {
-                result = items.length;
-                for (let i = 0; i < result; ++i) {
+                for (let i = 0; i < length; ++i) {
                     items[i].delete(false);
                 }
+                result = length;
                 items.length = 0;
             }
             else {
+                const data = items.slice(0);
                 const min = config?.min || 0;
-                const data = items.slice(0).sort((a, b) => a.lastAccessed - b.lastAccessed);
-                for (let i = 0, length = Math.floor(data.length * Math.min(percent, 1)); i < length; ++i) {
+                let lfu = config?.type === 'lfu';
+                if (lfu) {
+                    data.sort((a, b) => (a.accessCount - b.accessCount) || (a.lastAccessed - b.lastAccessed));
+                }
+                else {
+                    data.sort((a, b) => a.lastAccessed - b.lastAccessed);
+                    lfu = min === 0;
+                }
+                for (let i = 0, j = Math.floor(length * Math.min(percent, 1)); i < length && j > 0; ++i) {
                     const item = data[i];
-                    if (min === 0 || item.accessCount < min) {
+                    if (lfu || item.accessCount < min) {
                         item.delete(true);
                         ++result;
+                        --j;
                     }
                 }
             }
@@ -249,10 +130,10 @@ class DbCache {
     user;
     query;
     value;
-    expires;
     accessCount = 0;
     lastAccessed = Date.now();
     disposed = false;
+    expires;
     userData;
     queryData;
     sourceList;
@@ -261,13 +142,18 @@ class DbCache {
         this.user = user;
         this.query = query;
         this.value = value;
-        this.expires = expires;
-        this.userData = CACHE_USER[source] ||= Object.create(null);
-        this.queryData = this.userData[user] ||= Object.create(null);
-        this.queryData[query] = this;
+        this.userData = CACHE_USER[source] ||= new Map();
+        let data = this.userData.get(user);
+        if (!data) {
+            data = {};
+            this.userData.set(user, data);
+        }
+        data[query] = this;
+        this.queryData = data;
         this.sourceList = DbLRU.get(source);
         this.sourceList.refresh();
         this.sourceList.items.push(this);
+        this.expires = expireTime(expires);
     }
     get(seconds) {
         const current = Date.now();
@@ -329,7 +215,7 @@ class DbCache {
             }
         }
         if (!found) {
-            delete this.userData[this.user];
+            this.userData.delete(this.user);
         }
         if (typeof value === 'string') {
             try {
@@ -349,41 +235,254 @@ class DbCache {
 }
 class DbSession {
     source;
-    sourceData = Object.create(null);
+    timeout;
+    sourceData = new Map();
     constructor(source) {
         this.source = source;
-        const timer = setInterval(() => {
-            this.clear();
-            if (this.users.length === 0) {
-                CACHE_SESSION[source] = undefined;
-                clearInterval(timer);
-            }
-        }, 60000);
+        this.timeout = setInterval(() => {
+            this.cleanup();
+            this.refresh();
+        }, GC.INTERVAL);
     }
     set(user, key, result, seconds) {
-        let data = this.sourceData[user];
+        let data = this.sourceData.get(user);
         if (!data) {
-            data = [Object.create(null), Date.now() + Math.trunc(seconds * 1000)];
-            this.sourceData[user] = data;
+            data = [Object.create(null), expireTime(seconds)];
+            this.sourceData.set(user, data);
         }
         data[0][key] = result;
     }
     get(user, key) {
-        return this.sourceData[user]?.[0][key];
+        return this.sourceData.get(user)?.[0][key];
     }
-    clear() {
+    refresh() {
+        if (this.done) {
+            CACHE_SESSION[this.source] = undefined;
+            if (this.timeout) {
+                clearInterval(this.timeout);
+                this.timeout = null;
+            }
+        }
+    }
+    cleanup() {
         const current = Date.now();
-        for (const user of this.users) {
-            const expires = this.sourceData[user][1];
-            if (expires >= current) {
-                delete this.sourceData[user];
+        for (const [user, item] of this.sourceData) {
+            if (item[1] >= current) {
+                this.sourceData.delete(user);
+            }
+        }
+    }
+    destroy() {
+        this.sourceData.clear();
+        this.refresh();
+    }
+    get done() {
+        return this.sourceData.size === 0;
+    }
+}
+class HostQueue {
+    thread;
+    host;
+    priority;
+    joined = false;
+    args = [];
+    startTime = Date.now();
+    constructor(thread, host, priority) {
+        this.thread = thread;
+        this.host = host;
+        this.priority = priority;
+    }
+    join(args) {
+        if (!this.joined) {
+            if (Array.isArray(args)) {
+                this.args = args;
+            }
+            this.joined = true;
+            this.thread.queued++;
+            return true;
+        }
+        return false;
+    }
+    resume(aborted) {
+        if (!this.joined) {
+            return;
+        }
+        const { thread, host, args, startTime } = this;
+        if (!aborted) {
+            if (thread.progress) {
+                host.pauseLog('progress');
+            }
+            else if (thread.foreground.has(host)) {
+                thread.progress = host;
+                host.resumeLog('progress');
+                for (const pended of thread.items.keys()) {
+                    if (pended !== host) {
+                        host.pauseLog('progress');
+                    }
+                }
+            }
+            host.writeTimeElapsed('JOIN', ['Thread restarting...', HOST.THREAD_LIMIT > 1 ? `Availability: ${thread.size} / ${HOST.THREAD_LIMIT}` : ''], startTime, { type: 2, ...module_1.LOG_STYLE_WARN });
+        }
+        thread.foreground.delete(host);
+        if (typeof host.resumeThread === 'function') {
+            queueMicrotask(() => host.resumeThread({ args, startTime, aborted }));
+        }
+    }
+    notify(broadcast, position = this.position) {
+        const host = this.host;
+        if (!broadcast || host.broadcastId) {
+            host.formatMessage(2, 'QUEUE', ["Thread limit exceeded" + ` (position #${position + 1})`, host.username], 'Priority: ' + this.priority, { type: 2, ...module_1.LOG_STYLE_WARN });
+        }
+    }
+    get position() {
+        return this.thread.position(this.host);
+    }
+}
+class HostThread {
+    pid = 1;
+    queued = 0;
+    closed = 0;
+    rejected = 0;
+    killed = 0;
+    progress = null;
+    items = new Map();
+    queue = [];
+    paused = new Set();
+    foreground = new WeakSet();
+    messages = [];
+    *[Symbol.iterator]() {
+        for (const item of this.items) {
+            yield item;
+        }
+    }
+    add(host, progress) {
+        this.items.set(host, this.pid++);
+        if (this.progress) {
+            host.pauseLog('progress');
+            if (progress) {
+                this.foreground.add(host);
+            }
+        }
+        else if (progress) {
+            this.progress = host;
+            host['_logDelayed'] = [];
+        }
+    }
+    pause(host) {
+        this.paused.add(host);
+    }
+    cancel(host, hint, rejected = false) {
+        host.writeFail(["Transaction was cancelled", host.username], (0, types_1.errorValue)("Thread was killed", hint), { type: 2, fatal: true });
+        host.abort();
+        this.resetLog(host);
+        if (rejected) {
+            this.rejected++;
+        }
+        else {
+            this.killed++;
+        }
+    }
+    close(host) {
+        this.items.delete(host);
+        this.resumeLog(host);
+        this.closed++;
+        const current = Date.now();
+        const queue = this.queue;
+        for (let i = 0; i < queue.length; ++i) {
+            const item = queue[i];
+            if (current >= item.startTime + HOST.QUEUE_EXPIRES) {
+                this.cancel(item.host, 'expired: ' + (0, types_1.formatTime)(item.startTime, true));
+                item.resume(true);
+                queue.splice(i--, 1);
+            }
+        }
+        if (queue.length > 0 && this.size < HOST.THREAD_LIMIT) {
+            for (let i = 0; i < queue.length; ++i) {
+                const item = queue[i];
+                if (item.joined) {
+                    this.add(item.host);
+                    item.resume(false);
+                    queue.splice(i, 1);
+                    break;
+                }
+            }
+            queue.forEach((item, index) => item.notify(true, index));
+        }
+    }
+    kill() {
+        const result = new Map();
+        const current = Date.now();
+        for (const [host, pid] of this.items) {
+            if (host.done) {
+                this.close(host);
             }
+            else if (host.startTime + HOST.THREAD_EXPIRES >= current) {
+                host.writeFail(["Transaction was cancelled", host.username], (0, types_1.errorValue)("Timeout was exceeded", (0, types_1.formatTime)(HOST.THREAD_EXPIRES)), { fatal: true });
+                host.abort();
+                this.close(host);
+            }
+            else {
+                result.set(host, pid);
+            }
+        }
+        return result;
+    }
+    resumeLog(host) {
+        this.resetLog(host);
+        if (!this.progress) {
+            for (const item of this.paused) {
+                item.resumeLog('progress');
+            }
+        }
+    }
+    resetLog(host) {
+        if (this.progress === host) {
+            this.progress = null;
+            this.messages.length = 0;
         }
+        this.foreground.delete(host);
+        this.paused.delete(host);
     }
-    get users() {
-        return Object.keys(this.sourceData);
+    schedule(host, priority) {
+        const item = new HostQueue(this, host, priority);
+        this.queue.push(item);
+        this.queue.sort((a, b) => {
+            const au = a.host.username;
+            const bu = b.host.username;
+            if (au && !bu) {
+                return -1;
+            }
+            if (!au && bu) {
+                return 1;
+            }
+            return a.priority - b.priority;
+        });
+        item.notify(false);
+    }
+    join(host, options = {}) {
+        const index = this.position(host);
+        if (index !== -1) {
+            const queue = this.queue[index];
+            if (options.reject) {
+                this.queue.splice(index, 1);
+                return false;
+            }
+            queue.join(options.args);
+            return true;
+        }
+        return false;
+    }
+    position(host) {
+        return this.queue.findIndex(item => item.host === host);
+    }
+    get pending() {
+        return this.queue.length;
+    }
+    get size() {
+        return this.items.size;
     }
 }
+const HOST_MAIN = new HostThread();
 class Host extends module_1 {
     static [kHost] = true;
     static async purgeMemory(percent = 1, limit = 0, parent) {
@@ -539,10 +638,10 @@ class Host extends module_1 {
         }
         let result = 0;
         if (HOST.ADMIN_USERS.includes(username) || iv && HOST.ADMIN_USERS.includes(encryptText(username, iv))) {
-            for (const [host, id] of HOST.DONE) {
+            for (const [host, id] of HOST_MAIN) {
                 if (pid === true || id === pid || Array.isArray(pid) && pid.includes(id)) {
-                    cancelHostThread(host, 'pid: ' + id.toString());
-                    closeHostThread(host);
+                    HOST_MAIN.cancel(host, `pid: ${id}`);
+                    HOST_MAIN.close(host);
                     ++result;
                 }
             }
@@ -569,24 +668,10 @@ class Host extends module_1 {
         if (HOST.ADMIN_PRIVATE && !username) {
             return full ? { count: -1 } : -1;
         }
-        const current = Date.now();
-        const items = [];
-        for (const [host, pid] of HOST.DONE) {
-            if (host.done) {
-                closeHostThread(host);
-            }
-            else if (host.startTime + HOST.THREAD_EXPIRES >= current) {
-                host.writeFail(["Transaction was cancelled", host.username], (0, types_1.errorValue)("Timeout was exceeded", (0, types_1.formatTime)(HOST.THREAD_EXPIRES)), { fatal: true });
-                host.abort();
-                closeHostThread(host);
-            }
-            else {
-                items.push([host, pid]);
-            }
-        }
+        const items = Array.from(HOST_MAIN.kill());
         const count = items.length;
         if (full) {
-            const result = { count, pending: HOST.QUEUE.length, opened: HOST.DONE.size, closed: HOST.CLOSED, queued: HOST.QUEUED, rejected: HOST.REJECTED, killed: HOST.KILLED };
+            const result = { count, pending: HOST_MAIN.pending, opened: HOST_MAIN.size, closed: HOST_MAIN.closed, queued: HOST_MAIN.queued, rejected: HOST_MAIN.rejected, killed: HOST_MAIN.killed };
             if (count) {
                 if (count > 1) {
                     items.sort((a, b) => a[0].startTime - b[0].startTime);
@@ -617,8 +702,34 @@ class Host extends module_1 {
         }
         return count;
     }
+    static parseIp(value, kind) {
+        if ((0, types_1.isString)(value)) {
+            try {
+                let ip = ipaddr.parse(value);
+                if (kind) {
+                    if (ip.kind() === 'ipv4') {
+                        if (kind === 'ipv6') {
+                            ip = ip.toIPv4MappedAddress();
+                        }
+                    }
+                    else if (kind === 'ipv4') {
+                        if (ip.isIPv4MappedAddress()) {
+                            ip = ip.toIPv4Address();
+                        }
+                        else {
+                            return '';
+                        }
+                    }
+                }
+                return ip.toNormalizedString();
+            }
+            catch {
+            }
+        }
+        return '';
+    }
     static getLogDelayed() {
-        return HOST.LOG_DELAYED;
+        return HOST_MAIN.messages;
     }
     static getPermissionFromSettings(freeze = true) {
         return freeze ? PERMISSION : Permission.clone(PERMISSION);
@@ -670,22 +781,17 @@ class Host extends module_1 {
             this.ignoreLog(typeof log === 'boolean' ? !log : log);
         }
         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) {
-                this.pauseLog('progress');
-            }
-            else if (showProgress) {
-                HOST.LOG_PROGRESS = this;
-                this._logDelayed = [];
-            }
+        if (HOST_MAIN.size >= HOST.THREAD_LIMIT) {
+            HOST_MAIN.kill();
+        }
+        if (HOST_MAIN.size < HOST.THREAD_LIMIT || this.username && typeof priority === 'number' && priority === HOST.PRIORITY_BYPASS) {
+            HOST_MAIN.add(this, showProgress);
         }
-        else if (typeof priority === 'number' && priority >= HOST.PRIORITY_MIN && priority <= HOST.PRIORITY_MAX && HOST.QUEUE.length < HOST.QUEUE_LIMIT && typeof this.resumeThread === 'function') {
-            addHostQueue({ instance: this, priority, startTime: Date.now() });
-            notifyHostQueue(this, HOST.QUEUE.findIndex(item => item.instance === this), priority);
+        else if (typeof priority === 'number' && priority >= HOST.PRIORITY_MIN && priority <= HOST.PRIORITY_MAX && HOST_MAIN.pending < HOST.QUEUE_LIMIT && typeof this.resumeThread === 'function') {
+            HOST_MAIN.schedule(this, priority);
         }
         else {
-            cancelHostThread(this, 'limit: ' + HOST.THREAD_LIMIT.toString(), true);
+            HOST_MAIN.cancel(this, `limit: ${HOST.THREAD_LIMIT}`, true);
         }
     }
     restart(...args) { }
@@ -793,7 +899,7 @@ class Host extends module_1 {
     hasLog(type) {
         switch (type) {
             case 'progress':
-                return this === HOST.LOG_PROGRESS;
+                return this === HOST_MAIN.progress;
             default:
                 return false;
         }
@@ -801,12 +907,12 @@ class Host extends module_1 {
     pauseLog(type) {
         if (type === 'progress') {
             this._logDelayed ||= [];
-            HOST.LOG_PROGRESS_PAUSED.add(this);
+            HOST_MAIN.pause(this);
         }
         this.#logState = 0;
     }
     resumeLog(type) {
-        if (!type || this.hasLog(type) || type === 'progress' && !HOST.LOG_PROGRESS) {
+        if (!type || this.hasLog(type) || type === 'progress' && !HOST_MAIN.progress) {
             this.#logState = 1;
             const log = this._logDelayed;
             if (log?.length) {
@@ -827,12 +933,12 @@ class Host extends module_1 {
                 }
                 log.length = 0;
             }
-            resumeHostLog(this);
+            HOST_MAIN.resumeLog(this);
         }
     }
     delayMessage(args) {
         this._logDelayed?.push(args);
-        HOST.LOG_DELAYED.push(args);
+        HOST_MAIN.messages.push(args);
     }
     retain(process) {
         this.subProcesses.add(process);
@@ -862,27 +968,7 @@ class Host extends module_1 {
         return null;
     }
     joinQueue(options) {
-        const index = HOST.QUEUE.findIndex(item => item.instance === this);
-        if (index !== -1) {
-            const queue = HOST.QUEUE[index];
-            let args, reject;
-            if (options) {
-                ({ args, reject } = options);
-            }
-            if (reject) {
-                HOST.QUEUE.splice(index, 1);
-                return false;
-            }
-            if (Array.isArray(args)) {
-                queue.args = args;
-            }
-            if (!queue.joined) {
-                queue.joined = true;
-                ++HOST.QUEUED;
-            }
-            return true;
-        }
-        return false;
+        return HOST_MAIN.join(this, options);
     }
     set host(value) { }
     get host() {
@@ -895,22 +981,22 @@ class Host extends module_1 {
         return this.#username;
     }
     get ipV4() {
-        return parseIp(this.config.remoteIp, 4);
+        return Host.parseIp(this.config.remoteIp, 'ipv4');
     }
     get ipV6() {
-        return parseIp(this.config.remoteIp, 6);
+        return Host.parseIp(this.config.remoteIp, 'ipv6');
     }
     set done(value) {
         if (value) {
             this.#done = true;
-            closeHostThread(this);
+            HOST_MAIN.close(this);
         }
     }
     get done() {
         return this.#done || this.aborted;
     }
     get queued() {
-        return !!HOST.QUEUE.find(item => item.instance === this);
+        return HOST_MAIN.position(this) !== -1;
     }
     get logState() {
         return this.#logState;
@@ -974,7 +1060,7 @@ class Client extends module_1 {
         return result;
     }
     set cacheDir(value) {
-        if (path.isAbsolute(value) && module_1.isDir(value)) {
+        if (path.isAbsolute(value) && module_1.isDir(value) && this.supportsProperty('cacheDir')) {
             this.#cacheDir = value;
         }
     }
@@ -1022,15 +1108,31 @@ class ClientDb extends Client {
             return false;
         }
         const memory = settings.memory;
-        if ((0, types_1.isPlainObject)(memory)) {
-            for (const name in memory) {
+        for (const name in memory) {
+            if (name === 'settings') {
+                const gc = memory.settings?.gc;
+                if (gc) {
+                    let { expires, interval, expires_limit } = gc;
+                    if (expires_limit !== undefined && (expires_limit = (0, types_1.parseExpires)(expires_limit) / 1000) >= 1) {
+                        GC.EXPIRES_LIMIT = expires_limit;
+                    }
+                    if (expires !== undefined && (expires = (0, types_1.parseExpires)(expires) / 1000) > 0) {
+                        GC.EXPIRES = Math.min(expires, GC.EXPIRES_LIMIT);
+                        GC.EXPIRES_DEFAULT = true;
+                    }
+                    if (interval !== undefined && (interval = (0, types_1.parseExpires)(interval)) > 0) {
+                        GC.INTERVAL = interval;
+                    }
+                }
+            }
+            else {
                 const client = memory[name];
                 if ((0, types_1.isPlainObject)(client)) {
                     for (const source in client) {
                         const item = client[source];
-                        if ((0, types_1.isPlainObject)(item) && 'enabled' in item) {
+                        if ((0, types_1.isObject)(item) && 'enabled' in item) {
                             const key = name + '_' + source;
-                            const { enabled, limit = 0, min = 0, max = 0 } = item;
+                            const { enabled, limit = 0, min = 0, max = 0, type = 'lru' } = item;
                             if (enabled && +limit > 0) {
                                 let percent = item.percent || 0;
                                 if ((0, types_1.isString)(percent)) {
@@ -1041,6 +1143,7 @@ class ClientDb extends Client {
                                 }
                                 if (percent > 0) {
                                     DbLRU.get(key).config = {
+                                        type,
                                         limit: +limit,
                                         percent: Math.min(percent, 1),
                                         min: min > 0 ? min : 0,
@@ -1062,7 +1165,7 @@ class ClientDb extends Client {
         return parent ? super.purgeMemory(percent, limit, parent) : 0;
     }
     static getTimeout(value) {
-        if (value === undefined) {
+        if (value == null) {
             return 0;
         }
         let result = 0;
@@ -1074,7 +1177,7 @@ class ClientDb extends Client {
                 result = convertSeconds(value);
                 break;
             case 'object':
-                if (value !== null && typeof (result = value.timeout) === 'string') {
+                if (typeof (result = value.timeout) === 'string') {
                     result = convertSeconds(value.timeout);
                     value.timeout = result;
                 }
@@ -1097,15 +1200,14 @@ class ClientDb extends Client {
     static findResult(source, credential, queryString, timeout, sessionKey, renewCache) {
         const userKey = credential ? this.extractUUID(credential) || (0, types_1.hashKey)(this.asString(credential)) : undefined;
         if (userKey) {
-            queryString = (0, types_1.hashKey)(queryString);
             if (timeout > 0) {
-                const stored = CACHE_USER[source]?.[userKey]?.[queryString];
+                const stored = CACHE_USER[source]?.get(userKey)?.[(0, types_1.hashKey)(queryString)];
                 if (stored) {
                     return stored.get(renewCache ? timeout : 0);
                 }
             }
             else if (sessionKey) {
-                return this.findSession(source, userKey + sessionKey, queryString);
+                return this.findSession(source, userKey + sessionKey, (0, types_1.hashKey)(queryString));
             }
         }
     }
@@ -1122,21 +1224,22 @@ class ClientDb extends Client {
         }
         let timeout = 0, userKey, whenEmpty, partition = false;
         switch (typeof cache) {
-            case 'object': {
-                let seconds, dir;
-                ({ timeout: seconds, when_empty: whenEmpty, dir } = cache);
-                if (dir && (!cacheDir || module_1.isDir(dir))) {
-                    cacheDir = dir;
-                    partition = true;
-                }
-                if (typeof seconds === 'number') {
-                    timeout = seconds;
-                }
-                else {
-                    cache.timeout = seconds ? timeout = convertSeconds(seconds) : 0;
+            case 'object':
+                if (cache) {
+                    let seconds, dir;
+                    ({ timeout: seconds, when_empty: whenEmpty, dir } = cache);
+                    if (dir && (!cacheDir || module_1.isDir(dir))) {
+                        cacheDir = dir;
+                        partition = true;
+                    }
+                    if (typeof seconds === 'number') {
+                        timeout = seconds;
+                    }
+                    else {
+                        cache.timeout = seconds ? timeout = convertSeconds(seconds) : 0;
+                    }
                 }
                 break;
-            }
             case 'number':
                 timeout = cache;
                 break;
@@ -1150,9 +1253,9 @@ class ClientDb extends Client {
                 break;
         }
         if ((result.length > 0 || whenEmpty) && (userKey = this.extractUUID(credential) || (0, types_1.hashKey)(this.asString(credential)))) {
-            queryString = (0, types_1.hashKey)(queryString);
             if (timeout > 0) {
-                const item = new DbCache(source, userKey, queryString, result, expireTime(timeout));
+                queryString = (0, types_1.hashKey)(queryString);
+                const item = new DbCache(source, userKey, queryString, result, timeout);
                 if (cacheDir) {
                     if (partition) {
                         if (STORE_RESULT_COUNT === this.STORE_RESULT_PARTITION_SIZE) {
@@ -1171,8 +1274,8 @@ class ClientDb extends Client {
                     });
                 }
             }
-            else if (typeof sessionKey === 'string' && typeof sessionExpires === 'number' && sessionExpires > 0) {
-                this.storeSession(source, userKey + sessionKey, queryString, result, sessionExpires);
+            else if (typeof sessionKey === 'string') {
+                this.storeSession(source, userKey + sessionKey, (0, types_1.hashKey)(queryString), result, sessionExpires);
             }
         }
         return result;
@@ -1180,8 +1283,10 @@ class ClientDb extends Client {
     static findSession(source, user, key) {
         return CACHE_SESSION[source]?.get(user, key);
     }
-    static storeSession(source, user, key, result, expires = 600) {
-        (CACHE_SESSION[source] ||= new DbSession(source)).set(user, key, result, expires);
+    static storeSession(source, user, key, result, expires = 0) {
+        if (expires > 0 || GC.EXPIRES_DEFAULT) {
+            (CACHE_SESSION[source] ||= new DbSession(source)).set(user, key, result, expires > 0 ? expires : GC.EXPIRES);
+        }
     }
     static async purgeResult(prefix, lru) {
         const cache = lru ? CACHE_SOURCE : CACHE_USER;
@@ -1194,15 +1299,26 @@ class ClientDb extends Client {
                         items.push(cache[key]);
                     }
                 }
+                for (const key in CACHE_SESSION) {
+                    if (key.startsWith(prefix)) {
+                        CACHE_SESSION[key]?.destroy();
+                    }
+                }
             }
-            else if (cache[prefix]) {
-                items.push(cache[prefix]);
+            else {
+                if (cache[prefix]) {
+                    items.push(cache[prefix]);
+                }
+                CACHE_SESSION[prefix]?.destroy();
             }
         }
         else {
             for (const key in cache) {
                 items.push(cache[key]);
             }
+            for (const key in CACHE_SESSION) {
+                CACHE_SESSION[key]?.destroy();
+            }
         }
         let result = 0;
         if (lru) {
@@ -1213,8 +1329,7 @@ class ClientDb extends Client {
         else {
             const current = Date.now();
             for (const source of items) {
-                for (const session in source) {
-                    const data = source[session];
+                for (const data of source.values()) {
                     for (const query in data) {
                         const item = data[query];
                         if (item.expired(current)) {
@@ -1253,13 +1368,8 @@ class ClientDb extends Client {
             this.cacheDir = cache_dir;
         }
         if (expires !== undefined) {
-            if (typeof expires === 'string') {
-                if (!isNaN(expires = (0, types_1.parseTime)(expires))) {
-                    this.settings.session_expires = expires;
-                }
-                else {
-                    delete this.settings.cache_session;
-                }
+            if (typeof expires === 'string' && !isNaN(expires = (0, types_1.parseTime)(expires))) {
+                this.settings.session_expires = expires;
             }
             if (expires >= 0) {
                 this.cacheExpires = expires;
@@ -1306,7 +1416,7 @@ class ClientDb extends Client {
                 sessionKey = options;
                 break;
             case 'object':
-                if (options !== null) {
+                if (options) {
                     ({ value, sessionKey, exclusiveOf, renewCache } = options);
                     if (Array.isArray(exclusiveOf)) {
                         const ignoreCache = exclusiveOf[2];
@@ -1411,18 +1521,27 @@ class ClientDb extends Client {
     settingsOf(source, name, component) {
         const data = this.settings[source];
         if ((0, types_1.isObject)(data)) {
-            return getSettingsValue(data, name, component);
+            return this.#settingsValue(data, name, component);
         }
     }
     settingsKey(uuidKey, name, component) {
         const data = this.settings.user_key?.[uuidKey];
         if ((0, types_1.isObject)(data)) {
-            return getSettingsValue(data, name, component);
+            return this.#settingsValue(data, name, component);
         }
     }
     getSourceName(value) {
         return this.moduleName + '_' + value;
     }
+    #settingsValue(options, name, component) {
+        const result = options[name];
+        if (!component) {
+            return result;
+        }
+        if ((0, types_1.isObject)(result)) {
+            return result[component];
+        }
+    }
     get pending() {
         return this.database.filter(item => {
             const state = item.transactionState || 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/core",
-  "version": "0.13.6",
+  "version": "0.13.7",
   "description": "Core modules for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -19,8 +19,8 @@
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.13.6",
-    "@e-mc/types": "0.13.6",
+    "@e-mc/module": "0.13.7",
+    "@e-mc/types": "0.13.7",
     "ipaddr.js": "^2.3.0",
     "picomatch": "^4.0.3"
   }