ray-logger-core 0.0.1

package/index.js

@@ -0,0 +1,1559 @@
+import { record } from 'rrweb';
+
+const PACKAGE_NAME = '@ray-web-logger/core';
+const SESSION_EXPORT_SCHEMA_VERSION = 1;
+const DEFAULT_MEMORY_FLUSH_THRESHOLD_BYTES = 1_048_576;
+const DEFAULT_RRWEB_CHECKOUT_EVERY_NMS = 30_000;
+const DEFAULT_INDEXED_DB_NAME = 'ray-web-logger-webLogger';
+const DEFAULT_SESSION_STORAGE_KEY = '__web_logger_session__';
+/** 与规格 DevTools 对齐的 `console.*` 方法名；采集时写入 `ConsolePayload.level`，宿主无实现则跳过 patch。 */
+const CONSOLE_CAPTURE_METHODS = [
+    'debug',
+    'log',
+    'info',
+    'warn',
+    'error',
+    'trace',
+    'dir',
+    'dirxml',
+    'table',
+    'group',
+    'groupCollapsed',
+    'groupEnd',
+    'assert',
+    'count',
+    'countReset',
+    'time',
+    'timeLog',
+    'timeEnd',
+];
+
+const MAX_DEPTH = 5;
+const MAX_ARRAY_ITEMS = 50;
+const MAX_OBJECT_KEYS = 50;
+function serializeValue(value) {
+    return serializeUnknown(value, new WeakSet(), 0);
+}
+function serializeArgs(args) {
+    return args.map((arg) => serializeValue(arg));
+}
+function serializeUnknown(value, seen, depth) {
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'undefined') {
+        return { type: 'unserializable', reason: 'undefined' };
+    }
+    if (typeof value === 'bigint') {
+        return { type: 'unserializable', reason: 'bigint', preview: value.toString() };
+    }
+    if (typeof value === 'symbol' || typeof value === 'function') {
+        return { type: 'unserializable', reason: typeof value, preview: String(value) };
+    }
+    if (depth >= MAX_DEPTH) {
+        return { type: 'unserializable', reason: 'max-depth', preview: previewValue(value) };
+    }
+    if (seen.has(value)) {
+        return { type: 'circular', reason: 'circular-reference', preview: previewValue(value) };
+    }
+    seen.add(value);
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack ?? null,
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, MAX_ARRAY_ITEMS).map((item) => serializeUnknown(item, seen, depth + 1));
+    }
+    const result = {};
+    for (const key of Object.keys(value).slice(0, MAX_OBJECT_KEYS)) {
+        result[key] = serializeUnknown(value[key], seen, depth + 1);
+    }
+    return result;
+}
+function previewValue(value) {
+    try {
+        return String(value);
+    }
+    catch {
+        return Object.prototype.toString.call(value);
+    }
+}
+
+/** Collector 与其它 web-logger 内部帧需在展示前跳过 */
+const INTERNAL_STACK_MARKERS = [
+    '/collectors/console',
+    '\\collectors\\console',
+    'collectors/console.ts',
+    'collectors\\console.ts',
+    'collectors/console.js',
+    'collectors\\console.js',
+    '@ray-web-logger/core',
+    'packages/core/src/collectors/console',
+    'packages\\core\\src\\collectors\\console',
+];
+/** 从同步 `new Error().stack` 推导 `ConsolePayload` 中与调用位置相关的可选字段（非 trace 不写 `stack/stackFrames`，控制体积）。 */
+function deriveConsoleLocationFields(options) {
+    const { stack, method } = options;
+    if (!stack?.trim()) {
+        return {};
+    }
+    const rawLines = splitStackLines(stack);
+    const parsedFrames = [];
+    for (const raw of rawLines) {
+        if (!raw.trim()) {
+            continue;
+        }
+        const frame = parseStackLine(raw);
+        if (frame.url !== undefined || frame.line !== undefined || frame.file !== undefined) {
+            parsedFrames.push({ raw, frame });
+        }
+    }
+    const userFrames = dropInternalPrefix(parsedFrames);
+    if (userFrames.length === 0) {
+        return method === 'trace' ? { stack } : {};
+    }
+    const callSite = normalizeFrame(userFrames[0].frame);
+    if (method !== 'trace') {
+        return { callSite };
+    }
+    return {
+        callSite,
+        stack,
+        stackFrames: userFrames.map((f) => normalizeFrame(f.frame)),
+    };
+}
+function splitStackLines(stack) {
+    return stack.split(/\r?\n/);
+}
+function parseStackLine(line) {
+    const trimmed = line.trim();
+    const ff = /^(.+?)@(.+):(\d+):(\d+)$/.exec(trimmed);
+    if (ff && !trimmed.startsWith('at ')) {
+        const url = ff[2];
+        return {
+            functionName: ff[1] || undefined,
+            url,
+            line: Number(ff[3]),
+            column: Number(ff[4]),
+            file: basenameFromUrl(url),
+        };
+    }
+    const parenOpen = trimmed.lastIndexOf('(');
+    const parenClose = trimmed.lastIndexOf(')');
+    if (trimmed.startsWith('at ') && parenOpen !== -1 && parenClose > parenOpen) {
+        const inside = trimmed.slice(parenOpen + 1, parenClose);
+        const loc = parseUrlLineColumn(inside);
+        if (loc) {
+            const head = trimmed.slice(3, parenOpen).trim();
+            return {
+                functionName: head || undefined,
+                url: loc.url,
+                line: loc.line,
+                column: loc.column,
+                file: basenameFromUrl(loc.url),
+            };
+        }
+    }
+    if (trimmed.startsWith('at ')) {
+        const rest = trimmed.slice(3).trim();
+        const loc = parseUrlLineColumn(rest);
+        if (loc) {
+            return {
+                url: loc.url,
+                line: loc.line,
+                column: loc.column,
+                file: basenameFromUrl(loc.url),
+            };
+        }
+    }
+    return {};
+}
+function parseUrlLineColumn(s) {
+    const m = /^(.*):(\d+):(\d+)$/.exec(s);
+    if (!m) {
+        return undefined;
+    }
+    return { url: m[1], line: Number(m[2]), column: Number(m[3]) };
+}
+function basenameFromUrl(url) {
+    const trimmed = url.trim();
+    if (!trimmed || trimmed === '(native)') {
+        return undefined;
+    }
+    try {
+        const u = new URL(trimmed);
+        const seg = u.pathname.split('/').filter(Boolean);
+        return seg[seg.length - 1] || trimmed;
+    }
+    catch {
+        const parts = trimmed.split(/[/\\]/);
+        const last = parts[parts.length - 1];
+        return last || trimmed;
+    }
+}
+function isInternalFrame(raw, frame) {
+    if (raw.includes('(native)')) {
+        return true;
+    }
+    const blob = `${raw} ${frame.url ?? ''}`;
+    for (const marker of INTERNAL_STACK_MARKERS) {
+        if (blob.includes(marker)) {
+            return true;
+        }
+    }
+    return false;
+}
+function dropInternalPrefix(frames) {
+    let i = 0;
+    while (i < frames.length && isInternalFrame(frames[i].raw, frames[i].frame)) {
+        i += 1;
+    }
+    return frames.slice(i);
+}
+function normalizeFrame(frame) {
+    const url = frame.url;
+    const file = frame.file ?? (url ? basenameFromUrl(url) : undefined);
+    return {
+        ...frame,
+        file,
+        ...(url ? { url } : {}),
+    };
+}
+
+function installConsoleCollector(options) {
+    const consoleRef = options.consoleRef ?? globalThis.console;
+    if (!consoleRef) {
+        return noop$6;
+    }
+    const sink = consoleRef;
+    const originals = new Map();
+    for (const method of CONSOLE_CAPTURE_METHODS) {
+        const native = sink[method];
+        if (typeof native !== 'function') {
+            continue;
+        }
+        const impl = native;
+        originals.set(method, impl);
+        sink[method] = (...args) => {
+            const stack = options.recordConsoleCallSite !== false ? captureStackString() : undefined;
+            void impl.apply(consoleRef, args);
+            try {
+                const locationFields = stack !== undefined ? deriveConsoleLocationFields({ stack, method }) : {};
+                options.record({
+                    type: 'console',
+                    payload: {
+                        level: method,
+                        args: serializeArgs(args),
+                        ...locationFields,
+                    },
+                });
+            }
+            catch {
+                // Console 行为不应因采集失败而受影响。
+            }
+        };
+    }
+    return () => {
+        for (const [method, impl] of originals) {
+            sink[method] = impl;
+        }
+    };
+}
+function noop$6() {
+    // noop
+}
+/** 在调用原生 console 方法**之前**截取栈，才能包含业务调用者；实现需极轻量。 */
+function captureStackString() {
+    const err = new Error();
+    return err.stack;
+}
+
+function installCookieCollector(options) {
+    const documentRef = options.documentRef ?? (typeof document !== 'undefined' ? document : undefined);
+    if (!documentRef) {
+        return noop$5;
+    }
+    recordCookieSnapshot(options.record, documentRef, options.config);
+    const descriptorOwner = findCookieDescriptorOwner(documentRef);
+    const descriptor = descriptorOwner
+        ? Object.getOwnPropertyDescriptor(descriptorOwner, 'cookie')
+        : undefined;
+    if (!descriptorOwner || !descriptor?.set || !descriptor.configurable) {
+        return noop$5;
+    }
+    Object.defineProperty(descriptorOwner, 'cookie', {
+        configurable: descriptor.configurable,
+        enumerable: descriptor.enumerable,
+        get: descriptor.get,
+        set(value) {
+            descriptor.set?.call(this, value);
+            recordCookieWrite(options.record, value, options.config);
+        },
+    });
+    return () => {
+        Object.defineProperty(descriptorOwner, 'cookie', descriptor);
+    };
+}
+function recordCookieSnapshot(record, documentRef, config) {
+    const snapshot = readCookieSnapshot(documentRef, config);
+    if (!snapshot || (snapshot.cookies.length === 0 && snapshot.skipped.length === 0)) {
+        return;
+    }
+    record({
+        type: 'cookie',
+        payload: {
+            op: 'snapshot',
+            cookies: snapshot.cookies,
+            ...(snapshot.skipped.length > 0 ? { skipped: snapshot.skipped } : {}),
+        },
+    });
+}
+function readCookieSnapshot(documentRef, config) {
+    let rawCookie = '';
+    try {
+        rawCookie = documentRef.cookie;
+    }
+    catch {
+        return undefined;
+    }
+    if (!rawCookie) {
+        return { cookies: [], skipped: [] };
+    }
+    const cookies = [];
+    const skipped = [];
+    for (const rawPair of rawCookie.split(';')) {
+        const pair = rawPair.trim();
+        const separatorIndex = pair.indexOf('=');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const name = pair.slice(0, separatorIndex).trim();
+        const value = pair.slice(separatorIndex + 1).trim();
+        if (!name) {
+            continue;
+        }
+        if (shouldSkipCookie(name, config)) {
+            skipped.push({ name, reason: 'disallowed' });
+            continue;
+        }
+        cookies.push({ name, value });
+    }
+    return { cookies, skipped };
+}
+function recordCookieWrite(record, rawCookie, config) {
+    const parsed = parseCookieWrite(rawCookie);
+    if (!parsed || shouldSkipCookie(parsed.name, config)) {
+        return;
+    }
+    record({
+        type: 'cookie',
+        payload: {
+            name: parsed.name,
+            value: parsed.value,
+            op: parsed.isDelete ? 'delete' : 'set',
+            ...(parsed.domain ? { domain: parsed.domain } : {}),
+            ...(parsed.expires ? { expires: parsed.expires } : {}),
+            ...(parsed.maxAge ? { maxAge: parsed.maxAge } : {}),
+        },
+    });
+}
+function parseCookieWrite(rawCookie) {
+    const [pair = '', ...attrs] = rawCookie.split(';');
+    const separatorIndex = pair.indexOf('=');
+    if (separatorIndex <= 0) {
+        return undefined;
+    }
+    const name = pair.slice(0, separatorIndex).trim();
+    const value = pair.slice(separatorIndex + 1).trim();
+    if (!name) {
+        return undefined;
+    }
+    return {
+        name,
+        value,
+        isDelete: isDeleteCookie(value, attrs),
+        ...parseCookieAttrs(attrs),
+    };
+}
+function parseCookieAttrs(attrs) {
+    const parsed = {};
+    for (const attr of attrs) {
+        const separatorIndex = attr.indexOf('=');
+        const rawKey = separatorIndex >= 0 ? attr.slice(0, separatorIndex) : attr;
+        const rawValue = separatorIndex >= 0 ? attr.slice(separatorIndex + 1) : '';
+        const key = rawKey.trim().toLowerCase();
+        const value = rawValue.trim();
+        if (key === 'domain' && value) {
+            parsed.domain = value;
+        }
+        else if (key === 'expires' && value) {
+            parsed.expires = value;
+        }
+        else if (key === 'max-age' && value) {
+            parsed.maxAge = value;
+        }
+    }
+    return parsed;
+}
+function isDeleteCookie(value, attrs) {
+    for (const attr of attrs) {
+        const [rawKey = '', rawValue = ''] = attr.split('=');
+        const key = rawKey.trim().toLowerCase();
+        const attrValue = rawValue.trim();
+        if (key === 'max-age' && Number(attrValue) <= 0) {
+            return true;
+        }
+        if (key === 'expires') {
+            const expiresAt = Date.parse(attrValue);
+            if (Number.isFinite(expiresAt) && expiresAt <= Date.now()) {
+                return true;
+            }
+        }
+    }
+    return value === '' && attrs.length > 0;
+}
+function shouldSkipCookie(name, config) {
+    return new Set(config.disallowRecordCookieKeys ?? []).has(name);
+}
+function findCookieDescriptorOwner(documentRef) {
+    let proto = Object.getPrototypeOf(documentRef);
+    while (proto) {
+        const descriptor = Object.getOwnPropertyDescriptor(proto, 'cookie');
+        if (descriptor) {
+            return proto;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+}
+function noop$5() {
+    // noop
+}
+
+function installErrorCollector(options) {
+    const windowRef = options.windowRef ?? (typeof window !== 'undefined' ? window : undefined);
+    if (!windowRef) {
+        return noop$4;
+    }
+    const previousOnError = windowRef.onerror;
+    const onErrorEvent = (event) => {
+        recordError(options.record, event.error, event.message, event.filename);
+    };
+    const onUnhandledRejection = (event) => {
+        recordError(options.record, event.reason, 'Unhandled promise rejection');
+    };
+    windowRef.onerror = (message, source, lineno, colno, error) => {
+        recordError(options.record, error, String(message), source ? String(source) : undefined);
+        if (typeof previousOnError === 'function') {
+            return previousOnError.call(windowRef, message, source, lineno, colno, error);
+        }
+        return previousOnError ?? false;
+    };
+    windowRef.addEventListener('error', onErrorEvent);
+    windowRef.addEventListener('unhandledrejection', onUnhandledRejection);
+    return () => {
+        windowRef.onerror = previousOnError;
+        windowRef.removeEventListener('error', onErrorEvent);
+        windowRef.removeEventListener('unhandledrejection', onUnhandledRejection);
+    };
+}
+function recordError(record, errorLike, fallbackMessage, source) {
+    try {
+        const error = errorLike instanceof Error ? errorLike : undefined;
+        record({
+            type: 'error',
+            payload: {
+                message: error?.message || fallbackMessage,
+                ...(error?.stack ? { stack: error.stack } : {}),
+                ...(source ? { source } : {}),
+            },
+        });
+    }
+    catch {
+        // 全局错误处理不能再抛异常，避免影响宿主错误链路。
+    }
+}
+function noop$4() {
+    // noop
+}
+
+function installFetchCollector(options) {
+    const originalFetch = options.fetchRef ?? globalThis.fetch;
+    if (typeof originalFetch !== 'function' || typeof globalThis.fetch !== 'function') {
+        return noop$3;
+    }
+    globalThis.fetch = (async (input, init) => {
+        const startedAt = Date.now();
+        const requestInfo = await createRequestInfo(input, init, options.config);
+        try {
+            const response = await originalFetch.call(globalThis, input, init);
+            const durationMs = Date.now() - startedAt;
+            void recordSuccess(options.record, requestInfo, response, durationMs, options.config);
+            return response;
+        }
+        catch (error) {
+            options.record({
+                type: 'network',
+                payload: {
+                    outcome: 'failed',
+                    url: requestInfo.url,
+                    method: requestInfo.method,
+                    durationMs: Date.now() - startedAt,
+                    error: normalizeNetworkError(error),
+                    ...(requestInfo.bodySkippedReason
+                        ? { bodySkippedReason: requestInfo.bodySkippedReason }
+                        : {}),
+                },
+            });
+            throw error;
+        }
+    });
+    return () => {
+        if (globalThis.fetch === originalFetch) {
+            return;
+        }
+        globalThis.fetch = originalFetch;
+    };
+}
+async function createRequestInfo(input, init, config) {
+    const request = input instanceof Request ? input : undefined;
+    const method = normalizeMethod(init?.method ?? request?.method ?? 'GET');
+    const url = sanitizeUrl$1(getInputUrl(input), config.disallowRecordSearches);
+    const headers = config.enableRecordRequestHeaders === false
+        ? undefined
+        : headersToRecord(init?.headers ?? request?.headers, config.disallowRecordRequestHeaders);
+    const bodyInfo = await readRequestBody(input, init, config);
+    return {
+        url,
+        method,
+        ...(headers ? { headers } : {}),
+        ...bodyInfo,
+    };
+}
+async function recordSuccess(record, requestInfo, response, durationMs, config) {
+    const responseBody = await readResponseBody(response, config);
+    const bodySkippedReason = requestInfo.bodySkippedReason ?? responseBody.bodySkippedReason;
+    record({
+        type: 'network',
+        payload: {
+            outcome: 'success',
+            url: requestInfo.url,
+            method: requestInfo.method,
+            status: response.status,
+            durationMs,
+            ...(requestInfo.headers ? { requestHeaders: requestInfo.headers } : {}),
+            ...(config.enableRecordResponseHeaders === false
+                ? {}
+                : {
+                    responseHeaders: headersToRecord(response.headers, config.disallowRecordResponseHeaders),
+                }),
+            ...(requestInfo.body !== undefined ? { requestBody: requestInfo.body } : {}),
+            ...(responseBody.body !== undefined ? { responseBody: responseBody.body } : {}),
+            ...(bodySkippedReason ? { bodySkippedReason } : {}),
+        },
+    });
+}
+function getInputUrl(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (input instanceof URL) {
+        return input.toString();
+    }
+    return input.url;
+}
+function sanitizeUrl$1(url, disallowSearches) {
+    if (!disallowSearches?.length) {
+        return url;
+    }
+    try {
+        const parsed = new URL(url, globalThis.location?.href);
+        for (const key of disallowSearches) {
+            parsed.searchParams.delete(key);
+        }
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
+function headersToRecord(headersInit, disallowHeaders) {
+    if (!headersInit) {
+        return undefined;
+    }
+    const disallowed = new Set((disallowHeaders ?? []).map((header) => header.toLowerCase()));
+    const headers = new Headers(headersInit);
+    const result = {};
+    headers.forEach((value, key) => {
+        if (!disallowed.has(key.toLowerCase())) {
+            result[key] = value;
+        }
+    });
+    return result;
+}
+async function readRequestBody(input, init, config) {
+    if (config.enableRecordRequestBody === false) {
+        return { bodySkippedReason: 'request-body-disabled' };
+    }
+    if (init?.body) {
+        return bodyInitToString(init.body);
+    }
+    if (input instanceof Request && input.body) {
+        try {
+            return { body: await input.clone().text() };
+        }
+        catch {
+            return { bodySkippedReason: 'request-body-unreadable' };
+        }
+    }
+    return { body: null };
+}
+async function readResponseBody(response, config) {
+    if (config.enableRecordResponseBody === false) {
+        return { bodySkippedReason: 'response-body-disabled' };
+    }
+    try {
+        return { body: await response.clone().text() };
+    }
+    catch {
+        return { bodySkippedReason: 'response-body-unreadable' };
+    }
+}
+async function bodyInitToString(body) {
+    if (typeof body === 'string') {
+        return { body };
+    }
+    if (body instanceof URLSearchParams) {
+        return { body: body.toString() };
+    }
+    if (body instanceof Blob) {
+        return { body: await body.text() };
+    }
+    if (body instanceof FormData) {
+        return { bodySkippedReason: 'request-body-form-data' };
+    }
+    if (body instanceof ArrayBuffer) {
+        return { bodySkippedReason: 'request-body-binary' };
+    }
+    if (ArrayBuffer.isView(body)) {
+        return { bodySkippedReason: 'request-body-binary' };
+    }
+    if (body instanceof ReadableStream) {
+        return { bodySkippedReason: 'request-body-stream' };
+    }
+    return { bodySkippedReason: 'request-body-unknown' };
+}
+function normalizeMethod(method) {
+    return method.toUpperCase();
+}
+function normalizeNetworkError(error) {
+    if (error instanceof DOMException) {
+        return { message: error.message, name: error.name, code: error.code };
+    }
+    if (error instanceof Error) {
+        return { message: error.message, name: error.name };
+    }
+    return { message: String(error) };
+}
+function noop$3() {
+    // noop
+}
+
+function installXhrCollector(options) {
+    if (typeof globalThis.XMLHttpRequest === 'undefined') {
+        return noop$2;
+    }
+    const prototype = globalThis.XMLHttpRequest.prototype;
+    const originalOpen = prototype.open;
+    const originalSend = prototype.send;
+    const originalSetRequestHeader = prototype.setRequestHeader;
+    const states = new WeakMap();
+    prototype.open = function patchedOpen(method, url, async, username, password) {
+        states.set(this, {
+            method: method.toUpperCase(),
+            url: sanitizeUrl(String(url), options.config.disallowRecordSearches),
+            startedAt: 0,
+            recorded: false,
+        });
+        return originalOpen.call(this, method, url, async ?? true, username, password);
+    };
+    prototype.setRequestHeader = function patchedSetRequestHeader(name, value) {
+        const state = states.get(this);
+        if (state && options.config.enableRecordRequestHeaders !== false) {
+            const disallowed = new Set((options.config.disallowRecordRequestHeaders ?? []).map((header) => header.toLowerCase()));
+            if (!disallowed.has(name.toLowerCase())) {
+                state.requestHeaders ??= {};
+                state.requestHeaders[name] = value;
+            }
+        }
+        return originalSetRequestHeader.call(this, name, value);
+    };
+    prototype.send = function patchedSend(body) {
+        const state = states.get(this);
+        if (state) {
+            state.startedAt = Date.now();
+            const bodyInfo = requestBodyToString(body ?? null, options.config);
+            state.requestBody = bodyInfo.body;
+            state.bodySkippedReason = bodyInfo.bodySkippedReason;
+            const onError = () => {
+                state.failure = { message: 'XMLHttpRequest error', name: 'error' };
+            };
+            const onAbort = () => {
+                state.failure = { message: 'XMLHttpRequest aborted', name: 'abort' };
+            };
+            const onTimeout = () => {
+                state.failure = { message: 'XMLHttpRequest timeout', name: 'timeout' };
+            };
+            const onLoadEnd = () => {
+                recordXhr(options.record, this, state, options.config);
+                this.removeEventListener('error', onError);
+                this.removeEventListener('abort', onAbort);
+                this.removeEventListener('timeout', onTimeout);
+                this.removeEventListener('loadend', onLoadEnd);
+            };
+            this.addEventListener('error', onError);
+            this.addEventListener('abort', onAbort);
+            this.addEventListener('timeout', onTimeout);
+            this.addEventListener('loadend', onLoadEnd);
+        }
+        return originalSend.call(this, body ?? null);
+    };
+    return () => {
+        prototype.open = originalOpen;
+        prototype.send = originalSend;
+        prototype.setRequestHeader = originalSetRequestHeader;
+    };
+}
+function recordXhr(record, xhr, state, config) {
+    if (state.recorded) {
+        return;
+    }
+    state.recorded = true;
+    try {
+        if (state.failure) {
+            record({
+                type: 'network',
+                payload: {
+                    outcome: 'failed',
+                    url: state.url,
+                    method: state.method,
+                    durationMs: Date.now() - state.startedAt,
+                    error: state.failure,
+                    ...(state.bodySkippedReason ? { bodySkippedReason: state.bodySkippedReason } : {}),
+                },
+            });
+            return;
+        }
+        const responseBody = readXhrResponseBody(xhr, config);
+        const bodySkippedReason = state.bodySkippedReason ?? responseBody.bodySkippedReason;
+        record({
+            type: 'network',
+            payload: {
+                outcome: 'success',
+                url: state.url,
+                method: state.method,
+                status: xhr.status,
+                durationMs: Date.now() - state.startedAt,
+                ...(state.requestHeaders ? { requestHeaders: state.requestHeaders } : {}),
+                ...(config.enableRecordResponseHeaders === false
+                    ? {}
+                    : {
+                        responseHeaders: parseResponseHeaders(xhr.getAllResponseHeaders(), config.disallowRecordResponseHeaders),
+                    }),
+                ...(state.requestBody !== undefined ? { requestBody: state.requestBody } : {}),
+                ...(responseBody.body !== undefined ? { responseBody: responseBody.body } : {}),
+                ...(bodySkippedReason ? { bodySkippedReason } : {}),
+            },
+        });
+    }
+    catch {
+        // XHR 回调链不能因采集异常影响宿主监听器。
+    }
+}
+function sanitizeUrl(url, disallowSearches) {
+    if (!disallowSearches?.length) {
+        return url;
+    }
+    try {
+        const parsed = new URL(url, globalThis.location?.href);
+        for (const key of disallowSearches) {
+            parsed.searchParams.delete(key);
+        }
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
+function requestBodyToString(body, config) {
+    if (config.enableRecordRequestBody === false) {
+        return { bodySkippedReason: 'request-body-disabled' };
+    }
+    if (body === null) {
+        return { body: null };
+    }
+    if (typeof body === 'string') {
+        return { body };
+    }
+    if (body instanceof URLSearchParams) {
+        return { body: body.toString() };
+    }
+    if (body instanceof FormData) {
+        return { bodySkippedReason: 'request-body-form-data' };
+    }
+    if (body instanceof Blob) {
+        return { bodySkippedReason: 'request-body-blob' };
+    }
+    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+        return { bodySkippedReason: 'request-body-binary' };
+    }
+    return { bodySkippedReason: 'request-body-unknown' };
+}
+function readXhrResponseBody(xhr, config) {
+    if (config.enableRecordResponseBody === false) {
+        return { bodySkippedReason: 'response-body-disabled' };
+    }
+    if (xhr.responseType && xhr.responseType !== 'text') {
+        return { bodySkippedReason: `response-body-${xhr.responseType}` };
+    }
+    try {
+        return { body: xhr.responseText };
+    }
+    catch {
+        return { bodySkippedReason: 'response-body-unreadable' };
+    }
+}
+function parseResponseHeaders(rawHeaders, disallowHeaders) {
+    const disallowed = new Set((disallowHeaders ?? []).map((header) => header.toLowerCase()));
+    const result = {};
+    for (const line of rawHeaders.trim().split(/[\r\n]+/)) {
+        if (!line) {
+            continue;
+        }
+        const separatorIndex = line.indexOf(':');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        if (!disallowed.has(key.toLowerCase())) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function noop$2() {
+    // noop
+}
+
+function installRrwebCollector(options) {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return noop$1;
+    }
+    try {
+        const stop = record({
+            emit(event) {
+                options.record({
+                    type: 'rrweb',
+                    timestamp: event.timestamp,
+                    payload: {
+                        rrwebEvent: event,
+                    },
+                });
+            },
+            recordCanvas: true,
+            sampling: {
+                canvas: 2,
+                media: 2,
+            },
+            collectFonts: true,
+            checkoutEveryNms: normalizeCheckoutEveryNms(options.checkoutEveryNms),
+        });
+        return stop ?? noop$1;
+    }
+    catch {
+        return noop$1;
+    }
+}
+function noop$1() {
+    // noop
+}
+function normalizeCheckoutEveryNms(checkoutEveryNms) {
+    if (checkoutEveryNms === undefined) {
+        return DEFAULT_RRWEB_CHECKOUT_EVERY_NMS;
+    }
+    return checkoutEveryNms > 0 ? checkoutEveryNms : undefined;
+}
+
+function installStorageCollector(options) {
+    const windowRef = options.windowRef ?? (typeof window !== 'undefined' ? window : undefined);
+    if (!windowRef || typeof globalThis.Storage === 'undefined') {
+        return noop;
+    }
+    const prototype = globalThis.Storage.prototype;
+    const originalSetItem = prototype.setItem;
+    const originalRemoveItem = prototype.removeItem;
+    const originalClear = prototype.clear;
+    prototype.setItem = function patchedSetItem(key, value) {
+        originalSetItem.call(this, key, value);
+        const area = resolveStorageArea(windowRef, this);
+        if (!area || shouldSkipStorageKey(key, options.config)) {
+            return;
+        }
+        options.record({
+            type: 'storage',
+            payload: {
+                area,
+                op: 'set',
+                key,
+                value: String(value),
+            },
+        });
+    };
+    prototype.removeItem = function patchedRemoveItem(key) {
+        originalRemoveItem.call(this, key);
+        const area = resolveStorageArea(windowRef, this);
+        if (!area || shouldSkipStorageKey(key, options.config)) {
+            return;
+        }
+        options.record({
+            type: 'storage',
+            payload: {
+                area,
+                op: 'remove',
+                key,
+                value: null,
+            },
+        });
+    };
+    prototype.clear = function patchedClear() {
+        originalClear.call(this);
+        const area = resolveStorageArea(windowRef, this);
+        if (!area) {
+            return;
+        }
+        options.record({
+            type: 'storage',
+            payload: {
+                area,
+                op: 'clear',
+            },
+        });
+    };
+    recordStorageSnapshot(options.record, windowRef, 'local', options.config);
+    recordStorageSnapshot(options.record, windowRef, 'session', options.config);
+    return () => {
+        prototype.setItem = originalSetItem;
+        prototype.removeItem = originalRemoveItem;
+        prototype.clear = originalClear;
+    };
+}
+function resolveStorageArea(windowRef, storage) {
+    try {
+        if (storage === windowRef.localStorage) {
+            return 'local';
+        }
+        if (storage === windowRef.sessionStorage) {
+            return 'session';
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function recordStorageSnapshot(record, windowRef, area, config) {
+    const storage = getStorageArea(windowRef, area);
+    if (!storage) {
+        return;
+    }
+    const snapshot = readStorageSnapshot(storage, config);
+    if (Object.keys(snapshot.entries).length === 0 && snapshot.skipped.length === 0) {
+        return;
+    }
+    record({
+        type: 'storage',
+        payload: {
+            area,
+            op: 'snapshot',
+            entries: snapshot.entries,
+            ...(snapshot.skipped.length > 0 ? { skipped: snapshot.skipped } : {}),
+        },
+    });
+}
+function getStorageArea(windowRef, area) {
+    try {
+        return area === 'local' ? windowRef.localStorage : windowRef.sessionStorage;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readStorageSnapshot(storage, config) {
+    const entries = {};
+    const skipped = [];
+    try {
+        for (let index = 0; index < storage.length; index += 1) {
+            const key = storage.key(index);
+            if (!key) {
+                continue;
+            }
+            if (shouldSkipStorageKey(key, config)) {
+                skipped.push({ key, reason: 'disallowed' });
+                continue;
+            }
+            const value = storage.getItem(key);
+            if (value === null) {
+                continue;
+            }
+            entries[key] = value;
+        }
+    }
+    catch {
+        return { entries, skipped };
+    }
+    return { entries, skipped };
+}
+function shouldSkipStorageKey(key, config) {
+    const disallowed = new Set(config.disallowRecordStorageKeys ?? []);
+    disallowed.add(config.sessionStorageKey ?? DEFAULT_SESSION_STORAGE_KEY);
+    return disallowed.has(key);
+}
+function noop() {
+    // noop
+}
+
+class Timeline {
+    sessionId;
+    #events = [];
+    #nextSeq;
+    #now;
+    constructor(options) {
+        this.sessionId = options.sessionId;
+        this.#nextSeq = options.initialSeq ?? 0;
+        this.#now = options.now ?? Date.now;
+    }
+    append(event) {
+        const normalized = {
+            ...event,
+            sessionId: this.sessionId,
+            seq: this.#nextSeq,
+            timestamp: event.timestamp ?? this.#now(),
+        };
+        this.#nextSeq += 1;
+        this.#events.push(normalized);
+        return normalized;
+    }
+    all() {
+        return [...this.#events].sort(compareTimelineEvents);
+    }
+    pending() {
+        return [...this.#events];
+    }
+    ensureNextSeqAtLeast(nextSeq) {
+        this.#nextSeq = Math.max(this.#nextSeq, nextSeq);
+    }
+    since(sinceMs, untilMs = this.#now()) {
+        return this.all().filter((event) => event.timestamp >= sinceMs && event.timestamp <= untilMs);
+    }
+    latestRrwebFullSnapshotBefore(beforeMs) {
+        return latestRrwebFullSnapshotBefore(this.#events, beforeMs);
+    }
+    clear(events) {
+        if (!events) {
+            this.#events = [];
+            return;
+        }
+        const flushedSeq = new Set(events.map((event) => event.seq));
+        this.#events = this.#events.filter((event) => !flushedSeq.has(event.seq));
+    }
+}
+function compareTimelineEvents(left, right) {
+    return left.timestamp - right.timestamp || left.seq - right.seq;
+}
+function latestRrwebFullSnapshotBefore(events, beforeMs) {
+    return events
+        .filter((event) => isRrwebFullSnapshotBefore(event, beforeMs))
+        .sort(compareTimelineEvents)
+        .at(-1);
+}
+function hasRrwebFullSnapshot(events) {
+    return events.some(isRrwebFullSnapshot);
+}
+function isRrwebFullSnapshot(event) {
+    return event.type === 'rrweb' && event.payload.rrwebEvent.type === 2;
+}
+function isRrwebFullSnapshotBefore(event, beforeMs) {
+    return isRrwebFullSnapshot(event) && event.timestamp < beforeMs;
+}
+
+const IDB_VERSION = 2;
+const SESSION_META_STORE = 'sessionMeta';
+const EVENT_CHUNKS_STORE = 'eventChunks';
+const EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX = 'byNamespaceMaxTimestamp';
+const EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX = 'byNamespaceMinTimestamp';
+class IndexedDbEventStore {
+    namespaceKey;
+    dbName;
+    #dbPromise;
+    #now;
+    constructor(options) {
+        this.namespaceKey = options.namespaceKey;
+        this.dbName = DEFAULT_INDEXED_DB_NAME;
+        this.#now = options.now ?? Date.now;
+    }
+    static isSupported() {
+        return typeof globalThis.indexedDB !== 'undefined';
+    }
+    async appendChunk(events) {
+        if (events.length === 0) {
+            return undefined;
+        }
+        const db = await this.#open();
+        const chunkSeq = await this.#nextChunkSeq(db);
+        const ordered = [...events].sort(compareTimelineEvents);
+        const seqList = ordered.map((event) => event.seq);
+        const timestampList = ordered.map((event) => event.timestamp);
+        const chunk = {
+            namespaceKey: this.namespaceKey,
+            chunkSeq,
+            events: ordered,
+            minSeq: Math.min(...seqList),
+            maxSeq: Math.max(...seqList),
+            minTimestamp: Math.min(...timestampList),
+            maxTimestamp: Math.max(...timestampList),
+        };
+        const tx = db.transaction([SESSION_META_STORE, EVENT_CHUNKS_STORE], 'readwrite');
+        tx.objectStore(EVENT_CHUNKS_STORE).put(chunk);
+        tx.objectStore(SESSION_META_STORE).put({
+            namespaceKey: this.namespaceKey,
+            lastSeq: chunk.maxSeq,
+            updatedAt: this.#now(),
+            schemaVersion: SESSION_EXPORT_SCHEMA_VERSION,
+        });
+        await transactionDone(tx);
+        return chunk;
+    }
+    async readEvents(options = {}) {
+        const db = await this.#open();
+        const events = await this.#readEventsFromChunks(db, options);
+        return events.sort(compareTimelineEvents);
+    }
+    async readMeta() {
+        const db = await this.#open();
+        return requestToPromise(db
+            .transaction(SESSION_META_STORE, 'readonly')
+            .objectStore(SESSION_META_STORE)
+            .get(this.namespaceKey));
+    }
+    async readLatestRrwebFullSnapshotBefore(beforeMs) {
+        const db = await this.#open();
+        const range = IDBKeyRange.bound([this.namespaceKey, 0], [this.namespaceKey, beforeMs], false, true);
+        const tx = db.transaction(EVENT_CHUNKS_STORE, 'readonly');
+        const cursor = tx
+            .objectStore(EVENT_CHUNKS_STORE)
+            .index(EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX)
+            .openCursor(range, 'prev');
+        return findLatestRrwebFullSnapshotCursor(cursor, beforeMs);
+    }
+    async #nextChunkSeq(db) {
+        const tx = db.transaction(EVENT_CHUNKS_STORE, 'readonly');
+        const store = tx.objectStore(EVENT_CHUNKS_STORE);
+        const range = IDBKeyRange.bound([this.namespaceKey, 0], [this.namespaceKey, Number.MAX_SAFE_INTEGER]);
+        const cursor = await requestToPromise(store.openCursor(range, 'prev'));
+        return cursor ? cursor.value.chunkSeq + 1 : 0;
+    }
+    async #readEventsFromChunks(db, options) {
+        const tx = db.transaction(EVENT_CHUNKS_STORE, 'readonly');
+        const store = tx.objectStore(EVENT_CHUNKS_STORE);
+        if (options.sinceMs !== undefined) {
+            const range = IDBKeyRange.bound([this.namespaceKey, options.sinceMs], [this.namespaceKey, Number.MAX_SAFE_INTEGER]);
+            return collectEventsCursor(store.index(EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX).openCursor(range), options);
+        }
+        const range = IDBKeyRange.bound([this.namespaceKey, 0], [this.namespaceKey, Number.MAX_SAFE_INTEGER]);
+        return collectEventsCursor(store.openCursor(range), options);
+    }
+    #open() {
+        this.#dbPromise ??= openDatabase(this.dbName);
+        return this.#dbPromise;
+    }
+}
+function openDatabase(dbName) {
+    return new Promise((resolve, reject) => {
+        const request = globalThis.indexedDB.open(dbName, IDB_VERSION);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(SESSION_META_STORE)) {
+                db.createObjectStore(SESSION_META_STORE, { keyPath: 'namespaceKey' });
+            }
+            let eventChunksStore;
+            if (!db.objectStoreNames.contains(EVENT_CHUNKS_STORE)) {
+                eventChunksStore = db.createObjectStore(EVENT_CHUNKS_STORE, {
+                    keyPath: ['namespaceKey', 'chunkSeq'],
+                });
+            }
+            else {
+                eventChunksStore = request.transaction.objectStore(EVENT_CHUNKS_STORE);
+            }
+            if (!eventChunksStore.indexNames.contains(EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX)) {
+                eventChunksStore.createIndex(EVENT_CHUNKS_BY_NAMESPACE_MAX_TIMESTAMP_INDEX, [
+                    'namespaceKey',
+                    'maxTimestamp',
+                ]);
+            }
+            if (!eventChunksStore.indexNames.contains(EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX)) {
+                eventChunksStore.createIndex(EVENT_CHUNKS_BY_NAMESPACE_MIN_TIMESTAMP_INDEX, [
+                    'namespaceKey',
+                    'minTimestamp',
+                ]);
+            }
+        };
+        request.onerror = () => reject(request.error ?? new Error('Failed to open IndexedDB.'));
+        request.onsuccess = () => resolve(request.result);
+    });
+}
+function requestToPromise(request) {
+    return new Promise((resolve, reject) => {
+        request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));
+        request.onsuccess = () => resolve(request.result);
+    });
+}
+function transactionDone(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error ?? new Error('IndexedDB transaction failed.'));
+        transaction.onabort = () => reject(transaction.error ?? new Error('IndexedDB transaction aborted.'));
+    });
+}
+function collectEventsCursor(request, options) {
+    return new Promise((resolve, reject) => {
+        const values = [];
+        const sinceMs = options.sinceMs ?? Number.NEGATIVE_INFINITY;
+        const untilMs = options.untilMs ?? Number.POSITIVE_INFINITY;
+        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (!cursor) {
+                resolve(values);
+                return;
+            }
+            const chunk = cursor.value;
+            for (const event of chunk.events) {
+                if (event.timestamp >= sinceMs && event.timestamp <= untilMs) {
+                    values.push(event);
+                }
+            }
+            cursor.continue();
+        };
+    });
+}
+function findLatestRrwebFullSnapshotCursor(request, beforeMs) {
+    return new Promise((resolve, reject) => {
+        request.onerror = () => reject(request.error ?? new Error('IndexedDB cursor failed.'));
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (!cursor) {
+                resolve(undefined);
+                return;
+            }
+            const chunk = cursor.value;
+            const snapshot = latestRrwebFullSnapshotBefore(chunk.events, beforeMs);
+            if (snapshot) {
+                resolve(snapshot);
+                return;
+            }
+            cursor.continue();
+        };
+    });
+}
+
+function resolveSession(options) {
+    const storage = getSessionStorage();
+    if (!storage) {
+        return memoryOnlySession(options.sessionId);
+    }
+    const sessionStorageKey = options.sessionStorageKey ?? DEFAULT_SESSION_STORAGE_KEY;
+    const stored = readStoredSessionState(storage, sessionStorageKey);
+    const persistentSessionId = options.persistentSessionId ?? stored?.persistentSessionId ?? createPersistentSessionId();
+    const initialSeq = Math.max(0, (stored?.lastSeq ?? -1) + 1);
+    writeStoredSessionState(storage, sessionStorageKey, {
+        persistentSessionId,
+        lastSeq: initialSeq - 1,
+    });
+    return {
+        persistentSessionId,
+        namespaceKey: persistentSessionId,
+        initialSeq,
+        updateLastSeq(seq) {
+            writeStoredSessionState(storage, sessionStorageKey, {
+                persistentSessionId,
+                lastSeq: seq,
+            });
+        },
+    };
+}
+function memoryOnlySession(sessionId) {
+    return {
+        namespaceKey: sessionId,
+        initialSeq: 0,
+        updateLastSeq() {
+            // sessionStorage 不可用时，按 Spec §1.3.3 仅保留当前运行期会话。
+        },
+    };
+}
+function getSessionStorage() {
+    try {
+        return globalThis.sessionStorage;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readStoredSessionState(storage, sessionStorageKey) {
+    try {
+        const raw = storage.getItem(sessionStorageKey);
+        if (!raw) {
+            return undefined;
+        }
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.persistentSessionId !== 'string') {
+            return undefined;
+        }
+        return {
+            persistentSessionId: parsed.persistentSessionId,
+            lastSeq: typeof parsed.lastSeq === 'number' ? parsed.lastSeq : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeStoredSessionState(storage, sessionStorageKey, state) {
+    try {
+        storage.setItem(sessionStorageKey, JSON.stringify(state));
+    }
+    catch {
+        // 写入失败等同 sessionStorage 不可用；当前运行期仍可继续采集与导出内存/IDB 数据。
+    }
+}
+function createPersistentSessionId() {
+    if (globalThis.crypto?.randomUUID) {
+        return globalThis.crypto.randomUUID();
+    }
+    return `persistent-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+
+class WebLoggerCoreController {
+    sessionId;
+    persistentSessionId;
+    namespaceKey;
+    config;
+    #timeline;
+    #store;
+    #flushPromise;
+    #estimatedBufferBytes = 0;
+    #destroyed = false;
+    #now;
+    #sessionState;
+    #readyPromise;
+    #collectorDisposers = [];
+    constructor(options = {}) {
+        this.sessionId = options.sessionId ?? createSessionId();
+        this.#sessionState = resolveSession({
+            sessionId: this.sessionId,
+            persistentSessionId: options.persistentSessionId,
+            sessionStorageKey: options.sessionStorageKey,
+        });
+        this.persistentSessionId = this.#sessionState.persistentSessionId;
+        this.namespaceKey = this.#sessionState.namespaceKey;
+        this.#now = options.now ?? Date.now;
+        this.config = {
+            ...options,
+            memoryFlushThresholdBytes: options.memoryFlushThresholdBytes ?? DEFAULT_MEMORY_FLUSH_THRESHOLD_BYTES,
+        };
+        this.#timeline = new Timeline({
+            sessionId: this.sessionId,
+            now: this.#now,
+            initialSeq: this.#sessionState.initialSeq,
+        });
+        if (IndexedDbEventStore.isSupported()) {
+            this.#store = new IndexedDbEventStore({
+                namespaceKey: this.namespaceKey,
+                now: this.#now,
+            });
+        }
+        this.#readyPromise = this.#hydrateSeqFromIdb();
+        this.#collectorDisposers = [
+            installConsoleCollector({
+                record: (event) => this.record(event),
+                recordConsoleCallSite: options.recordConsoleCallSite !== false,
+            }),
+            installErrorCollector({ record: (event) => this.record(event) }),
+            installFetchCollector({ config: this.config, record: (event) => this.record(event) }),
+            installXhrCollector({ config: this.config, record: (event) => this.record(event) }),
+            installStorageCollector({ config: this.config, record: (event) => this.record(event) }),
+            installCookieCollector({ config: this.config, record: (event) => this.record(event) }),
+            installRrwebCollector({
+                record: (event) => this.record(event),
+                checkoutEveryNms: this.config.rrwebCheckoutEveryNms,
+            }),
+        ];
+    }
+    record(event) {
+        this.#assertActive();
+        const recorded = this.#timeline.append(event);
+        this.#sessionState.updateLastSeq(recorded.seq);
+        this.#estimatedBufferBytes += estimateEventBytes(recorded);
+        if (this.#estimatedBufferBytes >= this.config.memoryFlushThresholdBytes) {
+            void this.flushToIdb().catch(() => {
+                // Export still includes memory events if background persistence fails.
+            });
+        }
+        return recorded;
+    }
+    async flushToIdb() {
+        this.#assertActive();
+        if (!this.#store) {
+            return;
+        }
+        await this.#waitUntilReady();
+        if (this.#flushPromise) {
+            return this.#flushPromise;
+        }
+        const pendingEvents = this.#timeline.pending();
+        if (pendingEvents.length === 0) {
+            return;
+        }
+        this.#flushPromise = this.#store
+            .appendChunk(pendingEvents)
+            .then(() => {
+            this.#timeline.clear(pendingEvents);
+            this.#estimatedBufferBytes = estimateEventsBytes(this.#timeline.pending());
+        })
+            .finally(() => {
+            this.#flushPromise = undefined;
+        });
+        return this.#flushPromise;
+    }
+    async exportFull() {
+        this.#assertActive();
+        await this.#waitUntilReady();
+        await this.#waitForFlush();
+        const persistedEvents = await this.#readPersistedEvents();
+        return this.#createExport('full', mergeEvents(persistedEvents, this.#timeline.all()));
+    }
+    async exportSince(sinceMs) {
+        this.#assertActive();
+        const untilMs = this.#now();
+        await this.#waitUntilReady();
+        await this.#waitForFlush();
+        const persistedEvents = await this.#readPersistedEvents({ sinceMs, untilMs });
+        const memoryEvents = this.#timeline.since(sinceMs, untilMs);
+        const windowEvents = mergeEvents(persistedEvents, memoryEvents);
+        const rrwebAnchor = hasRrwebFullSnapshot(windowEvents)
+            ? undefined
+            : await this.#readLatestRrwebFullSnapshotBefore(sinceMs);
+        const events = rrwebAnchor ? mergeEvents([rrwebAnchor], windowEvents) : windowEvents;
+        const includesRrwebBaseline = hasRrwebFullSnapshot(events);
+        return this.#createExport('since', events, {
+            sinceMs,
+            rrwebAnchorSeq: rrwebAnchor?.seq,
+            includesRrwebBaseline,
+            replayableStandalone: includesRrwebBaseline,
+        });
+    }
+    destroy() {
+        for (const dispose of this.#collectorDisposers.splice(0)) {
+            dispose();
+        }
+        this.#timeline.clear();
+        this.#destroyed = true;
+    }
+    #createExport(kind, events, exportMeta = {}) {
+        return {
+            schemaVersion: SESSION_EXPORT_SCHEMA_VERSION,
+            sessionId: this.sessionId,
+            ...(this.persistentSessionId ? { persistentSessionId: this.persistentSessionId } : {}),
+            exportedAt: new Date(this.#now()).toISOString(),
+            export: { kind, ...exportMeta },
+            events,
+        };
+    }
+    #assertActive() {
+        if (this.#destroyed) {
+            throw new Error('WebLoggerController has been destroyed.');
+        }
+    }
+    async #waitForFlush() {
+        if (this.#flushPromise) {
+            await this.#flushPromise;
+        }
+    }
+    async #waitUntilReady() {
+        await this.#readyPromise;
+    }
+    async #hydrateSeqFromIdb() {
+        if (!this.#store) {
+            return;
+        }
+        try {
+            const meta = await this.#store.readMeta();
+            if (!meta) {
+                return;
+            }
+            const nextSeq = meta.lastSeq + 1;
+            this.#timeline.ensureNextSeqAtLeast(nextSeq);
+            this.#sessionState.updateLastSeq(meta.lastSeq);
+        }
+        catch {
+            // IDB 元数据校准失败不阻断当前运行期采集；导出仍会包含内存事件。
+        }
+    }
+    async #readPersistedEvents(options = {}) {
+        if (!this.#store) {
+            return [];
+        }
+        return this.#store.readEvents(options);
+    }
+    async #readLatestRrwebFullSnapshotBefore(beforeMs) {
+        const anchors = [
+            await this.#store?.readLatestRrwebFullSnapshotBefore(beforeMs),
+            this.#timeline.latestRrwebFullSnapshotBefore(beforeMs),
+        ].filter((event) => event !== undefined);
+        return anchors.sort(compareTimelineEvents).at(-1);
+    }
+}
+function initWebLogger(options = {}) {
+    return new WebLoggerCoreController(options);
+}
+function createSessionId() {
+    if (globalThis.crypto?.randomUUID) {
+        return globalThis.crypto.randomUUID();
+    }
+    return `session-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function estimateEventBytes(event) {
+    return JSON.stringify(event).length * 2;
+}
+function estimateEventsBytes(events) {
+    return events.reduce((total, event) => total + estimateEventBytes(event), 0);
+}
+function mergeEvents(persistedEvents, memoryEvents) {
+    const bySeq = new Map();
+    for (const event of persistedEvents) {
+        bySeq.set(event.seq, event);
+    }
+    for (const event of memoryEvents) {
+        bySeq.set(event.seq, event);
+    }
+    return [...bySeq.values()].sort(compareTimelineEvents);
+}
+
+export { CONSOLE_CAPTURE_METHODS, DEFAULT_INDEXED_DB_NAME, DEFAULT_MEMORY_FLUSH_THRESHOLD_BYTES, DEFAULT_RRWEB_CHECKOUT_EVERY_NMS, DEFAULT_SESSION_STORAGE_KEY, EVENT_CHUNKS_STORE, IDB_VERSION, WebLoggerCoreController as InMemoryWebLoggerController, IndexedDbEventStore, PACKAGE_NAME, SESSION_EXPORT_SCHEMA_VERSION, SESSION_META_STORE, Timeline, WebLoggerCoreController, compareTimelineEvents, initWebLogger, resolveSession };
+//# sourceMappingURL=index.js.map