@likec4/log 1.48.0 → 1.50.0

package/dist/THIRD-PARTY-LICENSES.md

@@ -0,0 +1,76 @@
+# Licenses of Bundled Dependencies
+
+The published artifact additionally contains code with the following licenses:
+MIT
+
+# Bundled Dependencies
+
+## is-error-instance
+
+License: MIT
+By: ehmicky
+Repository: https://github.com/ehmicky/is-error-instance
+
+> Copyright © 2024 ehmicky
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the “Software”), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## is-plain-obj, safe-stringify
+
+License: MIT
+By: Sindre Sorhus
+Repositories: https://github.com/sindresorhus/is-plain-obj, https://github.com/sindresorhus/safe-stringify
+
+> MIT License
+> 
+> Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---------------------------------------
+
+## merge-error-cause, normalize-exception, redefine-property, set-error-class, set-error-message, set-error-props, wrap-error-message
+
+License: MIT
+By: ehmicky
+Repositories: https://github.com/ehmicky/merge-error-cause, https://github.com/ehmicky/normalize-exception, https://github.com/ehmicky/redefine-property, https://github.com/ehmicky/set-error-class, https://github.com/ehmicky/set-error-message, https://github.com/ehmicky/set-error-props, https://github.com/ehmicky/wrap-error-message
+
+> Copyright © 2025 ehmicky
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy of
+> this software and associated documentation files (the “Software”), to deal in
+> the Software without restriction, including without limitation the rights to
+> use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+> the Software, and to permit persons to whom the Software is furnished to do so,
+> subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+> FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+> COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+> IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+> CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/_chunks/libs/is-error-instance.mjs

@@ -1,6 +1,4 @@
-//#region ../../node_modules/.pnpm/is-error-instance@3.0.1/node_modules/is-error-instance/build/src/main.js
 const isErrorInstance = (value) => isInstanceOfError(value) || hasErrorTag(value);
