logixia 2.1.0 → 2.2.0

package/dist/error.utils-fZkRExam.js

@@ -0,0 +1,212 @@
+const require_own_property = require("./own-property-BWkibepN.js");
+// 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 {
+			require_own_property.assignOwn(serialized, key, serializeValue(errorRecord[key], maxDepth - depth - 1, seen));
+		} catch {
+			require_own_property.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 {
+			require_own_property.assignOwn(out, k, serializeValue(v, remainingDepth - 1, seen));
+		} catch {
+			require_own_property.assignOwn(out, k, "[Unserializable]");
+		}
+		return out;
+	}
+	return String(value);
+}
+/**
+* Type guard: returns true if the value looks like an Error object.
+*/
+function isError(value) {
+	return value instanceof Error || Boolean(value) && typeof value === "object" && "name" in value && "message" in value;
+}
+const MAX_ERROR_SEARCH_DEPTH = 3;
+const MAX_ERROR_SEARCH_NODES = 2e3;
+/**
+* Replaces real Error instances inside a log payload with their serialized form,
+* because JSON output drops an Error's non-enumerable `message` and `stack`. Runs on
+* every log call, so its work is capped and it copies nothing until it finds one.
+* Duck-typed objects are data, and an Error with its own toJSON has already chosen
+* what to show. The caller's objects are never mutated.
+*/
+function serializeNestedErrors(data) {
+	const outerBudget = errorSearchBudget;
+	errorSearchBudget = MAX_ERROR_SEARCH_NODES;
+	try {
+		return walkForErrors(data, MAX_ERROR_SEARCH_DEPTH, void 0, void 0);
+	} finally {
+		errorSearchBudget = outerBudget;
+	}
+}
+let errorSearchBudget = 0;
+const hasOwn = Object.prototype.hasOwnProperty;
+function walkForErrors(value, depth, parent, grandparent) {
+	if (value instanceof Error) return typeof value.toJSON === "function" ? value : serializeError(value);
+	if (depth === 0 || --errorSearchBudget < 0 || value === parent || value === grandparent) return value;
+	let copy;
+	if (Array.isArray(value)) for (let i = 0; i < value.length; i++) {
+		const item = value[i];
+		if (item === null || typeof item !== "object") continue;
+		const next = walkForErrors(item, depth - 1, value, parent);
+		if (next !== item) {
+			copy ??= value.slice();
+			copy[i] = next;
+		}
+	}
+	else {
+		const proto = Object.getPrototypeOf(value);
+		if (proto !== Object.prototype && proto !== null) return value;
+		const record = value;
+		for (const key in record) {
+			if (!hasOwn.call(record, key)) continue;
+			let item;
+			try {
+				item = record[key];
+			} catch {
+				continue;
+			}
+			if (item === null || typeof item !== "object") continue;
+			const next = walkForErrors(item, depth - 1, record, parent);
+			if (next !== item) {
+				copy ??= { ...record };
+				require_own_property.assignOwn(copy, key, next);
+			}
+		}
+	}
+	return copy ?? value;
+}
+/**
+* Coerce any thrown value into a proper Error instance.
+*/
+function normalizeError(error) {
+	if (isError(error)) return error;
+	if (typeof error === "string") return new Error(error);
+	if (typeof error === "object" && error !== null) {
+		const e = error;
+		const err = new Error(typeof e["message"] === "string" ? e["message"] : "Unknown error");
+		Object.assign(err, error);
+		return err;
+	}
+	return new Error(String(error));
+}
+Object.defineProperty(exports, "isError", {
+	enumerable: true,
+	get: function() {
+		return isError;
+	}
+});
+Object.defineProperty(exports, "normalizeError", {
+	enumerable: true,
+	get: function() {
+		return normalizeError;
+	}
+});
+Object.defineProperty(exports, "serializeError", {
+	enumerable: true,
+	get: function() {
+		return serializeError;
+	}
+});
+Object.defineProperty(exports, "serializeNestedErrors", {
+	enumerable: true,
+	get: function() {
+		return serializeNestedErrors;
+	}
+});
+
+//# sourceMappingURL=error.utils-fZkRExam.js.map

