@editor-x/wme-logstream 0.1.0-alpha.1

package/dist/index.cjs.js

@@ -0,0 +1,980 @@
+'use strict';
+
+var jsondiffpatch = require('jsondiffpatch');
+var fflate = require('fflate');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fflate__namespace = /*#__PURE__*/_interopNamespaceDefault(fflate);
+
+class Dispatcher {
+    pipes = [];
+    addPipe(pipe) {
+        this.pipes.push(pipe);
+    }
+    dispatch(payload) {
+        for (const pipe of this.pipes) {
+            try {
+                const result = pipe.write(payload);
+                if (result instanceof Promise) {
+                    result.catch((err) => {
+                        console.error('Error writing to pipe:', err);
+                    });
+                }
+            }
+            catch (err) {
+                console.error('Error writing to pipe:', err);
+            }
+        }
+    }
+    async flush() {
+        const flushPromises = this.pipes.map(async (pipe) => {
+            try {
+                await pipe.flush();
+            }
+            catch (err) {
+                console.error('Error flushing pipe:', err);
+            }
+        });
+        await Promise.all(flushPromises);
+    }
+}
+
+class BasePipe {
+}
+
+class ConsolePipe extends BasePipe {
+    scriptPrefix;
+    brandColor;
+    styles = {
+        TRACE: 'color: #888888; font-weight: normal;',
+        DEBUG: 'color: #03A9F4; font-weight: bold;',
+        INFO: 'color: #4CAF50; font-weight: bold;',
+        WARN: 'color: #FF9800; font-weight: bold;',
+        ERROR: 'color: #F44336; font-weight: bold;',
+        FATAL: 'color: #FFFFFF; background-color: #B71C1C; font-weight: bold; padding: 2px 4px; border-radius: 2px;',
+    };
+    constructor(config) {
+        super();
+        this.scriptPrefix = config?.scriptPrefix ?? 'EditorX';
+        this.brandColor = config?.brandColor ?? '#00E676';
+    }
+    write(payload) {
+        const timestampStr = new Date(payload.timestamp).toISOString().split('T')[1].slice(0, -1);
+        const scopesStr = payload.scopes.map((s) => `[${s}]`).join('');
+        const levelStr = payload.level;
+        const prefixStyle = `color: ${this.brandColor}; font-weight: bold;`;
+        const timeStyle = 'color: #9E9E9E;';
+        const levelStyle = this.styles[levelStr];
+        const scopeStyle = 'color: #9C27B0; font-weight: bold;';
+        const format = `%c[${this.scriptPrefix}] %c${timestampStr} %c[${levelStr}]%c%c${scopesStr}%c ${payload.message}`;
+        const args = [
+            format,
+            prefixStyle,
+            timeStyle,
+            levelStyle,
+            '', // reset level style
+            scopeStyle,
+            '', // reset scope style
+        ];
+        if (payload.data !== undefined) {
+            console.log(...args, payload.data);
+        }
+        else {
+            console.log(...args);
+        }
+    }
+    flush() { }
+}
+
+class IndexedDBPipe extends BasePipe {
+    dbManager = null;
+    initPromise = null;
+    buffer = [];
+    constructor(dbManagerOrPromise) {
+        super();
+        if (dbManagerOrPromise instanceof Promise) {
+            this.initPromise = dbManagerOrPromise.then((manager) => {
+                this.dbManager = manager;
+                for (const payload of this.buffer) {
+                    manager.writeLog(payload).catch(() => { });
+                }
+                this.buffer = [];
+                return manager;
+            });
+        }
+        else {
+            this.dbManager = dbManagerOrPromise;
+        }
+    }
+    async write(payload) {
+        if (this.dbManager) {
+            await this.dbManager.writeLog(payload);
+        }
+        else if (this.initPromise) {
+            this.buffer.push(payload);
+        }
+    }
+    async flush() {
+        if (this.dbManager) {
+            await this.dbManager.flush();
+        }
+        else if (this.initPromise) {
+            const manager = await this.initPromise;
+            await manager.flush();
+        }
+    }
+}
+
+/**
+ * Opens an IndexedDB connection and wraps the request in a Promise.
+ */
+function openDB(name, version, options) {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(name, version);
+        if (options?.onUpgradeNeeded) {
+            request.onupgradeneeded = (event) => {
+                options.onUpgradeNeeded(request.result, event);
+            };
+        }
+        if (options?.onBlocked) {
+            request.onblocked = (event) => {
+                options.onBlocked(event);
+            };
+        }
+        request.onsuccess = () => {
+            resolve(request.result);
+        };
+        request.onerror = () => {
+            reject(request.error);
+        };
+    });
+}
+/**
+ * Wraps a standard IDBRequest in a Promise.
+ */
+function wrapRequest(request) {
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+/**
+ * Runs a transaction on the database and resolves when the transaction completes.
+ */
+function runTransaction(db, storeNames, mode, callback) {
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeNames, mode);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+        callback(tx);
+    });
+}
+
+const DEFAULT_CONFIG = {
+    maxArchivedSessions: 15,
+    flushIntervalMs: 2000,
+};
+class IndexedDBManager {
+    dbPrefix;
+    maxArchivedSessions;
+    scriptVersion;
+    sessionId;
+    wmeVersion;
+    flushIntervalMs;
+    db = null;
+    queue = [];
+    flushTimer = null;
+    heartbeatTimer = null;
+    loggerVersion = '1.0.0';
+    schemaVersion = '1.0.0';
+    constructor(config) {
+        const merged = Object.assign({}, DEFAULT_CONFIG, config);
+        this.dbPrefix = merged.dbPrefix;
+        this.maxArchivedSessions = merged.maxArchivedSessions;
+        this.scriptVersion = merged.scriptVersion;
+        this.sessionId = merged.sessionId;
+        this.wmeVersion = merged.wmeVersion;
+        this.flushIntervalMs = merged.flushIntervalMs;
+    }
+    /**
+     * Returns the database name with prefix.
+     */
+    getDatabaseName() {
+        return `LogStreamDB_${this.dbPrefix}`;
+    }
+    /**
+     * Initializes the database connection and saves session metadata.
+     */
+    async init() {
+        const dbName = this.getDatabaseName();
+        this.db = await openDB(dbName, 1, {
+            onUpgradeNeeded: (db) => {
+                if (!db.objectStoreNames.contains('sessions')) {
+                    db.createObjectStore('sessions', { keyPath: 'id' });
+                }
+                if (!db.objectStoreNames.contains('logs')) {
+                    const logStore = db.createObjectStore('logs', { keyPath: 'id', autoIncrement: true });
+                    logStore.createIndex('sessionId', 'sessionId', { unique: false });
+                }
+            },
+        });
+        const now = Date.now();
+        const metadata = {
+            id: this.sessionId,
+            createdAt: now,
+            lastUpdated: now,
+            scriptVersion: this.scriptVersion,
+            wmeVersion: this.wmeVersion ?? 'unknown',
+            loggerVersion: this.loggerVersion,
+            schemaVersion: this.schemaVersion,
+        };
+        try {
+            await this.saveSessionMetadata(metadata);
+            this.startHeartbeat();
+        }
+        catch (err) {
+            if (this.db) {
+                this.db.close();
+                this.db = null;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Saves a session metadata record.
+     */
+    async saveSessionMetadata(metadata) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const transaction = this.db.transaction('sessions', 'readwrite');
+        const store = transaction.objectStore('sessions');
+        await wrapRequest(store.put(metadata));
+    }
+    /**
+     * Periodically updates the current session's lastUpdated timestamp.
+     */
+    async touchSession() {
+        if (!this.db)
+            return;
+        const transaction = this.db.transaction('sessions', 'readwrite');
+        const store = transaction.objectStore('sessions');
+        const metadata = (await wrapRequest(store.get(this.sessionId)));
+        if (metadata) {
+            metadata.lastUpdated = Date.now();
+            await wrapRequest(store.put(metadata));
+        }
+    }
+    /**
+     * Starts the session heartbeat interval.
+     */
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            this.touchSession().catch(() => { });
+        }, 10000); // 10-second heartbeat
+    }
+    /**
+     * Stops the session heartbeat interval.
+     */
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /**
+     * Writes a log entry, scheduling a flush or flushing immediately for high priority.
+     */
+    async writeLog(payload) {
+        const enrichedPayload = {
+            ...payload,
+            sessionId: this.sessionId,
+        };
+        const isHighPriority = payload.level === 'WARN' || payload.level === 'ERROR' || payload.level === 'FATAL';
+        if (isHighPriority) {
+            this.queue.push(enrichedPayload);
+            await this.flush();
+        }
+        else {
+            this.queue.push(enrichedPayload);
+            if (this.queue.length >= 50) {
+                await this.flush();
+            }
+            else if (!this.flushTimer) {
+                this.scheduleFlush();
+            }
+        }
+    }
+    /**
+     * Schedules a background flush if not already scheduled.
+     */
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flush().catch(() => { });
+        }, this.flushIntervalMs);
+    }
+    /**
+     * Instantly flushes the in-memory queue to IndexedDB.
+     */
+    async flush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.queue.length === 0) {
+            return;
+        }
+        const batch = [...this.queue];
+        this.queue = [];
+        await this.writeLogsBatch(batch);
+    }
+    /**
+     * Writes a batch of logs in a single transaction.
+     */
+    async writeLogsBatch(logs) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        await runTransaction(this.db, 'logs', 'readwrite', (tx) => {
+            const store = tx.objectStore('logs');
+            for (const log of logs) {
+                store.add(log);
+            }
+        });
+    }
+    /**
+     * Retrieves all logs for a specific session.
+     */
+    async getLogsForSession(sessionId) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const transaction = this.db.transaction('logs', 'readonly');
+        const store = transaction.objectStore('logs');
+        const index = store.index('sessionId');
+        return wrapRequest(index.getAll(IDBKeyRange.only(sessionId)));
+    }
+    /**
+     * Retrieves all archived session records.
+     */
+    async getAllSessions() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const transaction = this.db.transaction('sessions', 'readonly');
+        const store = transaction.objectStore('sessions');
+        const result = await wrapRequest(store.getAll());
+        return result || [];
+    }
+    /**
+     * Prunes older sessions, keeping maxArchivedSessions.
+     * Protects active sessions in other tabs (updated in last 30s) and the current active session.
+     */
+    async pruneSessions() {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        const sessions = await this.getAllSessions();
+        if (sessions.length <= this.maxArchivedSessions) {
+            return;
+        }
+        // Sort by createdAt ascending (oldest first)
+        sessions.sort((a, b) => a.createdAt - b.createdAt);
+        const now = Date.now();
+        // Exclude active sessions:
+        // 1. Current session
+        // 2. Active sessions in other tabs (heartbeat within 2m / 120s)
+        const candidates = sessions.filter((s) => {
+            const isActiveSelf = s.id === this.sessionId;
+            const isActiveOther = s.lastUpdated && now - s.lastUpdated < 120000;
+            return !isActiveSelf && !isActiveOther;
+        });
+        const totalToPrune = sessions.length - this.maxArchivedSessions;
+        if (totalToPrune <= 0) {
+            return;
+        }
+        const sessionsToPrune = candidates.slice(0, totalToPrune);
+        for (const session of sessionsToPrune) {
+            const transaction = this.db.transaction('sessions', 'readwrite');
+            const store = transaction.objectStore('sessions');
+            await wrapRequest(store.delete(session.id));
+            await new Promise((resolve, reject) => {
+                const transaction = this.db.transaction('logs', 'readwrite');
+                const store = transaction.objectStore('logs');
+                const index = store.index('sessionId');
+                const request = index.openCursor(IDBKeyRange.only(session.id));
+                request.onsuccess = () => {
+                    const cursor = request.result;
+                    if (cursor) {
+                        cursor.delete();
+                        cursor.continue();
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                request.onerror = () => reject(request.error);
+            });
+        }
+    }
+    /**
+     * Streams logs for a session via cursor.
+     */
+    async streamLogsForSession(sessionId, onLog) {
+        if (!this.db)
+            throw new Error('Database not initialized');
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction('logs', 'readonly');
+            const store = transaction.objectStore('logs');
+            const index = store.index('sessionId');
+            const request = index.openCursor(IDBKeyRange.only(sessionId));
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    onLog(cursor.value);
+                    cursor.continue();
+                }
+                else {
+                    resolve();
+                }
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Flushes outstanding logs, stops heartbeat, and closes connection.
+     */
+    async close() {
+        this.stopHeartbeat();
+        await this.flush();
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+}
+
+/**
+ * Generates a unique, randomized Session ID string.
+ */
+function generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+
+class EventChannel {
+    channel;
+    listeners = new Map();
+    constructor(name) {
+        this.channel = new BroadcastChannel(name);
+        this.channel.onmessage = (event) => {
+            const data = event.data;
+            if (data && typeof data.type === 'string') {
+                const callbacks = this.listeners.get(data.type);
+                if (callbacks) {
+                    for (const callback of callbacks) {
+                        try {
+                            callback(data.payload);
+                        }
+                        catch (e) {
+                            console.error('Error in EventChannel callback:', e);
+                        }
+                    }
+                }
+            }
+        };
+    }
+    /**
+     * Publishes an event to the BroadcastChannel.
+     */
+    publish(type, payload) {
+        this.channel.postMessage({ type, payload });
+    }
+    /**
+     * Subscribes to a specific event type. Returns an unsubscribe function.
+     */
+    subscribe(type, callback) {
+        if (!this.listeners.has(type)) {
+            this.listeners.set(type, new Set());
+        }
+        this.listeners.get(type).add(callback);
+        return () => {
+            const callbacks = this.listeners.get(type);
+            if (callbacks) {
+                callbacks.delete(callback);
+                if (callbacks.size === 0) {
+                    this.listeners.delete(type);
+                }
+            }
+        };
+    }
+    /**
+     * Closes the underlying BroadcastChannel.
+     */
+    close() {
+        this.channel.close();
+        this.listeners.clear();
+    }
+}
+
+/**
+ * Returns the actual active window object, prioritizing unsafeWindow in Tampermonkey.
+ */
+function getWazeWindow() {
+    if (typeof globalThis.unsafeWindow !== 'undefined') {
+        return globalThis.unsafeWindow;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    return globalThis;
+}
+
+class SessionManager {
+    dbPrefix;
+    scriptVersion;
+    wmeSDK;
+    sessionId = null;
+    tabId;
+    channel = null;
+    constructor(config) {
+        this.dbPrefix = config.dbPrefix;
+        this.scriptVersion = config.scriptVersion;
+        this.wmeSDK = config.wmeSDK;
+        this.tabId = `tab_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+    }
+    /**
+     * Initializes the session, handling tab isolation and duplicates.
+     */
+    async initSession() {
+        const channelName = `wme-logstream-tab-isolation-${this.dbPrefix}`;
+        this.channel = new EventChannel(channelName);
+        let candidateId = sessionStorage.getItem('wme_logstream_session_id');
+        if (!candidateId || (await this._probeConflict(candidateId))) {
+            candidateId = generateSessionId();
+            sessionStorage.setItem('wme_logstream_session_id', candidateId);
+        }
+        this.sessionId = candidateId;
+        // Listen to respond to other tabs' probes
+        this.channel.subscribe('PROBE', (payload) => {
+            if (payload.sessionId === this.sessionId && payload.tabId !== this.tabId) {
+                // Send conflict response
+                this.channel?.publish('CONFLICT', {
+                    sessionId: this.sessionId,
+                });
+            }
+        });
+        return this.sessionId;
+    }
+    async _probeConflict(sessionId = this.sessionId) {
+        if (!sessionId || !this.channel) {
+            throw new Error('Session has not been initialized or channel is closed.');
+        }
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                resolve(false);
+            }, 50);
+            const unsubscribeConflict = this.channel.subscribe('CONFLICT', (payload) => {
+                if (payload.sessionId === sessionId) {
+                    unsubscribeConflict?.();
+                    clearTimeout(timeout);
+                    resolve(true);
+                }
+            });
+            this.channel.publish('PROBE', {
+                sessionId,
+                tabId: this.tabId,
+            });
+        });
+    }
+    /**
+     * Defensively extract the WME version from passed SDK or global window context.
+     */
+    getWmeVersion() {
+        try {
+            // 1. Try passed SDK
+            if (typeof this.wmeSDK?.getWMEVersion === 'function') {
+                return this.wmeSDK.getWMEVersion();
+            }
+            // 2. Try window.W.version or unsafeWindow.W.version via getWazeWindow
+            const wazeWin = getWazeWindow();
+            if (wazeWin?.W?.version) {
+                return wazeWin.W.version;
+            }
+        }
+        catch {
+            // Safe fallback
+        }
+        return null;
+    }
+    /**
+     * Returns current session ID if initialized
+     */
+    getSessionId() {
+        if (!this.sessionId) {
+            throw new Error('Session has not been initialized. Call initSession() first.');
+        }
+        return this.sessionId;
+    }
+    /**
+     * Closes the session event channel
+     */
+    close() {
+        if (this.channel) {
+            this.channel.close();
+            this.channel = null;
+        }
+    }
+}
+
+class ZipStreamer {
+    dbManager;
+    constructor(dbManager) {
+        this.dbManager = dbManager;
+    }
+    /**
+     * Exports all sessions and their logs from IndexedDB into a Zip compressed Blob.
+     */
+    async exportAllSessions() {
+        // Flush any pending logs to IndexedDB first
+        await this.dbManager.flush();
+        const sessions = await this.dbManager.getAllSessions();
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            const zip = new fflate__namespace.Zip();
+            zip.ondata = (err, data, final) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                chunks.push(data);
+                if (final) {
+                    resolve(new Blob(chunks, { type: 'application/zip' }));
+                }
+            };
+            const run = async () => {
+                const encoder = new TextEncoder();
+                for (const session of sessions) {
+                    const folderName = session.id.startsWith('session_')
+                        ? session.id
+                        : `session_${session.id}`;
+                    // 1. Add session details file
+                    const detailsFile = new fflate__namespace.ZipDeflate(`${folderName}/details.json`);
+                    zip.add(detailsFile);
+                    const detailsJson = JSON.stringify(session);
+                    detailsFile.push(encoder.encode(detailsJson), true);
+                    // 2. Add session logs file (streamed)
+                    const logsFile = new fflate__namespace.ZipDeflate(`${folderName}/logs.json`);
+                    zip.add(logsFile);
+                    // Write starting bracket
+                    logsFile.push(encoder.encode('['));
+                    let first = true;
+                    // Stream logs directly from IndexedDB cursor
+                    await this.dbManager.streamLogsForSession(session.id, (log) => {
+                        const logContent = (first ? '' : ',') + JSON.stringify(log);
+                        first = false;
+                        logsFile.push(encoder.encode(logContent));
+                    });
+                    // Write closing bracket and finalize this file
+                    logsFile.push(encoder.encode(']'), true);
+                }
+                // Finalize the zip archive
+                zip.end();
+            };
+            run().catch(reject);
+        });
+    }
+}
+
+const SEVERITY = {
+    TRACE: 0,
+    DEBUG: 1,
+    INFO: 2,
+    WARN: 3,
+    ERROR: 4,
+    FATAL: 5,
+};
+function cloneDeep(val) {
+    if (val === undefined)
+        return undefined;
+    if (typeof structuredClone !== 'undefined') {
+        try {
+            return structuredClone(val);
+        }
+        catch {
+            // Fallback on serialization error
+        }
+    }
+    return JSON.parse(JSON.stringify(val));
+}
+/**
+ * Prunes an object to a maximum depth, stringifying any nested objects/arrays at that depth limit.
+ */
+function pruneToDepth(val, depth, maxDepth) {
+    if (typeof val !== 'object' || val === null) {
+        return val;
+    }
+    if (depth >= maxDepth) {
+        try {
+            return JSON.stringify(val);
+        }
+        catch {
+            return '[Object]';
+        }
+    }
+    if (Array.isArray(val)) {
+        return val.map((item) => pruneToDepth(item, depth + 1, maxDepth));
+    }
+    const result = {};
+    for (const key of Object.keys(val)) {
+        result[key] = pruneToDepth(val[key], depth + 1, maxDepth);
+    }
+    return result;
+}
+/**
+ * The main logger class for WME LogStream.
+ * Handles hierarchical scoping, console styling, state diff tracking, and persistent database exports.
+ */
+class LogStream {
+    minLogLevel;
+    dispatcher;
+    scopes;
+    states;
+    patcher = jsondiffpatch.create();
+    dbManagerPromise = null;
+    /**
+     * Initializes a LogStream instance.
+     * Prefer using `LogStream.create()` for a simplified, zero-boilerplate setup.
+     */
+    constructor(config, internal) {
+        this.minLogLevel = config.minLogLevel ?? 'INFO';
+        if (internal) {
+            this.dispatcher = internal.dispatcher;
+            this.scopes = internal.scopes;
+            this.states = internal.states;
+            this.dbManagerPromise = internal.dbManagerPromise ?? null;
+        }
+        else {
+            this.dispatcher = new Dispatcher();
+            this.scopes = [];
+            this.states = new Map();
+            if (config.dbManager) {
+                this.dbManagerPromise = Promise.resolve(config.dbManager);
+            }
+            if (config.pipes) {
+                for (const pipe of config.pipes) {
+                    this.dispatcher.addPipe(pipe);
+                }
+            }
+        }
+    }
+    /**
+     * Synchronously creates a configured LogStream instance, initializing console outputs
+     * and setting up background persistence/session managers if enabled.
+     *
+     * @param config The unified configuration options for console branding and persistence.
+     * @returns A pre-configured LogStream instance ready to log immediately.
+     */
+    static create(config) {
+        const pipes = [];
+        let dbManagerPromise = null;
+        if (config.brand !== null) {
+            pipes.push(new ConsolePipe(config.brand));
+        }
+        if (config.persist) {
+            if (!config.dbPrefix || !config.scriptVersion) {
+                throw new Error('dbPrefix and scriptVersion are required when persist is true');
+            }
+            dbManagerPromise = (async () => {
+                const sessionManager = new SessionManager({
+                    dbPrefix: config.dbPrefix,
+                    scriptVersion: config.scriptVersion,
+                    wmeSDK: config.wmeSDK,
+                });
+                const sessionId = await sessionManager.initSession();
+                const wmeVersion = sessionManager.getWmeVersion();
+                const dbManager = new IndexedDBManager({
+                    dbPrefix: config.dbPrefix,
+                    scriptVersion: config.scriptVersion,
+                    sessionId,
+                    wmeVersion,
+                    maxArchivedSessions: config.maxArchivedSessions,
+                    flushIntervalMs: config.flushIntervalMs,
+                });
+                await dbManager.init();
+                await dbManager.pruneSessions();
+                return dbManager;
+            })();
+            pipes.push(new IndexedDBPipe(dbManagerPromise));
+        }
+        const dispatcher = new Dispatcher();
+        for (const pipe of pipes) {
+            dispatcher.addPipe(pipe);
+        }
+        return new LogStream({
+            minLogLevel: config.minLogLevel,
+        }, {
+            dispatcher,
+            scopes: [],
+            states: new Map(),
+            dbManagerPromise,
+        });
+    }
+    /**
+     * Spawns a child logger with a hierarchical scope prefix appended to the console/db entries.
+     *
+     * @param name The scope namespace (e.g. 'API', 'Auth').
+     * @returns A new LogStream child instance carrying the hierarchical scope.
+     */
+    scope(name) {
+        return new LogStream({ minLogLevel: this.minLogLevel }, {
+            dispatcher: this.dispatcher,
+            scopes: [...this.scopes, name],
+            states: this.states,
+            dbManagerPromise: this.dbManagerPromise,
+        });
+    }
+    /** Logs a TRACE level message. */
+    trace(message, data) {
+        this.log('TRACE', message, data);
+    }
+    /** Logs a DEBUG level message. */
+    debug(message, data) {
+        this.log('DEBUG', message, data);
+    }
+    /** Logs an INFO level message. */
+    info(message, data) {
+        this.log('INFO', message, data);
+    }
+    /** Logs a WARN level message. */
+    warn(message, data) {
+        this.log('WARN', message, data);
+    }
+    /** Logs an ERROR level message. */
+    error(message, data) {
+        this.log('ERROR', message, data);
+    }
+    /** Logs a FATAL level message. */
+    fatal(message, data) {
+        this.log('FATAL', message, data);
+    }
+    /**
+     * Compares the given state object against its previous version, calculating the deep-diff
+     * and logging only modified properties as a DEBUG entry.
+     *
+     * @param name The state tracking key.
+     * @param state The state object to track.
+     * @param options Config options, e.g., max depth for nested objects.
+     */
+    stateDelta(name, state, options) {
+        const maxDepth = options?.maxDepth ?? 3;
+        if (!this.states.has(name)) {
+            this.states.set(name, cloneDeep(state));
+            this.log('DEBUG', `State Delta: ${name} (initial)`, { delta: state });
+            return;
+        }
+        const prevState = this.states.get(name);
+        // Prune both objects up to maxDepth before diffing
+        const prunedPrev = pruneToDepth(prevState, 0, maxDepth);
+        const prunedState = pruneToDepth(state, 0, maxDepth);
+        const delta = this.patcher.diff(prunedPrev, prunedState);
+        if (delta !== undefined) {
+            this.states.set(name, cloneDeep(state));
+            this.log('DEBUG', `State Delta: ${name}`, { delta });
+        }
+    }
+    /**
+     * Returns a bound function that tracks changes to a specific state key over time.
+     *
+     * @param name The state tracking key.
+     * @param options Config options, e.g., max depth for nested objects.
+     * @returns A function accepting a state object to diff and log.
+     */
+    createStateTracker(name, options) {
+        return (state) => {
+            this.stateDelta(name, state, options);
+        };
+    }
+    /**
+     * Asynchronously exports all stored database sessions and logs into a single compressed ZIP file.
+     *
+     * @returns A promise resolving to the compressed ZIP Blob.
+     */
+    async exportLogs() {
+        if (!this.dbManagerPromise) {
+            throw new Error('Persistence (IndexedDB) is not enabled on this LogStream.');
+        }
+        const dbManager = await this.dbManagerPromise;
+        const streamer = new ZipStreamer(dbManager);
+        return streamer.exportAllSessions();
+    }
+    /**
+     * Triggers a browser-native file download of the compressed log sessions.
+     *
+     * @param filename Custom download filename. Defaults to `wme-logs-<timestamp>.xlog`.
+     */
+    async downloadLogs(filename) {
+        const blob = await this.exportLogs();
+        if (typeof document === 'undefined') {
+            throw new Error('downloadLogs can only be called in a browser environment.');
+        }
+        const name = filename || `wme-logs-${Date.now()}.xlog`;
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = name;
+        a.click();
+        setTimeout(() => URL.revokeObjectURL(url), 100);
+    }
+    /**
+     * Triggers a flush of all buffered logs on registered pipes.
+     */
+    async flush() {
+        await this.dispatcher.flush();
+    }
+    /**
+     * Closes underlying active database connections if persistence is enabled.
+     */
+    async close() {
+        if (this.dbManagerPromise) {
+            const dbManager = await this.dbManagerPromise;
+            await dbManager.close();
+        }
+    }
+    log(level, message, data) {
+        if (SEVERITY[level] < SEVERITY[this.minLogLevel]) {
+            return;
+        }
+        const payload = {
+            timestamp: Date.now(),
+            level,
+            scopes: [...this.scopes],
+            message,
+        };
+        if (data !== undefined) {
+            payload.data = data;
+        }
+        this.dispatcher.dispatch(payload);
+    }
+}
+
+exports.ConsolePipe = ConsolePipe;
+exports.IndexedDBManager = IndexedDBManager;
+exports.IndexedDBPipe = IndexedDBPipe;
+exports.LogStream = LogStream;
+exports.SessionManager = SessionManager;
+exports.ZipStreamer = ZipStreamer;
+//# sourceMappingURL=index.cjs.js.map