-var main_default = isErrorInstance;
 const isInstanceOfError = (value) => {
 	try {
 		return value instanceof Error;
@@ -21,6 +19,4 @@ const ERROR_TAGS = new Set([
 	"[object DOMError]",
 	"[object Exception]"
 ]);
-
-//#endregion
-export { main_default as t };
+export { isErrorInstance as t };

package/dist/_chunks/libs/is-plain-obj.mjs

@@ -1,9 +1,6 @@
-//#region ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const prototype = Object.getPrototypeOf(value);
 	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
 }
-
-//#endregion
-export { isPlainObject as t };
+export { isPlainObject as t };

package/dist/_chunks/libs/merge-error-cause.mjs

@@ -1,7 +1,5 @@
-import { t as main_default$7 } from "./is-error-instance.mjs";
+import { t as isErrorInstance } from "./is-error-instance.mjs";
 import { t as isPlainObject } from "./is-plain-obj.mjs";
-
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/descriptors.js
 const normalizeDescriptors = (error) => {
 	CORE_ERROR_PROPS.forEach((propName) => {
 		normalizeDescriptor$1(error, propName);
@@ -42,9 +40,6 @@ const setErrorDescriptor = (error, propName, descriptor) => {
 		configurable: true
 	});
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/aggregate.js
 const normalizeAggregate = (error, recurse) => {
 	if (Array.isArray(error.errors)) setErrorProperty$1(error, "errors", error.errors.filter(isDefined).map(recurse).filter(Boolean));
 	else if (isAggregateError(error)) setErrorProperty$1(error, "errors", []);
@@ -56,18 +51,12 @@ const deleteAggregateErrors = (error) => {
 	delete error.errors;
 	if (error.errors !== void 0) setErrorProperty$1(error, "errors", []);
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/cause.js
 const normalizeCause = (error, recurse) => {
 	if (!("cause" in error)) return;
 	const cause = error.cause === void 0 ? error.cause : recurse(error.cause);
 	if (cause === void 0) delete error.cause;
 	else setErrorProperty$1(error, "cause", cause);
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/modifiable.js
 const isNonModifiableError = (error) => !Object.isExtensible(error) || CORE_ERROR_PROPS.some((propName) => isNonConfigurableProp(error, propName) || isThrowingProp(error, propName));
 const isNonConfigurableProp = (error, propName) => {
 	const descriptor = Object.getOwnPropertyDescriptor(error, propName);
@@ -81,9 +70,6 @@ const isThrowingProp = (error, propName) => {
 		return true;
 	}
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/stack.js
 const setStack = (error) => {
 	setErrorProperty$1(error, "stack", getStack$3(error.message, error.name));
 };
@@ -102,9 +88,6 @@ const getErrorClass = (name) => {
 	Object.defineProperty(StackError.prototype, "name", descriptor);
 	return StackError;
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/copy.js
 const copyObject = (object) => {
 	const objectCopy = {};
 	for (const propName of getPropsToCopy(object)) try {
@@ -138,9 +121,6 @@ const isInheritedProp = (object, propName) => {
 		return false;
 	}
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/object.js
 const objectifyError = (object) => {
 	const { name, message, stack, cause, errors, ...objectA } = copyObject(object);
 	const messageA = getMessage$1(message, objectA);
@@ -194,9 +174,6 @@ const assignObjectProps = (error, object) => {
 const setNewErrorProperty = (error, propName, propValue) => {
 	if (propValue !== void 0) setErrorProperty$1(error, propName, propValue);
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/string.js
 const stringifyError = (value) => {
 	try {
 		const error = new Error(String(value));
@@ -206,13 +183,10 @@ const stringifyError = (value) => {
 		return error_;
 	}
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/main.js
 const { toString: objectToString } = Object.prototype;
 const createError = (value) => {
 	if (isErrorPlainObj(value)) return objectifyError(value);
-	if (!main_default$7(value)) return stringifyError(value);
+	if (!isErrorInstance(value)) return stringifyError(value);
 	if (isInvalidError(value)) return objectifyError(value);
 	return value;
 };
@@ -232,11 +206,7 @@ const isProxy = (value) => {
 	}
 };
 const hasInvalidConstructor = (error) => typeof error.constructor !== "function" || typeof error.constructor.name !== "string" || error.constructor.name === "" || error.constructor.prototype !== Object.getPrototypeOf(error);
-
-//#endregion
-//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/main.js
 const normalizeException = (error, { shallow = false } = {}) => recurseException(error, [], shallow);
-var main_default$6 = normalizeException;
 const recurseException = (error, parents, shallow) => {
 	if (parents.includes(error)) return;
 	const recurse = shallow ? identity : (innerError) => recurseException(innerError, [...parents, error], shallow);
@@ -265,9 +235,6 @@ const normalizeStack = (error) => {
 	if (!isDefinedString$1(error.stack)) setStack(error);
 };
 const isDefinedString$1 = (value) => typeof value === "string" && value !== "";
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/args.js
 const normalizeArgs$1 = (error, ErrorClass, currentName = error.name) => {
 	validateErrorClass(ErrorClass);
 	if (typeof currentName !== "string") throw new TypeError(`currentName must be a string: ${currentName}`);
@@ -281,9 +248,6 @@ const validateErrorClass = (ErrorClass) => {
 const isClass = (ErrorClass) => typeof ErrorClass === "function" && typeof ErrorClass.prototype === "object" && ErrorClass.prototype !== null;
 const isErrorClass = (prototype) => prototype !== null && (prototype.name === "Error" || isErrorClass(Object.getPrototypeOf(prototype)));
 const hasConstructor = (ErrorClass) => typeof ErrorClass.prototype.constructor === "function";
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/enum.js
 const setNonEnumProp$1 = (error, propName, value) => {
 	Object.defineProperty(error, propName, {
 		value,
@@ -292,9 +256,6 @@ const setNonEnumProp$1 = (error, propName, value) => {
 		configurable: true
 	});
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/prototype.js
 const updatePrototype = (error, ErrorClass) => {
 	if (Object.getPrototypeOf(error) === ErrorClass.prototype) return;
 	setPrototype(error, ErrorClass);
@@ -316,9 +277,6 @@ const isDefinedString = (value) => typeof value === "string" && value !== "";
 const deleteOwnProperty = (error, propName) => {
 	if (Object.hasOwn(error, propName)) delete error[propName];
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/stack.js
 const updateStack$1 = (error, currentName) => {
 	if (!shouldUpdateStack(error, currentName)) return;
 	setNonEnumProp$1(error, "stack", getStack$2(error, currentName));
@@ -349,20 +307,13 @@ const getReplacers$1 = (currentName, newName) => [
 	[`${currentName} `, `${newName} `],
 	[currentName, newName]
 ];
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-class@3.0.1/node_modules/set-error-class/build/src/main.js
 const setErrorClass = (error, ErrorClass, currentName) => {
-	const errorA = main_default$6(error);
+	const errorA = normalizeException(error);
 	const currentNameA = normalizeArgs$1(errorA, ErrorClass, currentName);
 	updatePrototype(errorA, ErrorClass);
 	updateStack$1(errorA, currentNameA);
 	return errorA;
 };
-var main_default$5 = setErrorClass;
-
-//#endregion
-//#region ../../node_modules/.pnpm/redefine-property@3.0.1/node_modules/redefine-property/build/src/merge.js
 const mergeDescriptors = (newDescriptor, currentDescriptor) => currentDescriptor.configurable === false ? mergeNonConfig(newDescriptor, currentDescriptor) : mergeConfig(newDescriptor, currentDescriptor);
 const mergeNonConfig = (newDescriptor, currentDescriptor) => ({
 	...currentDescriptor,
@@ -397,9 +348,6 @@ const mergeValue = (newDescriptor, currentDescriptor, writable) => {
 };
 const hasGetSet = ({ get, set }) => get !== void 0 || set !== void 0;
 const mergeDescriptor = (newValue, currentValue, defaultValue) => newValue ?? currentValue ?? defaultValue;
-
-//#endregion
-//#region ../../node_modules/.pnpm/redefine-property@3.0.1/node_modules/redefine-property/build/src/normalize.js
 const normalizeInput = (input, key, newDescriptor) => {
 	if (!isAnyObj(input)) throw new TypeError(`Argument must be an object: ${input}`);
 	if (!isValidKey(key)) throw new TypeError(`Property key must be a string, a symbol or an integer: ${key}`);
@@ -455,14 +403,10 @@ const validateUnknownProps = (unknownProps) => {
 	const [unknownProp] = Object.keys(unknownProps);
 	if (unknownProp !== void 0) throw new TypeError(`Unknown descriptor property "${unknownProp}": ${unknownProps[unknownProp]}`);
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/redefine-property@3.0.1/node_modules/redefine-property/build/src/main.js
 const redefineProperty = (input, key, newDescriptor) => {
 	setProperty(input, key, mergeDescriptors(normalizeInput(input, key, newDescriptor), getCurrentDescriptor(input, key)));
 	return input;
 };
-var main_default$4 = redefineProperty;
 const getCurrentDescriptor = (input, key) => {
 	const descriptor = Object.getOwnPropertyDescriptor(input, key);
 	if (descriptor !== void 0) return descriptor;
@@ -474,9 +418,6 @@ const setProperty = (input, key, finalDescriptor) => {
 		Object.defineProperty(input, key, finalDescriptor);
 	} catch {}
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/assign.js
 const assignProp = (error, propName, propValue) => {
 	if (propValue !== void 0) return setProp(error, propName, propValue);
 	try {
@@ -485,15 +426,12 @@ const assignProp = (error, propName, propValue) => {
 	if (error[propName] !== void 0) return setProp(error, propName);
 };
 const setProp = (error, propName, propValue) => {
-	main_default$4(error, propName, {
+	redefineProperty(error, propName, {
 		value: propValue,
 		...getNonEnum(propName)
 	});
 };
 const getNonEnum = (propName) => typeof propName === "string" && propName.startsWith("_") ? { enumerable: false } : {};
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/options.js
 const normalizeOptions = (error, props, opts = {}) => {
 	validateErrorOrObject(error, "First argument");
 	validateErrorOrObject(props, "Second argument");
@@ -506,10 +444,7 @@ const validateErrorOrObject = (value, prefix) => {
 	if (value === void 0) throw new TypeError(`${prefix} is required.`);
 	if (!isErrorOrObject(value)) throw new TypeError(`${prefix} must be a plain object or an error: ${value}`);
 };
-const isErrorOrObject = (value) => isPlainObject(value) || main_default$7(value);
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/skip.js
+const isErrorOrObject = (value) => isPlainObject(value) || isErrorInstance(value);
 const shouldSkipProp = ({ error, props, propName, soft }) => isIgnoredPropName(propName) || !isEnum.call(props, propName) || soft && error[propName] !== void 0;
 const isIgnoredPropName = (propName) => propName in CHECK_ERROR || IGNORED_PROPS.has(propName);
 const CHECK_ERROR = /* @__PURE__ */ new Error("check");
@@ -519,9 +454,6 @@ const IGNORED_PROPS = new Set([
 	"cause"
 ]);
 const { propertyIsEnumerable: isEnum } = Object.prototype;
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-props@6.0.1/node_modules/set-error-props/build/src/main.js
 const setErrorProps = (error, props, opts) => {
 	const { soft } = normalizeOptions(error, props, opts);
 	for (const propName of Reflect.ownKeys(props)) setErrorProp({
@@ -532,7 +464,6 @@ const setErrorProps = (error, props, opts) => {
 	});
 	return error;
 };
-var main_default$3 = setErrorProps;
 const setErrorProp = ({ error, props, propName, soft }) => {
 	if (!shouldSkipProp({
 		error,
@@ -541,9 +472,6 @@ const setErrorProp = ({ error, props, propName, soft }) => {
 		soft
 	})) assignProp(error, propName, props[propName]);
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/set.js
 const setErrorProperty = (error, propName, value) => {
 	Object.defineProperty(error, propName, {
 		value,
@@ -552,9 +480,6 @@ const setErrorProperty = (error, propName, value) => {
 		configurable: true
 	});
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/aggregate.js
 const mergeAggregateCauses = (parent, recurse) => {
 	if (parent.errors === void 0) return;
 	setErrorProperty(parent, "errors", parent.errors.map((error) => recurse(error).error).filter(Boolean));
@@ -570,17 +495,11 @@ const mergeSourceErrors = (target, source) => {
 	if (source.errors !== void 0) setErrorProperty(target, "errors", source.errors);
 };
 const hasErrors = (targetOrSource) => targetOrSource.errors !== void 0 && targetOrSource.errors.length !== 0;
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-message@3.0.1/node_modules/set-error-message/build/src/args.js
 const normalizeArgs = (error, newMessage, currentMessage = error.message) => {
 	if (typeof newMessage !== "string") throw new TypeError(`newMessage must be a string: ${newMessage}`);
 	if (typeof currentMessage !== "string") throw new TypeError(`currentMessage must be a string: ${currentMessage}`);
 	return currentMessage;
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-message@3.0.1/node_modules/set-error-message/build/src/stack.js
 const getStack$1 = ({ name, stack }, newMessage, currentMessage) => currentMessage !== "" && stack.includes(currentMessage) ? replaceMessage({
 	name,
 	stack,
@@ -604,17 +523,13 @@ const insertMessage = (name, stack, newMessage) => {
 	if (stack === name || stack.startsWith(`${name}\n`)) return stack.replace(name, `${nameAndColon}${newMessageA}`);
 	return stack.startsWith(nameAndColon) ? stack.replace(nameAndColon, `${nameAndColon}${newMessageA}\n`) : `${nameAndColon}${newMessageA}\n${stack}`;
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/set-error-message@3.0.1/node_modules/set-error-message/build/src/main.js
 const setErrorMessage = (error, newMessage, currentMessage) => {
-	const errorA = main_default$6(error);
+	const errorA = normalizeException(error);
 	const currentMessageA = normalizeArgs(errorA, newMessage, currentMessage);
 	setNonEnumProp(errorA, "message", newMessage);
 	updateStack(errorA, newMessage, currentMessageA);
 	return errorA;
 };
-var main_default$2 = setErrorMessage;
 const updateStack = (error, newMessage, currentMessage) => {
 	if (newMessage === currentMessage || !stackIncludesMessage()) return;
 	setNonEnumProp(error, "stack", getStack$1(error, newMessage, currentMessage));
@@ -632,15 +547,11 @@ const setNonEnumProp = (error, propName, value) => {
 		configurable: true
 	});
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/wrap-error-message@3.0.1/node_modules/wrap-error-message/build/src/main.js
 const wrapErrorMessage = (error, newMessage, oldMessage) => {
 	if (typeof newMessage !== "string") throw new TypeError(`Second argument must be a message string: ${newMessage}`);
-	const errorA = main_default$6(error);
-	return main_default$2(errorA, getMessage(newMessage, errorA.message), oldMessage);
+	const errorA = normalizeException(error);
+	return setErrorMessage(errorA, getMessage(newMessage, errorA.message), oldMessage);
 };
-var main_default$1 = wrapErrorMessage;
 const getMessage = (rawNewMessage, rawCurrentMessage) => {
 	const newMessage = rawNewMessage.trim();
 	const currentMessage = rawCurrentMessage.trim();
@@ -654,18 +565,12 @@ const concatMessages = (newMessage, currentMessage, rawNewMessage) => {
 };
 const PREPEND_CHAR = ":";
 const PREPEND_NEWLINE_CHAR = "\n";
-
-//#endregion
-//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/message.js
 const mergeMessage = ({ parent, child, target, stackError }) => {
 	const parentMessage = parent.message;
 	const stackErrorMessage = stackError.message;
 	target.message = child.message;
-	return main_default$1(target, parentMessage, stackErrorMessage);
+	return wrapErrorMessage(target, parentMessage, stackErrorMessage);
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/stack.js
 const hasStack = (error, stack) => getStack(error) === stack;
 const getStack = (error) => typeof error === "object" && error !== null ? error.stack : void 0;
 const mergeStack = ({ wrap, target, source, childHasStack }) => {
@@ -673,25 +578,18 @@ const mergeStack = ({ wrap, target, source, childHasStack }) => {
 	setErrorProperty(target, "stack", source.stack);
 	return source;
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/wrap.js
 const getWrap = (parent) => {
 	const { wrap, name } = parent;
 	if (typeof wrap !== "boolean") return name === "Error";
 	if (Object.hasOwn(parent, "wrap")) delete parent.wrap;
 	return wrap;
 };
-
-//#endregion
-//#region ../../node_modules/.pnpm/merge-error-cause@5.0.2/node_modules/merge-error-cause/build/src/main.js
 const mergeErrorCause = (error) => mergeError(error, []).error;
-var main_default = mergeErrorCause;
 const mergeError = (error, parents) => {
 	if (parents.includes(error)) return {};
 	const recurse = (innerError) => mergeError(innerError, [...parents, error]);
 	const stack = getStack(error);
-	const errorA = main_default$6(error, { shallow: true });
+	const errorA = normalizeException(error, { shallow: true });
 	const parentHasStack = hasStack(errorA, stack);
 	mergeAggregateCauses(errorA, recurse);
 	const { parent: errorB, childHasStack } = mergeCause(errorA, recurse);
@@ -730,7 +628,7 @@ const mergeChild = ({ parent, child, childHasStack, wrap }) => {
 	const targetB = mergeMessage({
 		parent,
 		child,
-		target: main_default$5(target, target.constructor, stackError.name),
+		target: setErrorClass(target, target.constructor, stackError.name),
 		stackError
 	});
 	mergeAggregateErrors({
@@ -739,8 +637,6 @@ const mergeChild = ({ parent, child, childHasStack, wrap }) => {
 		parent,
 		child
 	});
-	return main_default$3(targetB, source, { soft: !wrap });
+	return setErrorProps(targetB, source, { soft: !wrap });
 };
-
-//#endregion
-export { main_default$1 as n, main_default as t };
+export { wrapErrorMessage as n, mergeErrorCause as t };

package/dist/_chunks/libs/safe-stringify.mjs

@@ -1,21 +1,19 @@
-//#region ../../node_modules/.pnpm/safe-stringify@1.2.0/node_modules/safe-stringify/index.js
-function safeStringifyReplacer(seen) {
-	const replacer = function(key, value) {
-		if (typeof value?.toJSON === "function") value = value.toJSON();
-		if (!(value !== null && typeof value === "object")) return value;
-		if (seen.has(value)) return "[Circular]";
-		seen.add(value);
-		const newValue = Array.isArray(value) ? [] : {};
-		for (const [key2, value2] of Object.entries(value)) newValue[key2] = replacer(key2, value2);
-		seen.delete(value);
-		return newValue;
-	};
-	return replacer;
+function serializeValue(value, seen, trace, currentPath) {
+	if (typeof value?.toJSON === "function") value = value.toJSON();
+	if (!(value !== null && typeof value === "object")) return value;
+	if (seen.has(value)) {
+		if (!trace) return "[Circular]";
+		const existingPath = seen.get(value);
+		return `[Circular ${existingPath === "" ? "*" : `*${existingPath}`}]`;
+	}
+	seen.set(value, currentPath);
+	const newValue = Array.isArray(value) ? [] : {};
+	for (const [propertyKey, propertyValue] of Object.entries(value)) newValue[propertyKey] = serializeValue(propertyValue, seen, trace, currentPath === "" ? propertyKey : `${currentPath}.${propertyKey}`);
+	seen.delete(value);
+	return newValue;
 }
-function safeStringify(object, { indentation } = {}) {
-	const seen = /* @__PURE__ */ new WeakSet();
-	return JSON.stringify(object, safeStringifyReplacer(seen), indentation);
+function safeStringify(value, { indentation, trace } = {}) {
+	const serializedValue = serializeValue(value, /* @__PURE__ */ new WeakMap(), trace, "");
+	return JSON.stringify(serializedValue, void 0, indentation);
 }
-
-//#endregion
-export { safeStringify as t };
+export { safeStringify as t };

package/dist/index.d.mts

@@ -2,28 +2,61 @@ import * as _logtape_logtape0 from "@logtape/logtape";
 import { AnsiColorFormatterOptions, Config, ConsoleFormatter, ConsoleSinkOptions, Filter, LogLevel, LogRecord, LogRecord as LogRecord$1, Logger, Sink, Sink as Sink$1, TextFormatter, TextFormatter as TextFormatter$1, TextFormatterOptions, withFilter } from "@logtape/logtape";
 
 //#region src/formatters.d.ts
+/**
+ * Extract a single Error from a log record (from properties or rawMessage).
+ * @param record - Log record that may contain error in properties or rawMessage
+ * @returns Merged/wrapped Error or null if none found
+ */
 declare function errorFromLogRecord(record: LogRecord$1): Error | null;
+/**
+ * Formatter that outputs only the log message (no timestamp/level/category).
+ * @returns TextFormatter that returns just the message string
+ */
 declare function getMessageOnlyFormatter(): TextFormatter$1;
+/**
+ * Build a text formatter with optional custom format; appends error from record.
+ * @param options - Optional format and logtape options
+ * @returns TextFormatter
+ */
 declare function getTextFormatter(options?: TextFormatterOptions): TextFormatter$1;
+/**
+ * Build an ANSI-colored text formatter (level/category colors); appends error in red.
+ * @param options - Optional format and logtape ANSI options
+ * @returns TextFormatter with ANSI colors
+ */
 declare function getAnsiColorFormatter(options?: AnsiColorFormatterOptions): TextFormatter$1;
 /**
  * The formatter returns an array where:
  * - First element is the formatted message string
  * - Second element is the record properties object
+ * @param options - Optional messageFormatter (TextFormatter)
+ * @returns ConsoleFormatter for console.log/error
  */
 declare function getConsoleFormatter(options?: {
   messageFormatter?: TextFormatter$1;
 }): ConsoleFormatter;
 //#endregion
 //#region src/sink.d.ts
+/**
+ * Create a sink that writes formatted log records to stdout (default formatter).
+ * @param options - Optional console sink options (e.g. custom formatter)
+ * @returns Sink that writes to stdout
+ */
 declare function getConsoleSink(options?: ConsoleSinkOptions): Sink$1;
 /**
  * Creates a console sink that writes to stderr.
  * (MCP protocol requires stderr to be used for logging)
+ * @param options - Optional console sink options (e.g. custom formatter)
+ * @returns Sink that writes to stderr
  */
 declare function getConsoleStderrSink(options?: ConsoleSinkOptions): Sink$1;
 //#endregion
 //#region src/utils.d.ts
+/**
+ * Serialize unknown to a string (Error → message + stack; else safe-stringify).
+ * @param error - Caught value (Error, string, or arbitrary object)
+ * @returns Human-readable string for logging
+ */
 declare function loggable(error: unknown): string;
 type NormalizeError<ErrorArg> = ErrorArg extends Error ? ErrorArg : Error;
 /**
@@ -70,6 +103,10 @@ declare const logger: _logtape_logtape0.Logger;
  * @returns The child logger.
  */
 declare function createLogger(subcategory: string | readonly [string] | readonly [string, ...string[]]): _logtape_logtape0.Logger;
+/**
+ * Configure the global logger: sinks, loggers, and lowest level per category.
+ * @param config - Optional partial config (sinks, loggers). Merged with defaults.
+ */
 declare function configureLogger<TSinkId extends string, TFilterId extends string>(config?: Partial<Config<TSinkId, TFilterId>>): void;
 //#endregion
 export { type Filter, type LogLevel, type LogRecord, type Logger, type Sink, type TextFormatter, configureLogger, logger as consola, logger, logger as rootLogger, createLogger, errorFromLogRecord, getAnsiColorFormatter, getConsoleFormatter, getConsoleSink, getConsoleStderrSink, getMessageOnlyFormatter, getTextFormatter, loggable, withFilter, wrapError };

package/dist/index.mjs

@@ -1,22 +1,38 @@
-import { n as main_default$1, t as main_default } from "./_chunks/libs/merge-error-cause.mjs";
+import { n as wrapErrorMessage, t as mergeErrorCause } from "./_chunks/libs/merge-error-cause.mjs";
+import "./_chunks/libs/is-error-instance.mjs";
+import "./_chunks/libs/is-plain-obj.mjs";
 import { t as safeStringify } from "./_chunks/libs/safe-stringify.mjs";
 import { configureSync, getAnsiColorFormatter as getAnsiColorFormatter$1, getConsoleSink as getConsoleSink$1, getLogger, getTextFormatter as getTextFormatter$1, withFilter } from "@logtape/logtape";
-
-//#region src/utils.ts
+/**
+* Split stack string into lines and normalize (e.g. strip file://).
+* @param stack - Error stack string
+* @returns Array of normalized lines
+*/
 const parseStack = (stack) => {
 	return stack.split("\n").map((l) => {
 		return l.trim().replace("file://", "");
 	});
 };
+/**
+* Indent each line of value by the given number of spaces.
+* @param value - String or array of lines to indent
+* @param indentation - Number of spaces (default 2)
+* @returns Indented string
+*/
 function indent(value, indentation = 2) {
 	value = Array.isArray(value) ? value : value.split("\n");
 	const prefix = " ".repeat(indentation);
 	return value.map((l) => `${prefix}${l}`).join("\n");
 }
+/**
+* Serialize unknown to a string (Error → message + stack; else safe-stringify).
+* @param error - Caught value (Error, string, or arbitrary object)
+* @returns Human-readable string for logging
+*/
 function loggable(error) {
 	if (typeof error === "string") return error;
 	if (error instanceof Error) {
-		const mergedErr = main_default(error);
+		const mergedErr = mergeErrorCause(error);
 		if (mergedErr.stack) {
 			const stack = parseStack(mergedErr.stack);
 			return mergedErr.message + "\n" + indent(stack.slice(1));
@@ -59,38 +75,46 @@ function loggable(error) {
 * ```
 */
 function wrapError(error, newMessage) {
-	return main_default$1(error, newMessage);
+	return wrapErrorMessage(error, newMessage);
 }
-
-//#endregion
-//#region src/formatters.ts
-function gerErrorFromLogRecord(record) {
+function getErrorFromLogRecord(record) {
 	const errors = Object.entries(record.properties).flatMap(([k, err]) => {
 		if (err instanceof Error) {
-			const mergedErr = main_default(err);
+			const mergedErr = mergeErrorCause(err);
 			if (mergedErr.stack) mergedErr.stack = parseStack(mergedErr.stack).join("\n");
 			return [mergedErr];
 		}
-		if (k === "error" || k === "err") return [/* @__PURE__ */ new Error(`${err}`)];
+		if (k === "error" || k === "err") return [new Error(loggable(err))];
 		return [];
 	});
 	if (errors.length === 0) return null;
 	return errors.length === 1 ? errors[0] : new AggregateError(errors);
 }
+/**
+* Extract a single Error from a log record (from properties or rawMessage).
+* @param record - Log record that may contain error in properties or rawMessage
+* @returns Merged/wrapped Error or null if none found
+*/
 function errorFromLogRecord(record) {
-	const error = gerErrorFromLogRecord(record);
-	if (error && typeof record.rawMessage === "string") return main_default$1(error, record.rawMessage + "\n");
+	const error = getErrorFromLogRecord(record);
+	if (error && typeof record.rawMessage === "string") return wrapErrorMessage(error, record.rawMessage + "\n");
 	return error;
 }
+/**
+* Append error from record properties to the formatted message (optionally colored).
+* @param values - Formatted values (record + message)
+* @param color - When true, wrap error text in ANSI red
+* @returns Updated FormattedValues with error appended to message
+*/
 function appendErrorToMessage(values, color = false) {
-	const error = gerErrorFromLogRecord(values.record);
+	const error = getErrorFromLogRecord(values.record);
 	if (error) {
-		let errorMessge = error.message;
-		if (error.stack) errorMessge = errorMessge + "\n" + indent(error.stack.split("\n").slice(1));
-		if (color) errorMessge = `${ansiColors.red}${errorMessge}${RESET}`;
+		let errorMessage = error.message;
+		if (error.stack) errorMessage = errorMessage + "\n" + indent(error.stack.split("\n").slice(1));
+		if (color) errorMessage = `${ansiColors.red}${errorMessage}${RESET}`;
 		return {
 			...values,
-			message: values.message + "\n" + indent(errorMessge)
+			message: values.message + "\n" + indent(errorMessage)
 		};
 	}
 	return values;
@@ -103,12 +127,21 @@ const levelAbbreviations = {
 	"error": "ERROR",
 	"fatal": "FATAL"
 };
+/**
+* Formatter that outputs only the log message (no timestamp/level/category).
+* @returns TextFormatter that returns just the message string
+*/
 function getMessageOnlyFormatter() {
 	return getTextFormatter({ format: ({ message }) => {
 		return message;
 	} });
 }
 const level = (l) => levelAbbreviations[l];
+/**
+* Build a text formatter with optional custom format; appends error from record.
+* @param options - Optional format and logtape options
+* @returns TextFormatter
+*/
 function getTextFormatter(options) {
 	const _format = options?.format ?? (({ timestamp, level, category, message }) => {
 		return `${timestamp} ${level} ${category} ${message}`;
@@ -125,6 +158,11 @@ function getTextFormatter(options) {
 }
 const RESET = "\x1B[0m";
 const ansiColors = { red: "\x1B[31m" };
+/**
+* Build an ANSI-colored text formatter (level/category colors); appends error in red.
+* @param options - Optional format and logtape ANSI options
+* @returns TextFormatter with ANSI colors
+*/
 function getAnsiColorFormatter(options) {
 	const _format = options?.format ?? (({ timestamp, level, category, message }) => {
 		return `${timestamp} ${level} ${category} ${message}`;
@@ -145,6 +183,8 @@ function getAnsiColorFormatter(options) {
 * The formatter returns an array where:
 * - First element is the formatted message string
 * - Second element is the record properties object
+* @param options - Optional messageFormatter (TextFormatter)
+* @returns ConsoleFormatter for console.log/error
 */
 function getConsoleFormatter(options) {
 	const formatter = options?.messageFormatter;
@@ -159,9 +199,11 @@ function getConsoleFormatter(options) {
 		return message;
 	};
 }
-
-//#endregion
-//#region src/sink.ts
+/**
+* Create a sink that writes formatted log records to stdout (default formatter).
+* @param options - Optional console sink options (e.g. custom formatter)
+* @returns Sink that writes to stdout
+*/
 function getConsoleSink(options) {
 	return getConsoleSink$1({
 		formatter: getConsoleFormatter(),
@@ -171,6 +213,8 @@ function getConsoleSink(options) {
 /**
 * Creates a console sink that writes to stderr.
 * (MCP protocol requires stderr to be used for logging)
+* @param options - Optional console sink options (e.g. custom formatter)
+* @returns Sink that writes to stderr
 */
 function getConsoleStderrSink(options) {
 	const formatter = options?.formatter ?? getConsoleFormatter();
@@ -182,9 +226,6 @@ function getConsoleStderrSink(options) {
 		} else console.error(...args);
 	};
 }
-
-//#endregion
-//#region src/index.ts
 const logger = getLogger("likec4");
 /**
 * Get a child logger with the given subcategory.
@@ -195,16 +236,21 @@ const logger = getLogger("likec4");
 function createLogger(subcategory) {
 	return logger.getChild(subcategory);
 }
+/**
+* Configure the global logger: sinks, loggers, and lowest level per category.
+* @param config - Optional partial config (sinks, loggers). Merged with defaults.
+*/
 function configureLogger(config) {
 	try {
-		const sinks = config?.sinks ?? {};
+		const { sinks = {}, loggers: _loggers, ...restConfig } = config ?? {};
+		const sinksWithConsole = {
+			console: getConsoleSink(),
+			...sinks
+		};
 		configureSync({
 			reset: true,
-			...config,
-			sinks: {
-				console: getConsoleSink(),
-				...sinks
-			},
+			...restConfig,
+			sinks: sinksWithConsole,
 			loggers: [{
 				category: ["logtape", "meta"],
 				sinks: ["console"],
@@ -219,6 +265,4 @@ function configureLogger(config) {
 		console.error(e);
 	}
 }
-
-//#endregion
-export { configureLogger, logger as consola, logger, logger as rootLogger, createLogger, errorFromLogRecord, getAnsiColorFormatter, getConsoleFormatter, getConsoleSink, getConsoleStderrSink, getMessageOnlyFormatter, getTextFormatter, loggable, withFilter, wrapError };
+export { configureLogger, logger as consola, logger, logger as rootLogger, createLogger, errorFromLogRecord, getAnsiColorFormatter, getConsoleFormatter, getConsoleSink, getConsoleStderrSink, getMessageOnlyFormatter, getTextFormatter, loggable, withFilter, wrapError };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@likec4/log",
   "description": "Shared interface for logging",
   "license": "MIT",
-  "version": "1.48.0",
+  "version": "1.50.0",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -32,17 +32,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@logtape/logtape": "^1.3.5",
-    "std-env": "^3.10.0"
+    "@logtape/logtape": "^1.3.7"
   },
   "devDependencies": {
-    "@types/node": "~22.19.7",
+    "@types/node": "~22.19.11",
     "merge-error-cause": "^5.0.2",
-    "safe-stringify": "^1.2.0",
+    "safe-stringify": "^1.3.0",
     "typescript": "5.9.3",
-    "obuild": "^0.4.20",
+    "obuild": "^0.4.31",
     "wrap-error-message": "^3.0.1",
-    "@likec4/tsconfig": "1.48.0",
+    "@likec4/tsconfig": "1.50.0",
     "@likec4/devops": "1.42.0"
   },
   "scripts": {

package/src/formatters.ts

@@ -11,9 +11,9 @@ import {
 } from '@logtape/logtape'
 import mergeErrorCause from 'merge-error-cause'
 import wrapErrorMessage from 'wrap-error-message'
-import { indent, parseStack } from './utils'
+import { indent, loggable, parseStack } from './utils'
 
-function gerErrorFromLogRecord(record: LogRecord): Error | null {
+function getErrorFromLogRecord(record: LogRecord): Error | null {
   const errors = Object
     .entries(record.properties)
     .flatMap(([k, err]) => {
@@ -25,7 +25,7 @@ function gerErrorFromLogRecord(record: LogRecord): Error | null {
         return [mergedErr]
       }
       if (k === 'error' || k === 'err') {
-        return [new Error(`${err}`)]
+        return [new Error(loggable(err))]
       }
       return []
     })
@@ -35,27 +35,38 @@ function gerErrorFromLogRecord(record: LogRecord): Error | null {
   return errors.length === 1 ? errors[0]! : new AggregateError(errors)
 }
 
+/**
+ * Extract a single Error from a log record (from properties or rawMessage).
+ * @param record - Log record that may contain error in properties or rawMessage
+ * @returns Merged/wrapped Error or null if none found
+ */
 export function errorFromLogRecord(record: LogRecord): Error | null {
-  const error = gerErrorFromLogRecord(record)
+  const error = getErrorFromLogRecord(record)
   if (error && typeof record.rawMessage === 'string') {
     return wrapErrorMessage(error, record.rawMessage + '\n')
   }
   return error
 }
 
+/**
+ * Append error from record properties to the formatted message (optionally colored).
+ * @param values - Formatted values (record + message)
+ * @param color - When true, wrap error text in ANSI red
+ * @returns Updated FormattedValues with error appended to message
+ */
 export function appendErrorToMessage(values: FormattedValues, color = false): FormattedValues {
-  const error = gerErrorFromLogRecord(values.record)
+  const error = getErrorFromLogRecord(values.record)
   if (error) {
-    let errorMessge = error.message
+    let errorMessage = error.message
     if (error.stack) {
-      errorMessge = errorMessge + '\n' + indent(error.stack.split('\n').slice(1))
+      errorMessage = errorMessage + '\n' + indent(error.stack.split('\n').slice(1))
     }
     if (color) {
-      errorMessge = `${ansiColors.red}${errorMessge}${RESET}`
+      errorMessage = `${ansiColors.red}${errorMessage}${RESET}`
     }
     return {
       ...values,
-      message: values.message + '\n' + indent(errorMessge),
+      message: values.message + '\n' + indent(errorMessage),
     }
   }
   return values
@@ -70,6 +81,10 @@ const levelAbbreviations: Record<LogLevel, string> = {
   'fatal': 'FATAL',
 }
 
+/**
+ * Formatter that outputs only the log message (no timestamp/level/category).
+ * @returns TextFormatter that returns just the message string
+ */
 export function getMessageOnlyFormatter(): TextFormatter {
   return getTextFormatter({
     format: ({ message }): string => {
@@ -80,11 +95,15 @@ export function getMessageOnlyFormatter(): TextFormatter {
 
 const level = (l: LogLevel): string => levelAbbreviations[l]
 
+/**
+ * Build a text formatter with optional custom format; appends error from record.
+ * @param options - Optional format and logtape options
+ * @returns TextFormatter
+ */
 export function getTextFormatter(options?: TextFormatterOptions): TextFormatter {
   const _format = options?.format ?? (({ timestamp, level, category, message }: FormattedValues): string => {
     return `${timestamp} ${level} ${category} ${message}`
   })
-  // const format = options?.format
   return getLogtapeTextFormatter({
     timestamp: 'time',
     level,
@@ -109,6 +128,11 @@ const ansiColors = {
   // white: "\x1b[37m",
 } as const
 
+/**
+ * Build an ANSI-colored text formatter (level/category colors); appends error in red.
+ * @param options - Optional format and logtape ANSI options
+ * @returns TextFormatter with ANSI colors
+ */
 export function getAnsiColorFormatter(options?: AnsiColorFormatterOptions): TextFormatter {
   const _format = options?.format ?? (({ timestamp, level, category, message }: FormattedValues): string => {
     return `${timestamp} ${level} ${category} ${message}`
@@ -130,6 +154,8 @@ export function getAnsiColorFormatter(options?: AnsiColorFormatterOptions): Text
  * The formatter returns an array where:
  * - First element is the formatted message string
  * - Second element is the record properties object
+ * @param options - Optional messageFormatter (TextFormatter)
+ * @returns ConsoleFormatter for console.log/error
  */
 export function getConsoleFormatter(options?: {
   messageFormatter?: TextFormatter

package/src/index.ts

@@ -1,5 +1,6 @@
 import {
   type Config,
+  type Sink,
   configureSync as configureLogtape,
   getLogger,
 } from '@logtape/logtape'
@@ -53,18 +54,23 @@ export function createLogger(subcategory: string | readonly [string] | readonly
   return logger.getChild(subcategory)
 }
 
+/**
+ * Configure the global logger: sinks, loggers, and lowest level per category.
+ * @param config - Optional partial config (sinks, loggers). Merged with defaults.
+ */
 export function configureLogger<TSinkId extends string, TFilterId extends string>(
   config?: Partial<Config<TSinkId, TFilterId>>,
 ) {
   try {
-    const sinks = config?.sinks ?? {}
-    configureLogtape<any, any>({
+    const { sinks = {}, loggers: _loggers, ...restConfig } = config ?? {}
+    const sinksWithConsole: Record<TSinkId | 'console', Sink> = {
+      console: getConsoleSink(),
+      ...sinks,
+    } as Record<TSinkId | 'console', Sink>
+    configureLogtape<TSinkId | 'console', TFilterId>({
       reset: true,
-      ...config,
-      sinks: {
-        console: getConsoleSink(),
-        ...sinks,
-      },
+      ...restConfig,
+      sinks: sinksWithConsole,
       loggers: [
         { category: ['logtape', 'meta'], sinks: ['console'], lowestLevel: 'warning' },
         ...(config?.loggers ?? [

package/src/sink.ts

@@ -6,6 +6,11 @@ import {
 } from '@logtape/logtape'
 import { getConsoleFormatter } from './formatters'
 
+/**
+ * Create a sink that writes formatted log records to stdout (default formatter).
+ * @param options - Optional console sink options (e.g. custom formatter)
+ * @returns Sink that writes to stdout
+ */
 export function getConsoleSink(options?: ConsoleSinkOptions): Sink {
   return getLogtapeConsoleSink({
     formatter: getConsoleFormatter(),
@@ -16,6 +21,8 @@ export function getConsoleSink(options?: ConsoleSinkOptions): Sink {
 /**
  * Creates a console sink that writes to stderr.
  * (MCP protocol requires stderr to be used for logging)
+ * @param options - Optional console sink options (e.g. custom formatter)
+ * @returns Sink that writes to stderr
  */
 export function getConsoleStderrSink(options?: ConsoleSinkOptions): Sink {
   const formatter = options?.formatter ?? getConsoleFormatter()

package/src/utils.ts

@@ -2,6 +2,11 @@ import mergeErrorCause from 'merge-error-cause'
 import safeStringify from 'safe-stringify'
 import wrapErrorMessage from 'wrap-error-message'
 
+/**
+ * Split stack string into lines and normalize (e.g. strip file://).
+ * @param stack - Error stack string
+ * @returns Array of normalized lines
+ */
 export const parseStack = (stack: string): string[] => {
   const lines = stack
     .split('\n')
@@ -17,12 +22,23 @@ export const parseStack = (stack: string): string[] => {
   return lines
 }
 
+/**
+ * Indent each line of value by the given number of spaces.
+ * @param value - String or array of lines to indent
+ * @param indentation - Number of spaces (default 2)
+ * @returns Indented string
+ */
 export function indent(value: string | string[], indentation = 2): string {
   value = Array.isArray(value) ? value : value.split('\n')
   const prefix = ' '.repeat(indentation)
   return value.map((l) => `${prefix}${l}`).join('\n')
 }
 
+/**
+ * Serialize unknown to a string (Error → message + stack; else safe-stringify).
+ * @param error - Caught value (Error, string, or arbitrary object)
+ * @returns Human-readable string for logging
+ */
 export function loggable(error: unknown): string {
   if (typeof error === 'string') {
     return error