package/dist/error.utils-fZkRExam.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.utils-fZkRExam.js","names":[],"sources":["../src/utils/error.utils.ts"],"sourcesContent":["/**\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"],"mappings":"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"}

package/dist/fastify.d.mts

@@ -0,0 +1,89 @@
+import { u as IBaseLogger } from "./index-B3ajtXJd.mjs";
+type PinoLevelName = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+type SerializerFn = (value: unknown) => unknown;
+/** pino's log function: `(obj, msg?, ...args)` or `(msg, ...args)`. Always returns `void`. */
+interface PinoCompatibleLogFn {
+  <T extends object>(obj: T, msg?: string, ...args: unknown[]): void;
+  (obj: unknown, msg?: string, ...args: unknown[]): void;
+  (msg: string, ...args: unknown[]): void;
+}
+interface PinoChildOptions {
+  /** Level for the child: a pino level name, `silent`, or a logixia level name. */
+  level?: string | undefined;
+  /** Serializers added to (and overriding) the ones the parent already has. */
+  serializers?: Record<string, SerializerFn> | undefined;
+}
+/** The pino surface Fastify and its plugins use. Satisfies `FastifyBaseLogger` without importing it. */
+interface PinoCompatibleLogger {
+  trace: PinoCompatibleLogFn;
+  debug: PinoCompatibleLogFn;
+  info: PinoCompatibleLogFn;
+  warn: PinoCompatibleLogFn;
+  error: PinoCompatibleLogFn;
+  fatal: PinoCompatibleLogFn;
+  /** Accepts the call and writes nothing, like pino's `silent`. */
+  silent: PinoCompatibleLogFn;
+  /** Current level: a pino level name, `silent`, or a logixia-only level such as `verbose`. */
+  level: string;
+  /** Numeric value of the current level (pino scale), `Infinity` when silent. */
+  readonly levelVal: number;
+  readonly levels: {
+    readonly values: Record<string, number>;
+    readonly labels: Record<number, string>;
+  };
+  /** Serializers Fastify merges over its own, so these win for `req`, `res` and `err`. */
+  readonly serializers: Record<string, SerializerFn>;
+  /** True when the configured level would let `level` through. */
+  isLevelEnabled(level: string): boolean;
+  /** The fields bound to this logger by `child()`. */
+  bindings(): Record<string, unknown>;
+  child(bindings: Record<string, unknown>, options?: PinoChildOptions): PinoCompatibleLogger;
+}
+interface FastifyLoggerOptions {
+  /**
+   * Serializers keyed by field name. They replace the defaults for `req`, `res` and
+   * `err` and apply to any other key you add.
+   */
+  serializers?: Record<string, SerializerFn>;
+  /**
+   * Query-string parameter names redacted from the `req` URL, merged with the defaults
+   * (token, access_token, refresh_token, code, password, secret, api_key, ...).
+   */
+  redactQueryParams?: string[];
+  /**
+   * Binding whose value becomes the trace ID of entries logged outside a trace scope.
+   * Default: `'reqId'` (Fastify's `requestIdLogLabel`). Counter IDs such as `req-1`
+   * are never used. Pass `false` to leave trace IDs alone.
+   */
+  traceIdBinding?: string | false;
+}
+interface FastifySerializerOptions {
+  redactQueryParams?: string[];
+}
+/**
+ * pino-std-like `req`, `res` and `err` serializers. `req` reads a Fastify request or a
+ * Node `IncomingMessage` and keeps only method, url (query secrets redacted), hostname,
+ * remote address and port, and the request ID; headers, body and sockets are dropped.
+ */
+export declare function createFastifySerializers(options?: FastifySerializerOptions): Record<'req' | 'res' | 'err', SerializerFn>;
+/**
+ * Wrap a logixia logger so Fastify accepts it as `loggerInstance`.
+ *
+ * - Call shapes: `(obj, msg?, ...args)`, `(msg, ...args)` with `%s %d %i %f %j %o %O`,
+ *   and `(err)` / `(err, msg)`. An `Error` under `err` is logged under `error`, like
+ *   `logger.error(err)` does, with its stack and `cause` chain.
+ * - `fatal` is logged at `error`. `silent` mutes the facade (and children made after).
+ * - `child(bindings)` creates a logixia child that carries the bindings as context data.
+ *   It starts no transports and registers nothing for shutdown, so one per request is cheap.
+ * - Methods return `void`; rejected log calls are caught.
+ * - `req`, `res` and `err` serializers are supplied; Fastify gives them precedence over
+ *   its own. Override or extend them with `options.serializers`.
+ *
+ * @example
+ * ```ts
+ * const app = Fastify({ loggerInstance: createFastifyLogger(logger) });
+ * ```
+ */
+export declare function createFastifyLogger(logger: IBaseLogger, options?: FastifyLoggerOptions): PinoCompatibleLogger;
+export type { FastifyLoggerOptions, FastifySerializerOptions, PinoChildOptions, PinoCompatibleLogFn, PinoCompatibleLogger, PinoLevelName, SerializerFn };
+//# sourceMappingURL=fastify.d.mts.map

