@dxos/log 0.10.0 → 0.11.1

package/dist/lib/index.mjs

@@ -0,0 +1,619 @@
+import { a as logInfo, c as LogProcessorType, i as gatherLogInfoFromScope, l as levels, n as getContextFromEntry, o as getRelativeFilename, r as shouldLog, s as LogLevel, t as LogEntry, u as shortLevelName } from "./chunk-context.mjs";
+import { CircularBuffer, omit, pick, safariCheck } from "@dxos/util";
+import chalk from "chalk";
+import { inspect } from "@dxos/node-std/util";
+import defaultsDeep from "lodash.defaultsdeep";
+export * from "#console-processor";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region src/environment.ts
+/**
+* Per-tab session-storage key used to stabilize the random suffix for the main thread.
+* `sessionStorage` is per-tab and survives reloads of the same tab.
+*/
+var TAB_SUFFIX_STORAGE_KEY = "@dxos/log:env-suffix";
+var SUFFIX_LENGTH = 6;
+/**
+* Generate a 6-character lowercase-alphanumeric suffix.
+* Cryptographically random when `crypto` is available; falls back to `Math.random`.
+*/
+var randomSuffix = () => {
+	const cryptoRef = globalThis.crypto;
+	if (cryptoRef?.getRandomValues) {
+		const bytes = new Uint8Array(SUFFIX_LENGTH);
+		cryptoRef.getRandomValues(bytes);
+		let suffix = "";
+		for (const byte of bytes) suffix += (byte % 36).toString(36);
+		return suffix;
+	}
+	return Math.random().toString(36).slice(2, 8).padEnd(SUFFIX_LENGTH, "0");
+};
+/**
+* Look up (or create) a stable per-tab suffix in `sessionStorage`.
+* Same browser tab keeps the same suffix across reloads; different tabs get
+* different suffixes; private/blocked storage falls back to a fresh random.
+*/
+var getOrCreateTabSuffix = (session) => {
+	if (!session) return randomSuffix();
+	try {
+		const existing = session.getItem(TAB_SUFFIX_STORAGE_KEY);
+		if (existing && existing.length > 0) return existing;
+		const suffix = randomSuffix();
+		session.setItem(TAB_SUFFIX_STORAGE_KEY, suffix);
+		return suffix;
+	} catch {
+		return randomSuffix();
+	}
+};
+var isInstanceOf = (scope, ctorName) => {
+	const ctor = scope?.[ctorName];
+	return typeof ctor === "function" && scope instanceof ctor;
+};
+/**
+* Cloudflare Workers set `navigator.userAgent` to this exact string, regardless of
+* whether the worker is using modules or service-worker syntax. This is the most
+* stable signal and is checked before browser worker scopes because CF workers in
+* service-worker syntax also expose a `ServiceWorkerGlobalScope`.
+*/
+var CF_WORKER_USER_AGENT = "Cloudflare-Workers";
+/**
+* Infer a writer/environment identifier from the current execution context.
+*
+* Safe to invoke in any JS runtime — never throws. Falls back to `unknown::<suffix>`
+* when the runtime can't be classified.
+*
+* Format is always three colon-separated segments: `<scope>:<name>:<suffix>`.
+* - `scope` — `tab | dedicated-worker | shared-worker | service-worker | cf-worker | node | unknown`.
+* - `name` — `location.origin` for tabs, `self.name` for browser workers, `process.pid`
+*   for node, empty for cf-workers / service workers / anonymous workers.
+*   Note that `name` may itself contain `:` (e.g. `http://localhost:5173`); when parsing,
+*   take the first segment as scope and the last as suffix, and treat everything in
+*   between as the name.
+* - `suffix` — 6-char random; stable per-tab via `sessionStorage`, fresh per worker / process instance.
+*/
+var inferEnvironmentName = (options = {}) => {
+	const scope = options.scope ?? globalThis;
+	if (scope.navigator?.userAgent === CF_WORKER_USER_AGENT) return `cf-worker::${randomSuffix()}`;
+	if (isInstanceOf(scope, "SharedWorkerGlobalScope")) return `shared-worker:${scope.name ?? ""}:${randomSuffix()}`;
+	if (isInstanceOf(scope, "ServiceWorkerGlobalScope")) return `service-worker::${randomSuffix()}`;
+	if (isInstanceOf(scope, "DedicatedWorkerGlobalScope")) return `dedicated-worker:${scope.name ?? ""}:${randomSuffix()}`;
+	if (scope.window !== void 0 && scope.window === scope) return `tab:${scope.location?.origin ?? ""}:${getOrCreateTabSuffix(scope.sessionStorage)}`;
+	const proc = scope.process;
+	if (proc && typeof proc === "object" && proc.versions?.node) return `node:${typeof proc.pid === "number" ? String(proc.pid) : ""}:${randomSuffix()}`;
+	return `unknown::${randomSuffix()}`;
+};
+//#endregion
+//#region src/jsonl.ts
+/**
+* Serialize a {@link LogEntry} to a single compact JSON line (no trailing newline).
+*
+* Returns `undefined` for entries at TRACE level — callers can use this to skip them.
+*
+* The output is compatible with newline-delimited JSON (NDJSON / JSONL): join multiple
+* results with `\n` for a stream / file representation.
+*
+* Context is taken from {@link LogEntry.computedContext}, which has already flattened
+* nested objects to strings (see `stringifyOneLevel` in `context.ts`), so the resulting
+* `c` field is a JSON string of a flat `Record<string, primitive>` map. The function
+* does **not** truncate context — callers that care about line size should set their own
+* cap before calling, or trim post-hoc.
+*/
+var serializeToJsonl = (entry, opts = {}) => {
+	if (entry.level <= LogLevel.TRACE) return;
+	const { filename, line, context: scopeName } = entry.computedMeta;
+	const record = {
+		t: new Date(entry.timestamp).toISOString(),
+		l: shortLevelName[entry.level] ?? "?",
+		m: entry.message ?? ""
+	};
+	if (filename !== void 0) record.f = filename;
+	if (line !== void 0) record.n = line;
+	if (scopeName !== void 0) record.o = scopeName;
+	if (entry.computedError !== void 0) record.e = entry.computedError;
+	if (opts.env !== void 0) record.i = opts.env;
+	const computedContext = entry.computedContext;
+	if (Object.keys(computedContext).length > 0) try {
+		record.c = JSON.stringify(computedContext);
+	} catch {}
+	try {
+		return JSON.stringify(record);
+	} catch {
+		return;
+	}
+};
+//#endregion
+//#region src/decorators.ts
+var nextPromiseId = 0;
+var createMethodLogDecorator = (log) => (arg0, arg1, meta) => (target, propertyKey, descriptor) => {
+	const method = descriptor.value;
+	const methodName = propertyKey;
+	descriptor.value = function(...args) {
+		const combinedMeta = {
+			F: "",
+			L: 0,
+			...meta ?? {},
+			S: this
+		};
+		const formattedArgs = args.map((arg) => inspect(arg, false, 1, true)).join(", ");
+		try {
+			const startTime = performance.now();
+			const result = method.apply(this, args);
+			if (isThenable(result)) {
+				const id = nextPromiseId++;
+				logAsyncBegin(log, methodName, formattedArgs, id, combinedMeta);
+				result.then((resolvedValue) => {
+					logAsyncResolved(log, methodName, resolvedValue, id, startTime, combinedMeta);
+				}, (err) => {
+					logAsyncRejected(log, methodName, err, id, startTime, combinedMeta);
+				});
+			} else logSyncCall(log, methodName, formattedArgs, result, combinedMeta);
+			return result;
+		} catch (err) {
+			logSyncError(log, methodName, formattedArgs, err, combinedMeta);
+			throw err;
+		}
+	};
+	Object.defineProperty(descriptor.value, "name", { value: methodName + "$log" });
+};
+var createFunctionLogDecorator = (log) => (name, fn, opts = {}) => {
+	const decoratedFn = function(...args) {
+		const combinedMeta = {
+			F: "",
+			L: 0
+		};
+		const formattedArgs = args.map((arg) => inspect(arg, false, 1, true)).join(", ");
+		try {
+			const startTime = performance.now();
+			const result = fn.apply(this, args);
+			let transformedResult = result;
+			if (opts.transformOutput) if (isThenable(result)) transformedResult = result.then(opts.transformOutput);
+			else transformedResult = opts.transformOutput(result);
+			if (isThenable(transformedResult)) {
+				const id = nextPromiseId++;
+				logAsyncBegin(log, name, formattedArgs, id, combinedMeta);
+				transformedResult.then((resolvedValue) => {
+					logAsyncResolved(log, name, resolvedValue, id, startTime, combinedMeta);
+				}, (err) => {
+					logAsyncRejected(log, name, err, id, startTime, combinedMeta);
+				});
+			} else logSyncCall(log, name, formattedArgs, transformedResult, combinedMeta);
+			return result;
+		} catch (err) {
+			logSyncError(log, name, formattedArgs, err, combinedMeta);
+			throw err;
+		}
+	};
+	Object.defineProperty(decoratedFn, "name", { value: name + "$log" });
+	return decoratedFn;
+};
+var isThenable = (obj) => obj && typeof obj.then === "function";
+var logSyncCall = (log, methodName, formattedArgs, result, combinedMeta) => {
+	log.info(`.${formatFunction(methodName)} (${formattedArgs}) ${chalk.gray("=>")} ${inspect(result, false, 1, true)}`, {}, combinedMeta);
+};
+var logSyncError = (log, methodName, formattedArgs, err, combinedMeta) => {
+	log.error(`.${formatFunction(methodName)} (${formattedArgs}) 🔥 ${err}`, {}, combinedMeta);
+};
+var logAsyncBegin = (log, methodName, formattedArgs, promiseId, combinedMeta) => {
+	log.info(`.${formatFunction(methodName)} ↴ (${formattedArgs}) ${chalk.gray("=>")} ${formatPromise(promiseId)}`, {}, combinedMeta);
+};
+var logAsyncResolved = (log, methodName, resolvedValue, promiseId, startTime, combinedMeta) => {
+	if (resolvedValue !== void 0) log.info(`.${formatFunction(methodName)} ↲ ${greenCheck} ${chalk.gray("resolve")} ${formatPromise(promiseId)} ${formatTimeElapsed(startTime)} ${chalk.gray("=>")} ${inspect(resolvedValue, false, 1, true)}`, {}, combinedMeta);
+	else log.info(`.${formatFunction(methodName)} ↲ ${greenCheck} ${chalk.gray("resolve")} ${formatPromise(promiseId)} ${formatTimeElapsed(startTime)}`, {}, combinedMeta);
+};
+var logAsyncRejected = (log, methodName, err, promiseId, startTime, combinedMeta) => {
+	log.info(`.${formatFunction(methodName)} ↲ 🔥 ${chalk.gray("reject")} ${formatPromise(promiseId)} ${formatTimeElapsed(startTime)} ${chalk.gray("=>")} ${err}`, {}, combinedMeta);
+};
+var COLOR_FUNCTION = [
+	220,
+	220,
+	170
+];
+var greenCheck = typeof chalk.green === "function" ? chalk.green("✔") : "✔";
+var formatTimeElapsed = (startTime) => chalk.gray(`${(performance.now() - startTime).toFixed(0)}ms`);
+var formatFunction = (name) => chalk.bold(chalk.rgb(...COLOR_FUNCTION)(name));
+var formatPromise = (id) => chalk.blue(`Promise#${id}`);
+//#endregion
+//#region src/platform/index.ts
+var platform_exports = /* @__PURE__ */ __exportAll({});
+import * as import__platform from "#platform";
+__reExport(platform_exports, import__platform);
+//#endregion
+//#region src/processors/browser-processor.ts
+var CONFIG = {
+	useTestProcessor: false,
+	printFileLinks: false
+};
+/**
+* For running apps in the browser normally.
+*/
+var APP_BROWSER_PROCESSOR = (config, entry) => {
+	if (!shouldLog(entry, config.filters)) return;
+	const LOG_BROWSER_PREFIX = config.prefix ?? "https://vscode.dev/github.com/dxos/dxos/blob/main/";
+	const LOG_BROWSER_CSS = [];
+	const { filename, line: lineNumber, context: scopeDebugName } = entry.computedMeta;
+	let link = "";
+	if (filename !== void 0 && lineNumber !== void 0) link = `${`${LOG_BROWSER_PREFIX.replace(/\/$/, "")}/${filename}`}#L${lineNumber}`;
+	let args = [];
+	const scope = entry.meta?.S;
+	if (scope) {
+		const scopeName = scope.name || scopeDebugName;
+		if (scopeName) {
+			const processPrefix = scope.hostSessionId ? "[worker] " : "";
+			args.push(`%c${processPrefix}${scopeName}`, "color:#C026D3;font-weight:bold");
+		}
+	}
+	if (entry.message) args.push(entry.message);
+	const context = getContextFromEntry(entry);
+	if (context) if (Object.keys(context).length === 1 && "error" in context) args.push(unwrapEffectError(context.error));
+	else if (Object.keys(context).length === 1 && "err" in context) args.push(unwrapEffectError(context.err));
+	else args.push(context);
+	const levels = {
+		[LogLevel.ERROR]: console.error.bind(console),
+		[LogLevel.WARN]: console.warn.bind(console),
+		[LogLevel.DEBUG]: console.log.bind(console)
+	};
+	if (CONFIG.printFileLinks || safariCheck()) if (LOG_BROWSER_CSS?.length) args = [`%c${link}\n%c${args.join(" ")}`, ...LOG_BROWSER_CSS];
+	else args = [link + "\n", ...args];
+	const level = levels[entry.level] ?? console.log.bind(console);
+	if (typeof entry.meta?.C === "function") entry.meta.C(level, args);
+	else level(...args);
+};
+/**
+* For running unit tests in the headless browser.
+*/
+var TEST_BROWSER_PROCESSOR = (config, entry) => {
+	if (!shouldLog(entry, config.filters)) return;
+	const { filename, line: lineNumber } = entry.computedMeta;
+	const path = filename !== void 0 && lineNumber !== void 0 ? `${filename}:${lineNumber}` : "";
+	let args = [];
+	const processPrefix = entry.meta?.S?.hostSessionId ? "[worker] " : "";
+	args.push(`${processPrefix}${entry.message}`);
+	const context = getContextFromEntry(entry);
+	if (context) args.push(context);
+	const levels = {
+		[LogLevel.ERROR]: console.error,
+		[LogLevel.WARN]: console.warn,
+		[LogLevel.DEBUG]: console.log
+	};
+	if (CONFIG.printFileLinks) args = [path, ...args];
+	const level = levels[entry.level] ?? console.log;
+	if (typeof entry.meta?.C === "function") entry.meta.C(level, args);
+	else level(...args);
+};
+var BROWSER_PROCESSOR = CONFIG.useTestProcessor ? TEST_BROWSER_PROCESSOR : APP_BROWSER_PROCESSOR;
+var originalSymbol = Symbol.for("effect/OriginalAnnotation");
+var unwrapEffectError = (error) => {
+	if (typeof error === "object" && error !== null && originalSymbol in error) return error[originalSymbol];
+	return error;
+};
+//#endregion
+//#region src/processors/debug-processor.ts
+var DEBUG_PROCESSOR = (config, entry) => {
+	console.log(inspect(entry, false, null, true));
+};
+//#endregion
+//#region src/processors/index.ts
+var processors_exports = /* @__PURE__ */ __exportAll({
+	BROWSER_PROCESSOR: () => BROWSER_PROCESSOR,
+	DEBUG_PROCESSOR: () => DEBUG_PROCESSOR,
+	getRelativeFilename: () => getRelativeFilename
+});
+import * as import__console_processor from "#console-processor";
+__reExport(processors_exports, import__console_processor);
+//#endregion
+//#region src/options.ts
+/**
+* Processor variants.
+*/
+var processors = {
+	[LogProcessorType.CONSOLE]: processors_exports.CONSOLE_PROCESSOR,
+	[LogProcessorType.BROWSER]: BROWSER_PROCESSOR,
+	[LogProcessorType.DEBUG]: DEBUG_PROCESSOR
+};
+var DEFAULT_PROCESSORS = [(typeof window !== "undefined" || typeof navigator !== "undefined") && !(typeof process !== "undefined" && process?.env?.VITEST) ? BROWSER_PROCESSOR : processors_exports.CONSOLE_PROCESSOR];
+var parseLogLevel = (level, defValue = LogLevel.WARN) => levels[level.toLowerCase()] ?? defValue;
+/**
+* @internal
+*/
+var parseFilter = (filter) => {
+	if (typeof filter === "number") return [{ level: filter }];
+	return (typeof filter === "string" ? filter.split(/,\s*/) : filter).map((filter) => {
+		const [pattern, level] = filter.split(":");
+		return level ? {
+			level: parseLogLevel(level),
+			pattern
+		} : { level: parseLogLevel(pattern) };
+	});
+};
+/**
+* @internal
+*/
+var createConfig = (options) => {
+	const envOptions = "process" in globalThis ? {
+		file: process.env.LOG_CONFIG,
+		filter: process.env.LOG_FILTER,
+		processor: process.env.LOG_PROCESSOR
+	} : void 0;
+	const mergedOptions = defaultsDeep({}, (0, platform_exports.loadOptions)(envOptions?.file), envOptions, options);
+	return {
+		options: mergedOptions,
+		filters: parseFilter(mergedOptions.filter ?? LogLevel.INFO),
+		captureFilters: parseFilter(mergedOptions.captureFilter ?? LogLevel.WARN),
+		processors: mergedOptions.processor ? [processors[mergedOptions.processor]] : [...DEFAULT_PROCESSORS],
+		prefix: mergedOptions.prefix
+	};
+};
+//#endregion
+//#region src/log.ts
+var logCount = 0;
+/**
+* Create a logging function with properties.
+* @internal
+*/
+var createLog = () => {
+	const log = ((...params) => processLog(LogLevel.DEBUG, ...params));
+	Object.assign(log, {
+		_id: `log-${++logCount}`,
+		_config: createConfig()
+	});
+	Object.defineProperty(log, "runtimeConfig", { get: () => log._config });
+	/**
+	* Process the current log call.
+	*/
+	const processLog = (level, message, context = {}, meta, error) => {
+		const entry = new LogEntry({
+			level,
+			message,
+			context,
+			meta,
+			error
+		});
+		log._config.processors.forEach((processor) => processor(log._config, entry));
+	};
+	/**
+	* API.
+	*/
+	Object.assign(log, {
+		/**
+		* Update config.
+		* NOTE: Preserves any processors that were already added to this logger instance
+		* unless an explicit processor option is provided.
+		*/
+		config: ({ processor, ...options } = {}) => {
+			const config = createConfig(options);
+			const processors = processor ? config.processors : log._config.processors;
+			log._config = {
+				...config,
+				processors
+			};
+			return log;
+		},
+		/**
+		* Adds a processor to the logger.
+		*/
+		addProcessor: (processor) => {
+			if (log._config.processors.filter((p) => p === processor).length === 0) log._config.processors.push(processor);
+			return () => {
+				log._config.processors = log._config.processors.filter((p) => p !== processor);
+			};
+		},
+		trace: (...params) => processLog(LogLevel.TRACE, ...params),
+		debug: (...params) => processLog(LogLevel.DEBUG, ...params),
+		verbose: (...params) => processLog(LogLevel.VERBOSE, ...params),
+		info: (...params) => processLog(LogLevel.INFO, ...params),
+		warn: (...params) => processLog(LogLevel.WARN, ...params),
+		error: (...params) => processLog(LogLevel.ERROR, ...params),
+		catch: (error, context, meta) => processLog(LogLevel.ERROR, void 0, context, meta, error),
+		method: createMethodLogDecorator(log),
+		function: createFunctionLogDecorator(log),
+		break: () => log.info("-".repeat(80)),
+		stack: (message, context, meta) => {
+			return processLog(LogLevel.INFO, `${message ?? "Stack Dump"}\n${getFormattedStackTrace()}`, context, meta);
+		}
+	});
+	return log;
+};
+/**
+* Global logging function.
+*/
+var log = globalThis.DX_LOG ??= createLog();
+var start = Date.now();
+var last = start;
+/**
+* Log debug stack.
+*/
+var debug = (label, args) => {
+	const now = Date.now();
+	const err = /* @__PURE__ */ new Error();
+	console.group(`DEBUG[${label}]`, JSON.stringify({
+		t: Number(now - start).toLocaleString(),
+		dt: Number(now - last).toLocaleString(),
+		...args
+	}));
+	console.warn(err.stack);
+	console.groupEnd();
+	last = Date.now();
+};
+var getFormattedStackTrace = () => (/* @__PURE__ */ new Error()).stack.split("\n").slice(3).join("\n");
+//#endregion
+//#region src/registry.ts
+/** Create an isolated {@link LogFileRegistry} backed by an in-memory set with change notification. */
+var createLogFileRegistry = () => {
+	const files = /* @__PURE__ */ new Set();
+	const listeners = /* @__PURE__ */ new Set();
+	const notify = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		register: (file) => {
+			if (typeof file !== "string" || file.length === 0 || files.has(file)) return;
+			files.add(file);
+			notify();
+		},
+		getFiles: () => [...files].sort(),
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		clear: () => {
+			files.clear();
+			notify();
+		}
+	};
+};
+/**
+* Global singleton so all (possibly duplicated) copies of `@dxos/log` and the
+* transform-injected `globalThis.DX_LOG_FILES.register(...)` calls share one registry —
+* mirrors how `log` is `globalThis.DX_LOG`.
+*/
+var logFileRegistry = globalThis.DX_LOG_FILES ??= createLogFileRegistry();
+//#endregion
+//#region src/meta.ts
+/**
+* Marker key + value injected on every {@link CallMetadata} object by the log transform plugin.
+* Used by {@link isLogMeta} to detect a log-meta argument at runtime (e.g. for variadic
+* `param_index: 'last'` callees that don't have a fixed meta slot).
+*/
+var LOG_META_MARKER = "~LogMeta";
+/**
+* Type guard: `true` when `value` is a {@link CallMetadata} object emitted by the log transform plugin.
+* Detection is based on the presence of the {@link LOG_META_MARKER} marker key/value.
+*/
+var isLogMeta = (value) => {
+	return value != null && typeof value === "object" && value["~LogMeta"] === "~LogMeta";
+};
+//#endregion
+//#region src/dbg.ts
+/**
+* Debug-log value to console.
+* Log's the expression being evaluated.
+*
+* If only one argument is provided, it will also be returned.
+*
+* @example
+* ```ts
+* dbg(foo, bar);
+* // foo = 1
+* // bar = 2
+*
+* bar = dbg(foo * 2);
+* // foo * 2 = 2
+* ```
+*
+* NOTE: The second argument is injected by the log transform plugin.
+*/
+var dbg = (arg, meta) => {
+	if (meta?.A) console.log(`${meta.A[0]} =`, arg);
+	else console.log(arg);
+	return arg;
+};
+//#endregion
+//#region src/log-buffer.ts
+var DEFAULT_BUFFER_SIZE = 2e3;
+var MAX_CONTEXT_LENGTH = 500;
+/**
+* Captures recent log entries in a circular buffer for debug log dump.
+*/
+var LogBuffer = class {
+	_buffer;
+	constructor(size = DEFAULT_BUFFER_SIZE) {
+		this._buffer = new CircularBuffer(size);
+	}
+	/**
+	* Log processor that can be registered with `log.runtimeConfig.processors`.
+	* Captures every level except TRACE (does not apply `shouldLog` / filter; use for full debug dumps).
+	*/
+	logProcessor = (_config, entry) => {
+		if (entry.level <= LogLevel.TRACE) return;
+		const { filename, line, context: scopeName } = entry.computedMeta;
+		const record = {
+			t: new Date(entry.timestamp).toISOString(),
+			l: shortLevelName[entry.level] ?? "?",
+			m: entry.message ?? ""
+		};
+		if (filename !== void 0) record.f = filename;
+		if (line !== void 0) record.n = line;
+		if (scopeName !== void 0) record.o = scopeName;
+		if (entry.computedError !== void 0) record.e = entry.computedError;
+		const computedContext = entry.computedContext;
+		if (Object.keys(computedContext).length > 0) try {
+			let json = JSON.stringify(computedContext);
+			if (json.length > MAX_CONTEXT_LENGTH) json = json.slice(0, MAX_CONTEXT_LENGTH);
+			record.c = json;
+		} catch {}
+		this._buffer.push(record);
+	};
+	/** Number of entries currently in the buffer. */
+	get size() {
+		return this._buffer.elementCount;
+	}
+	/** Discard all buffered entries. */
+	clear() {
+		this._buffer.clear();
+	}
+	/** Serialize buffer contents as NDJSON (newline-delimited JSON). */
+	serialize() {
+		const lines = [];
+		for (const record of this._buffer) lines.push(JSON.stringify(record));
+		return lines.join("\n");
+	}
+};
+inspect.custom;
+var getCurrentOwnershipScope = (thisRef) => thisRef;
+__reExport(/* @__PURE__ */ __exportAll({
+	BROWSER_PROCESSOR: () => BROWSER_PROCESSOR,
+	DEBUG_PROCESSOR: () => DEBUG_PROCESSOR,
+	LOG_META_MARKER: () => LOG_META_MARKER,
+	LogBuffer: () => LogBuffer,
+	LogEntry: () => LogEntry,
+	LogLevel: () => LogLevel,
+	LogProcessorType: () => LogProcessorType,
+	createLog: () => createLog,
+	createLogFileRegistry: () => createLogFileRegistry,
+	dbg: () => dbg,
+	debug: () => debug,
+	gatherLogInfoFromScope: () => gatherLogInfoFromScope,
+	getContextFromEntry: () => getContextFromEntry,
+	getCurrentOwnershipScope: () => getCurrentOwnershipScope,
+	getRelativeFilename: () => getRelativeFilename,
+	inferEnvironmentName: () => inferEnvironmentName,
+	isLogMeta: () => isLogMeta,
+	levels: () => levels,
+	log: () => log,
+	logFileRegistry: () => logFileRegistry,
+	logInfo: () => logInfo,
+	omit: () => omit,
+	parseFilter: () => parseFilter,
+	pick: () => pick,
+	serializeToJsonl: () => serializeToJsonl,
+	shortLevelName: () => shortLevelName,
+	shouldLog: () => shouldLog
+}), processors_exports);
+//#endregion
+export { BROWSER_PROCESSOR, DEBUG_PROCESSOR, LOG_META_MARKER, LogBuffer, LogEntry, LogLevel, LogProcessorType, createLog, createLogFileRegistry, dbg, debug, gatherLogInfoFromScope, getContextFromEntry, getCurrentOwnershipScope, getRelativeFilename, inferEnvironmentName, isLogMeta, levels, log, logFileRegistry, logInfo, omit, parseFilter, pick, serializeToJsonl, shortLevelName, shouldLog };
+
+//# sourceMappingURL=index.mjs.map