@vlian/framework 1.2.54 → 1.2.56

package/dist/kernel/manager/i18nManager.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/kernel/manager/i18nManager.ts"],"sourcesContent":["import { setupI18n, setLang } from '../../library';\nimport type { I18nSnapshot, KernelConfig, KernelManager, KernelManagerContext } from '../types';\nimport { DEFAULT_CONFIG, DEFAULT_I18N } from '../constants';\nimport { readPersistedValue, writePersistedValue } from './persistence';\n\ntype I18nListener = (next: I18nSnapshot, prev: I18nSnapshot) => void;\n\nexport class I18nManager implements KernelManager<I18nSnapshot> {\n  private snapshot: I18nSnapshot = DEFAULT_I18N;\n  private config: KernelConfig['i18n'] = DEFAULT_CONFIG.i18n;\n  private listeners = new Set<I18nListener>();\n\n  public async initialize(context: KernelManagerContext): Promise<void> {\n    this.config = context.config.i18n;\n    this.snapshot = { ...DEFAULT_I18N, ...(this.config.initial || {}) };\n\n    const persisted = await readPersistedValue(this.config.persistence);\n    if (persisted !== null) {\n      try {\n        const parsed = JSON.parse(persisted) as Partial<I18nSnapshot>;\n        this.snapshot = { ...this.snapshot, ...parsed };\n      } catch {\n        // ignore parse errors\n      }\n    } else {\n      await writePersistedValue(this.config.persistence, JSON.stringify(this.snapshot));\n    }\n\n    await setupI18n((this.snapshot.resources || {}) as any);\n    setLang(this.snapshot.locale);\n  }\n\n  public getSnapshot(): I18nSnapshot {\n    return { ...this.snapshot };\n  }\n\n  public subscribe(listener: I18nListener): () => void {\n    this.listeners.add(listener);\n    return () => {\n      this.listeners.delete(listener);\n    };\n  }\n\n  private emit(next: I18nSnapshot, prev: I18nSnapshot): void {\n    this.listeners.forEach((listener) => {\n      listener({ ...next }, { ...prev });\n    });\n  }\n\n  public async setLocale(locale: I18nSnapshot['locale']): Promise<void> {\n    const prev = this.snapshot;\n    this.snapshot = { ...this.snapshot, locale };\n    setLang(locale);\n    await writePersistedValue(this.config.persistence, JSON.stringify(this.snapshot));\n    this.emit(this.snapshot, prev);\n  }\n}\n"],"names":["I18nManager","initialize","context","config","i18n","snapshot","DEFAULT_I18N","initial","persisted","readPersistedValue","persistence","parsed","JSON","parse","writePersistedValue","stringify","setupI18n","resources","setLang","locale","getSnapshot","subscribe","listener","listeners","add","delete","emit","next","prev","forEach","setLocale","DEFAULT_CONFIG","Set"],"mappings":";;;;+BAOaA;;;eAAAA;;;yBAPsB;2BAEU;6BACW;;;;;;;;;;;;;;AAIjD,IAAA,AAAMA,cAAN,MAAMA;IAKX,MAAaC,WAAWC,OAA6B,EAAiB;QACpE,IAAI,CAACC,MAAM,GAAGD,QAAQC,MAAM,CAACC,IAAI;QACjC,IAAI,CAACC,QAAQ,GAAG;YAAE,GAAGC,uBAAY;YAAE,GAAI,IAAI,CAACH,MAAM,CAACI,OAAO,IAAI,CAAC,CAAC;QAAE;QAElE,MAAMC,YAAY,MAAMC,IAAAA,+BAAkB,EAAC,IAAI,CAACN,MAAM,CAACO,WAAW;QAClE,IAAIF,cAAc,MAAM;YACtB,IAAI;gBACF,MAAMG,SAASC,KAAKC,KAAK,CAACL;gBAC1B,IAAI,CAACH,QAAQ,GAAG;oBAAE,GAAG,IAAI,CAACA,QAAQ;oBAAE,GAAGM,MAAM;gBAAC;YAChD,EAAE,OAAM;YACN,sBAAsB;YACxB;QACF,OAAO;YACL,MAAMG,IAAAA,gCAAmB,EAAC,IAAI,CAACX,MAAM,CAACO,WAAW,EAAEE,KAAKG,SAAS,CAAC,IAAI,CAACV,QAAQ;QACjF;QAEA,MAAMW,IAAAA,kBAAS,EAAE,IAAI,CAACX,QAAQ,CAACY,SAAS,IAAI,CAAC;QAC7CC,IAAAA,gBAAO,EAAC,IAAI,CAACb,QAAQ,CAACc,MAAM;IAC9B;IAEOC,cAA4B;QACjC,OAAO;YAAE,GAAG,IAAI,CAACf,QAAQ;QAAC;IAC5B;IAEOgB,UAAUC,QAAsB,EAAc;QACnD,IAAI,CAACC,SAAS,CAACC,GAAG,CAACF;QACnB,OAAO;YACL,IAAI,CAACC,SAAS,CAACE,MAAM,CAACH;QACxB;IACF;IAEQI,KAAKC,IAAkB,EAAEC,IAAkB,EAAQ;QACzD,IAAI,CAACL,SAAS,CAACM,OAAO,CAAC,CAACP;YACtBA,SAAS;gBAAE,GAAGK,IAAI;YAAC,GAAG;gBAAE,GAAGC,IAAI;YAAC;QAClC;IACF;IAEA,MAAaE,UAAUX,MAA8B,EAAiB;QACpE,MAAMS,OAAO,IAAI,CAACvB,QAAQ;QAC1B,IAAI,CAACA,QAAQ,GAAG;YAAE,GAAG,IAAI,CAACA,QAAQ;YAAEc;QAAO;QAC3CD,IAAAA,gBAAO,EAACC;QACR,MAAML,IAAAA,gCAAmB,EAAC,IAAI,CAACX,MAAM,CAACO,WAAW,EAAEE,KAAKG,SAAS,CAAC,IAAI,CAACV,QAAQ;QAC/E,IAAI,CAACqB,IAAI,CAAC,IAAI,CAACrB,QAAQ,EAAEuB;IAC3B;;QA/CA,uBAAQvB,YAAyBC,uBAAY;QAC7C,uBAAQH,UAA+B4B,yBAAc,CAAC3B,IAAI;QAC1D,uBAAQmB,aAAY,IAAIS;;AA8C1B"}
+{"version":3,"sources":["../../../src/kernel/manager/i18nManager.ts"],"sourcesContent":["export { I18nManager } from './i18n';\n"],"names":["I18nManager"],"mappings":";;;;+BAASA;;;eAAAA,iBAAW;;;sBAAQ"}

package/dist/kernel/manager/i18nManager.d.ts

@@ -1,13 +1 @@
-import type { I18nSnapshot, KernelManager, KernelManagerContext } from '../types';
-type I18nListener = (next: I18nSnapshot, prev: I18nSnapshot) => void;
-export declare class I18nManager implements KernelManager<I18nSnapshot> {
-    private snapshot;
-    private config;
-    private listeners;
-    initialize(context: KernelManagerContext): Promise<void>;
-    getSnapshot(): I18nSnapshot;
-    subscribe(listener: I18nListener): () => void;
-    private emit;
-    setLocale(locale: I18nSnapshot['locale']): Promise<void>;
-}
-export {};
+export { I18nManager } from './i18n';

package/dist/kernel/manager/i18nManager.js

@@ -1,78 +1,3 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { setupI18n, setLang } from "../../library";
-import { DEFAULT_CONFIG, DEFAULT_I18N } from "../constants";
-import { readPersistedValue, writePersistedValue } from "./persistence";
-export class I18nManager {
-    async initialize(context) {
-        this.config = context.config.i18n;
-        this.snapshot = {
-            ...DEFAULT_I18N,
-            ...this.config.initial || {}
-        };
-        const persisted = await readPersistedValue(this.config.persistence);
-        if (persisted !== null) {
-            try {
-                const parsed = JSON.parse(persisted);
-                this.snapshot = {
-                    ...this.snapshot,
-                    ...parsed
-                };
-            } catch  {
-            // ignore parse errors
-            }
-        } else {
-            await writePersistedValue(this.config.persistence, JSON.stringify(this.snapshot));
-        }
-        await setupI18n(this.snapshot.resources || {});
-        setLang(this.snapshot.locale);
-    }
-    getSnapshot() {
-        return {
-            ...this.snapshot
-        };
-    }
-    subscribe(listener) {
-        this.listeners.add(listener);
-        return ()=>{
-            this.listeners.delete(listener);
-        };
-    }
-    emit(next, prev) {
-        this.listeners.forEach((listener)=>{
-            listener({
-                ...next
-            }, {
-                ...prev
-            });
-        });
-    }
-    async setLocale(locale) {
-        const prev = this.snapshot;
-        this.snapshot = {
-            ...this.snapshot,
-            locale
-        };
-        setLang(locale);
-        await writePersistedValue(this.config.persistence, JSON.stringify(this.snapshot));
-        this.emit(this.snapshot, prev);
-    }
-    constructor(){
-        _define_property(this, "snapshot", DEFAULT_I18N);
-        _define_property(this, "config", DEFAULT_CONFIG.i18n);
-        _define_property(this, "listeners", new Set());
-    }
-}
+export { I18nManager } from "./i18n";
 
 //# sourceMappingURL=i18nManager.js.map

package/dist/kernel/manager/i18nManager.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/kernel/manager/i18nManager.ts"],"sourcesContent":["import { setupI18n, setLang } from '../../library';\nimport type { I18nSnapshot, KernelConfig, KernelManager, KernelManagerContext } from '../types';\nimport { DEFAULT_CONFIG, DEFAULT_I18N } from '../constants';\nimport { readPersistedValue, writePersistedValue } from './persistence';\n\ntype I18nListener = (next: I18nSnapshot, prev: I18nSnapshot) => void;\n\nexport class I18nManager implements KernelManager<I18nSnapshot> {\n  private snapshot: I18nSnapshot = DEFAULT_I18N;\n  private config: KernelConfig['i18n'] = DEFAULT_CONFIG.i18n;\n  private listeners = new Set<I18nListener>();\n\n  public async initialize(context: KernelManagerContext): Promise<void> {\n    this.config = context.config.i18n;\n    this.snapshot = { ...DEFAULT_I18N, ...(this.config.initial || {}) };\n\n    const persisted = await readPersistedValue(this.config.persistence);\n    if (persisted !== null) {\n      try {\n        const parsed = JSON.parse(persisted) as Partial<I18nSnapshot>;\n        this.snapshot = { ...this.snapshot, ...parsed };\n      } catch {\n        // ignore parse errors\n      }\n    } else {\n      await writePersistedValue(this.config.persistence, JSON.stringify(this.snapshot));\n    }\n\n    await setupI18n((this.snapshot.resources || {}) as any);\n    setLang(this.snapshot.locale);\n  }\n\n  public getSnapshot(): I18nSnapshot {\n    return { ...this.snapshot };\n  }\n\n  public subscribe(listener: I18nListener): () => void {\n    this.listeners.add(listener);\n    return () => {\n      this.listeners.delete(listener);\n    };\n  }\n\n  private emit(next: I18nSnapshot, prev: I18nSnapshot): void {\n    this.listeners.forEach((listener) => {\n      listener({ ...next }, { ...prev });\n    });\n  }\n\n  public async setLocale(locale: I18nSnapshot['locale']): Promise<void> {\n    const prev = this.snapshot;\n    this.snapshot = { ...this.snapshot, locale };\n    setLang(locale);\n    await writePersistedValue(this.config.persistence, JSON.stringify(this.snapshot));\n    this.emit(this.snapshot, prev);\n  }\n}\n"],"names":["setupI18n","setLang","DEFAULT_CONFIG","DEFAULT_I18N","readPersistedValue","writePersistedValue","I18nManager","initialize","context","config","i18n","snapshot","initial","persisted","persistence","parsed","JSON","parse","stringify","resources","locale","getSnapshot","subscribe","listener","listeners","add","delete","emit","next","prev","forEach","setLocale","Set"],"mappings":";;;;;;;;;;;;;AAAA,SAASA,SAAS,EAAEC,OAAO,QAAQ,gBAAgB;AAEnD,SAASC,cAAc,EAAEC,YAAY,QAAQ,eAAe;AAC5D,SAASC,kBAAkB,EAAEC,mBAAmB,QAAQ,gBAAgB;AAIxE,OAAO,MAAMC;IAKX,MAAaC,WAAWC,OAA6B,EAAiB;QACpE,IAAI,CAACC,MAAM,GAAGD,QAAQC,MAAM,CAACC,IAAI;QACjC,IAAI,CAACC,QAAQ,GAAG;YAAE,GAAGR,YAAY;YAAE,GAAI,IAAI,CAACM,MAAM,CAACG,OAAO,IAAI,CAAC,CAAC;QAAE;QAElE,MAAMC,YAAY,MAAMT,mBAAmB,IAAI,CAACK,MAAM,CAACK,WAAW;QAClE,IAAID,cAAc,MAAM;YACtB,IAAI;gBACF,MAAME,SAASC,KAAKC,KAAK,CAACJ;gBAC1B,IAAI,CAACF,QAAQ,GAAG;oBAAE,GAAG,IAAI,CAACA,QAAQ;oBAAE,GAAGI,MAAM;gBAAC;YAChD,EAAE,OAAM;YACN,sBAAsB;YACxB;QACF,OAAO;YACL,MAAMV,oBAAoB,IAAI,CAACI,MAAM,CAACK,WAAW,EAAEE,KAAKE,SAAS,CAAC,IAAI,CAACP,QAAQ;QACjF;QAEA,MAAMX,UAAW,IAAI,CAACW,QAAQ,CAACQ,SAAS,IAAI,CAAC;QAC7ClB,QAAQ,IAAI,CAACU,QAAQ,CAACS,MAAM;IAC9B;IAEOC,cAA4B;QACjC,OAAO;YAAE,GAAG,IAAI,CAACV,QAAQ;QAAC;IAC5B;IAEOW,UAAUC,QAAsB,EAAc;QACnD,IAAI,CAACC,SAAS,CAACC,GAAG,CAACF;QACnB,OAAO;YACL,IAAI,CAACC,SAAS,CAACE,MAAM,CAACH;QACxB;IACF;IAEQI,KAAKC,IAAkB,EAAEC,IAAkB,EAAQ;QACzD,IAAI,CAACL,SAAS,CAACM,OAAO,CAAC,CAACP;YACtBA,SAAS;gBAAE,GAAGK,IAAI;YAAC,GAAG;gBAAE,GAAGC,IAAI;YAAC;QAClC;IACF;IAEA,MAAaE,UAAUX,MAA8B,EAAiB;QACpE,MAAMS,OAAO,IAAI,CAAClB,QAAQ;QAC1B,IAAI,CAACA,QAAQ,GAAG;YAAE,GAAG,IAAI,CAACA,QAAQ;YAAES;QAAO;QAC3CnB,QAAQmB;QACR,MAAMf,oBAAoB,IAAI,CAACI,MAAM,CAACK,WAAW,EAAEE,KAAKE,SAAS,CAAC,IAAI,CAACP,QAAQ;QAC/E,IAAI,CAACgB,IAAI,CAAC,IAAI,CAAChB,QAAQ,EAAEkB;IAC3B;;QA/CA,uBAAQlB,YAAyBR;QACjC,uBAAQM,UAA+BP,eAAeQ,IAAI;QAC1D,uBAAQc,aAAY,IAAIQ;;AA8C1B"}
+{"version":3,"sources":["../../../src/kernel/manager/i18nManager.ts"],"sourcesContent":["export { I18nManager } from './i18n';\n"],"names":["I18nManager"],"mappings":"AAAA,SAASA,WAAW,QAAQ,SAAS"}

package/dist/kernel/manager/logger/LoggerManager.cjs

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LoggerManager", {
+    enumerable: true,
+    get: function() {
+        return LoggerManager;
+    }
+});
+const _logger = require("@vlian/logger");
+const _constants = require("../../constants");
+const _loggerschema = require("./logger.schema");
+const _loggerpersistence = require("./logger.persistence");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+let LoggerManager = class LoggerManager {
+    async initialize(context) {
+        this.config = context.config.logger;
+        this.cacheManager = context.cacheManager;
+        const initialSnapshot = (0, _loggerschema.normalizeLoggerSnapshot)({
+            level: this.config.level
+        }, {
+            level: _logger.LogLevel.INFO
+        });
+        this.snapshot = await (0, _loggerpersistence.loadLoggerFromCache)(this.cacheManager, this.config.persistence, initialSnapshot);
+        _logger.logger.setLevel(this.snapshot.level);
+        this.initialized = true;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return ()=>{
+            this.listeners.delete(listener);
+        };
+    }
+    debug(...args) {
+        _logger.logger.debug(...args);
+    }
+    info(...args) {
+        _logger.logger.info(...args);
+    }
+    warn(...args) {
+        _logger.logger.warn(...args);
+    }
+    error(...args) {
+        _logger.logger.error(...args);
+    }
+    async setLevel(level) {
+        this.ensureInitialized();
+        const prevSnapshot = this.snapshot;
+        const nextSnapshot = (0, _loggerschema.normalizeLoggerSnapshot)({
+            level
+        }, prevSnapshot);
+        if ((0, _loggerschema.isLoggerEqual)(prevSnapshot, nextSnapshot)) {
+            return;
+        }
+        this.snapshot = nextSnapshot;
+        _logger.logger.setLevel(this.snapshot.level);
+        if (this.cacheManager) {
+            await (0, _loggerpersistence.saveLoggerToCache)(this.cacheManager, this.config.persistence, this.snapshot);
+        }
+        this.emit(this.snapshot, prevSnapshot);
+    }
+    getSnapshot() {
+        return {
+            ...this.snapshot
+        };
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('LoggerManager must be initialized before use.');
+        }
+    }
+    emit(next, prev) {
+        for (const listener of this.listeners){
+            try {
+                listener({
+                    ...next
+                }, {
+                    ...prev
+                });
+            } catch  {
+            // Keep notifying remaining listeners even if one fails.
+            }
+        }
+    }
+    constructor(){
+        _define_property(this, "snapshot", {
+            level: _logger.LogLevel.INFO
+        });
+        _define_property(this, "config", _constants.DEFAULT_CONFIG.logger);
+        _define_property(this, "listeners", new Set());
+        _define_property(this, "cacheManager", null);
+        _define_property(this, "initialized", false);
+    }
+};
+
+//# sourceMappingURL=LoggerManager.js.map

package/dist/kernel/manager/logger/LoggerManager.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/kernel/manager/logger/LoggerManager.ts"],"sourcesContent":["import { logger, LogLevel } from '@vlian/logger';\nimport type { Logger } from '@vlian/logger';\nimport type { StorageInstance } from '@vlian/utils';\nimport { DEFAULT_CONFIG } from '../../constants';\nimport type { KernelConfig, KernelManager, KernelManagerContext } from '../../types';\nimport {\n  isLoggerEqual,\n  normalizeLoggerSnapshot,\n  type LoggerListener,\n  type LoggerSnapshot,\n} from './logger.schema';\nimport { loadLoggerFromCache, saveLoggerToCache } from './logger.persistence';\n\nexport class LoggerManager implements KernelManager<LoggerSnapshot> {\n  private snapshot: LoggerSnapshot = { level: LogLevel.INFO };\n  private config: KernelConfig['logger'] = DEFAULT_CONFIG.logger;\n  private listeners = new Set<LoggerListener>();\n  private cacheManager: StorageInstance | null = null;\n  private initialized = false;\n\n  public async initialize(context: KernelManagerContext): Promise<void> {\n    this.config = context.config.logger;\n    this.cacheManager = context.cacheManager;\n\n    const initialSnapshot = normalizeLoggerSnapshot(\n      { level: this.config.level },\n      { level: LogLevel.INFO }\n    );\n\n    this.snapshot = await loadLoggerFromCache(this.cacheManager, this.config.persistence, initialSnapshot);\n    logger.setLevel(this.snapshot.level);\n    this.initialized = true;\n  }\n\n  public subscribe(listener: LoggerListener): () => void {\n    this.listeners.add(listener);\n\n    return () => {\n      this.listeners.delete(listener);\n    };\n  }\n\n  public debug(...args: Parameters<Logger['debug']>): void {\n    logger.debug(...args);\n  }\n\n  public info(...args: Parameters<Logger['info']>): void {\n    logger.info(...args);\n  }\n\n  public warn(...args: Parameters<Logger['warn']>): void {\n    logger.warn(...args);\n  }\n\n  public error(...args: Parameters<Logger['error']>): void {\n    logger.error(...args);\n  }\n\n  public async setLevel(level: LogLevel): Promise<void> {\n    this.ensureInitialized();\n\n    const prevSnapshot = this.snapshot;\n    const nextSnapshot = normalizeLoggerSnapshot({ level }, prevSnapshot);\n\n    if (isLoggerEqual(prevSnapshot, nextSnapshot)) {\n      return;\n    }\n\n    this.snapshot = nextSnapshot;\n    logger.setLevel(this.snapshot.level);\n\n    if (this.cacheManager) {\n      await saveLoggerToCache(this.cacheManager, this.config.persistence, this.snapshot);\n    }\n\n    this.emit(this.snapshot, prevSnapshot);\n  }\n\n  public getSnapshot(): LoggerSnapshot {\n    return { ...this.snapshot };\n  }\n\n  private ensureInitialized(): void {\n    if (!this.initialized) {\n      throw new Error('LoggerManager must be initialized before use.');\n    }\n  }\n\n  private emit(next: LoggerSnapshot, prev: LoggerSnapshot): void {\n    for (const listener of this.listeners) {\n      try {\n        listener({ ...next }, { ...prev });\n      } catch {\n        // Keep notifying remaining listeners even if one fails.\n      }\n    }\n  }\n}\n"],"names":["LoggerManager","initialize","context","config","logger","cacheManager","initialSnapshot","normalizeLoggerSnapshot","level","LogLevel","INFO","snapshot","loadLoggerFromCache","persistence","setLevel","initialized","subscribe","listener","listeners","add","delete","debug","args","info","warn","error","ensureInitialized","prevSnapshot","nextSnapshot","isLoggerEqual","saveLoggerToCache","emit","getSnapshot","Error","next","prev","DEFAULT_CONFIG","Set"],"mappings":";;;;+BAaaA;;;eAAAA;;;wBAboB;2BAGF;8BAOxB;mCACgD;;;;;;;;;;;;;;AAEhD,IAAA,AAAMA,gBAAN,MAAMA;IAOX,MAAaC,WAAWC,OAA6B,EAAiB;QACpE,IAAI,CAACC,MAAM,GAAGD,QAAQC,MAAM,CAACC,MAAM;QACnC,IAAI,CAACC,YAAY,GAAGH,QAAQG,YAAY;QAExC,MAAMC,kBAAkBC,IAAAA,qCAAuB,EAC7C;YAAEC,OAAO,IAAI,CAACL,MAAM,CAACK,KAAK;QAAC,GAC3B;YAAEA,OAAOC,gBAAQ,CAACC,IAAI;QAAC;QAGzB,IAAI,CAACC,QAAQ,GAAG,MAAMC,IAAAA,sCAAmB,EAAC,IAAI,CAACP,YAAY,EAAE,IAAI,CAACF,MAAM,CAACU,WAAW,EAAEP;QACtFF,cAAM,CAACU,QAAQ,CAAC,IAAI,CAACH,QAAQ,CAACH,KAAK;QACnC,IAAI,CAACO,WAAW,GAAG;IACrB;IAEOC,UAAUC,QAAwB,EAAc;QACrD,IAAI,CAACC,SAAS,CAACC,GAAG,CAACF;QAEnB,OAAO;YACL,IAAI,CAACC,SAAS,CAACE,MAAM,CAACH;QACxB;IACF;IAEOI,MAAM,GAAGC,IAAiC,EAAQ;QACvDlB,cAAM,CAACiB,KAAK,IAAIC;IAClB;IAEOC,KAAK,GAAGD,IAAgC,EAAQ;QACrDlB,cAAM,CAACmB,IAAI,IAAID;IACjB;IAEOE,KAAK,GAAGF,IAAgC,EAAQ;QACrDlB,cAAM,CAACoB,IAAI,IAAIF;IACjB;IAEOG,MAAM,GAAGH,IAAiC,EAAQ;QACvDlB,cAAM,CAACqB,KAAK,IAAIH;IAClB;IAEA,MAAaR,SAASN,KAAe,EAAiB;QACpD,IAAI,CAACkB,iBAAiB;QAEtB,MAAMC,eAAe,IAAI,CAAChB,QAAQ;QAClC,MAAMiB,eAAerB,IAAAA,qCAAuB,EAAC;YAAEC;QAAM,GAAGmB;QAExD,IAAIE,IAAAA,2BAAa,EAACF,cAAcC,eAAe;YAC7C;QACF;QAEA,IAAI,CAACjB,QAAQ,GAAGiB;QAChBxB,cAAM,CAACU,QAAQ,CAAC,IAAI,CAACH,QAAQ,CAACH,KAAK;QAEnC,IAAI,IAAI,CAACH,YAAY,EAAE;YACrB,MAAMyB,IAAAA,oCAAiB,EAAC,IAAI,CAACzB,YAAY,EAAE,IAAI,CAACF,MAAM,CAACU,WAAW,EAAE,IAAI,CAACF,QAAQ;QACnF;QAEA,IAAI,CAACoB,IAAI,CAAC,IAAI,CAACpB,QAAQ,EAAEgB;IAC3B;IAEOK,cAA8B;QACnC,OAAO;YAAE,GAAG,IAAI,CAACrB,QAAQ;QAAC;IAC5B;IAEQe,oBAA0B;QAChC,IAAI,CAAC,IAAI,CAACX,WAAW,EAAE;YACrB,MAAM,IAAIkB,MAAM;QAClB;IACF;IAEQF,KAAKG,IAAoB,EAAEC,IAAoB,EAAQ;QAC7D,KAAK,MAAMlB,YAAY,IAAI,CAACC,SAAS,CAAE;YACrC,IAAI;gBACFD,SAAS;oBAAE,GAAGiB,IAAI;gBAAC,GAAG;oBAAE,GAAGC,IAAI;gBAAC;YAClC,EAAE,OAAM;YACN,wDAAwD;YAC1D;QACF;IACF;;QAlFA,uBAAQxB,YAA2B;YAAEH,OAAOC,gBAAQ,CAACC,IAAI;QAAC;QAC1D,uBAAQP,UAAiCiC,yBAAc,CAAChC,MAAM;QAC9D,uBAAQc,aAAY,IAAImB;QACxB,uBAAQhC,gBAAuC;QAC/C,uBAAQU,eAAc;;AA+ExB"}

package/dist/kernel/manager/logger/LoggerManager.d.ts

@@ -0,0 +1,21 @@
+import { LogLevel } from '@vlian/logger';
+import type { Logger } from '@vlian/logger';
+import type { KernelManager, KernelManagerContext } from '../../types';
+import { type LoggerListener, type LoggerSnapshot } from './logger.schema';
+export declare class LoggerManager implements KernelManager<LoggerSnapshot> {
+    private snapshot;
+    private config;
+    private listeners;
+    private cacheManager;
+    private initialized;
+    initialize(context: KernelManagerContext): Promise<void>;
+    subscribe(listener: LoggerListener): () => void;
+    debug(...args: Parameters<Logger['debug']>): void;
+    info(...args: Parameters<Logger['info']>): void;
+    warn(...args: Parameters<Logger['warn']>): void;
+    error(...args: Parameters<Logger['error']>): void;
+    setLevel(level: LogLevel): Promise<void>;
+    getSnapshot(): LoggerSnapshot;
+    private ensureInitialized;
+    private emit;
+}

package/dist/kernel/manager/logger/LoggerManager.js

@@ -0,0 +1,99 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { logger, LogLevel } from "@vlian/logger";
+import { DEFAULT_CONFIG } from "../../constants";
+import { isLoggerEqual, normalizeLoggerSnapshot } from "./logger.schema";
+import { loadLoggerFromCache, saveLoggerToCache } from "./logger.persistence";
+export class LoggerManager {
+    async initialize(context) {
+        this.config = context.config.logger;
+        this.cacheManager = context.cacheManager;
+        const initialSnapshot = normalizeLoggerSnapshot({
+            level: this.config.level
+        }, {
+            level: LogLevel.INFO
+        });
+        this.snapshot = await loadLoggerFromCache(this.cacheManager, this.config.persistence, initialSnapshot);
+        logger.setLevel(this.snapshot.level);
+        this.initialized = true;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return ()=>{
+            this.listeners.delete(listener);
+        };
+    }
+    debug(...args) {
+        logger.debug(...args);
+    }
+    info(...args) {
+        logger.info(...args);
+    }
+    warn(...args) {
+        logger.warn(...args);
+    }
+    error(...args) {
+        logger.error(...args);
+    }
+    async setLevel(level) {
+        this.ensureInitialized();
+        const prevSnapshot = this.snapshot;
+        const nextSnapshot = normalizeLoggerSnapshot({
+            level
+        }, prevSnapshot);
+        if (isLoggerEqual(prevSnapshot, nextSnapshot)) {
+            return;
+        }
+        this.snapshot = nextSnapshot;
+        logger.setLevel(this.snapshot.level);
+        if (this.cacheManager) {
+            await saveLoggerToCache(this.cacheManager, this.config.persistence, this.snapshot);
+        }
+        this.emit(this.snapshot, prevSnapshot);
+    }
+    getSnapshot() {
+        return {
+            ...this.snapshot
+        };
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('LoggerManager must be initialized before use.');
+        }
+    }
+    emit(next, prev) {
+        for (const listener of this.listeners){
+            try {
+                listener({
+                    ...next
+                }, {
+                    ...prev
+                });
+            } catch  {
+            // Keep notifying remaining listeners even if one fails.
+            }
+        }
+    }
+    constructor(){
+        _define_property(this, "snapshot", {
+            level: LogLevel.INFO
+        });
+        _define_property(this, "config", DEFAULT_CONFIG.logger);
+        _define_property(this, "listeners", new Set());
+        _define_property(this, "cacheManager", null);
+        _define_property(this, "initialized", false);
+    }
+}
+
+//# sourceMappingURL=LoggerManager.js.map

package/dist/kernel/manager/logger/LoggerManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/kernel/manager/logger/LoggerManager.ts"],"sourcesContent":["import { logger, LogLevel } from '@vlian/logger';\nimport type { Logger } from '@vlian/logger';\nimport type { StorageInstance } from '@vlian/utils';\nimport { DEFAULT_CONFIG } from '../../constants';\nimport type { KernelConfig, KernelManager, KernelManagerContext } from '../../types';\nimport {\n  isLoggerEqual,\n  normalizeLoggerSnapshot,\n  type LoggerListener,\n  type LoggerSnapshot,\n} from './logger.schema';\nimport { loadLoggerFromCache, saveLoggerToCache } from './logger.persistence';\n\nexport class LoggerManager implements KernelManager<LoggerSnapshot> {\n  private snapshot: LoggerSnapshot = { level: LogLevel.INFO };\n  private config: KernelConfig['logger'] = DEFAULT_CONFIG.logger;\n  private listeners = new Set<LoggerListener>();\n  private cacheManager: StorageInstance | null = null;\n  private initialized = false;\n\n  public async initialize(context: KernelManagerContext): Promise<void> {\n    this.config = context.config.logger;\n    this.cacheManager = context.cacheManager;\n\n    const initialSnapshot = normalizeLoggerSnapshot(\n      { level: this.config.level },\n      { level: LogLevel.INFO }\n    );\n\n    this.snapshot = await loadLoggerFromCache(this.cacheManager, this.config.persistence, initialSnapshot);\n    logger.setLevel(this.snapshot.level);\n    this.initialized = true;\n  }\n\n  public subscribe(listener: LoggerListener): () => void {\n    this.listeners.add(listener);\n\n    return () => {\n      this.listeners.delete(listener);\n    };\n  }\n\n  public debug(...args: Parameters<Logger['debug']>): void {\n    logger.debug(...args);\n  }\n\n  public info(...args: Parameters<Logger['info']>): void {\n    logger.info(...args);\n  }\n\n  public warn(...args: Parameters<Logger['warn']>): void {\n    logger.warn(...args);\n  }\n\n  public error(...args: Parameters<Logger['error']>): void {\n    logger.error(...args);\n  }\n\n  public async setLevel(level: LogLevel): Promise<void> {\n    this.ensureInitialized();\n\n    const prevSnapshot = this.snapshot;\n    const nextSnapshot = normalizeLoggerSnapshot({ level }, prevSnapshot);\n\n    if (isLoggerEqual(prevSnapshot, nextSnapshot)) {\n      return;\n    }\n\n    this.snapshot = nextSnapshot;\n    logger.setLevel(this.snapshot.level);\n\n    if (this.cacheManager) {\n      await saveLoggerToCache(this.cacheManager, this.config.persistence, this.snapshot);\n    }\n\n    this.emit(this.snapshot, prevSnapshot);\n  }\n\n  public getSnapshot(): LoggerSnapshot {\n    return { ...this.snapshot };\n  }\n\n  private ensureInitialized(): void {\n    if (!this.initialized) {\n      throw new Error('LoggerManager must be initialized before use.');\n    }\n  }\n\n  private emit(next: LoggerSnapshot, prev: LoggerSnapshot): void {\n    for (const listener of this.listeners) {\n      try {\n        listener({ ...next }, { ...prev });\n      } catch {\n        // Keep notifying remaining listeners even if one fails.\n      }\n    }\n  }\n}\n"],"names":["logger","LogLevel","DEFAULT_CONFIG","isLoggerEqual","normalizeLoggerSnapshot","loadLoggerFromCache","saveLoggerToCache","LoggerManager","initialize","context","config","cacheManager","initialSnapshot","level","INFO","snapshot","persistence","setLevel","initialized","subscribe","listener","listeners","add","delete","debug","args","info","warn","error","ensureInitialized","prevSnapshot","nextSnapshot","emit","getSnapshot","Error","next","prev","Set"],"mappings":";;;;;;;;;;;;;AAAA,SAASA,MAAM,EAAEC,QAAQ,QAAQ,gBAAgB;AAGjD,SAASC,cAAc,QAAQ,kBAAkB;AAEjD,SACEC,aAAa,EACbC,uBAAuB,QAGlB,kBAAkB;AACzB,SAASC,mBAAmB,EAAEC,iBAAiB,QAAQ,uBAAuB;AAE9E,OAAO,MAAMC;IAOX,MAAaC,WAAWC,OAA6B,EAAiB;QACpE,IAAI,CAACC,MAAM,GAAGD,QAAQC,MAAM,CAACV,MAAM;QACnC,IAAI,CAACW,YAAY,GAAGF,QAAQE,YAAY;QAExC,MAAMC,kBAAkBR,wBACtB;YAAES,OAAO,IAAI,CAACH,MAAM,CAACG,KAAK;QAAC,GAC3B;YAAEA,OAAOZ,SAASa,IAAI;QAAC;QAGzB,IAAI,CAACC,QAAQ,GAAG,MAAMV,oBAAoB,IAAI,CAACM,YAAY,EAAE,IAAI,CAACD,MAAM,CAACM,WAAW,EAAEJ;QACtFZ,OAAOiB,QAAQ,CAAC,IAAI,CAACF,QAAQ,CAACF,KAAK;QACnC,IAAI,CAACK,WAAW,GAAG;IACrB;IAEOC,UAAUC,QAAwB,EAAc;QACrD,IAAI,CAACC,SAAS,CAACC,GAAG,CAACF;QAEnB,OAAO;YACL,IAAI,CAACC,SAAS,CAACE,MAAM,CAACH;QACxB;IACF;IAEOI,MAAM,GAAGC,IAAiC,EAAQ;QACvDzB,OAAOwB,KAAK,IAAIC;IAClB;IAEOC,KAAK,GAAGD,IAAgC,EAAQ;QACrDzB,OAAO0B,IAAI,IAAID;IACjB;IAEOE,KAAK,GAAGF,IAAgC,EAAQ;QACrDzB,OAAO2B,IAAI,IAAIF;IACjB;IAEOG,MAAM,GAAGH,IAAiC,EAAQ;QACvDzB,OAAO4B,KAAK,IAAIH;IAClB;IAEA,MAAaR,SAASJ,KAAe,EAAiB;QACpD,IAAI,CAACgB,iBAAiB;QAEtB,MAAMC,eAAe,IAAI,CAACf,QAAQ;QAClC,MAAMgB,eAAe3B,wBAAwB;YAAES;QAAM,GAAGiB;QAExD,IAAI3B,cAAc2B,cAAcC,eAAe;YAC7C;QACF;QAEA,IAAI,CAAChB,QAAQ,GAAGgB;QAChB/B,OAAOiB,QAAQ,CAAC,IAAI,CAACF,QAAQ,CAACF,KAAK;QAEnC,IAAI,IAAI,CAACF,YAAY,EAAE;YACrB,MAAML,kBAAkB,IAAI,CAACK,YAAY,EAAE,IAAI,CAACD,MAAM,CAACM,WAAW,EAAE,IAAI,CAACD,QAAQ;QACnF;QAEA,IAAI,CAACiB,IAAI,CAAC,IAAI,CAACjB,QAAQ,EAAEe;IAC3B;IAEOG,cAA8B;QACnC,OAAO;YAAE,GAAG,IAAI,CAAClB,QAAQ;QAAC;IAC5B;IAEQc,oBAA0B;QAChC,IAAI,CAAC,IAAI,CAACX,WAAW,EAAE;YACrB,MAAM,IAAIgB,MAAM;QAClB;IACF;IAEQF,KAAKG,IAAoB,EAAEC,IAAoB,EAAQ;QAC7D,KAAK,MAAMhB,YAAY,IAAI,CAACC,SAAS,CAAE;YACrC,IAAI;gBACFD,SAAS;oBAAE,GAAGe,IAAI;gBAAC,GAAG;oBAAE,GAAGC,IAAI;gBAAC;YAClC,EAAE,OAAM;YACN,wDAAwD;YAC1D;QACF;IACF;;QAlFA,uBAAQrB,YAA2B;YAAEF,OAAOZ,SAASa,IAAI;QAAC;QAC1D,uBAAQJ,UAAiCR,eAAeF,MAAM;QAC9D,uBAAQqB,aAAY,IAAIgB;QACxB,uBAAQ1B,gBAAuC;QAC/C,uBAAQO,eAAc;;AA+ExB"}

package/dist/kernel/manager/logger/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LoggerManager", {
+    enumerable: true,
+    get: function() {
+        return _LoggerManager.LoggerManager;
+    }
+});
+const _LoggerManager = require("./LoggerManager");
+
+//# sourceMappingURL=index.js.map

package/dist/kernel/manager/logger/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/kernel/manager/logger/index.ts"],"sourcesContent":["export { LoggerManager } from './LoggerManager';\n"],"names":["LoggerManager"],"mappings":";;;;+BAASA;;;eAAAA,4BAAa;;;+BAAQ"}

package/dist/kernel/manager/logger/index.d.ts

@@ -0,0 +1 @@
+export { LoggerManager } from './LoggerManager';

package/dist/kernel/manager/logger/index.js

@@ -0,0 +1,3 @@
+export { LoggerManager } from "./LoggerManager";
+
+//# sourceMappingURL=index.js.map

package/dist/kernel/manager/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/kernel/manager/logger/index.ts"],"sourcesContent":["export { LoggerManager } from './LoggerManager';\n"],"names":["LoggerManager"],"mappings":"AAAA,SAASA,aAAa,QAAQ,kBAAkB"}

package/dist/kernel/manager/logger/logger.persistence.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_LOGGER_CACHE_KEY () {
+        return DEFAULT_LOGGER_CACHE_KEY;
+    },
+    get loadLoggerFromCache () {
+        return loadLoggerFromCache;
+    },
+    get saveLoggerToCache () {
+        return saveLoggerToCache;
+    }
+});
+const _loggerschema = require("./logger.schema");
+const DEFAULT_LOGGER_CACHE_KEY = 'vlian:kernel:logger-level';
+function resolvePersistenceContext(persistence) {
+    if (persistence?.enabled !== true) {
+        return null;
+    }
+    return {
+        key: persistence.key || DEFAULT_LOGGER_CACHE_KEY
+    };
+}
+async function loadLoggerFromCache(cacheManager, persistence, fallback) {
+    const persistenceContext = resolvePersistenceContext(persistence);
+    if (!persistenceContext) {
+        return {
+            ...fallback
+        };
+    }
+    try {
+        const cached = await cacheManager.get(persistenceContext.key, {
+            defaultValue: fallback
+        });
+        return (0, _loggerschema.normalizeLoggerSnapshot)(cached, fallback);
+    } catch  {
+        return {
+            ...fallback
+        };
+    }
+}
+async function saveLoggerToCache(cacheManager, persistence, snapshot) {
+    const persistenceContext = resolvePersistenceContext(persistence);
+    if (!persistenceContext) {
+        return;
+    }
+    try {
+        await cacheManager.set(persistenceContext.key, {
+            ...snapshot
+        });
+    } catch  {
+    // Ignore persistence failures and keep logger updates in memory.
+    }
+}
+
+//# sourceMappingURL=logger.persistence.js.map

package/dist/kernel/manager/logger/logger.persistence.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/kernel/manager/logger/logger.persistence.ts"],"sourcesContent":["import type { StorageInstance } from '@vlian/utils';\nimport type { PersistenceOptions } from '../../types';\nimport { normalizeLoggerSnapshot, type LoggerSnapshot } from './logger.schema';\n\nexport const DEFAULT_LOGGER_CACHE_KEY = 'vlian:kernel:logger-level';\n\ntype ResolvedPersistenceContext = {\n  key: string;\n};\n\nfunction resolvePersistenceContext(\n  persistence: PersistenceOptions | undefined\n): ResolvedPersistenceContext | null {\n  if (persistence?.enabled !== true) {\n    return null;\n  }\n\n  return {\n    key: persistence.key || DEFAULT_LOGGER_CACHE_KEY,\n  };\n}\n\nexport async function loadLoggerFromCache(\n  cacheManager: StorageInstance,\n  persistence: PersistenceOptions | undefined,\n  fallback: LoggerSnapshot\n): Promise<LoggerSnapshot> {\n  const persistenceContext = resolvePersistenceContext(persistence);\n\n  if (!persistenceContext) {\n    return { ...fallback };\n  }\n\n  try {\n    const cached = await cacheManager.get<LoggerSnapshot | string | number>(persistenceContext.key, {\n      defaultValue: fallback,\n    });\n    return normalizeLoggerSnapshot(cached, fallback);\n  } catch {\n    return { ...fallback };\n  }\n}\n\nexport async function saveLoggerToCache(\n  cacheManager: StorageInstance,\n  persistence: PersistenceOptions | undefined,\n  snapshot: LoggerSnapshot\n): Promise<void> {\n  const persistenceContext = resolvePersistenceContext(persistence);\n\n  if (!persistenceContext) {\n    return;\n  }\n\n  try {\n    await cacheManager.set(persistenceContext.key, { ...snapshot });\n  } catch {\n    // Ignore persistence failures and keep logger updates in memory.\n  }\n}\n"],"names":["DEFAULT_LOGGER_CACHE_KEY","loadLoggerFromCache","saveLoggerToCache","resolvePersistenceContext","persistence","enabled","key","cacheManager","fallback","persistenceContext","cached","get","defaultValue","normalizeLoggerSnapshot","snapshot","set"],"mappings":";;;;;;;;;;;QAIaA;eAAAA;;QAkBSC;eAAAA;;QAqBAC;eAAAA;;;8BAzCuC;AAEtD,MAAMF,2BAA2B;AAMxC,SAASG,0BACPC,WAA2C;IAE3C,IAAIA,aAAaC,YAAY,MAAM;QACjC,OAAO;IACT;IAEA,OAAO;QACLC,KAAKF,YAAYE,GAAG,IAAIN;IAC1B;AACF;AAEO,eAAeC,oBACpBM,YAA6B,EAC7BH,WAA2C,EAC3CI,QAAwB;IAExB,MAAMC,qBAAqBN,0BAA0BC;IAErD,IAAI,CAACK,oBAAoB;QACvB,OAAO;YAAE,GAAGD,QAAQ;QAAC;IACvB;IAEA,IAAI;QACF,MAAME,SAAS,MAAMH,aAAaI,GAAG,CAAmCF,mBAAmBH,GAAG,EAAE;YAC9FM,cAAcJ;QAChB;QACA,OAAOK,IAAAA,qCAAuB,EAACH,QAAQF;IACzC,EAAE,OAAM;QACN,OAAO;YAAE,GAAGA,QAAQ;QAAC;IACvB;AACF;AAEO,eAAeN,kBACpBK,YAA6B,EAC7BH,WAA2C,EAC3CU,QAAwB;IAExB,MAAML,qBAAqBN,0BAA0BC;IAErD,IAAI,CAACK,oBAAoB;QACvB;IACF;IAEA,IAAI;QACF,MAAMF,aAAaQ,GAAG,CAACN,mBAAmBH,GAAG,EAAE;YAAE,GAAGQ,QAAQ;QAAC;IAC/D,EAAE,OAAM;IACN,iEAAiE;IACnE;AACF"}

package/dist/kernel/manager/logger/logger.persistence.d.ts

@@ -0,0 +1,6 @@
+import type { StorageInstance } from '@vlian/utils';
+import type { PersistenceOptions } from '../../types';
+import { type LoggerSnapshot } from './logger.schema';
+export declare const DEFAULT_LOGGER_CACHE_KEY = "vlian:kernel:logger-level";
+export declare function loadLoggerFromCache(cacheManager: StorageInstance, persistence: PersistenceOptions | undefined, fallback: LoggerSnapshot): Promise<LoggerSnapshot>;
+export declare function saveLoggerToCache(cacheManager: StorageInstance, persistence: PersistenceOptions | undefined, snapshot: LoggerSnapshot): Promise<void>;

package/dist/kernel/manager/logger/logger.persistence.js

@@ -0,0 +1,43 @@
+import { normalizeLoggerSnapshot } from "./logger.schema";
+export const DEFAULT_LOGGER_CACHE_KEY = 'vlian:kernel:logger-level';
+function resolvePersistenceContext(persistence) {
+    if (persistence?.enabled !== true) {
+        return null;
+    }
+    return {
+        key: persistence.key || DEFAULT_LOGGER_CACHE_KEY
+    };
+}
+export async function loadLoggerFromCache(cacheManager, persistence, fallback) {
+    const persistenceContext = resolvePersistenceContext(persistence);
+    if (!persistenceContext) {
+        return {
+            ...fallback
+        };
+    }
+    try {
+        const cached = await cacheManager.get(persistenceContext.key, {
+            defaultValue: fallback
+        });
+        return normalizeLoggerSnapshot(cached, fallback);
+    } catch  {
+        return {
+            ...fallback
+        };
+    }
+}
+export async function saveLoggerToCache(cacheManager, persistence, snapshot) {
+    const persistenceContext = resolvePersistenceContext(persistence);
+    if (!persistenceContext) {
+        return;
+    }
+    try {
+        await cacheManager.set(persistenceContext.key, {
+            ...snapshot
+        });
+    } catch  {
+    // Ignore persistence failures and keep logger updates in memory.
+    }
+}
+
+//# sourceMappingURL=logger.persistence.js.map

package/dist/kernel/manager/logger/logger.persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/kernel/manager/logger/logger.persistence.ts"],"sourcesContent":["import type { StorageInstance } from '@vlian/utils';\nimport type { PersistenceOptions } from '../../types';\nimport { normalizeLoggerSnapshot, type LoggerSnapshot } from './logger.schema';\n\nexport const DEFAULT_LOGGER_CACHE_KEY = 'vlian:kernel:logger-level';\n\ntype ResolvedPersistenceContext = {\n  key: string;\n};\n\nfunction resolvePersistenceContext(\n  persistence: PersistenceOptions | undefined\n): ResolvedPersistenceContext | null {\n  if (persistence?.enabled !== true) {\n    return null;\n  }\n\n  return {\n    key: persistence.key || DEFAULT_LOGGER_CACHE_KEY,\n  };\n}\n\nexport async function loadLoggerFromCache(\n  cacheManager: StorageInstance,\n  persistence: PersistenceOptions | undefined,\n  fallback: LoggerSnapshot\n): Promise<LoggerSnapshot> {\n  const persistenceContext = resolvePersistenceContext(persistence);\n\n  if (!persistenceContext) {\n    return { ...fallback };\n  }\n\n  try {\n    const cached = await cacheManager.get<LoggerSnapshot | string | number>(persistenceContext.key, {\n      defaultValue: fallback,\n    });\n    return normalizeLoggerSnapshot(cached, fallback);\n  } catch {\n    return { ...fallback };\n  }\n}\n\nexport async function saveLoggerToCache(\n  cacheManager: StorageInstance,\n  persistence: PersistenceOptions | undefined,\n  snapshot: LoggerSnapshot\n): Promise<void> {\n  const persistenceContext = resolvePersistenceContext(persistence);\n\n  if (!persistenceContext) {\n    return;\n  }\n\n  try {\n    await cacheManager.set(persistenceContext.key, { ...snapshot });\n  } catch {\n    // Ignore persistence failures and keep logger updates in memory.\n  }\n}\n"],"names":["normalizeLoggerSnapshot","DEFAULT_LOGGER_CACHE_KEY","resolvePersistenceContext","persistence","enabled","key","loadLoggerFromCache","cacheManager","fallback","persistenceContext","cached","get","defaultValue","saveLoggerToCache","snapshot","set"],"mappings":"AAEA,SAASA,uBAAuB,QAA6B,kBAAkB;AAE/E,OAAO,MAAMC,2BAA2B,4BAA4B;AAMpE,SAASC,0BACPC,WAA2C;IAE3C,IAAIA,aAAaC,YAAY,MAAM;QACjC,OAAO;IACT;IAEA,OAAO;QACLC,KAAKF,YAAYE,GAAG,IAAIJ;IAC1B;AACF;AAEA,OAAO,eAAeK,oBACpBC,YAA6B,EAC7BJ,WAA2C,EAC3CK,QAAwB;IAExB,MAAMC,qBAAqBP,0BAA0BC;IAErD,IAAI,CAACM,oBAAoB;QACvB,OAAO;YAAE,GAAGD,QAAQ;QAAC;IACvB;IAEA,IAAI;QACF,MAAME,SAAS,MAAMH,aAAaI,GAAG,CAAmCF,mBAAmBJ,GAAG,EAAE;YAC9FO,cAAcJ;QAChB;QACA,OAAOR,wBAAwBU,QAAQF;IACzC,EAAE,OAAM;QACN,OAAO;YAAE,GAAGA,QAAQ;QAAC;IACvB;AACF;AAEA,OAAO,eAAeK,kBACpBN,YAA6B,EAC7BJ,WAA2C,EAC3CW,QAAwB;IAExB,MAAML,qBAAqBP,0BAA0BC;IAErD,IAAI,CAACM,oBAAoB;QACvB;IACF;IAEA,IAAI;QACF,MAAMF,aAAaQ,GAAG,CAACN,mBAAmBJ,GAAG,EAAE;YAAE,GAAGS,QAAQ;QAAC;IAC/D,EAAE,OAAM;IACN,iEAAiE;IACnE;AACF"}

package/dist/kernel/manager/logger/logger.schema.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get isLoggerEqual () {
+        return isLoggerEqual;
+    },
+    get normalizeLogLevel () {
+        return normalizeLogLevel;
+    },
+    get normalizeLoggerSnapshot () {
+        return normalizeLoggerSnapshot;
+    }
+});
+const _logger = require("@vlian/logger");
+function normalizeLogLevel(value, fallback) {
+    if (typeof value === 'number' && Number.isInteger(value)) {
+        switch(value){
+            case _logger.LogLevel.DEBUG:
+            case _logger.LogLevel.INFO:
+            case _logger.LogLevel.WARN:
+            case _logger.LogLevel.ERROR:
+            case _logger.LogLevel.NONE:
+                return value;
+            default:
+                return fallback;
+        }
+    }
+    if (typeof value !== 'string') {
+        return fallback;
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+        return fallback;
+    }
+    if (/^\d+$/.test(normalized)) {
+        return normalizeLogLevel(Number(normalized), fallback);
+    }
+    switch(normalized.toUpperCase()){
+        case 'DEBUG':
+            return _logger.LogLevel.DEBUG;
+        case 'INFO':
+            return _logger.LogLevel.INFO;
+        case 'WARN':
+            return _logger.LogLevel.WARN;
+        case 'ERROR':
+            return _logger.LogLevel.ERROR;
+        case 'NONE':
+            return _logger.LogLevel.NONE;
+        default:
+            return fallback;
+    }
+}
+function normalizeLoggerSnapshot(value, fallback) {
+    if (typeof value === 'number' || typeof value === 'string') {
+        return {
+            level: normalizeLogLevel(value, fallback.level)
+        };
+    }
+    const source = value && typeof value === 'object' ? value : {};
+    return {
+        level: normalizeLogLevel(source.level, fallback.level)
+    };
+}
+function isLoggerEqual(left, right) {
+    return left.level === right.level;
+}
+
+//# sourceMappingURL=logger.schema.js.map

package/dist/kernel/manager/logger/logger.schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/kernel/manager/logger/logger.schema.ts"],"sourcesContent":["import { LogLevel } from '@vlian/logger';\n\nexport type LoggerSnapshot = {\n  level: LogLevel;\n};\n\nexport type LoggerListener = (next: LoggerSnapshot, prev: LoggerSnapshot) => void;\n\nexport function normalizeLogLevel(value: unknown, fallback: LogLevel): LogLevel {\n  if (typeof value === 'number' && Number.isInteger(value)) {\n    switch (value) {\n      case LogLevel.DEBUG:\n      case LogLevel.INFO:\n      case LogLevel.WARN:\n      case LogLevel.ERROR:\n      case LogLevel.NONE:\n        return value;\n      default:\n        return fallback;\n    }\n  }\n\n  if (typeof value !== 'string') {\n    return fallback;\n  }\n\n  const normalized = value.trim();\n  if (!normalized) {\n    return fallback;\n  }\n\n  if (/^\\d+$/.test(normalized)) {\n    return normalizeLogLevel(Number(normalized), fallback);\n  }\n\n  switch (normalized.toUpperCase()) {\n    case 'DEBUG':\n      return LogLevel.DEBUG;\n    case 'INFO':\n      return LogLevel.INFO;\n    case 'WARN':\n      return LogLevel.WARN;\n    case 'ERROR':\n      return LogLevel.ERROR;\n    case 'NONE':\n      return LogLevel.NONE;\n    default:\n      return fallback;\n  }\n}\n\nexport function normalizeLoggerSnapshot(\n  value: unknown,\n  fallback: LoggerSnapshot\n): LoggerSnapshot {\n  if (typeof value === 'number' || typeof value === 'string') {\n    return {\n      level: normalizeLogLevel(value, fallback.level),\n    };\n  }\n\n  const source = value && typeof value === 'object' ? (value as Partial<LoggerSnapshot>) : {};\n\n  return {\n    level: normalizeLogLevel(source.level, fallback.level),\n  };\n}\n\nexport function isLoggerEqual(left: LoggerSnapshot, right: LoggerSnapshot): boolean {\n  return left.level === right.level;\n}\n"],"names":["isLoggerEqual","normalizeLogLevel","normalizeLoggerSnapshot","value","fallback","Number","isInteger","LogLevel","DEBUG","INFO","WARN","ERROR","NONE","normalized","trim","test","toUpperCase","level","source","left","right"],"mappings":";;;;;;;;;;;QAoEgBA;eAAAA;;QA5DAC;eAAAA;;QA2CAC;eAAAA;;;wBAnDS;AAQlB,SAASD,kBAAkBE,KAAc,EAAEC,QAAkB;IAClE,IAAI,OAAOD,UAAU,YAAYE,OAAOC,SAAS,CAACH,QAAQ;QACxD,OAAQA;YACN,KAAKI,gBAAQ,CAACC,KAAK;YACnB,KAAKD,gBAAQ,CAACE,IAAI;YAClB,KAAKF,gBAAQ,CAACG,IAAI;YAClB,KAAKH,gBAAQ,CAACI,KAAK;YACnB,KAAKJ,gBAAQ,CAACK,IAAI;gBAChB,OAAOT;YACT;gBACE,OAAOC;QACX;IACF;IAEA,IAAI,OAAOD,UAAU,UAAU;QAC7B,OAAOC;IACT;IAEA,MAAMS,aAAaV,MAAMW,IAAI;IAC7B,IAAI,CAACD,YAAY;QACf,OAAOT;IACT;IAEA,IAAI,QAAQW,IAAI,CAACF,aAAa;QAC5B,OAAOZ,kBAAkBI,OAAOQ,aAAaT;IAC/C;IAEA,OAAQS,WAAWG,WAAW;QAC5B,KAAK;YACH,OAAOT,gBAAQ,CAACC,KAAK;QACvB,KAAK;YACH,OAAOD,gBAAQ,CAACE,IAAI;QACtB,KAAK;YACH,OAAOF,gBAAQ,CAACG,IAAI;QACtB,KAAK;YACH,OAAOH,gBAAQ,CAACI,KAAK;QACvB,KAAK;YACH,OAAOJ,gBAAQ,CAACK,IAAI;QACtB;YACE,OAAOR;IACX;AACF;AAEO,SAASF,wBACdC,KAAc,EACdC,QAAwB;IAExB,IAAI,OAAOD,UAAU,YAAY,OAAOA,UAAU,UAAU;QAC1D,OAAO;YACLc,OAAOhB,kBAAkBE,OAAOC,SAASa,KAAK;QAChD;IACF;IAEA,MAAMC,SAASf,SAAS,OAAOA,UAAU,WAAYA,QAAoC,CAAC;IAE1F,OAAO;QACLc,OAAOhB,kBAAkBiB,OAAOD,KAAK,EAAEb,SAASa,KAAK;IACvD;AACF;AAEO,SAASjB,cAAcmB,IAAoB,EAAEC,KAAqB;IACvE,OAAOD,KAAKF,KAAK,KAAKG,MAAMH,KAAK;AACnC"}

package/dist/kernel/manager/logger/logger.schema.d.ts

@@ -0,0 +1,8 @@
+import { LogLevel } from '@vlian/logger';
+export type LoggerSnapshot = {
+    level: LogLevel;
+};
+export type LoggerListener = (next: LoggerSnapshot, prev: LoggerSnapshot) => void;
+export declare function normalizeLogLevel(value: unknown, fallback: LogLevel): LogLevel;
+export declare function normalizeLoggerSnapshot(value: unknown, fallback: LoggerSnapshot): LoggerSnapshot;
+export declare function isLoggerEqual(left: LoggerSnapshot, right: LoggerSnapshot): boolean;