package/dist/fastify.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify.d.mts","names":[],"sources":["../src/fastify/pino-facade.ts"],"mappings":";KAkCY;KAEA,gBAAgB;;UAGX;GACd,kBAAkB,KAAK,GAAG,iBAAiB;GAC3C,cAAc,iBAAiB;GAC/B,gBAAgB;;UAGF;;EAEf;;EAEA,cAAc,eAAe;;;UAId;EACf,OAAO;EACP,OAAO;EACP,MAAM;EACN,MAAM;EACN,OAAO;EACP,OAAO;;EAEP,QAAQ;;EAER;;WAES;WACA;aACE,QAAQ;aACR,QAAQ;;;WAGV,aAAa,eAAe;;EAErC,eAAe;;EAEf,YAAY;EACZ,MAAM,UAAU,yBAAyB,UAAU,mBAAmB;;UAGvD;;;;;EAKf,cAAc,eAAe;;;;;EAK7B;;;;;;EAMA;;UAGe;EACf;;;;;;;wBAwDc,yBACd,UAAS,2BACR,8BAA8B;;;;;;;;;;;;;;;;;;;wBA0OjB,oBACd,QAAQ,aACR,UAAS,uBACR"}

package/dist/fastify.d.ts

@@ -0,0 +1,89 @@
+import { u as IBaseLogger } from "./index-oqD3WNxf.js";
+type PinoLevelName = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+type SerializerFn = (value: unknown) => unknown;
+/** pino's log function: `(obj, msg?, ...args)` or `(msg, ...args)`. Always returns `void`. */
+interface PinoCompatibleLogFn {
+  <T extends object>(obj: T, msg?: string, ...args: unknown[]): void;
+  (obj: unknown, msg?: string, ...args: unknown[]): void;
+  (msg: string, ...args: unknown[]): void;
+}
+interface PinoChildOptions {
+  /** Level for the child: a pino level name, `silent`, or a logixia level name. */
+  level?: string | undefined;
+  /** Serializers added to (and overriding) the ones the parent already has. */
+  serializers?: Record<string, SerializerFn> | undefined;
+}
+/** The pino surface Fastify and its plugins use. Satisfies `FastifyBaseLogger` without importing it. */
+interface PinoCompatibleLogger {
+  trace: PinoCompatibleLogFn;
+  debug: PinoCompatibleLogFn;
+  info: PinoCompatibleLogFn;
+  warn: PinoCompatibleLogFn;
+  error: PinoCompatibleLogFn;
+  fatal: PinoCompatibleLogFn;
+  /** Accepts the call and writes nothing, like pino's `silent`. */
+  silent: PinoCompatibleLogFn;
+  /** Current level: a pino level name, `silent`, or a logixia-only level such as `verbose`. */
+  level: string;
+  /** Numeric value of the current level (pino scale), `Infinity` when silent. */
+  readonly levelVal: number;
+  readonly levels: {
+    readonly values: Record<string, number>;
+    readonly labels: Record<number, string>;
+  };
+  /** Serializers Fastify merges over its own, so these win for `req`, `res` and `err`. */
+  readonly serializers: Record<string, SerializerFn>;
+  /** True when the configured level would let `level` through. */
+  isLevelEnabled(level: string): boolean;
+  /** The fields bound to this logger by `child()`. */
+  bindings(): Record<string, unknown>;
+  child(bindings: Record<string, unknown>, options?: PinoChildOptions): PinoCompatibleLogger;
+}
+interface FastifyLoggerOptions {
+  /**
+   * Serializers keyed by field name. They replace the defaults for `req`, `res` and
+   * `err` and apply to any other key you add.
+   */
+  serializers?: Record<string, SerializerFn>;
+  /**
+   * Query-string parameter names redacted from the `req` URL, merged with the defaults
+   * (token, access_token, refresh_token, code, password, secret, api_key, ...).
+   */
+  redactQueryParams?: string[];
+  /**
+   * Binding whose value becomes the trace ID of entries logged outside a trace scope.
+   * Default: `'reqId'` (Fastify's `requestIdLogLabel`). Counter IDs such as `req-1`
+   * are never used. Pass `false` to leave trace IDs alone.
+   */
+  traceIdBinding?: string | false;
+}
+interface FastifySerializerOptions {
+  redactQueryParams?: string[];
+}
+/**
+ * pino-std-like `req`, `res` and `err` serializers. `req` reads a Fastify request or a
+ * Node `IncomingMessage` and keeps only method, url (query secrets redacted), hostname,
+ * remote address and port, and the request ID; headers, body and sockets are dropped.
+ */
+export declare function createFastifySerializers(options?: FastifySerializerOptions): Record<'req' | 'res' | 'err', SerializerFn>;
+/**
+ * Wrap a logixia logger so Fastify accepts it as `loggerInstance`.
+ *
+ * - Call shapes: `(obj, msg?, ...args)`, `(msg, ...args)` with `%s %d %i %f %j %o %O`,
+ *   and `(err)` / `(err, msg)`. An `Error` under `err` is logged under `error`, like
+ *   `logger.error(err)` does, with its stack and `cause` chain.
+ * - `fatal` is logged at `error`. `silent` mutes the facade (and children made after).
+ * - `child(bindings)` creates a logixia child that carries the bindings as context data.
+ *   It starts no transports and registers nothing for shutdown, so one per request is cheap.
+ * - Methods return `void`; rejected log calls are caught.
+ * - `req`, `res` and `err` serializers are supplied; Fastify gives them precedence over
+ *   its own. Override or extend them with `options.serializers`.
+ *
+ * @example
+ * ```ts
+ * const app = Fastify({ loggerInstance: createFastifyLogger(logger) });
+ * ```
+ */
+export declare function createFastifyLogger(logger: IBaseLogger, options?: FastifyLoggerOptions): PinoCompatibleLogger;
+export type { FastifyLoggerOptions, FastifySerializerOptions, PinoChildOptions, PinoCompatibleLogFn, PinoCompatibleLogger, PinoLevelName, SerializerFn };
+//# sourceMappingURL=fastify.d.ts.map

package/dist/fastify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify.d.ts","names":[],"sources":["../src/fastify/pino-facade.ts"],"mappings":";KAkCY;KAEA,gBAAgB;;UAGX;GACd,kBAAkB,KAAK,GAAG,iBAAiB;GAC3C,cAAc,iBAAiB;GAC/B,gBAAgB;;UAGF;;EAEf;;EAEA,cAAc,eAAe;;;UAId;EACf,OAAO;EACP,OAAO;EACP,MAAM;EACN,MAAM;EACN,OAAO;EACP,OAAO;;EAEP,QAAQ;;EAER;;WAES;WACA;aACE,QAAQ;aACR,QAAQ;;;WAGV,aAAa,eAAe;;EAErC,eAAe;;EAEf,YAAY;EACZ,MAAM,UAAU,yBAAyB,UAAU,mBAAmB;;UAGvD;;;;;EAKf,cAAc,eAAe;;;;;EAK7B;;;;;;EAMA;;UAGe;EACf;;;;;;;wBAwDc,yBACd,UAAS,2BACR,8BAA8B;;;;;;;;;;;;;;;;;;;wBA0OjB,oBACd,QAAQ,aACR,UAAS,uBACR"}