logixia 2.0.11 → 2.2.0

package/dist/hono.js

@@ -0,0 +1,512 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_async_hooks = require("node:async_hooks");
+let node_crypto = require("node:crypto");
+// src/utils/own-property.ts
+/**
+* Copy `value` onto `target[key]` as an own, enumerable data property.
+*
+* Normal keys use a plain assignment, which is the fast path. `__proto__` goes
+* through `Object.defineProperty` so that a key taken from logged or parsed data
+* becomes an own property instead of replacing the object's prototype.
+*/
+function assignOwn(target, key, value) {
+	if (key === "__proto__") Object.defineProperty(target, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else target[key] = value;
+}
+// src/utils/error.utils.ts
+const EXTRA_FIELDS = [
+	"code",
+	"statusCode",
+	"status",
+	"errno",
+	"syscall",
+	"path",
+	"address",
+	"port",
+	"type"
+];
+const SKIPPED_FIELDS = /* @__PURE__ */ new Set([
+	"name",
+	"message",
+	"stack",
+	"cause",
+	"errors",
+	...EXTRA_FIELDS
+]);
+const NO_OPTIONS = Object.freeze({});
+const NO_FIELDS = [];
+/**
+* Serialize an Error into a plain JSON-safe object, including:
+*  - `name`, `message`, `stack`
+*  - `cause` (recursively serialized, full ES2022 chain)
+*  - `errors` (for AggregateError)
+*  - standard Node.js error fields (`code`, `statusCode`, `errno`, …)
+*  - any other enumerable own properties
+*/
+function serializeError(error, options = NO_OPTIONS) {
+	const { includeStack = true, maxDepth = 5, excludeFields = NO_FIELDS } = options;
+	return _serializeError(error, includeStack, maxDepth, excludeFields, 0, /* @__PURE__ */ new WeakSet());
+}
+function _serializeError(error, includeStack, maxDepth, excludeFields, depth, seen) {
+	if (depth >= maxDepth) return {
+		name: error.name,
+		message: error.message,
+		_truncated: true
+	};
+	if (seen.has(error)) return {
+		name: error.name,
+		message: error.message,
+		_circular: true
+	};
+	seen.add(error);
+	const serialized = {
+		name: error.name,
+		message: error.message
+	};
+	if (includeStack && error.stack) serialized.stack = error.stack;
+	const errorWithCause = error;
+	if (errorWithCause.cause !== void 0) {
+		if (errorWithCause.cause instanceof Error) serialized.cause = _serializeError(errorWithCause.cause, includeStack, maxDepth, excludeFields, depth + 1, seen);
+		else serialized.cause = serializeValue(errorWithCause.cause, maxDepth - depth - 1, seen);
+	}
+	const aggregateError = error;
+	if (Array.isArray(aggregateError.errors)) serialized.errors = aggregateError.errors.map((e) => e instanceof Error ? _serializeError(e, includeStack, maxDepth, excludeFields, depth + 1, seen) : serializeValue(e, maxDepth - depth - 1, seen));
+	const errorRecord = error;
+	for (const field of EXTRA_FIELDS) if (!excludeFields.includes(field) && errorRecord[field] !== void 0) serialized[field] = errorRecord[field];
+	const skip = excludeFields.length === 0 ? SKIPPED_FIELDS : /* @__PURE__ */ new Set([...SKIPPED_FIELDS, ...excludeFields]);
+	for (const key of Object.getOwnPropertyNames(error)) {
+		if (skip.has(key)) continue;
+		try {
+			assignOwn(serialized, key, serializeValue(errorRecord[key], maxDepth - depth - 1, seen));
+		} catch {
+			assignOwn(serialized, key, "[Unserializable]");
+		}
+	}
+	return serialized;
+}
+/**
+* Recursively serialize an arbitrary value to a JSON-safe representation.
+*
+* The `seen` guard is threaded through (not recreated) so cross-referencing
+* errors nested inside plain objects/arrays are caught by the same circular
+* check that protects the top-level error tree, rather than only relying on the
+* depth limit.
+*/
+function serializeValue(value, remainingDepth, seen) {
+	if (remainingDepth <= 0) return "[Max Depth]";
+	if (value === null || value === void 0) return value;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Error) {
+		if (seen.has(value)) return {
+			name: value.name,
+			message: value.message,
+			_circular: true
+		};
+		return _serializeError(value, true, remainingDepth, [], 0, seen);
+	}
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		return value.map((item) => serializeValue(item, remainingDepth - 1, seen));
+	}
+	if (typeof value === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		const out = {};
+		for (const [k, v] of Object.entries(value)) try {
+			assignOwn(out, k, serializeValue(v, remainingDepth - 1, seen));
+		} catch {
+			assignOwn(out, k, "[Unserializable]");
+		}
+		return out;
+	}
+	return String(value);
+}
+// src/utils/internal-log.ts
+/**
+* Internal logging helpers for use within the logixia library itself.
+*
+* These functions write directly to stderr/stdout without going through
+* LogixiaLogger — this avoids circular dependencies and ensures internal
+* diagnostics still surface even when the logger is misconfigured.
+*
+* Library code must NEVER call console.log/warn/error directly. Use these
+* helpers instead so that internal output can be silenced in tests by setting
+* the LOGIXIA_SILENT_INTERNAL=1 environment variable.
+*/
+/**
+* Read the silence flag on each call rather than caching it at import time, so
+* setting LOGIXIA_SILENT_INTERNAL=1 AFTER the module is first imported (e.g. in
+* a test setup file) still takes effect — the documented test-silencing
+* behavior was previously unreliable because the value was frozen at load.
+*/
+function isSilent() {
+	var _process$env;
+	if (typeof process !== "undefined" && ((_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.LOGIXIA_SILENT_INTERNAL) === "1") return true;
+	const flag = globalThis["LOGIXIA_SILENT_INTERNAL"];
+	return flag === "1" || flag === 1 || flag === true;
+}
+/**
+* Write a line to stderr, falling back to the matching console method where
+* `process` is unavailable (browsers, Cloudflare Workers, Deno without Node compat).
+*/
+function writeLine(method, line) {
+	var _process$stderr;
+	if (typeof process !== "undefined" && typeof ((_process$stderr = process.stderr) === null || _process$stderr === void 0 ? void 0 : _process$stderr.write) === "function") process.stderr.write(`${line}\n`);
+	else if (typeof console !== "undefined" && typeof console[method] === "function") console[method](line);
+}
+/**
+* Emit an internal error to stderr.
+* Use when a transport write fails or a serious internal error occurs.
+*/
+function internalError(message, error) {
+	if (!isSilent()) {
+		let errStr = "";
+		if (error instanceof Error) errStr = ` — ${error.message}`;
+		else if (error != null) errStr = ` — ${String(error)}`;
+		writeLine("error", `[logixia:error] ${message}${errStr}`);
+	}
+}
+// src/utils/trace.utils.ts
+/**
+* Trace ID utilities for Logitron
+*/
+/** Default key used to store the trace ID in AsyncLocalStorage. */
+const TRACE_CONTEXT_KEY = "traceId";
+/**
+* Singleton that owns the AsyncLocalStorage and the active contextKey.
+*
+* Why a class instead of bare module-level variables?
+*  - The contextKey is user-configurable; encapsulating it here means there is
+*    exactly one place that reads and writes it.
+*  - All helpers (getCurrentTraceId, runWithTraceId, etc.) delegate to this
+*    instance, so the key is always in sync without hidden global state.
+*  - Easier to test: you can reset the singleton between test cases.
+*
+* Usage (advanced):
+*   import { TraceContext } from 'logixia';
+*   TraceContext.instance.contextKey          // → 'traceId' (or custom)
+*   TraceContext.instance.getCurrentTraceId() // same as standalone fn
+*/
+var TraceContext = class TraceContext {
+	static _instance = null;
+	storage = new node_async_hooks.AsyncLocalStorage();
+	_contextKey = TRACE_CONTEXT_KEY;
+	constructor() {}
+	/** The process-wide singleton. */
+	static get instance() {
+		if (!TraceContext._instance) TraceContext._instance = new TraceContext();
+		return TraceContext._instance;
+	}
+	/** @internal Reset the singleton (useful in tests). */
+	static _reset() {
+		TraceContext._instance = null;
+	}
+	/** The AsyncLocalStorage key that holds the trace ID value. */
+	get contextKey() {
+		return this._contextKey;
+	}
+	/** @internal Called by TraceMiddleware when it boots to register the user's key. */
+	setContextKey(key) {
+		this._contextKey = key;
+	}
+	/** UUID v4 generator (default). */
+	generate() {
+		return (0, node_crypto.randomUUID)();
+	}
+	/** Read the trace ID from the current async context. */
+	getCurrentTraceId() {
+		var _this$storage$getStor;
+		return (_this$storage$getStor = this.storage.getStore()) === null || _this$storage$getStor === void 0 ? void 0 : _this$storage$getStor[this._contextKey];
+	}
+	/**
+	* Mutate the CURRENT async context in-place.
+	*
+	* ⚠️  DEPRECATED — unsafe for concurrent requests.
+	*
+	* Uses `AsyncLocalStorage.enterWith()`, which mutates the current async
+	* execution context and every Promise chain spawned from it. In a server
+	* processing overlapping requests this can cause a trace ID set for one
+	* request to bleed into *other* in-flight requests that share the same
+	* async parent (e.g. a module-level setup function or a cached handler).
+	*
+	* Use {@link run} instead — it scopes the context to a callback so there
+	* is no risk of cross-request leakage.
+	*
+	* @deprecated Use `TraceContext.instance.run(traceId, fn)` — do not call
+	*             `setTraceId` from request-handling code.
+	*/
+	setTraceId(traceId, data) {
+		const current = this.storage.getStore() ?? {};
+		this.storage.enterWith({
+			...current,
+			[this._contextKey]: traceId,
+			...data
+		});
+	}
+	/** Run `fn` inside a new async context that carries `traceId`. */
+	run(traceId, fn, data) {
+		return this.storage.run({
+			[this._contextKey]: traceId,
+			...data
+		}, fn);
+	}
+};
+TraceContext.instance.storage;
+/** Generate a UUID v4 trace ID. */
+function generateTraceId() {
+	return TraceContext.instance.generate();
+}
+/** Run `fn` inside a new async context carrying `traceId`. */
+function runWithTraceId(traceId, fn, data) {
+	return TraceContext.instance.run(traceId, fn, data);
+}
+const SAFE_INCOMING_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+/**
+* Validate an externally supplied identifier (trace ID, correlation ID, origin
+* service name, message-queue ID). Accepts only 1-128 characters from
+* `[A-Za-z0-9._:-]`; surrounding whitespace is trimmed first. Arrays use their
+* first element. Returns the cleaned value, or `undefined` when it is unusable
+* so callers can generate a fresh ID instead of passing client text through.
+*/
+function sanitizeIncomingId(value) {
+	const first = Array.isArray(value) ? value[0] : value;
+	if (typeof first !== "string" || first.length > 256) return void 0;
+	const trimmed = first.trim();
+	return SAFE_INCOMING_ID.test(trimmed) ? trimmed : void 0;
+}
+/** W3C trace-context: `version-traceId(32hex)-spanId(16hex)-flags(2hex)`. */
+const W3C_TRACEPARENT_RE = /^[\da-f]{2}-([\da-f]{32})-[\da-f]{16}-[\da-f]{2}$/i;
+/**
+* Extract the 32-hex trace-id segment from a W3C `traceparent` header value.
+* Returns the parsed trace ID, or the original value unchanged when it is not a
+* well-formed traceparent (so non-W3C propagation still works).
+*/
+function parseTraceparent(value) {
+	const m = W3C_TRACEPARENT_RE.exec(value);
+	return m ? m[1] : value;
+}
+/** Extract trace ID from request using configuration (header → query → body → params). */
+function extractTraceId(request, config) {
+	const req = request;
+	if (config.header) {
+		const headers = Array.isArray(config.header) ? config.header : [config.header];
+		for (const header of headers) {
+			var _req$headers;
+			const lower = header.toLowerCase();
+			const value = sanitizeIncomingId((_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers[lower]);
+			if (value) return lower === "traceparent" ? parseTraceparent(value) : value;
+		}
+	}
+	if (config.query) {
+		const queries = Array.isArray(config.query) ? config.query : [config.query];
+		for (const query of queries) {
+			var _req$query;
+			const value = sanitizeIncomingId((_req$query = req.query) === null || _req$query === void 0 ? void 0 : _req$query[query]);
+			if (value) return value;
+		}
+	}
+	if (config.body) {
+		const bodyFields = Array.isArray(config.body) ? config.body : [config.body];
+		for (const field of bodyFields) {
+			var _req$body;
+			const value = sanitizeIncomingId((_req$body = req.body) === null || _req$body === void 0 ? void 0 : _req$body[field]);
+			if (value) return value;
+		}
+	}
+	if (config.params) {
+		const paramFields = Array.isArray(config.params) ? config.params : [config.params];
+		for (const param of paramFields) {
+			var _req$params;
+			const value = sanitizeIncomingId((_req$params = req.params) === null || _req$params === void 0 ? void 0 : _req$params[param]);
+			if (value) return value;
+		}
+	}
+}
+/**
+* Default headers checked for incoming trace ID propagation, in priority order:
+*   traceparent (W3C/OTel) → x-trace-id → x-request-id → x-correlation-id → trace-id
+*/
+const DEFAULT_TRACE_HEADERS = [
+	"traceparent",
+	"x-trace-id",
+	"x-request-id",
+	"x-correlation-id",
+	"trace-id"
+];
+// src/utils/request-trace.ts
+/** Header names to read a trace ID from, defaulting to the library-wide list. */
+function resolveTraceHeaders(option) {
+	if (option === void 0) return DEFAULT_TRACE_HEADERS;
+	return typeof option === "string" ? [option] : option;
+}
+// src/utils/sensitive-names.ts
+/** Query-string parameters whose values are never logged. */
+const DEFAULT_REDACT_QUERY_PARAMS = [
+	"token",
+	"access_token",
+	"refresh_token",
+	"code",
+	"password",
+	"secret",
+	"api_key",
+	"apikey",
+	"key",
+	"signature",
+	"sig",
+	"auth",
+	"accesstoken",
+	"refreshtoken",
+	"id_token",
+	"idtoken",
+	"client_secret",
+	"clientsecret",
+	"session",
+	"sessionid",
+	"session_id",
+	"jwt",
+	"auth_token",
+	"authtoken",
+	"api-key",
+	"x-api-key",
+	"x-amz-signature",
+	"x-amz-credential",
+	"x-amz-security-token",
+	"x-goog-signature",
+	"x-goog-credential",
+	"access-token",
+	"x-access-token",
+	"x-auth-token",
+	"apitoken",
+	"api_token"
+];
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value.replace(/\+/g, " "));
+	} catch {
+		return value;
+	}
+}
+/** Replace the values of sensitive query parameters, leaving the rest verbatim. */
+function redactUrlQuery(url, redactParams) {
+	const q = url.indexOf("?");
+	if (q === -1) return url;
+	const hashAt = url.indexOf("#", q);
+	const query = url.slice(q + 1, hashAt === -1 ? void 0 : hashAt);
+	const hash = hashAt === -1 ? "" : url.slice(hashAt);
+	const cleaned = query.split("&").map((pair) => {
+		const eq = pair.indexOf("=");
+		const rawKey = eq === -1 ? pair : pair.slice(0, eq);
+		const decoded = safeDecode(rawKey);
+		const bracket = decoded.indexOf("[");
+		const name = (bracket === -1 ? decoded : decoded.slice(0, bracket)).toLowerCase();
+		return redactParams.has(name) && eq !== -1 ? `${rawKey}=[REDACTED]` : pair;
+	}).join("&");
+	return `${url.slice(0, q)}?${cleaned}${hash}`;
+}
+/** Lower-cased lookup set of the default names plus any extras. */
+function buildNameSet(defaults, extra) {
+	return new Set([...defaults, ...extra ?? []].map((n) => n.toLowerCase()));
+}
+// src/hono/middleware.ts
+/**
+* Hono request logging middleware: trace ID, response header and a completion entry.
+*
+* Only structural types are used, so it works with any Hono version and runs on Node,
+* Bun and Cloudflare Workers (`nodejs_compat`, for `AsyncLocalStorage`).
+*
+* @example
+* ```ts
+* import { Hono } from 'hono';
+* import { createHonoMiddleware } from 'logixia/hono';
+*
+* const app = new Hono();
+* app.use(createHonoMiddleware(logger));
+* ```
+*/
+/** Fire-and-forget: a failing log call must never fail the request. */
+function emit(logger, level, message, data) {
+	try {
+		const result = logger[level](message, data);
+		if (result && typeof result.catch === "function") result.catch((error) => internalError("hono middleware: log call failed", error));
+	} catch (error) {
+		internalError("hono middleware: log call failed", error);
+	}
+}
+/** Pathname plus the query string with secret parameters redacted, from an absolute or relative URL. */
+function loggedPath(url, params) {
+	const schemeEnd = url.indexOf("://");
+	const pathStart = schemeEnd === -1 ? 0 : url.indexOf("/", schemeEnd + 3);
+	return pathStart === -1 ? "/" : redactUrlQuery(url.slice(pathStart), params);
+}
+function ensureHeader(c, name, value) {
+	try {
+		if (c.res.headers.get(name) === value) return;
+		c.res.headers.set(name, value);
+	} catch {
+		const copy = new Response(c.res.body, c.res);
+		copy.headers.set(name, value);
+		c.res = copy;
+	}
+}
+/**
+* Create a Hono middleware (`app.use(...)`).
+*
+* Per request it resolves the trace ID from headers, sets it on the response and on
+* `c.var.traceId`, runs the rest of the request inside {@link runWithTraceId} and logs
+* one entry when the request completes: `method`, `path` (query secrets redacted),
+* `status`, `duration` in ms and `traceId`. Responses with status 500 and above, and
+* errors thrown by handlers, are logged at `error`; other thrown errors at `warn`.
+*/
+function createHonoMiddleware(logger, options = {}) {
+	const { skip, extraFields, responseHeader = "x-trace-id" } = options;
+	const traceHeaders = resolveTraceHeaders(options.traceIdHeader);
+	const params = buildNameSet(DEFAULT_REDACT_QUERY_PARAMS, options.redactQueryParams);
+	return async function logixiaHonoMiddleware(c, next) {
+		if (skip === null || skip === void 0 ? void 0 : skip(c)) return next();
+		const headers = {};
+		for (const name of traceHeaders) {
+			const key = name.toLowerCase();
+			headers[key] = c.req.header(key);
+		}
+		const traceId = extractTraceId({ headers }, { header: [...traceHeaders] }) ?? generateTraceId();
+		const start = Date.now();
+		c.set("traceId", traceId);
+		if (responseHeader) c.header(responseHeader, traceId);
+		await runWithTraceId(traceId, async () => {
+			let thrown;
+			try {
+				await next();
+			} catch (error) {
+				thrown = error;
+			}
+			const failure = thrown ?? c.error;
+			if (responseHeader && thrown === void 0) ensureHeader(c, responseHeader, traceId);
+			const status = thrown === void 0 ? c.res.status : 500;
+			const entry = {
+				traceId,
+				method: c.req.method,
+				path: loggedPath(c.req.url, params),
+				status,
+				duration: Date.now() - start,
+				...failure === void 0 ? {} : { error: serializeError(toError(failure)) },
+				...extraFields === null || extraFields === void 0 ? void 0 : extraFields(c)
+			};
+			if (failure !== void 0) emit(logger, status >= 500 ? "error" : "warn", "request failed", entry);
+			else emit(logger, status >= 500 ? "error" : "info", "request completed", entry);
+			if (thrown !== void 0) throw thrown;
+		});
+	};
+}
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+exports.createHonoMiddleware = createHonoMiddleware;
+
+//# sourceMappingURL=hono.js.map

package/dist/hono.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono.js","names":["AsyncLocalStorage","randomUUID"],"sources":["../src/utils/own-property.ts","../src/utils/error.utils.ts","../src/utils/internal-log.ts","../src/utils/trace.utils.ts","../src/utils/request-trace.ts","../src/utils/sensitive-names.ts","../src/hono/middleware.ts"],"sourcesContent":["/**\n * True for the one key that must never be assigned with `target[key] = value`.\n *\n * Assigning `constructor` or `prototype` on a fresh plain object only creates an\n * own property, which is harmless. Only `__proto__` invokes the prototype setter.\n */\nexport function isProtoKey(key: string): boolean {\n  return key === '__proto__';\n}\n\n/**\n * Copy `value` onto `target[key]` as an own, enumerable data property.\n *\n * Normal keys use a plain assignment, which is the fast path. `__proto__` goes\n * through `Object.defineProperty` so that a key taken from logged or parsed data\n * becomes an own property instead of replacing the object's prototype.\n */\nexport function assignOwn(target: object, key: string, value: unknown): void {\n  if (key === '__proto__') {\n    Object.defineProperty(target, key, {\n      value,\n      enumerable: true,\n      writable: true,\n      configurable: true,\n    });\n  } else {\n    (target as Record<string, unknown>)[key] = value;\n  }\n}\n","/**\n * Error serialization utilities for Logixia\n *\n * v1.1 improvements:\n *  - Full ES2022 `cause` chain serialization (recursive)\n *  - AggregateError.errors array serialization\n *  - Standard extra fields: code, statusCode, status, errno, syscall, path\n *  - Circular-reference safe via a WeakSet seen guard\n */\n\nimport type { ErrorSerializationOptions } from '../types';\nimport { assignOwn } from './own-property';\n\n// Well-known extra fields to always capture when present on an error\nconst EXTRA_FIELDS = [\n  'code',\n  'statusCode',\n  'status',\n  'errno',\n  'syscall',\n  'path',\n  'address',\n  'port',\n  'type',\n] as const;\n\n// Fields the own-property pass skips, built once instead of per error.\nconst SKIPPED_FIELDS = new Set<string>([\n  'name',\n  'message',\n  'stack',\n  'cause',\n  'errors',\n  ...EXTRA_FIELDS,\n]);\nconst NO_OPTIONS: ErrorSerializationOptions = Object.freeze({});\nconst NO_FIELDS: string[] = [];\n\n/**\n * Serialize an Error into a plain JSON-safe object, including:\n *  - `name`, `message`, `stack`\n *  - `cause` (recursively serialized, full ES2022 chain)\n *  - `errors` (for AggregateError)\n *  - standard Node.js error fields (`code`, `statusCode`, `errno`, …)\n *  - any other enumerable own properties\n */\nexport function serializeError(\n  error: Error,\n  options: ErrorSerializationOptions = NO_OPTIONS\n): Record<string, unknown> {\n  const { includeStack = true, maxDepth = 5, excludeFields = NO_FIELDS } = options;\n  const seen = new WeakSet<object>();\n  return _serializeError(error, includeStack, maxDepth, excludeFields, 0, seen);\n}\n\nfunction _serializeError(\n  error: Error,\n  includeStack: boolean,\n  maxDepth: number,\n  excludeFields: string[],\n  depth: number,\n  seen: WeakSet<object>\n): Record<string, unknown> {\n  if (depth >= maxDepth) {\n    return { name: error.name, message: error.message, _truncated: true };\n  }\n\n  if (seen.has(error)) {\n    return { name: error.name, message: error.message, _circular: true };\n  }\n  seen.add(error);\n\n  const serialized: Record<string, unknown> = {\n    name: error.name,\n    message: error.message,\n  };\n\n  if (includeStack && error.stack) {\n    serialized.stack = error.stack;\n  }\n\n  // ── ES2022 cause chain ──────────────────────────────────────────────────────\n  const errorWithCause = error as Error & { cause?: unknown };\n  if (errorWithCause.cause !== undefined) {\n    if (errorWithCause.cause instanceof Error) {\n      serialized.cause = _serializeError(\n        errorWithCause.cause,\n        includeStack,\n        maxDepth,\n        excludeFields,\n        depth + 1,\n        seen\n      );\n    } else {\n      serialized.cause = serializeValue(errorWithCause.cause, maxDepth - depth - 1, seen);\n    }\n  }\n\n  // ── AggregateError.errors ───────────────────────────────────────────────────\n  const aggregateError = error as Error & { errors?: unknown[] };\n  if (Array.isArray(aggregateError.errors)) {\n    serialized.errors = aggregateError.errors.map((e) =>\n      e instanceof Error\n        ? _serializeError(e, includeStack, maxDepth, excludeFields, depth + 1, seen)\n        : serializeValue(e, maxDepth - depth - 1, seen)\n    );\n  }\n\n  // ── Standard Node.js / HTTP error fields ───────────────────────────────────\n  const errorRecord = error as unknown as Record<string, unknown>;\n  for (const field of EXTRA_FIELDS) {\n    if (!excludeFields.includes(field) && errorRecord[field] !== undefined) {\n      serialized[field] = errorRecord[field];\n    }\n  }\n\n  // ── All other own enumerable properties ────────────────────────────────────\n  const skip =\n    excludeFields.length === 0 ? SKIPPED_FIELDS : new Set([...SKIPPED_FIELDS, ...excludeFields]);\n\n  for (const key of Object.getOwnPropertyNames(error)) {\n    if (skip.has(key)) continue;\n    try {\n      assignOwn(serialized, key, serializeValue(errorRecord[key], maxDepth - depth - 1, seen));\n    } catch {\n      assignOwn(serialized, key, '[Unserializable]');\n    }\n  }\n\n  return serialized;\n}\n\n/**\n * Recursively serialize an arbitrary value to a JSON-safe representation.\n *\n * The `seen` guard is threaded through (not recreated) so cross-referencing\n * errors nested inside plain objects/arrays are caught by the same circular\n * check that protects the top-level error tree, rather than only relying on the\n * depth limit.\n */\nfunction serializeValue(value: unknown, remainingDepth: number, seen: WeakSet<object>): unknown {\n  if (remainingDepth <= 0) return '[Max Depth]';\n  if (value === null || value === undefined) return value;\n\n  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {\n    return value;\n  }\n\n  if (value instanceof Date) return value.toISOString();\n\n  if (value instanceof Error) {\n    if (seen.has(value)) {\n      return { name: value.name, message: value.message, _circular: true };\n    }\n    return _serializeError(value, true, remainingDepth, [], 0, seen);\n  }\n\n  if (Array.isArray(value)) {\n    if (seen.has(value)) return '[Circular]';\n    seen.add(value);\n    return value.map((item) => serializeValue(item, remainingDepth - 1, seen));\n  }\n\n  if (typeof value === 'object') {\n    if (seen.has(value)) return '[Circular]';\n    seen.add(value);\n    const out: Record<string, unknown> = {};\n    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {\n      try {\n        assignOwn(out, k, serializeValue(v, remainingDepth - 1, seen));\n      } catch {\n        assignOwn(out, k, '[Unserializable]');\n      }\n    }\n    return out;\n  }\n\n  return String(value);\n}\n\n/**\n * Type guard: returns true if the value looks like an Error object.\n */\nexport function isError(value: unknown): value is Error {\n  return (\n    value instanceof Error ||\n    (Boolean(value) &&\n      typeof value === 'object' &&\n      'name' in (value as object) &&\n      'message' in (value as object))\n  );\n}\n\nconst MAX_ERROR_SEARCH_DEPTH = 3;\nconst MAX_ERROR_SEARCH_NODES = 2000;\n\n/**\n * Replaces real Error instances inside a log payload with their serialized form,\n * because JSON output drops an Error's non-enumerable `message` and `stack`. Runs on\n * every log call, so its work is capped and it copies nothing until it finds one.\n * Duck-typed objects are data, and an Error with its own toJSON has already chosen\n * what to show. The caller's objects are never mutated.\n */\nexport function serializeNestedErrors(data: Record<string, unknown>): Record<string, unknown> {\n  // Saved and restored, because a getter read during the walk can log and re-enter.\n  const outerBudget = errorSearchBudget;\n  errorSearchBudget = MAX_ERROR_SEARCH_NODES;\n  try {\n    return walkForErrors(data, MAX_ERROR_SEARCH_DEPTH, undefined, undefined) as Record<\n      string,\n      unknown\n    >;\n  } finally {\n    errorSearchBudget = outerBudget;\n  }\n}\n\nlet errorSearchBudget = 0;\nconst hasOwn = Object.prototype.hasOwnProperty;\n\n// Allocates nothing until it finds an Error. With the depth cap, a node has at most\n// two ancestors that can still recurse, so they are passed as arguments for the cycle check.\nfunction walkForErrors(\n  value: object,\n  depth: number,\n  parent?: object,\n  grandparent?: object\n): unknown {\n  if (value instanceof Error) {\n    return typeof (value as { toJSON?: unknown }).toJSON === 'function'\n      ? value\n      : serializeError(value);\n  }\n  if (depth === 0 || --errorSearchBudget < 0 || value === parent || value === grandparent) {\n    return value;\n  }\n\n  let copy: unknown;\n  if (Array.isArray(value)) {\n    for (let i = 0; i < value.length; i++) {\n      const item: unknown = value[i];\n      if (item === null || typeof item !== 'object') continue;\n      const next = walkForErrors(item, depth - 1, value, parent);\n      if (next !== item) {\n        copy ??= value.slice();\n        (copy as unknown[])[i] = next;\n      }\n    }\n  } else {\n    const proto: unknown = Object.getPrototypeOf(value);\n    if (proto !== Object.prototype && proto !== null) return value;\n    const record = value as Record<string, unknown>;\n    // for...in avoids the key array that Object.keys allocates on every call.\n    for (const key in record) {\n      if (!hasOwn.call(record, key)) continue;\n      let item: unknown;\n      try {\n        item = record[key];\n      } catch {\n        continue;\n      }\n      if (item === null || typeof item !== 'object') continue;\n      const next = walkForErrors(item, depth - 1, record, parent);\n      if (next !== item) {\n        copy ??= { ...record };\n        assignOwn(copy as Record<string, unknown>, key, next);\n      }\n    }\n  }\n  return copy ?? value;\n}\n\n/**\n * Coerce any thrown value into a proper Error instance.\n */\nexport function normalizeError(error: unknown): Error {\n  if (isError(error)) return error;\n\n  if (typeof error === 'string') return new Error(error);\n\n  if (typeof error === 'object' && error !== null) {\n    const e = error as Record<string, unknown>;\n    const err = new Error(typeof e['message'] === 'string' ? e['message'] : 'Unknown error');\n    Object.assign(err, error);\n    return err;\n  }\n\n  return new Error(String(error));\n}\n","/**\n * Internal logging helpers for use within the logixia library itself.\n *\n * These functions write directly to stderr/stdout without going through\n * LogixiaLogger — this avoids circular dependencies and ensures internal\n * diagnostics still surface even when the logger is misconfigured.\n *\n * Library code must NEVER call console.log/warn/error directly. Use these\n * helpers instead so that internal output can be silenced in tests by setting\n * the LOGIXIA_SILENT_INTERNAL=1 environment variable.\n */\n\n/**\n * Read the silence flag on each call rather than caching it at import time, so\n * setting LOGIXIA_SILENT_INTERNAL=1 AFTER the module is first imported (e.g. in\n * a test setup file) still takes effect — the documented test-silencing\n * behavior was previously unreliable because the value was frozen at load.\n */\nfunction isSilent(): boolean {\n  if (typeof process !== 'undefined' && process.env?.LOGIXIA_SILENT_INTERNAL === '1') return true;\n  const flag = (globalThis as Record<string, unknown>)['LOGIXIA_SILENT_INTERNAL'];\n  return flag === '1' || flag === 1 || flag === true;\n}\n\ntype ConsoleMethod = 'log' | 'warn' | 'error';\n\n/**\n * Write a line to stderr, falling back to the matching console method where\n * `process` is unavailable (browsers, Cloudflare Workers, Deno without Node compat).\n */\nfunction writeLine(method: ConsoleMethod, line: string): void {\n  if (typeof process !== 'undefined' && typeof process.stderr?.write === 'function') {\n    process.stderr.write(`${line}\\n`);\n  } else if (typeof console !== 'undefined' && typeof console[method] === 'function') {\n    console[method](line);\n  }\n}\n\n/**\n * Emit an internal debug/info message to stderr.\n * Use for field-enable/disable notifications that a developer might want to see\n * during development but should not appear in production log streams.\n */\nexport function internalLog(message: string): void {\n  if (!isSilent()) {\n    writeLine('log', `[logixia] ${message}`);\n  }\n}\n\n/**\n * Emit an internal warning to stderr.\n * Use when something is misconfigured but logixia can continue operating.\n */\nexport function internalWarn(message: string): void {\n  if (!isSilent()) {\n    writeLine('warn', `[logixia:warn] ${message}`);\n  }\n}\n\n/**\n * Emit an internal error to stderr.\n * Use when a transport write fails or a serious internal error occurs.\n */\nexport function internalError(message: string, error?: unknown): void {\n  if (!isSilent()) {\n    let errStr = '';\n    if (error instanceof Error) {\n      errStr = ` — ${error.message}`;\n    } else if (error != null) {\n      errStr = ` — ${String(error)}`;\n    }\n    writeLine('error', `[logixia:error] ${message}${errStr}`);\n  }\n}\n","/**\n * Trace ID utilities for Logitron\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport { randomUUID } from 'node:crypto';\n\nimport type { TraceIdConfig, TraceIdExtractorConfig } from '../types';\n\n/** Default key used to store the trace ID in AsyncLocalStorage. */\nexport const TRACE_CONTEXT_KEY = 'traceId' as const;\n\n// ── TraceContext class ────────────────────────────────────────────────────────\n\n/**\n * Singleton that owns the AsyncLocalStorage and the active contextKey.\n *\n * Why a class instead of bare module-level variables?\n *  - The contextKey is user-configurable; encapsulating it here means there is\n *    exactly one place that reads and writes it.\n *  - All helpers (getCurrentTraceId, runWithTraceId, etc.) delegate to this\n *    instance, so the key is always in sync without hidden global state.\n *  - Easier to test: you can reset the singleton between test cases.\n *\n * Usage (advanced):\n *   import { TraceContext } from 'logixia';\n *   TraceContext.instance.contextKey          // → 'traceId' (or custom)\n *   TraceContext.instance.getCurrentTraceId() // same as standalone fn\n */\nexport class TraceContext {\n  private static _instance: TraceContext | null = null;\n\n  readonly storage = new AsyncLocalStorage<Record<string, unknown>>();\n  private _contextKey: string = TRACE_CONTEXT_KEY;\n\n  private constructor() {}\n\n  /** The process-wide singleton. */\n  static get instance(): TraceContext {\n    if (!TraceContext._instance) {\n      TraceContext._instance = new TraceContext();\n    }\n    return TraceContext._instance;\n  }\n\n  /** @internal Reset the singleton (useful in tests). */\n  static _reset(): void {\n    TraceContext._instance = null;\n  }\n\n  // ── Key management ──────────────────────────────────────────────────────────\n\n  /** The AsyncLocalStorage key that holds the trace ID value. */\n  get contextKey(): string {\n    return this._contextKey;\n  }\n\n  /** @internal Called by TraceMiddleware when it boots to register the user's key. */\n  setContextKey(key: string): void {\n    this._contextKey = key;\n  }\n\n  // ── Core operations ─────────────────────────────────────────────────────────\n\n  /** UUID v4 generator (default). */\n  generate(): string {\n    return randomUUID();\n  }\n\n  /** Read the trace ID from the current async context. */\n  getCurrentTraceId(): string | undefined {\n    return this.storage.getStore()?.[this._contextKey] as string | undefined;\n  }\n\n  /**\n   * Mutate the CURRENT async context in-place.\n   *\n   * ⚠️  DEPRECATED — unsafe for concurrent requests.\n   *\n   * Uses `AsyncLocalStorage.enterWith()`, which mutates the current async\n   * execution context and every Promise chain spawned from it. In a server\n   * processing overlapping requests this can cause a trace ID set for one\n   * request to bleed into *other* in-flight requests that share the same\n   * async parent (e.g. a module-level setup function or a cached handler).\n   *\n   * Use {@link run} instead — it scopes the context to a callback so there\n   * is no risk of cross-request leakage.\n   *\n   * @deprecated Use `TraceContext.instance.run(traceId, fn)` — do not call\n   *             `setTraceId` from request-handling code.\n   */\n  setTraceId(traceId: string, data?: Record<string, unknown>): void {\n    const current = this.storage.getStore() ?? {};\n    this.storage.enterWith({ ...current, [this._contextKey]: traceId, ...data });\n  }\n\n  /** Run `fn` inside a new async context that carries `traceId`. */\n  run<T>(traceId: string, fn: () => T, data?: Record<string, unknown>): T {\n    return this.storage.run({ [this._contextKey]: traceId, ...data }, fn);\n  }\n}\n\n// ── Module-level aliases (backwards-compatible public API) ────────────────────\n\n/**\n * The shared AsyncLocalStorage instance.\n * @deprecated Prefer `TraceContext.instance.storage` for new code.\n */\nexport const traceStorage = TraceContext.instance.storage;\n\n/** Returns the key currently used to store the trace ID in AsyncLocalStorage. */\nexport function getTraceContextKey(): string {\n  return TraceContext.instance.contextKey;\n}\n\n/** @internal Called by TraceMiddleware / traceMiddleware() when they boot. */\nexport function _setActiveContextKey(key: string): void {\n  TraceContext.instance.setContextKey(key);\n}\n\n/** Generate a UUID v4 trace ID. */\nexport function generateTraceId(): string {\n  return TraceContext.instance.generate();\n}\n\n/**\n * Get the current trace ID from async context.\n * Returns `undefined` when called outside a traced request.\n */\nexport function getCurrentTraceId(): string | undefined {\n  return TraceContext.instance.getCurrentTraceId();\n}\n\n/**\n * Set trace ID in the CURRENT async context without starting a new one.\n *\n * ⚠️  DEPRECATED — unsafe for concurrent requests.\n *\n * Uses `AsyncLocalStorage.enterWith()`, which mutates the current async\n * execution context and every Promise chain spawned from it. Under load this\n * can cause a trace ID from one request to bleed into others sharing the same\n * async parent.\n *\n * Use {@link runWithTraceId} instead. Migration patterns:\n *\n * **Express / Fastify middleware — before:**\n * ```ts\n * app.use((req, _res, next) => {\n *   setTraceId(req.headers['x-trace-id'] ?? generateTraceId());\n *   next();\n * });\n * ```\n * **after:**\n * ```ts\n * app.use((req, _res, next) => {\n *   runWithTraceId(req.headers['x-trace-id'] ?? generateTraceId(), () => next());\n * });\n * ```\n *\n * **Kafka / queue consumer — before:**\n * ```ts\n * async function handle(msg) {\n *   setTraceId(msg.headers['x-trace-id']);\n *   await processMessage(msg);\n * }\n * ```\n * **after:**\n * ```ts\n * async function handle(msg) {\n *   await runWithTraceId(msg.headers['x-trace-id'], () => processMessage(msg));\n * }\n * ```\n *\n * **Background job — before:**\n * ```ts\n * setTraceId(generateTraceId(), { jobId: job.id });\n * await job.run();\n * ```\n * **after:**\n * ```ts\n * await runWithTraceId(generateTraceId(), () => job.run(), { jobId: job.id });\n * ```\n *\n * @deprecated Use `runWithTraceId(traceId, fn)` — do not call `setTraceId`\n *             from request-handling code.\n */\nexport function setTraceId(traceId: string, data?: Record<string, unknown>): void {\n  TraceContext.instance.setTraceId(traceId, data);\n}\n\n/** Run `fn` inside a new async context carrying `traceId`. */\nexport function runWithTraceId<T>(traceId: string, fn: () => T, data?: Record<string, unknown>): T {\n  return TraceContext.instance.run(traceId, fn, data);\n}\n\n// ── Request extraction ────────────────────────────────────────────────────────\n\ntype HeaderValue = string | string[] | undefined;\n\n/** Shape that extractTraceId accepts (Express-compatible) */\ninterface RequestLike {\n  headers?: Record<string, HeaderValue>;\n  query?: Record<string, HeaderValue>;\n  body?: Record<string, string | undefined>;\n  params?: Record<string, string | undefined>;\n}\n\n/** Maximum accepted length for an incoming trace / correlation / request ID. */\nexport const MAX_INCOMING_ID_LENGTH = 128;\n\nconst SAFE_INCOMING_ID = /^[A-Za-z0-9._:-]{1,128}$/;\n\n/**\n * Validate an externally supplied identifier (trace ID, correlation ID, origin\n * service name, message-queue ID). Accepts only 1-128 characters from\n * `[A-Za-z0-9._:-]`; surrounding whitespace is trimmed first. Arrays use their\n * first element. Returns the cleaned value, or `undefined` when it is unusable\n * so callers can generate a fresh ID instead of passing client text through.\n */\nexport function sanitizeIncomingId(value: unknown): string | undefined {\n  const first = Array.isArray(value) ? value[0] : value;\n  if (typeof first !== 'string' || first.length > MAX_INCOMING_ID_LENGTH * 2) return undefined;\n  const trimmed = first.trim();\n  return SAFE_INCOMING_ID.test(trimmed) ? trimmed : undefined;\n}\n\n/** W3C trace-context: `version-traceId(32hex)-spanId(16hex)-flags(2hex)`. */\nconst W3C_TRACEPARENT_RE = /^[\\da-f]{2}-([\\da-f]{32})-[\\da-f]{16}-[\\da-f]{2}$/i;\n\n/**\n * Extract the 32-hex trace-id segment from a W3C `traceparent` header value.\n * Returns the parsed trace ID, or the original value unchanged when it is not a\n * well-formed traceparent (so non-W3C propagation still works).\n */\nfunction parseTraceparent(value: string): string {\n  const m = W3C_TRACEPARENT_RE.exec(value);\n  return m ? m[1]! : value;\n}\n\n/** Extract trace ID from request using configuration (header → query → body → params). */\nexport function extractTraceId(\n  request: unknown,\n  config: TraceIdExtractorConfig\n): string | undefined {\n  const req = request as RequestLike;\n\n  if (config.header) {\n    const headers = Array.isArray(config.header) ? config.header : [config.header];\n    for (const header of headers) {\n      const lower = header.toLowerCase();\n      const value = sanitizeIncomingId(req.headers?.[lower]);\n      if (value) return lower === 'traceparent' ? parseTraceparent(value) : value;\n    }\n  }\n\n  if (config.query) {\n    const queries = Array.isArray(config.query) ? config.query : [config.query];\n    for (const query of queries) {\n      const value = sanitizeIncomingId(req.query?.[query]);\n      if (value) return value;\n    }\n  }\n\n  if (config.body) {\n    const bodyFields = Array.isArray(config.body) ? config.body : [config.body];\n    for (const field of bodyFields) {\n      const value = sanitizeIncomingId(req.body?.[field]);\n      if (value) return value;\n    }\n  }\n\n  if (config.params) {\n    const paramFields = Array.isArray(config.params) ? config.params : [config.params];\n    for (const param of paramFields) {\n      const value = sanitizeIncomingId(req.params?.[param]);\n      if (value) return value;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Default headers checked for incoming trace ID propagation, in priority order:\n *   traceparent (W3C/OTel) → x-trace-id → x-request-id → x-correlation-id → trace-id\n */\nexport const DEFAULT_TRACE_HEADERS = [\n  'traceparent',\n  'x-trace-id',\n  'x-request-id',\n  'x-correlation-id',\n  'trace-id',\n];\n\n/**\n * Create trace ID middleware for Express/NestJS\n */\nexport function createTraceMiddleware(config: TraceIdConfig) {\n  const defaultExtractor = {\n    header: DEFAULT_TRACE_HEADERS,\n    query: ['traceId', 'trace_id'],\n  };\n  const resolvedConfig: TraceIdConfig = {\n    ...config,\n    extractor: config?.extractor ? { ...defaultExtractor, ...config.extractor } : defaultExtractor,\n  };\n\n  _setActiveContextKey(resolvedConfig.contextKey ?? TRACE_CONTEXT_KEY);\n\n  return (req: unknown, res: unknown, next: () => void) => {\n    let traceId: string | undefined;\n\n    if (resolvedConfig.extractor) {\n      traceId = extractTraceId(req, resolvedConfig.extractor);\n    }\n\n    if (!traceId) {\n      traceId = resolvedConfig.generator ? resolvedConfig.generator() : generateTraceId();\n    }\n\n    (req as Record<string, unknown>).traceId = traceId;\n    // Echo the trace ID back on the response, tolerating different response APIs:\n    // Express/Node use res.setHeader(), Fastify replies use reply.header(). Guard\n    // both and never let a missing/!function method (or already-sent headers)\n    // crash the request — the trace ID is still propagated via async context.\n    const resObj = res as {\n      setHeader?: (k: string, v: string) => void;\n      header?: (k: string, v: string) => void;\n      headersSent?: boolean;\n    };\n    if (!resObj.headersSent) {\n      try {\n        if (typeof resObj.setHeader === 'function') {\n          resObj.setHeader('X-Trace-Id', traceId);\n        } else if (typeof resObj.header === 'function') {\n          resObj.header('X-Trace-Id', traceId);\n        }\n      } catch {\n        /* response not in a header-settable state — context propagation still works */\n      }\n    }\n\n    runWithTraceId(traceId, () => next());\n  };\n}\n","/**\n * Per-request trace ID resolution shared by the HTTP logger middleware and the\n * context helpers. Internal: not re-exported from the package entry points.\n */\n\nimport type { HttpRequestShape } from '../types/http-shapes';\nimport {\n  DEFAULT_TRACE_HEADERS,\n  extractTraceId,\n  generateTraceId,\n  sanitizeIncomingId,\n} from './trace.utils';\n\nexport type TraceHeaderOption = string | readonly string[];\n\n/** Minimal structural request shape; Express and Fastify requests satisfy it. */\nexport type ContextRequestLike = HttpRequestShape;\n\n/** Fastify's default `genReqId` output (`req-` + base36 counter), unique only per process. */\nconst FASTIFY_COUNTER_ID = /^req-[\\da-z]+$/;\n\nconst FALLBACK_KEY = '_logixiaFallbackId';\n\n/** A caller-supplied request ID that is safe to use as a trace ID, or `undefined` for a counter ID. */\nexport function usableRequestId(id: unknown): string | undefined {\n  const sanitized = sanitizeIncomingId(id);\n  return sanitized !== undefined && !FASTIFY_COUNTER_ID.test(sanitized) ? sanitized : undefined;\n}\n\n/** Header names to read a trace ID from, defaulting to the library-wide list. */\nexport function resolveTraceHeaders(option: TraceHeaderOption | undefined): readonly string[] {\n  if (option === undefined) return DEFAULT_TRACE_HEADERS;\n  return typeof option === 'string' ? [option] : option;\n}\n\n/**\n * Resolve the trace ID for a request: a sanitised incoming header (honouring\n * `traceparent`), then a non-counter `request.id`, then a generated ID. Header\n * and `request.id` are recomputed per call so each caller's own header list is\n * honoured; only the generated fallback is stored on the request so every helper\n * agrees when no ID was sent.\n */\nexport function resolveRequestTraceId(req: ContextRequestLike, headers: readonly string[]): string {\n  const fromHeader = extractTraceId(req, { header: [...headers] });\n  if (fromHeader !== undefined) return fromHeader;\n\n  const fromId = usableRequestId(req.id);\n  if (fromId !== undefined) return fromId;\n\n  const holder = req as Record<string, unknown>;\n  const cached = holder[FALLBACK_KEY];\n  if (typeof cached === 'string') return cached;\n  const generated = generateTraceId();\n  try {\n    holder[FALLBACK_KEY] = generated;\n  } catch {\n    // frozen request object: each caller generates its own\n  }\n  return generated;\n}\n","/**\n * The one list of sensitive names. Log redaction (redact.utils), the HTTP logger\n * middleware and transport secret handling (transports/secret-config) all read it,\n * so the lists cannot drift. No imports: safe from any module, including browser code.\n */\n\n/** Field names redacted by name, wherever they appear in logged data. */\nexport const SENSITIVE_KEY_NAMES: readonly string[] = [\n  'password',\n  'passwd',\n  'secret',\n  'token',\n  'apiKey',\n  'api_key',\n  'accessToken',\n  'access_token',\n  'refreshToken',\n  'refresh_token',\n  'authorization',\n  'credentials',\n  'privateKey',\n  'private_key',\n  'clientSecret',\n  'client_secret',\n  'cookie',\n  'set-cookie',\n  'x-api-key',\n  'session',\n  'proxy-authorization',\n  'x-auth-token',\n  'x-access-token',\n  'aws_secret_access_key',\n  'awsSecretAccessKey',\n  'secretAccessKey',\n];\n\n/**\n * Extra names that only mean \"secret\" inside transport configuration, where\n * short words like `key` or `signature` are credentials, not log fields.\n */\nexport const TRANSPORT_CONFIG_SECRET_NAMES: readonly string[] = [\n  'writeKey',\n  'apiSecret',\n  'connectionString',\n  'sessionToken',\n  'passphrase',\n  'signature',\n  'pwd',\n  'pfx',\n  'cert',\n  'key',\n  'auth',\n];\n\n/** Request headers whose values are never logged. */\nexport const DEFAULT_REDACT_HEADERS: readonly string[] = [\n  'authorization',\n  'cookie',\n  'set-cookie',\n  'x-api-key',\n  'proxy-authorization',\n  'x-auth-token',\n  'x-access-token',\n  'x-csrf-token',\n  'x-amz-security-token',\n];\n\n/** Query-string parameters whose values are never logged. */\nexport const DEFAULT_REDACT_QUERY_PARAMS: readonly string[] = [\n  'token',\n  'access_token',\n  'refresh_token',\n  'code',\n  'password',\n  'secret',\n  'api_key',\n  'apikey',\n  'key',\n  'signature',\n  'sig',\n  'auth',\n  'accesstoken',\n  'refreshtoken',\n  'id_token',\n  'idtoken',\n  'client_secret',\n  'clientsecret',\n  'session',\n  'sessionid',\n  'session_id',\n  'jwt',\n  'auth_token',\n  'authtoken',\n  'api-key',\n  'x-api-key',\n  'x-amz-signature',\n  'x-amz-credential',\n  'x-amz-security-token',\n  'x-goog-signature',\n  'x-goog-credential',\n  'access-token',\n  'x-access-token',\n  'x-auth-token',\n  'apitoken',\n  'api_token',\n];\n\nfunction safeDecode(value: string): string {\n  try {\n    return decodeURIComponent(value.replace(/\\+/g, ' '));\n  } catch {\n    return value;\n  }\n}\n\n/** Replace the values of sensitive query parameters, leaving the rest verbatim. */\nexport function redactUrlQuery(url: string, redactParams: ReadonlySet<string>): string {\n  const q = url.indexOf('?');\n  if (q === -1) return url;\n  const hashAt = url.indexOf('#', q);\n  const query = url.slice(q + 1, hashAt === -1 ? undefined : hashAt);\n  const hash = hashAt === -1 ? '' : url.slice(hashAt);\n  const cleaned = query\n    .split('&')\n    .map((pair) => {\n      const eq = pair.indexOf('=');\n      const rawKey = eq === -1 ? pair : pair.slice(0, eq);\n      const decoded = safeDecode(rawKey);\n      const bracket = decoded.indexOf('[');\n      const name = (bracket === -1 ? decoded : decoded.slice(0, bracket)).toLowerCase();\n      return redactParams.has(name) && eq !== -1 ? `${rawKey}=[REDACTED]` : pair;\n    })\n    .join('&');\n  return `${url.slice(0, q)}?${cleaned}${hash}`;\n}\n\n/** Lower-cased lookup set of the default names plus any extras. */\nexport function buildNameSet(\n  defaults: readonly string[],\n  extra: readonly string[] | undefined\n): Set<string> {\n  return new Set([...defaults, ...(extra ?? [])].map((n) => n.toLowerCase()));\n}\n\nconst REDACTED = '[REDACTED]';\nconst MIN_SCRUB_LENGTH = 3;\n\nfunction queryNameOf(rawKey: string): string {\n  const decoded = safeDecode(rawKey);\n  const bracket = decoded.indexOf('[');\n  return (bracket === -1 ? decoded : decoded.slice(0, bracket)).toLowerCase();\n}\n\n/**\n * Raw and decoded values of sensitive query parameters present in this URL.\n * Values shorter than 3 characters or already `[REDACTED]` are ignored.\n */\nexport function sensitiveQueryValues(url: string, names: ReadonlySet<string>): string[] {\n  const q = url.indexOf('?');\n  if (q === -1) return [];\n  const hashAt = url.indexOf('#', q);\n  const query = url.slice(q + 1, hashAt === -1 ? undefined : hashAt);\n  const found = new Set<string>();\n  for (const pair of query.split('&')) {\n    const eq = pair.indexOf('=');\n    if (eq === -1 || !names.has(queryNameOf(pair.slice(0, eq)))) continue;\n    const raw = pair.slice(eq + 1);\n    for (const value of [raw, safeDecode(raw)]) {\n      if (value.length >= MIN_SCRUB_LENGTH && value !== REDACTED) found.add(value);\n    }\n  }\n  return [...found];\n}\n\n/** Replace every literal occurrence of `values` in `text` with `[REDACTED]`. */\nexport function scrubValues(text: string, values: readonly string[]): string {\n  if (values.length === 0 || text.length === 0) return text;\n  let out = text;\n  for (const value of [...values].sort((a, b) => b.length - a.length)) {\n    if (value.length > 0 && out.includes(value)) out = out.split(value).join(REDACTED);\n  }\n  return out;\n}\n\nfunction isUrlTerminator(ch: string): boolean {\n  return (\n    ch === ' ' ||\n    ch === '\\n' ||\n    ch === '\\r' ||\n    ch === '\\t' ||\n    ch === '\"' ||\n    ch === \"'\" ||\n    ch === '`'\n  );\n}\n\n/**\n * Redact sensitive query values in every `?query` found inside free text (an\n * error message, a stack line). Scans for `?` and cuts at whitespace or a quote.\n */\nexport function redactUrlsInText(text: string, names: ReadonlySet<string>): string {\n  let q = text.indexOf('?');\n  if (q === -1) return text;\n  let out = '';\n  let cursor = 0;\n  while (q !== -1) {\n    let end = q + 1;\n    while (end < text.length && !isUrlTerminator(text.charAt(end))) end++;\n    out += text.slice(cursor, q) + redactUrlQuery(text.slice(q, end), names);\n    cursor = end;\n    q = text.indexOf('?', end);\n  }\n  return out + text.slice(cursor);\n}\n\n/** Shape-preserving URL redaction plus literal scrubbing of this request's secret values. */\nexport function sanitizeText(\n  text: string,\n  names: ReadonlySet<string>,\n  values: readonly string[]\n): string {\n  return scrubValues(redactUrlsInText(text, names), values);\n}\n","/**\n * Hono request logging middleware: trace ID, response header and a completion entry.\n *\n * Only structural types are used, so it works with any Hono version and runs on Node,\n * Bun and Cloudflare Workers (`nodejs_compat`, for `AsyncLocalStorage`).\n *\n * @example\n * ```ts\n * import { Hono } from 'hono';\n * import { createHonoMiddleware } from 'logixia/hono';\n *\n * const app = new Hono();\n * app.use(createHonoMiddleware(logger));\n * ```\n */\n\nimport { serializeError } from '../utils/error.utils';\nimport { internalError } from '../utils/internal-log';\nimport { resolveTraceHeaders } from '../utils/request-trace';\nimport {\n  buildNameSet,\n  DEFAULT_REDACT_QUERY_PARAMS,\n  redactUrlQuery,\n} from '../utils/sensitive-names';\nimport { extractTraceId, generateTraceId, runWithTraceId } from '../utils/trace.utils';\n\n// ── Structural types ─────────────────────────────────────────────────────────\n\ntype LogFn = (message: string, data?: Record<string, unknown>) => unknown;\n\n/** The logger methods used: logixia's `Logger` and `createBrowserLogger()` both fit. */\nexport interface HonoLoggerLike {\n  info: LogFn;\n  warn: LogFn;\n  error: LogFn;\n}\n\n/** The slice of Hono's `Context` the middleware reads and writes. */\nexport interface HonoContextLike {\n  req: { method: string; url: string; header(name: string): string | undefined };\n  res: Response;\n  error?: Error | undefined;\n  header(name: string, value: string): unknown;\n  set(key: 'traceId', value: string): void;\n}\n\nexport type HonoNext = () => Promise<void>;\n\nexport interface HonoMiddlewareOptions {\n  /** Skip logging and tracing for a request, for example health checks. */\n  skip?: (c: HonoContextLike) => boolean;\n  /**\n   * Header name, or list of names tried in order, to read the trace ID from.\n   * Default: `DEFAULT_TRACE_HEADERS` (traceparent, x-trace-id, x-request-id,\n   * x-correlation-id, trace-id). A generated UUID is used when none is present.\n   */\n  traceIdHeader?: string | readonly string[];\n  /** Response header that carries the trace ID. Default: `'x-trace-id'`. `false` sets none. */\n  responseHeader?: string | false;\n  /**\n   * Extra query-string parameter names redacted from the logged path, merged with the\n   * defaults (token, access_token, refresh_token, code, password, secret, api_key, ...).\n   */\n  redactQueryParams?: string[];\n  /** Fields added to every entry. */\n  extraFields?: (c: HonoContextLike) => Record<string, unknown>;\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────────\n\n/** Fire-and-forget: a failing log call must never fail the request. */\nfunction emit(logger: HonoLoggerLike, level: keyof HonoLoggerLike, message: string, data: object) {\n  try {\n    const result = logger[level](message, data as Record<string, unknown>);\n    if (result && typeof (result as Promise<unknown>).catch === 'function') {\n      (result as Promise<unknown>).catch((error: unknown) =>\n        internalError('hono middleware: log call failed', error)\n      );\n    }\n  } catch (error) {\n    internalError('hono middleware: log call failed', error);\n  }\n}\n\n/** Pathname plus the query string with secret parameters redacted, from an absolute or relative URL. */\nfunction loggedPath(url: string, params: ReadonlySet<string>): string {\n  const schemeEnd = url.indexOf('://');\n  const pathStart = schemeEnd === -1 ? 0 : url.indexOf('/', schemeEnd + 3);\n  return pathStart === -1 ? '/' : redactUrlQuery(url.slice(pathStart), params);\n}\n\nfunction ensureHeader(c: HonoContextLike, name: string, value: string): void {\n  try {\n    if (c.res.headers.get(name) === value) return;\n    c.res.headers.set(name, value);\n  } catch {\n    // Immutable headers (a proxied fetch() response): rebuild the response with a mutable copy.\n    const copy = new Response(c.res.body, c.res);\n    copy.headers.set(name, value);\n    c.res = copy;\n  }\n}\n\n/**\n * Create a Hono middleware (`app.use(...)`).\n *\n * Per request it resolves the trace ID from headers, sets it on the response and on\n * `c.var.traceId`, runs the rest of the request inside {@link runWithTraceId} and logs\n * one entry when the request completes: `method`, `path` (query secrets redacted),\n * `status`, `duration` in ms and `traceId`. Responses with status 500 and above, and\n * errors thrown by handlers, are logged at `error`; other thrown errors at `warn`.\n */\nexport function createHonoMiddleware(\n  logger: HonoLoggerLike,\n  options: HonoMiddlewareOptions = {}\n): (c: HonoContextLike, next: HonoNext) => Promise<void> {\n  const { skip, extraFields, responseHeader = 'x-trace-id' } = options;\n  const traceHeaders = resolveTraceHeaders(options.traceIdHeader);\n  const params = buildNameSet(DEFAULT_REDACT_QUERY_PARAMS, options.redactQueryParams);\n\n  return async function logixiaHonoMiddleware(c, next) {\n    if (skip?.(c)) return next();\n\n    const headers: Record<string, string | undefined> = {};\n    for (const name of traceHeaders) {\n      const key = name.toLowerCase();\n      headers[key] = c.req.header(key);\n    }\n    const traceId = extractTraceId({ headers }, { header: [...traceHeaders] }) ?? generateTraceId();\n    const start = Date.now();\n    c.set('traceId', traceId);\n    if (responseHeader) c.header(responseHeader, traceId);\n\n    await runWithTraceId(traceId, async () => {\n      let thrown: unknown;\n      try {\n        await next();\n      } catch (error) {\n        thrown = error;\n      }\n      // Hono hands a handler's error to onError and resolves next(); c.error is how it shows up here.\n      const failure = thrown ?? c.error;\n      if (responseHeader && thrown === undefined) ensureHeader(c, responseHeader, traceId);\n\n      const status = thrown === undefined ? c.res.status : 500;\n      const entry = {\n        traceId,\n        method: c.req.method,\n        path: loggedPath(c.req.url, params),\n        status,\n        duration: Date.now() - start,\n        ...(failure === undefined ? {} : { error: serializeError(toError(failure)) }),\n        ...extraFields?.(c),\n      };\n      if (failure !== undefined) {\n        emit(logger, status >= 500 ? 'error' : 'warn', 'request failed', entry);\n      } else {\n        emit(logger, status >= 500 ? 'error' : 'info', 'request completed', entry);\n      }\n      if (thrown !== undefined) throw thrown;\n    });\n  };\n}\n\nfunction toError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value));\n}\n"],"mappings":"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"}