@logtape/logtape 2.1.0-dev.522 → 2.1.0-dev.531

package/dist/config.cjs

@@ -27,6 +27,21 @@ const asyncDisposables = /* @__PURE__ */ new Set();
 function isLoggerConfigMeta(cfg) {
 	return cfg.category.length === 0 || cfg.category.length === 1 && cfg.category[0] === "logtape" || cfg.category.length === 2 && cfg.category[0] === "logtape" && cfg.category[1] === "meta";
 }
+function registerDisposeHook(allowAsync) {
+	const handler = allowAsync ? dispose : disposeSync;
+	if (typeof globalThis.EdgeRuntime !== "string" && "process" in globalThis && !("Deno" in globalThis)) {
+		const proc = globalThis.process;
+		const onMethod = proc?.["on"];
+		if (typeof onMethod === "function") {
+			onMethod.call(proc, "exit", handler);
+			return;
+		}
+	}
+	const addEventListenerMethod = globalThis.addEventListener;
+	if (typeof addEventListenerMethod !== "function") return;
+	if ("Deno" in globalThis) addEventListenerMethod.call(globalThis, "unload", handler);
+	else addEventListenerMethod.call(globalThis, "pagehide", handler);
+}
 /**
 * Configure the loggers with the specified configuration.
 *
@@ -156,12 +171,7 @@ function configureInternal(config, allowAsync) {
 		else throw new ConfigError("Async disposables cannot be used with configureSync().");
 		if (Symbol.dispose in filter) disposables.add(filter);
 	}
-	if (typeof globalThis.EdgeRuntime !== "string" && "process" in globalThis && !("Deno" in globalThis)) {
-		const proc = globalThis.process;
-		const onMethod = proc?.["on"];
-		if (typeof onMethod === "function") onMethod.call(proc, "exit", allowAsync ? dispose : disposeSync);
-	} else if ("Deno" in globalThis) addEventListener("unload", allowAsync ? dispose : disposeSync);
-	else addEventListener("pagehide", allowAsync ? dispose : disposeSync);
+	registerDisposeHook(allowAsync);
 	const meta = require_logger.LoggerImpl.getLogger(["logtape", "meta"]);
 	if (!metaConfigured) meta.sinks.push(require_sink.getConsoleSink());
 	meta.info("LogTape loggers are configured.  Note that LogTape itself uses the meta logger, which has category {metaLoggerCategory}.  The meta logger is used to log internal diagnostics such as sink exceptions.  It's recommended to configure the meta logger with a separate sink so that you can easily notice if logging itself fails or is misconfigured.  To turn off this message, configure the meta logger with higher log levels than {dismissLevel}.  See also <https://logtape.org/manual/categories#meta-logger>.", {

package/dist/config.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAAuB,UAAN,MAAM,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;;EAUK,KAAE,EALrB,MAKqB,CALd,OAKc,EALL,IAKK,CAAA;EAAU;;;;EAKjB,OAMqB,CAAA,EAXhC,MAWgC,CAXzB,SAWyB,EAXd,UAWc,CAAA;EAAM;AAAP;AAW3C;EAA6B,OAAA,EAjBlB,YAiBkB,CAjBL,OAiBK,EAjBI,SAiBJ,CAAA,EAAA;EAAA;;;AAoCL;EA6EF,mBAAS,CAAA,EA5HP,mBA4HO,CA5Ha,MA4Hb,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAAA;;;EAGI,KAAzB,CAAA,EAAA,OAAA;;AAAoC;AAgD9C;;AACiB,UArKA,YAqKA,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAO;;AAAR;AA8IhB;EAOsB,QAAK,EAAA,MAAA,GAAI,MAAA,EAAO;EAUtB;AAgBhB;AAeA;EAQa,KAAA,CAAA,EA9VH,OA8Ve,EAAA;;;;;;;;;;;;;;YA9Ub;;;;;;gBAOI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6EM,oEAGZ,OAAO,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDvB,wEACN,OAAO,SAAS;;;;;iBA8IV,SAAA,CAAA,GAAa;;;;iBAOP,KAAA,CAAA,GAAS;;;;;;iBAUf,SAAA,CAAA;;;;iBAgBM,OAAA,CAAA,GAAW;;;;;;iBAejB,WAAA,CAAA;;;;cAQH,WAAA,SAAoB,KAAK"}
+{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAAuB,UAAN,MAAM,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;;EAUK,KAAE,EALrB,MAKqB,CALd,OAKc,EALL,IAKK,CAAA;EAAU;;;;EAKjB,OAMqB,CAAA,EAXhC,MAWgC,CAXzB,SAWyB,EAXd,UAWc,CAAA;EAAM;AAAP;AAW3C;EAA6B,OAAA,EAjBlB,YAiBkB,CAjBL,OAiBK,EAjBI,SAiBJ,CAAA,EAAA;EAAA;;;AAoCL;EA6GF,mBAAS,CAAA,EA5JP,mBA4JO,CA5Ja,MA4Jb,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAAA;;;EAGI,KAAzB,CAAA,EAAA,OAAA;;AAAoC;AAgD9C;;AACiB,UArMA,YAqMA,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAO;;AAAR;AAwHhB;EAOsB,QAAK,EAAA,MAAA,GAAI,MAAA,EAAO;EAUtB;AAgBhB;AAeA;EAQa,KAAA,CAAA,EAxWH,OAwWe,EAAA;;;;;;;;;;;;;;YAxVb;;;;;;gBAOI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6GM,oEAGZ,OAAO,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDvB,wEACN,OAAO,SAAS;;;;;iBAwHV,SAAA,CAAA,GAAa;;;;iBAOP,KAAA,CAAA,GAAS;;;;;;iBAUf,SAAA,CAAA;;;;iBAgBM,OAAA,CAAA,GAAW;;;;;;iBAejB,WAAA,CAAA;;;;cAQH,WAAA,SAAoB,KAAK"}

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","names":[],"sources":["../src/config.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAAuB,UAAN,MAAM,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;;EAUK,KAAE,EALrB,MAKqB,CALd,OAKc,EALL,IAKK,CAAA;EAAU;;;;EAKjB,OAMqB,CAAA,EAXhC,MAWgC,CAXzB,SAWyB,EAXd,UAWc,CAAA;EAAM;AAAP;AAW3C;EAA6B,OAAA,EAjBlB,YAiBkB,CAjBL,OAiBK,EAjBI,SAiBJ,CAAA,EAAA;EAAA;;;AAoCL;EA6EF,mBAAS,CAAA,EA5HP,mBA4HO,CA5Ha,MA4Hb,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAAA;;;EAGI,KAAzB,CAAA,EAAA,OAAA;;AAAoC;AAgD9C;;AACiB,UArKA,YAqKA,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAO;;AAAR;AA8IhB;EAOsB,QAAK,EAAA,MAAA,GAAI,MAAA,EAAO;EAUtB;AAgBhB;AAeA;EAQa,KAAA,CAAA,EA9VH,OA8Ve,EAAA;;;;;;;;;;;;;;YA9Ub;;;;;;gBAOI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6EM,oEAGZ,OAAO,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDvB,wEACN,OAAO,SAAS;;;;;iBA8IV,SAAA,CAAA,GAAa;;;;iBAOP,KAAA,CAAA,GAAS;;;;;;iBAUf,SAAA,CAAA;;;;iBAgBM,OAAA,CAAA,GAAW;;;;;;iBAejB,WAAA,CAAA;;;;cAQH,WAAA,SAAoB,KAAK"}
+{"version":3,"file":"config.d.ts","names":[],"sources":["../src/config.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AASA;AAAuB,UAAN,MAAM,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAA;;;;EAUK,KAAE,EALrB,MAKqB,CALd,OAKc,EALL,IAKK,CAAA;EAAU;;;;EAKjB,OAMqB,CAAA,EAXhC,MAWgC,CAXzB,SAWyB,EAXd,UAWc,CAAA;EAAM;AAAP;AAW3C;EAA6B,OAAA,EAjBlB,YAiBkB,CAjBL,OAiBK,EAjBI,SAiBJ,CAAA,EAAA;EAAA;;;AAoCL;EA6GF,mBAAS,CAAA,EA5JP,mBA4JO,CA5Ja,MA4Jb,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAAA;;;EAGI,KAAzB,CAAA,EAAA,OAAA;;AAAoC;AAgD9C;;AACiB,UArMA,YAqMA,CAAA,gBAAA,MAAA,EAAA,kBAAA,MAAA,CAAA,CAAA;EAAO;;AAAR;AAwHhB;EAOsB,QAAK,EAAA,MAAA,GAAI,MAAA,EAAO;EAUtB;AAgBhB;AAeA;EAQa,KAAA,CAAA,EAxWH,OAwWe,EAAA;;;;;;;;;;;;;;YAxVb;;;;;;gBAOI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6GM,oEAGZ,OAAO,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDvB,wEACN,OAAO,SAAS;;;;;iBAwHV,SAAA,CAAA,GAAa;;;;iBAOP,KAAA,CAAA,GAAS;;;;;;iBAUf,SAAA,CAAA;;;;iBAgBM,OAAA,CAAA,GAAW;;;;;;iBAejB,WAAA,CAAA;;;;cAQH,WAAA,SAAoB,KAAK"}

package/dist/config.js

@@ -27,6 +27,21 @@ const asyncDisposables = /* @__PURE__ */ new Set();
 function isLoggerConfigMeta(cfg) {
 	return cfg.category.length === 0 || cfg.category.length === 1 && cfg.category[0] === "logtape" || cfg.category.length === 2 && cfg.category[0] === "logtape" && cfg.category[1] === "meta";
 }
+function registerDisposeHook(allowAsync) {
+	const handler = allowAsync ? dispose : disposeSync;
+	if (typeof globalThis.EdgeRuntime !== "string" && "process" in globalThis && !("Deno" in globalThis)) {
+		const proc = globalThis.process;
+		const onMethod = proc?.["on"];
+		if (typeof onMethod === "function") {
+			onMethod.call(proc, "exit", handler);
+			return;
+		}
+	}
+	const addEventListenerMethod = globalThis.addEventListener;
+	if (typeof addEventListenerMethod !== "function") return;
+	if ("Deno" in globalThis) addEventListenerMethod.call(globalThis, "unload", handler);
+	else addEventListenerMethod.call(globalThis, "pagehide", handler);
+}
 /**
 * Configure the loggers with the specified configuration.
 *
@@ -156,12 +171,7 @@ function configureInternal(config, allowAsync) {
 		else throw new ConfigError("Async disposables cannot be used with configureSync().");
 		if (Symbol.dispose in filter) disposables.add(filter);
 	}
-	if (typeof globalThis.EdgeRuntime !== "string" && "process" in globalThis && !("Deno" in globalThis)) {
-		const proc = globalThis.process;
-		const onMethod = proc?.["on"];
-		if (typeof onMethod === "function") onMethod.call(proc, "exit", allowAsync ? dispose : disposeSync);
-	} else if ("Deno" in globalThis) addEventListener("unload", allowAsync ? dispose : disposeSync);
-	else addEventListener("pagehide", allowAsync ? dispose : disposeSync);
+	registerDisposeHook(allowAsync);
 	const meta = LoggerImpl.getLogger(["logtape", "meta"]);
 	if (!metaConfigured) meta.sinks.push(getConsoleSink());
 	meta.info("LogTape loggers are configured.  Note that LogTape itself uses the meta logger, which has category {metaLoggerCategory}.  The meta logger is used to log internal diagnostics such as sink exceptions.  It's recommended to configure the meta logger with a separate sink so that you can easily notice if logging itself fails or is misconfigured.  To turn off this message, configure the meta logger with higher log levels than {dismissLevel}.  See also <https://logtape.org/manual/categories#meta-logger>.", {

package/dist/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","names":["currentConfig: Config<string, string> | null","strongRefs: Set<LoggerImpl>","disposables: Set<Disposable>","asyncDisposables: Set<AsyncDisposable>","cfg: LoggerConfig<TSinkId, TFilterId>","config: Config<TSinkId, TFilterId>","allowAsync: boolean","promises: PromiseLike<void>[]","message: string"],"sources":["../src/config.ts"],"sourcesContent":["import type { ContextLocalStorage } from \"./context.ts\";\nimport { type FilterLike, toFilter } from \"./filter.ts\";\nimport type { LogLevel } from \"./level.ts\";\nimport { LoggerImpl } from \"./logger.ts\";\nimport { getConsoleSink, type Sink } from \"./sink.ts\";\n\n/**\n * A configuration for the loggers.\n */\nexport interface Config<TSinkId extends string, TFilterId extends string> {\n  /**\n   * The sinks to use.  The keys are the sink identifiers, and the values are\n   * {@link Sink}s.\n   */\n  sinks: Record<TSinkId, Sink>;\n  /**\n   * The filters to use.  The keys are the filter identifiers, and the values\n   * are either {@link Filter}s or {@link LogLevel}s.\n   */\n  filters?: Record<TFilterId, FilterLike>;\n\n  /**\n   * The loggers to configure.\n   */\n  loggers: LoggerConfig<TSinkId, TFilterId>[];\n\n  /**\n   * The context-local storage to use for implicit contexts.\n   * @since 0.7.0\n   */\n  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;\n\n  /**\n   * Whether to reset the configuration before applying this one.\n   */\n  reset?: boolean;\n}\n\n/**\n * A logger configuration.\n */\nexport interface LoggerConfig<\n  TSinkId extends string,\n  TFilterId extends string,\n> {\n  /**\n   * The category of the logger.  If a string, it is equivalent to an array\n   * with one element.\n   */\n  category: string | string[];\n\n  /**\n   * The sink identifiers to use.\n   */\n  sinks?: TSinkId[];\n\n  /**\n   * Whether to inherit the parent's sinks.  If `inherit`, the parent's sinks\n   * are used along with the specified sinks.  If `override`, the parent's\n   * sinks are not used, and only the specified sinks are used.\n   *\n   * The default is `inherit`.\n   * @default `\"inherit\"\n   * @since 0.6.0\n   */\n  parentSinks?: \"inherit\" | \"override\";\n\n  /**\n   * The filter identifiers to use.\n   */\n  filters?: TFilterId[];\n\n  /**\n   * The lowest log level to accept.  If `null`, the logger will reject all\n   * records.\n   * @since 0.8.0\n   */\n  lowestLevel?: LogLevel | null;\n}\n\n/**\n * The current configuration, if any.  Otherwise, `null`.\n */\nlet currentConfig: Config<string, string> | null = null;\n\n/**\n * Strong references to the loggers.\n * This is to prevent the loggers from being garbage collected so that their\n * sinks and filters are not removed.\n */\nconst strongRefs: Set<LoggerImpl> = new Set();\n\n/**\n * Disposables to dispose when resetting the configuration.\n */\nconst disposables: Set<Disposable> = new Set();\n\n/**\n * Async disposables to dispose when resetting the configuration.\n */\nconst asyncDisposables: Set<AsyncDisposable> = new Set();\n\n/**\n * Check if a config is for the meta logger.\n */\nfunction isLoggerConfigMeta<TSinkId extends string, TFilterId extends string>(\n  cfg: LoggerConfig<TSinkId, TFilterId>,\n): boolean {\n  return cfg.category.length === 0 ||\n    (cfg.category.length === 1 && cfg.category[0] === \"logtape\") ||\n    (cfg.category.length === 2 &&\n      cfg.category[0] === \"logtape\" &&\n      cfg.category[1] === \"meta\");\n}\n\n/**\n * Configure the loggers with the specified configuration.\n *\n * Note that if the given sinks or filters are disposable, they will be\n * disposed when the configuration is reset, or when the process exits.\n *\n * @example\n * ```typescript\n * await configure({\n *   sinks: {\n *     console: getConsoleSink(),\n *   },\n *   filters: {\n *     slow: (log) =>\n *       \"duration\" in log.properties &&\n *       log.properties.duration as number > 1000,\n *   },\n *   loggers: [\n *     {\n *       category: \"my-app\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"info\",\n *     },\n *     {\n *       category: [\"my-app\", \"sql\"],\n *       filters: [\"slow\"],\n *       lowestLevel: \"debug\",\n *     },\n *     {\n *       category: \"logtape\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"error\",\n *     },\n *   ],\n * });\n * ```\n *\n * @param config The configuration.\n */\nexport async function configure<\n  TSinkId extends string,\n  TFilterId extends string,\n>(config: Config<TSinkId, TFilterId>): Promise<void> {\n  if (currentConfig != null && !config.reset) {\n    throw new ConfigError(\n      \"Already configured; if you want to reset, turn on the reset flag.\",\n    );\n  }\n  await reset();\n  try {\n    configureInternal(config, true);\n  } catch (e) {\n    if (e instanceof ConfigError) await reset();\n    throw e;\n  }\n}\n\n/**\n * Configure sync loggers with the specified configuration.\n *\n * Note that if the given sinks or filters are disposable, they will be\n * disposed when the configuration is reset, or when the process exits.\n *\n * Also note that passing async sinks or filters will throw. If\n * necessary use {@link resetSync} or {@link disposeSync}.\n *\n * @example\n * ```typescript\n * configureSync({\n *   sinks: {\n *     console: getConsoleSink(),\n *   },\n *   loggers: [\n *     {\n *       category: \"my-app\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"info\",\n *     },\n *     {\n *       category: \"logtape\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"error\",\n *     },\n *   ],\n * });\n * ```\n *\n * @param config The configuration.\n * @since 0.9.0\n */\nexport function configureSync<TSinkId extends string, TFilterId extends string>(\n  config: Config<TSinkId, TFilterId>,\n): void {\n  if (currentConfig != null && !config.reset) {\n    throw new ConfigError(\n      \"Already configured; if you want to reset, turn on the reset flag.\",\n    );\n  }\n  if (asyncDisposables.size > 0) {\n    throw new ConfigError(\n      \"Previously configured async disposables are still active. \" +\n        \"Use configure() instead or explicitly dispose them using dispose().\",\n    );\n  }\n  resetSync();\n  try {\n    configureInternal(config, false);\n  } catch (e) {\n    if (e instanceof ConfigError) resetSync();\n    throw e;\n  }\n}\n\nfunction configureInternal<\n  TSinkId extends string,\n  TFilterId extends string,\n>(config: Config<TSinkId, TFilterId>, allowAsync: boolean): void {\n  currentConfig = config;\n\n  let metaConfigured = false;\n  const configuredCategories = new Set<string>();\n\n  for (const cfg of config.loggers) {\n    if (isLoggerConfigMeta(cfg)) {\n      metaConfigured = true;\n    }\n\n    // Check for duplicate logger categories\n    const categoryKey = Array.isArray(cfg.category)\n      ? JSON.stringify(cfg.category)\n      : JSON.stringify([cfg.category]);\n    if (configuredCategories.has(categoryKey)) {\n      throw new ConfigError(\n        `Duplicate logger configuration for category: ${categoryKey}. ` +\n          `Each category can only be configured once.`,\n      );\n    }\n    configuredCategories.add(categoryKey);\n\n    const logger = LoggerImpl.getLogger(cfg.category);\n    for (const sinkId of cfg.sinks ?? []) {\n      const sink = config.sinks[sinkId];\n      if (!sink) {\n        throw new ConfigError(`Sink not found: ${sinkId}.`);\n      }\n      logger.sinks.push(sink);\n    }\n    logger.parentSinks = cfg.parentSinks ?? \"inherit\";\n    if (cfg.lowestLevel !== undefined) {\n      logger.lowestLevel = cfg.lowestLevel;\n    }\n    for (const filterId of cfg.filters ?? []) {\n      const filter = config.filters?.[filterId];\n      if (filter === undefined) {\n        throw new ConfigError(`Filter not found: ${filterId}.`);\n      }\n      logger.filters.push(toFilter(filter));\n    }\n    strongRefs.add(logger);\n  }\n\n  LoggerImpl.getLogger().contextLocalStorage = config.contextLocalStorage;\n\n  for (const sink of Object.values<Sink>(config.sinks)) {\n    if (Symbol.asyncDispose in sink) {\n      if (allowAsync) asyncDisposables.add(sink as AsyncDisposable);\n      else {\n        throw new ConfigError(\n          \"Async disposables cannot be used with configureSync().\",\n        );\n      }\n    }\n    if (Symbol.dispose in sink) disposables.add(sink as Disposable);\n  }\n\n  for (const filter of Object.values<FilterLike>(config.filters ?? {})) {\n    if (filter == null || typeof filter === \"string\") continue;\n    if (Symbol.asyncDispose in filter) {\n      if (allowAsync) asyncDisposables.add(filter as AsyncDisposable);\n      else {\n        throw new ConfigError(\n          \"Async disposables cannot be used with configureSync().\",\n        );\n      }\n    }\n    if (Symbol.dispose in filter) disposables.add(filter as Disposable);\n  }\n\n  if (\n    // deno-lint-ignore no-explicit-any\n    typeof (globalThis as any).EdgeRuntime !== \"string\" &&\n    \"process\" in globalThis &&\n    !(\"Deno\" in globalThis)\n  ) {\n    // deno-lint-ignore no-explicit-any\n    const proc = (globalThis as any).process;\n    // Use bracket notation to avoid static analysis detection in Edge Runtime\n    const onMethod = proc?.[\"on\"];\n    if (typeof onMethod === \"function\") {\n      onMethod.call(proc, \"exit\", allowAsync ? dispose : disposeSync);\n    }\n  } else {\n    // Deno: use unload (pagehide is not supported)\n    if (\"Deno\" in globalThis) {\n      // @ts-ignore: unload event exists in Deno\n      addEventListener(\"unload\", allowAsync ? dispose : disposeSync);\n    } else {\n      // Browser: use pagehide (bfcache-compatible, doesn't block back/forward cache)\n      addEventListener(\"pagehide\", allowAsync ? dispose : disposeSync);\n    }\n  }\n  const meta = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n  if (!metaConfigured) {\n    meta.sinks.push(getConsoleSink());\n  }\n\n  meta.info(\n    \"LogTape loggers are configured.  Note that LogTape itself uses the meta \" +\n      \"logger, which has category {metaLoggerCategory}.  The meta logger is \" +\n      \"used to log internal diagnostics such as sink exceptions.  \" +\n      \"It's recommended to configure the meta logger with a separate sink \" +\n      \"so that you can easily notice if logging itself fails or is \" +\n      \"misconfigured.  To turn off this message, configure the meta logger \" +\n      \"with higher log levels than {dismissLevel}.  See also \" +\n      \"<https://logtape.org/manual/categories#meta-logger>.\",\n    { metaLoggerCategory: [\"logtape\", \"meta\"], dismissLevel: \"info\" },\n  );\n}\n\n/**\n * Get the current configuration, if any.  Otherwise, `null`.\n * @returns The current configuration, if any.  Otherwise, `null`.\n */\nexport function getConfig(): Config<string, string> | null {\n  return currentConfig;\n}\n\n/**\n * Reset the configuration.  Mostly for testing purposes.\n */\nexport async function reset(): Promise<void> {\n  await dispose();\n  resetInternal();\n}\n\n/**\n * Reset the configuration.  Mostly for testing purposes. Will not clear async\n * sinks, only use with sync sinks. Use {@link reset} if you have async sinks.\n * @since 0.9.0\n */\nexport function resetSync(): void {\n  disposeSync();\n  resetInternal();\n}\n\nfunction resetInternal(): void {\n  const rootLogger = LoggerImpl.getLogger([]);\n  rootLogger.resetDescendants();\n  delete rootLogger.contextLocalStorage;\n  strongRefs.clear();\n  currentConfig = null;\n}\n\n/**\n * Dispose of the disposables.\n */\nexport async function dispose(): Promise<void> {\n  disposeSync();\n  const promises: PromiseLike<void>[] = [];\n  for (const disposable of asyncDisposables) {\n    promises.push(disposable[Symbol.asyncDispose]());\n    asyncDisposables.delete(disposable);\n  }\n  await Promise.all(promises);\n}\n\n/**\n * Dispose of the sync disposables. Async disposables will be untouched,\n * use {@link dispose} if you have async sinks.\n * @since 0.9.0\n */\nexport function disposeSync(): void {\n  for (const disposable of disposables) disposable[Symbol.dispose]();\n  disposables.clear();\n}\n\n/**\n * A configuration error.\n */\nexport class ConfigError extends Error {\n  /**\n   * Constructs a new configuration error.\n   * @param message The error message.\n   */\n  constructor(message: string) {\n    super(message);\n    this.name = \"ConfigureError\";\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"config.js","names":["currentConfig: Config<string, string> | null","strongRefs: Set<LoggerImpl>","disposables: Set<Disposable>","asyncDisposables: Set<AsyncDisposable>","cfg: LoggerConfig<TSinkId, TFilterId>","allowAsync: boolean","config: Config<TSinkId, TFilterId>","promises: PromiseLike<void>[]","message: string"],"sources":["../src/config.ts"],"sourcesContent":["import type { ContextLocalStorage } from \"./context.ts\";\nimport { type FilterLike, toFilter } from \"./filter.ts\";\nimport type { LogLevel } from \"./level.ts\";\nimport { LoggerImpl } from \"./logger.ts\";\nimport { getConsoleSink, type Sink } from \"./sink.ts\";\n\n/**\n * A configuration for the loggers.\n */\nexport interface Config<TSinkId extends string, TFilterId extends string> {\n  /**\n   * The sinks to use.  The keys are the sink identifiers, and the values are\n   * {@link Sink}s.\n   */\n  sinks: Record<TSinkId, Sink>;\n  /**\n   * The filters to use.  The keys are the filter identifiers, and the values\n   * are either {@link Filter}s or {@link LogLevel}s.\n   */\n  filters?: Record<TFilterId, FilterLike>;\n\n  /**\n   * The loggers to configure.\n   */\n  loggers: LoggerConfig<TSinkId, TFilterId>[];\n\n  /**\n   * The context-local storage to use for implicit contexts.\n   * @since 0.7.0\n   */\n  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;\n\n  /**\n   * Whether to reset the configuration before applying this one.\n   */\n  reset?: boolean;\n}\n\n/**\n * A logger configuration.\n */\nexport interface LoggerConfig<\n  TSinkId extends string,\n  TFilterId extends string,\n> {\n  /**\n   * The category of the logger.  If a string, it is equivalent to an array\n   * with one element.\n   */\n  category: string | string[];\n\n  /**\n   * The sink identifiers to use.\n   */\n  sinks?: TSinkId[];\n\n  /**\n   * Whether to inherit the parent's sinks.  If `inherit`, the parent's sinks\n   * are used along with the specified sinks.  If `override`, the parent's\n   * sinks are not used, and only the specified sinks are used.\n   *\n   * The default is `inherit`.\n   * @default `\"inherit\"\n   * @since 0.6.0\n   */\n  parentSinks?: \"inherit\" | \"override\";\n\n  /**\n   * The filter identifiers to use.\n   */\n  filters?: TFilterId[];\n\n  /**\n   * The lowest log level to accept.  If `null`, the logger will reject all\n   * records.\n   * @since 0.8.0\n   */\n  lowestLevel?: LogLevel | null;\n}\n\n/**\n * The current configuration, if any.  Otherwise, `null`.\n */\nlet currentConfig: Config<string, string> | null = null;\n\n/**\n * Strong references to the loggers.\n * This is to prevent the loggers from being garbage collected so that their\n * sinks and filters are not removed.\n */\nconst strongRefs: Set<LoggerImpl> = new Set();\n\n/**\n * Disposables to dispose when resetting the configuration.\n */\nconst disposables: Set<Disposable> = new Set();\n\n/**\n * Async disposables to dispose when resetting the configuration.\n */\nconst asyncDisposables: Set<AsyncDisposable> = new Set();\n\n/**\n * Check if a config is for the meta logger.\n */\nfunction isLoggerConfigMeta<TSinkId extends string, TFilterId extends string>(\n  cfg: LoggerConfig<TSinkId, TFilterId>,\n): boolean {\n  return cfg.category.length === 0 ||\n    (cfg.category.length === 1 && cfg.category[0] === \"logtape\") ||\n    (cfg.category.length === 2 &&\n      cfg.category[0] === \"logtape\" &&\n      cfg.category[1] === \"meta\");\n}\n\nfunction registerDisposeHook(allowAsync: boolean): void {\n  const handler = allowAsync ? dispose : disposeSync;\n\n  if (\n    // deno-lint-ignore no-explicit-any\n    typeof (globalThis as any).EdgeRuntime !== \"string\" &&\n    \"process\" in globalThis &&\n    !(\"Deno\" in globalThis)\n  ) {\n    // deno-lint-ignore no-explicit-any\n    const proc = (globalThis as any).process;\n    // Use bracket notation to avoid static analysis detection in Edge Runtime.\n    const onMethod = proc?.[\"on\"];\n    if (typeof onMethod === \"function\") {\n      onMethod.call(proc, \"exit\", handler);\n      return;\n    }\n  }\n\n  // Some edge runtimes expose neither process.on() nor addEventListener().\n  // In those environments users can still call dispose()/disposeSync() manually.\n  // deno-lint-ignore no-explicit-any\n  const addEventListenerMethod = (globalThis as any).addEventListener;\n  if (typeof addEventListenerMethod !== \"function\") return;\n\n  if (\"Deno\" in globalThis) {\n    addEventListenerMethod.call(globalThis, \"unload\", handler);\n  } else {\n    addEventListenerMethod.call(globalThis, \"pagehide\", handler);\n  }\n}\n\n/**\n * Configure the loggers with the specified configuration.\n *\n * Note that if the given sinks or filters are disposable, they will be\n * disposed when the configuration is reset, or when the process exits.\n *\n * @example\n * ```typescript\n * await configure({\n *   sinks: {\n *     console: getConsoleSink(),\n *   },\n *   filters: {\n *     slow: (log) =>\n *       \"duration\" in log.properties &&\n *       log.properties.duration as number > 1000,\n *   },\n *   loggers: [\n *     {\n *       category: \"my-app\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"info\",\n *     },\n *     {\n *       category: [\"my-app\", \"sql\"],\n *       filters: [\"slow\"],\n *       lowestLevel: \"debug\",\n *     },\n *     {\n *       category: \"logtape\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"error\",\n *     },\n *   ],\n * });\n * ```\n *\n * @param config The configuration.\n */\nexport async function configure<\n  TSinkId extends string,\n  TFilterId extends string,\n>(config: Config<TSinkId, TFilterId>): Promise<void> {\n  if (currentConfig != null && !config.reset) {\n    throw new ConfigError(\n      \"Already configured; if you want to reset, turn on the reset flag.\",\n    );\n  }\n  await reset();\n  try {\n    configureInternal(config, true);\n  } catch (e) {\n    if (e instanceof ConfigError) await reset();\n    throw e;\n  }\n}\n\n/**\n * Configure sync loggers with the specified configuration.\n *\n * Note that if the given sinks or filters are disposable, they will be\n * disposed when the configuration is reset, or when the process exits.\n *\n * Also note that passing async sinks or filters will throw. If\n * necessary use {@link resetSync} or {@link disposeSync}.\n *\n * @example\n * ```typescript\n * configureSync({\n *   sinks: {\n *     console: getConsoleSink(),\n *   },\n *   loggers: [\n *     {\n *       category: \"my-app\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"info\",\n *     },\n *     {\n *       category: \"logtape\",\n *       sinks: [\"console\"],\n *       lowestLevel: \"error\",\n *     },\n *   ],\n * });\n * ```\n *\n * @param config The configuration.\n * @since 0.9.0\n */\nexport function configureSync<TSinkId extends string, TFilterId extends string>(\n  config: Config<TSinkId, TFilterId>,\n): void {\n  if (currentConfig != null && !config.reset) {\n    throw new ConfigError(\n      \"Already configured; if you want to reset, turn on the reset flag.\",\n    );\n  }\n  if (asyncDisposables.size > 0) {\n    throw new ConfigError(\n      \"Previously configured async disposables are still active. \" +\n        \"Use configure() instead or explicitly dispose them using dispose().\",\n    );\n  }\n  resetSync();\n  try {\n    configureInternal(config, false);\n  } catch (e) {\n    if (e instanceof ConfigError) resetSync();\n    throw e;\n  }\n}\n\nfunction configureInternal<\n  TSinkId extends string,\n  TFilterId extends string,\n>(config: Config<TSinkId, TFilterId>, allowAsync: boolean): void {\n  currentConfig = config;\n\n  let metaConfigured = false;\n  const configuredCategories = new Set<string>();\n\n  for (const cfg of config.loggers) {\n    if (isLoggerConfigMeta(cfg)) {\n      metaConfigured = true;\n    }\n\n    // Check for duplicate logger categories\n    const categoryKey = Array.isArray(cfg.category)\n      ? JSON.stringify(cfg.category)\n      : JSON.stringify([cfg.category]);\n    if (configuredCategories.has(categoryKey)) {\n      throw new ConfigError(\n        `Duplicate logger configuration for category: ${categoryKey}. ` +\n          `Each category can only be configured once.`,\n      );\n    }\n    configuredCategories.add(categoryKey);\n\n    const logger = LoggerImpl.getLogger(cfg.category);\n    for (const sinkId of cfg.sinks ?? []) {\n      const sink = config.sinks[sinkId];\n      if (!sink) {\n        throw new ConfigError(`Sink not found: ${sinkId}.`);\n      }\n      logger.sinks.push(sink);\n    }\n    logger.parentSinks = cfg.parentSinks ?? \"inherit\";\n    if (cfg.lowestLevel !== undefined) {\n      logger.lowestLevel = cfg.lowestLevel;\n    }\n    for (const filterId of cfg.filters ?? []) {\n      const filter = config.filters?.[filterId];\n      if (filter === undefined) {\n        throw new ConfigError(`Filter not found: ${filterId}.`);\n      }\n      logger.filters.push(toFilter(filter));\n    }\n    strongRefs.add(logger);\n  }\n\n  LoggerImpl.getLogger().contextLocalStorage = config.contextLocalStorage;\n\n  for (const sink of Object.values<Sink>(config.sinks)) {\n    if (Symbol.asyncDispose in sink) {\n      if (allowAsync) asyncDisposables.add(sink as AsyncDisposable);\n      else {\n        throw new ConfigError(\n          \"Async disposables cannot be used with configureSync().\",\n        );\n      }\n    }\n    if (Symbol.dispose in sink) disposables.add(sink as Disposable);\n  }\n\n  for (const filter of Object.values<FilterLike>(config.filters ?? {})) {\n    if (filter == null || typeof filter === \"string\") continue;\n    if (Symbol.asyncDispose in filter) {\n      if (allowAsync) asyncDisposables.add(filter as AsyncDisposable);\n      else {\n        throw new ConfigError(\n          \"Async disposables cannot be used with configureSync().\",\n        );\n      }\n    }\n    if (Symbol.dispose in filter) disposables.add(filter as Disposable);\n  }\n\n  registerDisposeHook(allowAsync);\n  const meta = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n  if (!metaConfigured) {\n    meta.sinks.push(getConsoleSink());\n  }\n\n  meta.info(\n    \"LogTape loggers are configured.  Note that LogTape itself uses the meta \" +\n      \"logger, which has category {metaLoggerCategory}.  The meta logger is \" +\n      \"used to log internal diagnostics such as sink exceptions.  \" +\n      \"It's recommended to configure the meta logger with a separate sink \" +\n      \"so that you can easily notice if logging itself fails or is \" +\n      \"misconfigured.  To turn off this message, configure the meta logger \" +\n      \"with higher log levels than {dismissLevel}.  See also \" +\n      \"<https://logtape.org/manual/categories#meta-logger>.\",\n    { metaLoggerCategory: [\"logtape\", \"meta\"], dismissLevel: \"info\" },\n  );\n}\n\n/**\n * Get the current configuration, if any.  Otherwise, `null`.\n * @returns The current configuration, if any.  Otherwise, `null`.\n */\nexport function getConfig(): Config<string, string> | null {\n  return currentConfig;\n}\n\n/**\n * Reset the configuration.  Mostly for testing purposes.\n */\nexport async function reset(): Promise<void> {\n  await dispose();\n  resetInternal();\n}\n\n/**\n * Reset the configuration.  Mostly for testing purposes. Will not clear async\n * sinks, only use with sync sinks. Use {@link reset} if you have async sinks.\n * @since 0.9.0\n */\nexport function resetSync(): void {\n  disposeSync();\n  resetInternal();\n}\n\nfunction resetInternal(): void {\n  const rootLogger = LoggerImpl.getLogger([]);\n  rootLogger.resetDescendants();\n  delete rootLogger.contextLocalStorage;\n  strongRefs.clear();\n  currentConfig = null;\n}\n\n/**\n * Dispose of the disposables.\n */\nexport async function dispose(): Promise<void> {\n  disposeSync();\n  const promises: PromiseLike<void>[] = [];\n  for (const disposable of asyncDisposables) {\n    promises.push(disposable[Symbol.asyncDispose]());\n    asyncDisposables.delete(disposable);\n  }\n  await Promise.all(promises);\n}\n\n/**\n * Dispose of the sync disposables. Async disposables will be untouched,\n * use {@link dispose} if you have async sinks.\n * @since 0.9.0\n */\nexport function disposeSync(): void {\n  for (const disposable of disposables) disposable[Symbol.dispose]();\n  disposables.clear();\n}\n\n/**\n * A configuration error.\n */\nexport class ConfigError extends Error {\n  /**\n   * Constructs a new configuration error.\n   * @param message The error message.\n   */\n  constructor(message: string) {\n    super(message);\n    this.name = \"ConfigureError\";\n  }\n}\n"],"mappings":"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"}

package/dist/logger.cjs

@@ -93,6 +93,9 @@ function getLogger(category = []) {
 * The symbol for the global root logger.
 */
 const globalRootLoggerSymbol = Symbol.for("logtape.rootLogger");
+function isMetaLoggerCategory(category) {
+	return category.length === 2 && category[0] === "logtape" && category[1] === "meta";
+}
 /**
 * A logger implementation.  Do not use this directly; use {@link getLogger}
 * instead.  This class is exported for testing purposes.
@@ -116,6 +119,16 @@ var LoggerImpl = class LoggerImpl {
 		if (category.length === 0) return rootLogger;
 		return rootLogger.getChild(category);
 	}
+	static getNearestExistingLogger(category) {
+		let logger = LoggerImpl.getLogger();
+		for (const name of category) {
+			const childRef = logger.children[name];
+			const child = childRef instanceof LoggerImpl ? childRef : childRef?.deref();
+			if (child == null) break;
+			logger = child;
+		}
+		return logger;
+	}
 	constructor(parent, category) {
 		this.parent = parent;
 		this.children = {};
@@ -168,13 +181,18 @@ var LoggerImpl = class LoggerImpl {
 		for (const sink of this.sinks) yield sink;
 	}
 	isEnabledFor(level) {
+		const categoryPrefix = isMetaLoggerCategory(this.category) ? [] : require_context.getCategoryPrefix();
+		const dispatcher = categoryPrefix.length > 0 ? LoggerImpl.getNearestExistingLogger([...categoryPrefix, ...this.category]) : this;
+		return dispatcher.isEnabledForResolved(level);
+	}
+	isEnabledForResolved(level) {
 		if (this.lowestLevel === null || require_level.compareLogLevel(level, this.lowestLevel) < 0) return false;
 		for (const _ of this.getSinks(level)) return true;
 		return false;
 	}
 	emit(record, bypassSinks) {
-		const categoryPrefix = require_context.getCategoryPrefix();
 		const baseCategory = "category" in record ? record.category : this.category;
+		const categoryPrefix = isMetaLoggerCategory(baseCategory) ? [] : require_context.getCategoryPrefix();
 		const fullCategory = categoryPrefix.length > 0 ? [...categoryPrefix, ...baseCategory] : baseCategory;
 		const descriptors = Object.getOwnPropertyDescriptors(record);
 		descriptors.category = {
@@ -183,18 +201,22 @@ var LoggerImpl = class LoggerImpl {
 			configurable: true
 		};
 		const fullRecord = Object.defineProperties({}, descriptors);
-		if (this.lowestLevel === null || require_level.compareLogLevel(fullRecord.level, this.lowestLevel) < 0 || !this.filter(fullRecord)) return;
-		for (const sink of this.getSinks(fullRecord.level)) {
+		const dispatcher = categoryPrefix.length > 0 ? LoggerImpl.getNearestExistingLogger(fullCategory) : this;
+		dispatcher.emitResolved(fullRecord, bypassSinks);
+	}
+	emitResolved(record, bypassSinks) {
+		if (this.lowestLevel === null || require_level.compareLogLevel(record.level, this.lowestLevel) < 0 || !this.filter(record)) return;
+		for (const sink of this.getSinks(record.level)) {
 			if (bypassSinks?.has(sink)) continue;
 			try {
-				sink(fullRecord);
+				sink(record);
 			} catch (error) {
 				const bypassSinks2 = new Set(bypassSinks);
 				bypassSinks2.add(sink);
 				metaLogger.log("fatal", "Failed to emit a log record to sink {sink}: {error}", {
 					sink,
 					error,
-					record: fullRecord
+					record
 				}, bypassSinks2);
 			}
 		}

package/dist/logger.js

@@ -93,6 +93,9 @@ function getLogger(category = []) {
 * The symbol for the global root logger.
 */
 const globalRootLoggerSymbol = Symbol.for("logtape.rootLogger");
+function isMetaLoggerCategory(category) {
+	return category.length === 2 && category[0] === "logtape" && category[1] === "meta";
+}
 /**
 * A logger implementation.  Do not use this directly; use {@link getLogger}
 * instead.  This class is exported for testing purposes.
@@ -116,6 +119,16 @@ var LoggerImpl = class LoggerImpl {
 		if (category.length === 0) return rootLogger;
 		return rootLogger.getChild(category);
 	}
+	static getNearestExistingLogger(category) {
+		let logger = LoggerImpl.getLogger();
+		for (const name of category) {
+			const childRef = logger.children[name];
+			const child = childRef instanceof LoggerImpl ? childRef : childRef?.deref();
+			if (child == null) break;
+			logger = child;
+		}
+		return logger;
+	}
 	constructor(parent, category) {
 		this.parent = parent;
 		this.children = {};
@@ -168,13 +181,18 @@ var LoggerImpl = class LoggerImpl {
 		for (const sink of this.sinks) yield sink;
 	}
 	isEnabledFor(level) {
+		const categoryPrefix = isMetaLoggerCategory(this.category) ? [] : getCategoryPrefix();
+		const dispatcher = categoryPrefix.length > 0 ? LoggerImpl.getNearestExistingLogger([...categoryPrefix, ...this.category]) : this;
+		return dispatcher.isEnabledForResolved(level);
+	}
+	isEnabledForResolved(level) {
 		if (this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0) return false;
 		for (const _ of this.getSinks(level)) return true;
 		return false;
 	}
 	emit(record, bypassSinks) {
-		const categoryPrefix = getCategoryPrefix();
 		const baseCategory = "category" in record ? record.category : this.category;
+		const categoryPrefix = isMetaLoggerCategory(baseCategory) ? [] : getCategoryPrefix();
 		const fullCategory = categoryPrefix.length > 0 ? [...categoryPrefix, ...baseCategory] : baseCategory;
 		const descriptors = Object.getOwnPropertyDescriptors(record);
 		descriptors.category = {
@@ -183,18 +201,22 @@ var LoggerImpl = class LoggerImpl {
 			configurable: true
 		};
 		const fullRecord = Object.defineProperties({}, descriptors);
-		if (this.lowestLevel === null || compareLogLevel(fullRecord.level, this.lowestLevel) < 0 || !this.filter(fullRecord)) return;
-		for (const sink of this.getSinks(fullRecord.level)) {
+		const dispatcher = categoryPrefix.length > 0 ? LoggerImpl.getNearestExistingLogger(fullCategory) : this;
+		dispatcher.emitResolved(fullRecord, bypassSinks);
+	}
+	emitResolved(record, bypassSinks) {
+		if (this.lowestLevel === null || compareLogLevel(record.level, this.lowestLevel) < 0 || !this.filter(record)) return;
+		for (const sink of this.getSinks(record.level)) {
 			if (bypassSinks?.has(sink)) continue;
 			try {
-				sink(fullRecord);
+				sink(record);
 			} catch (error) {
 				const bypassSinks2 = new Set(bypassSinks);
 				bypassSinks2.add(sink);
 				metaLogger.log("fatal", "Failed to emit a log record to sink {sink}: {error}", {
 					sink,
 					error,
-					record: fullRecord
+					record
 				}, bypassSinks2);
 			}
 		}

package/dist/logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"logger.js","names":["lazySymbol: unique symbol","value: unknown","getter: () => T","properties: Record<string, unknown>","resolved: Record<string, unknown>","logger: StringMessageLogger","level: LogLevel","message: string","props?: unknown","category: string | readonly string[]","rootLogger: LoggerImpl | null","parent: LoggerImpl | null","category: readonly string[]","subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])]","child: LoggerImpl | undefined","record: LogRecord","record: Omit<LogRecord, \"category\"> | LogRecord","bypassSinks?: Set<Sink>","rawMessage: string","properties: Record<string, unknown> | (() => Record<string, unknown>)","cachedProps: Record<string, unknown> | undefined","callback: LogCallback","rawMessage: TemplateStringsArray | undefined","msg: unknown[] | undefined","messageTemplate: TemplateStringsArray","values: unknown[]","message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>","level: \"warning\" | \"error\" | \"fatal\"","error: Error","message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error","logger: LoggerImpl","subcategory: string | readonly [string] | readonly [string, ...string[]]","record: Omit<LogRecord, \"category\">","key: string","obj: unknown","path: string","fromIndex: number","segment: string | number","current: unknown","template: string","message: unknown[]","prop: unknown","template: TemplateStringsArray","values: readonly unknown[]"],"sources":["../src/logger.ts"],"sourcesContent":["import {\n  type ContextLocalStorage,\n  getCategoryPrefix,\n  getImplicitContext,\n} from \"./context.ts\";\nimport type { Filter } from \"./filter.ts\";\nimport { compareLogLevel, type LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\nimport type { Sink } from \"./sink.ts\";\n\n/**\n * Symbol to identify lazy values.\n */\nconst lazySymbol: unique symbol = Symbol.for(\"logtape.lazy\");\n\n/**\n * A lazy value that is evaluated at logging time.\n *\n * @typeParam T The type of the value.\n * @since 2.0.0\n */\nexport interface Lazy<T> {\n  readonly [lazySymbol]: true;\n  readonly getter: () => T;\n}\n\n/**\n * Checks if a value is a lazy value.\n *\n * @param value The value to check.\n * @returns `true` if the value is a lazy value, `false` otherwise.\n * @since 2.0.0\n */\nexport function isLazy(value: unknown): value is Lazy<unknown> {\n  return value != null &&\n    typeof value === \"object\" &&\n    lazySymbol in value &&\n    (value as Lazy<unknown>)[lazySymbol] === true;\n}\n\n/**\n * Creates a lazy value that is evaluated at logging time.\n *\n * This is useful for logging contextual properties that may change over time,\n * such as the current user or request context.\n *\n * @example\n * ```typescript\n * let currentUser: string | null = null;\n * const logger = getLogger(\"app\").with({ user: lazy(() => currentUser) });\n *\n * logger.info(\"User action\");  // logs with user: null\n * currentUser = \"alice\";\n * logger.info(\"User action\");  // logs with user: \"alice\"\n * ```\n *\n * @typeParam T The type of the value.\n * @param getter A function that returns the value.\n * @returns A lazy value.\n * @since 2.0.0\n */\nexport function lazy<T>(getter: () => T): Lazy<T> {\n  return { [lazySymbol]: true, getter };\n}\n\n/**\n * Resolves lazy values in a properties object.\n *\n * @param properties The properties object with potential lazy values.\n * @returns A new object with all lazy values resolved.\n */\nfunction resolveProperties(\n  properties: Record<string, unknown>,\n): Record<string, unknown> {\n  const resolved: Record<string, unknown> = {};\n  for (const key in properties) {\n    const value = properties[key];\n    resolved[key] = isLazy(value) ? value.getter() : value;\n  }\n  return resolved;\n}\n\ntype LazyPropertiesCallback = () =>\n  | Record<string, unknown>\n  | Promise<Record<string, unknown>>;\n\nfunction isPromiseObject<T>(value: unknown): value is Promise<T> {\n  // `instanceof Promise` only works for promises created in this realm.\n  // Lazy callbacks may return a promise from another realm, such as a\n  // `node:vm` context or a browser iframe, so we need a fallback.\n  if (value instanceof Promise) return true;\n\n  // `Object.prototype.toString` recognizes native promises across realms.\n  // We also require a callable `then` so an object that only spoofs\n  // `Symbol.toStringTag = \"Promise\"` is not treated as an async result.\n  return Object.prototype.toString.call(value) === \"[object Promise]\" &&\n    typeof (value as Promise<T>).then === \"function\";\n}\n\ninterface StringMessageLogger {\n  isEnabledFor(level: LogLevel): boolean;\n  log(\n    level: LogLevel,\n    message: string,\n    properties: Record<string, unknown>,\n  ): void;\n}\n\n// Callback-based string-message overloads are intentionally \"fire-and-forget\".\n// When the level is filtered out, we return an already-resolved promise\n// without invoking the callback so async property callbacks remain awaitable.\n// Synchronous callback call sites are expected to ignore the return value.\nfunction logStringMessage(\n  logger: StringMessageLogger,\n  level: LogLevel,\n  message: string,\n  props?: unknown,\n): void | Promise<void> {\n  if (typeof props !== \"function\") {\n    const properties = (props ?? {}) as Record<string, unknown>;\n    logger.log(level, message, properties);\n    return;\n  }\n\n  if (!logger.isEnabledFor(level)) return Promise.resolve();\n\n  const result = (props as LazyPropertiesCallback)();\n  if (isPromiseObject<Record<string, unknown>>(result)) {\n    return Promise.resolve(result).then((resolvedProps) => {\n      logger.log(level, message, resolvedProps);\n    });\n  }\n\n  logger.log(level, message, result);\n}\n\n/**\n * A logger interface.  It provides methods to log messages at different\n * severity levels.\n *\n * ```typescript\n * const logger = getLogger(\"category\");\n * logger.trace `A trace message with ${value}`\n * logger.debug `A debug message with ${value}.`;\n * logger.info `An info message with ${value}.`;\n * logger.warn `A warning message with ${value}.`;\n * logger.error `An error message with ${value}.`;\n * logger.fatal `A fatal error message with ${value}.`;\n * ```\n *\n * Callback-based string-message overloads should be treated as\n * fire-and-forget.  Async callbacks return `Promise<void>`, and when a\n * callback is filtered out because the level is disabled an implementation may\n * still return an already-resolved promise so the async path remains awaitable\n * without invoking the callback.  Call sites should not branch on these\n * return values.\n */\nexport interface Logger {\n  /**\n   * The category of the logger.  It is an array of strings.\n   */\n  readonly category: readonly string[];\n\n  /**\n   * The logger with the supercategory of the current logger.  If the current\n   * logger is the root logger, this is `null`.\n   */\n  readonly parent: Logger | null;\n\n  /**\n   * Get a child logger with the given subcategory.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = logger.getChild(\"sub-category\");\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = getLogger([\"category\", \"sub-category\"]);\n   * ```\n   *\n   * @param subcategory The subcategory.\n   * @returns The child logger.\n   */\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger;\n\n  /**\n   * Get a logger with contextual properties.  This is useful for\n   * log multiple messages with the shared set of properties.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const ctx = logger.with({ foo: 123, bar: \"abc\" });\n   * ctx.info(\"A message with {foo} and {bar}.\");\n   * ctx.warn(\"Another message with {foo}, {bar}, and {baz}.\", { baz: true });\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * logger.info(\"A message with {foo} and {bar}.\", { foo: 123, bar: \"abc\" });\n   * logger.warn(\n   *   \"Another message with {foo}, {bar}, and {baz}.\",\n   *   { foo: 123, bar: \"abc\", baz: true },\n   * );\n   * ```\n   *\n   * @param properties\n   * @returns\n   * @since 0.5.0\n   */\n  with(properties: Record<string, unknown>): Logger;\n\n  /**\n   * Log a trace message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.trace `A trace message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   * @since 0.12.0\n   */\n  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a trace message with properties.\n   *\n   * ```typescript\n   * logger.trace('A trace message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.trace(\n   *   'A trace message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   * @since 0.12.0\n   */\n  trace(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a trace message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.trace(\n   *   'A trace message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  trace(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a trace values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.trace({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.trace('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.trace('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.12.0\n   */\n  trace(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a trace message.  Use this when the message values are expensive\n   * to compute and should only be computed if the message is actually logged.\n   *\n   * ```typescript\n   * logger.trace(l => l`A trace message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   * @since 0.12.0\n   */\n  trace(callback: LogCallback): void;\n\n  /**\n   * Log a debug message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.debug `A debug message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a debug message with properties.\n   *\n   * ```typescript\n   * logger.debug('A debug message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.debug(\n   *   'A debug message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a debug message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.debug(\n   *   'A debug message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  debug(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a debug values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.debug({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.debug('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.debug('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  debug(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a debug message.  Use this when the message values are expensive\n   * to compute and should only be computed if the message is actually logged.\n   *\n   * ```typescript\n   * logger.debug(l => l`A debug message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  debug(callback: LogCallback): void;\n\n  /**\n   * Log an informational message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.info `An info message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an informational message with properties.\n   *\n   * ```typescript\n   * logger.info('An info message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.info(\n   *   'An info message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an informational message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.info(\n   *   'An info message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  info(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log an informational values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.info({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.info('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.info('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  info(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an informational message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.info(l => l`An info message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  info(callback: LogCallback): void;\n\n  /**\n   * Log a warning.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.warn(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warn(error: Error): void;\n\n  /**\n   * Log a warning with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.warn(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  warn(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning with additional properties computed asynchronously.\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  warn(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.warn(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warn(message: string, error: Error): void;\n\n  /**\n   * Log a warning message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.warn `A warning message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a warning message with properties.\n   *\n   * ```typescript\n   * logger.warn('A warning message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.warn(\n   *   'A warning message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.warn(\n   *   'A warning message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  warn(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.warn({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.warn('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.warn('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  warn(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a warning message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.warn(l => l`A warning message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  warn(callback: LogCallback): void;\n\n  /**\n   * Log a warning.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.warning(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warning(error: Error): void;\n\n  /**\n   * Log a warning with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.warning(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  warning(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning with additional properties computed asynchronously.\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  warning(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.warning(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warning(message: string, error: Error): void;\n\n  /**\n   * Log a warning message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.warning `A warning message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   * @since 0.12.0\n   */\n  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a warning message with properties.\n   *\n   * ```typescript\n   * logger.warning('A warning message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.warning(\n   *   'A warning message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   * @since 0.12.0\n   */\n  warning(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.warning(\n   *   'A warning message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  warning(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.warning({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.warning('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.12.0\n   */\n  warning(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a warning message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   * @since 0.12.0\n   */\n  warning(callback: LogCallback): void;\n\n  /**\n   * Log an error.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.error(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  error(error: Error): void;\n\n  /**\n   * Log an error with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.error(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.error(\n   *   new Error(\"Oops\"),\n   *   () => ({ requestId: expensiveLookup() })\n   * );\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  error(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an error with additional properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.error(\n   *   new Error(\"Oops\"),\n   *   async () => ({ requestId: await fetchRequestId() })\n   * );\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  error(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log an error message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.error(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  error(message: string, error: Error): void;\n\n  /**\n   * Log an error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.error `An error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an error message with properties.\n   *\n   * ```typescript\n   * logger.warn('An error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.error(\n   *   'An error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an error message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.error(\n   *   'An error message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  error(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log an error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.error({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.error('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.error('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  error(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.error(l => l`An error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  error(callback: LogCallback): void;\n\n  /**\n   * Log a fatal error.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.fatal(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  fatal(error: Error): void;\n\n  /**\n   * Log a fatal error with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.fatal(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  fatal(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a fatal error with additional properties computed asynchronously.\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  fatal(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a fatal error message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.fatal(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  fatal(message: string, error: Error): void;\n\n  /**\n   * Log a fatal error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.fatal `A fatal error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a fatal error message with properties.\n   *\n   * ```typescript\n   * logger.warn('A fatal error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.fatal(\n   *   'A fatal error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a fatal error message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.fatal(\n   *   'A fatal error message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  fatal(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a fatal error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.fatal({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.fatal('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.fatal('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  fatal(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a fatal error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.fatal(l => l`A fatal error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  fatal(callback: LogCallback): void;\n\n  /**\n   * Emits a log record with custom fields while using this logger's\n   * category.\n   *\n   * This is a low-level API for integration scenarios where you need full\n   * control over the log record, particularly for preserving timestamps\n   * from external systems.\n   *\n   * ```typescript\n   * const logger = getLogger([\"my-app\", \"integration\"]);\n   *\n   * // Emit a log with a custom timestamp\n   * logger.emit({\n   *   timestamp: kafkaLog.originalTimestamp,\n   *   level: \"info\",\n   *   message: [kafkaLog.message],\n   *   rawMessage: kafkaLog.message,\n   *   properties: {\n   *     source: \"kafka\",\n   *     partition: kafkaLog.partition,\n   *     offset: kafkaLog.offset,\n   *   },\n   * });\n   * ```\n   *\n   * @param record Log record without category field (category comes from\n   *               the logger instance)\n   * @since 1.1.0\n   */\n  emit(record: Omit<LogRecord, \"category\">): void;\n\n  /**\n   * Check if a message of the given severity level would be processed by\n   * this logger.\n   *\n   * This is useful for conditionally executing expensive computations\n   * before logging, particularly for async operations where lazy\n   * evaluation callbacks cannot be used:\n   *\n   * ```typescript\n   * if (logger.isEnabledFor(\"debug\")) {\n   *   const result = await expensiveAsync();\n   *   logger.debug(\"Result: {result}\", { result });\n   * }\n   * ```\n   *\n   * @param level The log level to check.\n   * @returns `true` if a message of the given level would be logged,\n   *          `false` otherwise.\n   * @since 2.0.0\n   */\n  isEnabledFor(level: LogLevel): boolean;\n}\n\n/**\n * A logging callback function.  It is used to defer the computation of a\n * message template until it is actually logged.\n * @param prefix The message template prefix.\n * @returns The rendered message array.\n */\nexport type LogCallback = (prefix: LogTemplatePrefix) => unknown[];\n\n/**\n * A logging template prefix function.  It is used to log a message in\n * a {@link LogCallback} function.\n * @param message The message template strings array.\n * @param values The message template values.\n * @returns The rendered message array.\n */\nexport type LogTemplatePrefix = (\n  message: TemplateStringsArray,\n  ...values: unknown[]\n) => unknown[];\n\n/**\n * A function type for logging methods in the {@link Logger} interface.\n * @since 1.0.0\n */\nexport interface LogMethod {\n  /**\n   * Log a message with the given level using a template string.\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  (\n    message: TemplateStringsArray,\n    ...values: readonly unknown[]\n  ): void;\n\n  /**\n   * Log a message with the given level with properties.\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  (\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a message with the given level with properties computed asynchronously.\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  (\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a message with the given level with no message.\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   */\n  (properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a message with the given level.\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  (callback: LogCallback): void;\n}\n\n/**\n * Get a logger with the given category.\n *\n * ```typescript\n * const logger = getLogger([\"my-app\"]);\n * ```\n *\n * @param category The category of the logger.  It can be a string or an array\n *                 of strings.  If it is a string, it is equivalent to an array\n *                 with a single element.\n * @returns The logger.\n */\nexport function getLogger(category: string | readonly string[] = []): Logger {\n  return LoggerImpl.getLogger(category);\n}\n\n/**\n * The symbol for the global root logger.\n */\nconst globalRootLoggerSymbol = Symbol.for(\"logtape.rootLogger\");\n\n/**\n * The global root logger registry.\n */\ninterface GlobalRootLoggerRegistry {\n  [globalRootLoggerSymbol]?: LoggerImpl;\n}\n\n/**\n * A logger implementation.  Do not use this directly; use {@link getLogger}\n * instead.  This class is exported for testing purposes.\n */\nexport class LoggerImpl implements Logger {\n  readonly parent: LoggerImpl | null;\n  readonly children: Record<string, LoggerImpl | WeakRef<LoggerImpl>>;\n  readonly category: readonly string[];\n  readonly sinks: Sink[];\n  parentSinks: \"inherit\" | \"override\" = \"inherit\";\n  readonly filters: Filter[];\n  lowestLevel: LogLevel | null = \"trace\";\n  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;\n\n  static getLogger(category: string | readonly string[] = []): LoggerImpl {\n    let rootLogger: LoggerImpl | null = globalRootLoggerSymbol in globalThis\n      ? ((globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] ??\n        null)\n      : null;\n    if (rootLogger == null) {\n      rootLogger = new LoggerImpl(null, []);\n      (globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] =\n        rootLogger;\n    }\n    if (typeof category === \"string\") return rootLogger.getChild(category);\n    if (category.length === 0) return rootLogger;\n    return rootLogger.getChild(category as readonly [string, ...string[]]);\n  }\n\n  private constructor(parent: LoggerImpl | null, category: readonly string[]) {\n    this.parent = parent;\n    this.children = {};\n    this.category = category;\n    this.sinks = [];\n    this.filters = [];\n  }\n\n  getChild(\n    subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])],\n  ): LoggerImpl {\n    const name = typeof subcategory === \"string\" ? subcategory : subcategory[0];\n    const childRef = this.children[name];\n    let child: LoggerImpl | undefined = childRef instanceof LoggerImpl\n      ? childRef\n      : childRef?.deref();\n    if (child == null) {\n      child = new LoggerImpl(this, [...this.category, name]);\n      this.children[name] = \"WeakRef\" in globalThis\n        ? new WeakRef(child)\n        : child;\n    }\n    if (typeof subcategory === \"string\" || subcategory.length === 1) {\n      return child;\n    }\n    return child.getChild(\n      subcategory.slice(1) as [string, ...(readonly string[])],\n    );\n  }\n\n  /**\n   * Reset the logger.  This removes all sinks and filters from the logger.\n   */\n  reset(): void {\n    while (this.sinks.length > 0) this.sinks.shift();\n    this.parentSinks = \"inherit\";\n    while (this.filters.length > 0) this.filters.shift();\n    this.lowestLevel = \"trace\";\n  }\n\n  /**\n   * Reset the logger and all its descendants.  This removes all sinks and\n   * filters from the logger and all its descendants.\n   */\n  resetDescendants(): void {\n    for (const child of Object.values(this.children)) {\n      const logger = child instanceof LoggerImpl ? child : child.deref();\n      if (logger != null) logger.resetDescendants();\n    }\n    this.reset();\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this, { ...properties });\n  }\n\n  filter(record: LogRecord): boolean {\n    for (const filter of this.filters) {\n      if (!filter(record)) return false;\n    }\n    if (this.filters.length < 1) return this.parent?.filter(record) ?? true;\n    return true;\n  }\n\n  *getSinks(level: LogLevel): Iterable<Sink> {\n    if (\n      this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0\n    ) {\n      return;\n    }\n    if (this.parent != null && this.parentSinks === \"inherit\") {\n      for (const sink of this.parent.getSinks(level)) yield sink;\n    }\n    for (const sink of this.sinks) yield sink;\n  }\n\n  isEnabledFor(level: LogLevel): boolean {\n    if (\n      this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0\n    ) {\n      return false;\n    }\n    for (const _ of this.getSinks(level)) {\n      return true;\n    }\n    return false;\n  }\n\n  emit(record: Omit<LogRecord, \"category\">): void;\n  emit(record: LogRecord, bypassSinks?: Set<Sink>): void;\n  emit(\n    record: Omit<LogRecord, \"category\"> | LogRecord,\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const categoryPrefix = getCategoryPrefix();\n    const baseCategory = \"category\" in record\n      ? (record as LogRecord).category\n      : this.category;\n    const fullCategory = categoryPrefix.length > 0\n      ? [...categoryPrefix, ...baseCategory]\n      : baseCategory;\n\n    // Create the full record by copying property descriptors from the original\n    // record, which preserves getters without invoking them (unlike spread).\n    const descriptors = Object.getOwnPropertyDescriptors(record) as\n      & PropertyDescriptorMap\n      & { category?: PropertyDescriptor };\n    descriptors.category = {\n      value: fullCategory,\n      enumerable: true,\n      configurable: true,\n    };\n    const fullRecord = Object.defineProperties({}, descriptors) as LogRecord;\n\n    if (\n      this.lowestLevel === null ||\n      compareLogLevel(fullRecord.level, this.lowestLevel) < 0 ||\n      !this.filter(fullRecord)\n    ) {\n      return;\n    }\n    for (const sink of this.getSinks(fullRecord.level)) {\n      if (bypassSinks?.has(sink)) continue;\n      try {\n        sink(fullRecord);\n      } catch (error) {\n        const bypassSinks2 = new Set(bypassSinks);\n        bypassSinks2.add(sink);\n        metaLogger.log(\n          \"fatal\",\n          \"Failed to emit a log record to sink {sink}: {error}\",\n          { sink, error, record: fullRecord },\n          bypassSinks2,\n        );\n      }\n    }\n  }\n\n  log(\n    level: LogLevel,\n    rawMessage: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const implicitContext = getImplicitContext();\n    let cachedProps: Record<string, unknown> | undefined = undefined;\n    const record: LogRecord = typeof properties === \"function\"\n      ? {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        get message() {\n          return parseMessageTemplate(rawMessage, this.properties);\n        },\n        rawMessage,\n        get properties() {\n          if (cachedProps == null) {\n            cachedProps = {\n              ...implicitContext,\n              ...properties(),\n            };\n          }\n          return cachedProps;\n        },\n      }\n      : {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        message: parseMessageTemplate(rawMessage, {\n          ...implicitContext,\n          ...properties,\n        }),\n        rawMessage,\n        properties: { ...implicitContext, ...properties },\n      };\n    this.emit(record, bypassSinks);\n  }\n\n  logLazily(\n    level: LogLevel,\n    callback: LogCallback,\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext = getImplicitContext();\n    let rawMessage: TemplateStringsArray | undefined = undefined;\n    let msg: unknown[] | undefined = undefined;\n    function realizeMessage(): [unknown[], TemplateStringsArray] {\n      if (msg == null || rawMessage == null) {\n        msg = callback((tpl, ...values) => {\n          rawMessage = tpl;\n          return renderMessage(tpl, values);\n        });\n        if (rawMessage == null) throw new TypeError(\"No log record was made.\");\n      }\n      return [msg, rawMessage];\n    }\n    this.emit({\n      category: this.category,\n      level,\n      get message() {\n        return realizeMessage()[0];\n      },\n      get rawMessage() {\n        return realizeMessage()[1];\n      },\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext = getImplicitContext();\n    this.emit({\n      category: this.category,\n      level,\n      message: renderMessage(messageTemplate, values),\n      rawMessage: messageTemplate,\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  trace(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  trace(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  trace(properties: Record<string, unknown>): void;\n  trace(callback: LogCallback): void;\n  trace(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"trace\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"trace\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"trace\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"trace\", message as TemplateStringsArray, values);\n    }\n  }\n\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  debug(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  debug(properties: Record<string, unknown>): void;\n  debug(callback: LogCallback): void;\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"debug\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  info(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  info(properties: Record<string, unknown>): void;\n  info(callback: LogCallback): void;\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"info\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  private logError(\n    level: \"warning\" | \"error\" | \"fatal\",\n    error: Error,\n    props?: unknown,\n  ): void | Promise<void> {\n    if (typeof props !== \"function\") {\n      this.log(level, \"{error.message}\", {\n        ...(props as Record<string, unknown>),\n        error,\n      });\n      return;\n    }\n\n    if (!this.isEnabledFor(level)) return Promise.resolve();\n\n    const result = (props as () =>\n      | Record<string, unknown>\n      | Promise<Record<string, unknown>>)();\n\n    if (result instanceof Promise) {\n      return result.then((resolved) => {\n        this.log(level, \"{error.message}\", { ...resolved, error });\n      });\n    }\n\n    this.log(level, \"{error.message}\", { ...result, error });\n  }\n\n  warn(error: Error): void;\n  warn(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(message: string, error: Error): void;\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(properties: Record<string, unknown>): void;\n  warn(callback: LogCallback): void;\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warning(error: Error): void;\n  warning(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(message: string, error: Error): void;\n  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warning(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(properties: Record<string, unknown>): void;\n  warning(callback: LogCallback): void;\n  warning(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  error(error: Error): void;\n  error(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(message: string, error: Error): void;\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(properties: Record<string, unknown>): void;\n  error(callback: LogCallback): void;\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"error\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"error\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"error\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(error: Error): void;\n  fatal(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(message: string, error: Error): void;\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(properties: Record<string, unknown>): void;\n  fatal(callback: LogCallback): void;\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"fatal\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"fatal\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"fatal\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * A logger implementation with contextual properties.  Do not use this\n * directly; use {@link Logger.with} instead.  This class is exported\n * for testing purposes.\n */\nexport class LoggerCtx implements Logger {\n  logger: LoggerImpl;\n  properties: Record<string, unknown>;\n\n  constructor(logger: LoggerImpl, properties: Record<string, unknown>) {\n    this.logger = logger;\n    this.properties = properties;\n  }\n\n  get category(): readonly string[] {\n    return this.logger.category;\n  }\n\n  get parent(): Logger | null {\n    return this.logger.parent;\n  }\n\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger {\n    return this.logger.getChild(subcategory).with(this.properties);\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this.logger, { ...this.properties, ...properties });\n  }\n\n  log(\n    level: LogLevel,\n    message: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const contextProps = this.properties;\n    this.logger.log(\n      level,\n      message,\n      typeof properties === \"function\"\n        ? () =>\n          resolveProperties({\n            ...contextProps,\n            ...properties(),\n          })\n        : () => resolveProperties({ ...contextProps, ...properties }),\n      bypassSinks,\n    );\n  }\n\n  logLazily(level: LogLevel, callback: LogCallback): void {\n    this.logger.logLazily(level, callback, resolveProperties(this.properties));\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n  ): void {\n    this.logger.logTemplate(\n      level,\n      messageTemplate,\n      values,\n      resolveProperties(this.properties),\n    );\n  }\n\n  emit(record: Omit<LogRecord, \"category\">): void {\n    const recordWithContext = {\n      ...record,\n      properties: resolveProperties({\n        ...this.properties,\n        ...record.properties,\n      }),\n    };\n    this.logger.emit(recordWithContext);\n  }\n\n  isEnabledFor(level: LogLevel): boolean {\n    return this.logger.isEnabledFor(level);\n  }\n\n  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  trace(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  trace(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  trace(properties: Record<string, unknown>): void;\n  trace(callback: LogCallback): void;\n  trace(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"trace\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"trace\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"trace\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"trace\", message as TemplateStringsArray, values);\n    }\n  }\n\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  debug(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  debug(properties: Record<string, unknown>): void;\n  debug(callback: LogCallback): void;\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"debug\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  info(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  info(properties: Record<string, unknown>): void;\n  info(callback: LogCallback): void;\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"info\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  private logError(\n    level: \"warning\" | \"error\" | \"fatal\",\n    error: Error,\n    props?: unknown,\n  ): void | Promise<void> {\n    if (typeof props !== \"function\") {\n      this.log(level, \"{error.message}\", {\n        ...(props as Record<string, unknown>),\n        error,\n      });\n      return;\n    }\n\n    if (!this.isEnabledFor(level)) return Promise.resolve();\n\n    const result = (props as () =>\n      | Record<string, unknown>\n      | Promise<Record<string, unknown>>)();\n\n    if (result instanceof Promise) {\n      return result.then((resolved) => {\n        this.log(level, \"{error.message}\", { ...resolved, error });\n      });\n    }\n\n    this.log(level, \"{error.message}\", { ...result, error });\n  }\n\n  warn(error: Error): void;\n  warn(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(message: string, error: Error): void;\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(properties: Record<string, unknown>): void;\n  warn(callback: LogCallback): void;\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warning(error: Error): void;\n  warning(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(message: string, error: Error): void;\n  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warning(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(properties: Record<string, unknown>): void;\n  warning(callback: LogCallback): void;\n  warning(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  error(error: Error): void;\n  error(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(message: string, error: Error): void;\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(properties: Record<string, unknown>): void;\n  error(callback: LogCallback): void;\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"error\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"error\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"error\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(error: Error): void;\n  fatal(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(message: string, error: Error): void;\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(properties: Record<string, unknown>): void;\n  fatal(callback: LogCallback): void;\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"fatal\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"fatal\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"fatal\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * The meta logger.  It is a logger with the category `[\"logtape\", \"meta\"]`.\n */\nconst metaLogger = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n\n/**\n * Check if a property access key contains nested access patterns.\n * @param key The property key to check.\n * @returns True if the key contains nested access patterns.\n */\nfunction isNestedAccess(key: string): boolean {\n  return key.includes(\".\") || key.includes(\"[\") || key.includes(\"?.\");\n}\n\n/**\n * Safely access an own property from an object, blocking prototype pollution.\n *\n * @param obj The object to access the property from.\n * @param key The property key to access.\n * @returns The property value or undefined if not accessible.\n */\nfunction getOwnProperty(obj: unknown, key: string): unknown {\n  // Block dangerous prototype keys\n  if (key === \"__proto__\" || key === \"prototype\" || key === \"constructor\") {\n    return undefined;\n  }\n\n  if ((typeof obj === \"object\" || typeof obj === \"function\") && obj !== null) {\n    return Object.prototype.hasOwnProperty.call(obj, key)\n      ? (obj as Record<string, unknown>)[key]\n      : undefined;\n  }\n\n  return undefined;\n}\n\n/**\n * Result of parsing a single segment from a property path.\n */\ninterface ParseSegmentResult {\n  segment: string | number;\n  nextIndex: number;\n}\n\n/**\n * Parse the next segment from a property path string.\n *\n * @param path The full property path string.\n * @param fromIndex The index to start parsing from.\n * @returns The parsed segment and next index, or null if parsing fails.\n */\nfunction parseNextSegment(\n  path: string,\n  fromIndex: number,\n): ParseSegmentResult | null {\n  const len = path.length;\n  let i = fromIndex;\n\n  if (i >= len) return null;\n\n  let segment: string | number;\n\n  if (path[i] === \"[\") {\n    // Bracket notation: [0] or [\"prop\"]\n    i++;\n    if (i >= len) return null;\n\n    if (path[i] === '\"' || path[i] === \"'\") {\n      // Quoted property name: [\"prop-name\"]\n      const quote = path[i];\n      i++;\n      // Build segment with proper escape handling\n      let segmentStr = \"\";\n      while (i < len && path[i] !== quote) {\n        if (path[i] === \"\\\\\") {\n          i++; // Skip backslash\n          if (i < len) {\n            // Handle escape sequences according to JavaScript spec\n            const escapeChar = path[i];\n            switch (escapeChar) {\n              case \"n\":\n                segmentStr += \"\\n\";\n                break;\n              case \"t\":\n                segmentStr += \"\\t\";\n                break;\n              case \"r\":\n                segmentStr += \"\\r\";\n                break;\n              case \"b\":\n                segmentStr += \"\\b\";\n                break;\n              case \"f\":\n                segmentStr += \"\\f\";\n                break;\n              case \"v\":\n                segmentStr += \"\\v\";\n                break;\n              case \"0\":\n                segmentStr += \"\\0\";\n                break;\n              case \"\\\\\":\n                segmentStr += \"\\\\\";\n                break;\n              case '\"':\n                segmentStr += '\"';\n                break;\n              case \"'\":\n                segmentStr += \"'\";\n                break;\n              case \"u\":\n                // Unicode escape: \\uXXXX\n                if (i + 4 < len) {\n                  const hex = path.slice(i + 1, i + 5);\n                  const codePoint = Number.parseInt(hex, 16);\n                  if (!Number.isNaN(codePoint)) {\n                    segmentStr += String.fromCharCode(codePoint);\n                    i += 4; // Skip the 4 hex digits\n                  } else {\n                    // Invalid unicode escape, keep as-is\n                    segmentStr += escapeChar;\n                  }\n                } else {\n                  // Not enough characters for unicode escape\n                  segmentStr += escapeChar;\n                }\n                break;\n              default:\n                // For any other character after \\, just add it as-is\n                segmentStr += escapeChar;\n            }\n            i++;\n          }\n        } else {\n          segmentStr += path[i];\n          i++;\n        }\n      }\n      if (i >= len) return null;\n      segment = segmentStr;\n      i++; // Skip closing quote\n    } else {\n      // Array index: [0]\n      const startIndex = i;\n      while (\n        i < len && path[i] !== \"]\" && path[i] !== \"'\" && path[i] !== '\"'\n      ) {\n        i++;\n      }\n      if (i >= len) return null;\n      const indexStr = path.slice(startIndex, i);\n      // Empty bracket is invalid\n      if (indexStr.length === 0) return null;\n      const indexNum = Number(indexStr);\n      segment = Number.isNaN(indexNum) ? indexStr : indexNum;\n    }\n\n    // Skip closing bracket\n    while (i < len && path[i] !== \"]\") i++;\n    if (i < len) i++;\n  } else {\n    // Dot notation: prop\n    const startIndex = i;\n    while (\n      i < len && path[i] !== \".\" && path[i] !== \"[\" && path[i] !== \"?\" &&\n      path[i] !== \"]\"\n    ) {\n      i++;\n    }\n    segment = path.slice(startIndex, i);\n    // Empty segment is invalid (e.g., leading dot, double dot, trailing dot)\n    if (segment.length === 0) return null;\n  }\n\n  // Skip dot separator\n  if (i < len && path[i] === \".\") i++;\n\n  return { segment, nextIndex: i };\n}\n\n/**\n * Access a property or index on an object or array.\n *\n * @param obj The object or array to access.\n * @param segment The property key or array index.\n * @returns The accessed value or undefined if not accessible.\n */\nfunction accessProperty(obj: unknown, segment: string | number): unknown {\n  if (typeof segment === \"string\") {\n    return getOwnProperty(obj, segment);\n  }\n\n  // Numeric index for arrays\n  if (Array.isArray(obj) && segment >= 0 && segment < obj.length) {\n    return obj[segment];\n  }\n\n  return undefined;\n}\n\n/**\n * Resolve a nested property path from an object.\n *\n * There are two types of property access patterns:\n * 1. Array/index access: [0] or [\"prop\"]\n * 2. Property access: prop or prop?.next\n *\n * @param obj The object to traverse.\n * @param path The property path (e.g., \"user.name\", \"users[0].email\", \"user['full-name']\").\n * @returns The resolved value or undefined if path doesn't exist.\n */\nfunction resolvePropertyPath(obj: unknown, path: string): unknown {\n  if (obj == null) return undefined;\n\n  // Check for invalid paths\n  if (path.length === 0 || path.endsWith(\".\")) return undefined;\n\n  let current: unknown = obj;\n  let i = 0;\n  const len = path.length;\n\n  while (i < len) {\n    // Handle optional chaining\n    const isOptional = path.slice(i, i + 2) === \"?.\";\n    if (isOptional) {\n      i += 2;\n      if (current == null) return undefined;\n    } else if (current == null) {\n      return undefined;\n    }\n\n    // Parse the next segment\n    const result = parseNextSegment(path, i);\n    if (result === null) return undefined;\n\n    const { segment, nextIndex } = result;\n    i = nextIndex;\n\n    // Access the property/index\n    current = accessProperty(current, segment);\n    if (current === undefined) {\n      return undefined;\n    }\n  }\n\n  return current;\n}\n\n/**\n * Parse a message template into a message template array and a values array.\n *\n * Placeholders to be replaced with `values` are indicated by keys in curly braces\n * (e.g., `{value}`). The system supports both simple property access and nested\n * property access patterns:\n *\n * **Simple property access:**\n * ```ts\n * parseMessageTemplate(\"Hello, {user}!\", { user: \"foo\" })\n * // Returns: [\"Hello, \", \"foo\", \"!\"]\n * ```\n *\n * **Nested property access (dot notation):**\n * ```ts\n * parseMessageTemplate(\"Hello, {user.name}!\", {\n *   user: { name: \"foo\", email: \"foo@example.com\" }\n * })\n * // Returns: [\"Hello, \", \"foo\", \"!\"]\n * ```\n *\n * **Array indexing:**\n * ```ts\n * parseMessageTemplate(\"First: {users[0]}\", {\n *   users: [\"foo\", \"bar\", \"baz\"]\n * })\n * // Returns: [\"First: \", \"foo\", \"\"]\n * ```\n *\n * **Bracket notation for special property names:**\n * ```ts\n * parseMessageTemplate(\"Name: {user[\\\"full-name\\\"]}\", {\n *   user: { \"full-name\": \"foo bar\" }\n * })\n * // Returns: [\"Name: \", \"foo bar\", \"\"]\n * ```\n *\n * **Optional chaining for safe navigation:**\n * ```ts\n * parseMessageTemplate(\"Email: {user?.profile?.email}\", {\n *   user: { name: \"foo\" }\n * })\n * // Returns: [\"Email: \", undefined, \"\"]\n * ```\n *\n * **Wildcard patterns:**\n * - `{*}` - Replaced with the entire properties object\n * - `{ key-with-whitespace }` - Whitespace is trimmed when looking up keys\n *\n * **Escaping:**\n * - `{{` and `}}` are escaped literal braces\n *\n * **Error handling:**\n * - Non-existent paths return `undefined`\n * - Malformed expressions resolve to `undefined` without throwing errors\n * - Out of bounds array access returns `undefined`\n *\n * @param template The message template string containing placeholders.\n * @param properties The values to replace placeholders with.\n * @returns The message template array with values interleaved between text segments.\n */\nexport function parseMessageTemplate(\n  template: string,\n  properties: Record<string, unknown>,\n): readonly unknown[] {\n  const length = template.length;\n  if (length === 0) return [\"\"];\n\n  // Fast path: no placeholders\n  if (!template.includes(\"{\")) return [template];\n\n  const message: unknown[] = [];\n  let startIndex = 0;\n\n  for (let i = 0; i < length; i++) {\n    const char = template[i];\n\n    if (char === \"{\") {\n      const nextChar = i + 1 < length ? template[i + 1] : \"\";\n\n      if (nextChar === \"{\") {\n        // Escaped { character - skip and continue\n        i++; // Skip the next {\n        continue;\n      }\n\n      // Find the closing }\n      const closeIndex = template.indexOf(\"}\", i + 1);\n      if (closeIndex === -1) {\n        // No closing } found, treat as literal text\n        continue;\n      }\n\n      // Add text before placeholder\n      const beforeText = template.slice(startIndex, i);\n      message.push(beforeText.replace(/{{/g, \"{\").replace(/}}/g, \"}\"));\n\n      // Extract and process placeholder key\n      const key = template.slice(i + 1, closeIndex);\n\n      // Resolve property value\n      let prop: unknown;\n\n      // Check for wildcard patterns\n      const trimmedKey = key.trim();\n      if (trimmedKey === \"*\") {\n        // This is a wildcard pattern\n        prop = key in properties\n          ? properties[key]\n          : \"*\" in properties\n          ? properties[\"*\"]\n          : properties;\n      } else {\n        // Regular property lookup with possible whitespace handling\n        if (key !== trimmedKey) {\n          // Key has leading/trailing whitespace\n          prop = key in properties ? properties[key] : properties[trimmedKey];\n        } else {\n          // Key has no leading/trailing whitespace\n          prop = properties[key];\n        }\n\n        // If property not found directly and this looks like nested access, try nested resolution\n        if (prop === undefined && isNestedAccess(trimmedKey)) {\n          prop = resolvePropertyPath(properties, trimmedKey);\n        }\n      }\n\n      message.push(prop);\n      i = closeIndex; // Move to the }\n      startIndex = i + 1;\n    } else if (char === \"}\" && i + 1 < length && template[i + 1] === \"}\") {\n      // Escaped } character - skip\n      i++; // Skip the next }\n    }\n  }\n\n  // Add remaining text\n  const remainingText = template.slice(startIndex);\n  message.push(remainingText.replace(/{{/g, \"{\").replace(/}}/g, \"}\"));\n\n  return message;\n}\n\n/**\n * Render a message template with values.\n * @param template The message template.\n * @param values The message template values.\n * @returns The message template values interleaved between the substitution\n *          values.\n */\nexport function renderMessage(\n  template: TemplateStringsArray,\n  values: readonly unknown[],\n): unknown[] {\n  const args = [];\n  for (let i = 0; i < template.length; i++) {\n    args.push(template[i]);\n    if (i < values.length) args.push(values[i]);\n  }\n  return args;\n}\n"],"mappings":"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"}
+{"version":3,"file":"logger.js","names":["lazySymbol: unique symbol","value: unknown","getter: () => T","properties: Record<string, unknown>","resolved: Record<string, unknown>","logger: StringMessageLogger","level: LogLevel","message: string","props?: unknown","category: string | readonly string[]","category: readonly string[]","rootLogger: LoggerImpl | null","parent: LoggerImpl | null","subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])]","child: LoggerImpl | undefined","record: LogRecord","record: Omit<LogRecord, \"category\"> | LogRecord","bypassSinks?: Set<Sink>","rawMessage: string","properties: Record<string, unknown> | (() => Record<string, unknown>)","cachedProps: Record<string, unknown> | undefined","callback: LogCallback","rawMessage: TemplateStringsArray | undefined","msg: unknown[] | undefined","messageTemplate: TemplateStringsArray","values: unknown[]","message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>","level: \"warning\" | \"error\" | \"fatal\"","error: Error","message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error","logger: LoggerImpl","subcategory: string | readonly [string] | readonly [string, ...string[]]","record: Omit<LogRecord, \"category\">","key: string","obj: unknown","path: string","fromIndex: number","segment: string | number","current: unknown","template: string","message: unknown[]","prop: unknown","template: TemplateStringsArray","values: readonly unknown[]"],"sources":["../src/logger.ts"],"sourcesContent":["import {\n  type ContextLocalStorage,\n  getCategoryPrefix,\n  getImplicitContext,\n} from \"./context.ts\";\nimport type { Filter } from \"./filter.ts\";\nimport { compareLogLevel, type LogLevel } from \"./level.ts\";\nimport type { LogRecord } from \"./record.ts\";\nimport type { Sink } from \"./sink.ts\";\n\n/**\n * Symbol to identify lazy values.\n */\nconst lazySymbol: unique symbol = Symbol.for(\"logtape.lazy\");\n\n/**\n * A lazy value that is evaluated at logging time.\n *\n * @typeParam T The type of the value.\n * @since 2.0.0\n */\nexport interface Lazy<T> {\n  readonly [lazySymbol]: true;\n  readonly getter: () => T;\n}\n\n/**\n * Checks if a value is a lazy value.\n *\n * @param value The value to check.\n * @returns `true` if the value is a lazy value, `false` otherwise.\n * @since 2.0.0\n */\nexport function isLazy(value: unknown): value is Lazy<unknown> {\n  return value != null &&\n    typeof value === \"object\" &&\n    lazySymbol in value &&\n    (value as Lazy<unknown>)[lazySymbol] === true;\n}\n\n/**\n * Creates a lazy value that is evaluated at logging time.\n *\n * This is useful for logging contextual properties that may change over time,\n * such as the current user or request context.\n *\n * @example\n * ```typescript\n * let currentUser: string | null = null;\n * const logger = getLogger(\"app\").with({ user: lazy(() => currentUser) });\n *\n * logger.info(\"User action\");  // logs with user: null\n * currentUser = \"alice\";\n * logger.info(\"User action\");  // logs with user: \"alice\"\n * ```\n *\n * @typeParam T The type of the value.\n * @param getter A function that returns the value.\n * @returns A lazy value.\n * @since 2.0.0\n */\nexport function lazy<T>(getter: () => T): Lazy<T> {\n  return { [lazySymbol]: true, getter };\n}\n\n/**\n * Resolves lazy values in a properties object.\n *\n * @param properties The properties object with potential lazy values.\n * @returns A new object with all lazy values resolved.\n */\nfunction resolveProperties(\n  properties: Record<string, unknown>,\n): Record<string, unknown> {\n  const resolved: Record<string, unknown> = {};\n  for (const key in properties) {\n    const value = properties[key];\n    resolved[key] = isLazy(value) ? value.getter() : value;\n  }\n  return resolved;\n}\n\ntype LazyPropertiesCallback = () =>\n  | Record<string, unknown>\n  | Promise<Record<string, unknown>>;\n\nfunction isPromiseObject<T>(value: unknown): value is Promise<T> {\n  // `instanceof Promise` only works for promises created in this realm.\n  // Lazy callbacks may return a promise from another realm, such as a\n  // `node:vm` context or a browser iframe, so we need a fallback.\n  if (value instanceof Promise) return true;\n\n  // `Object.prototype.toString` recognizes native promises across realms.\n  // We also require a callable `then` so an object that only spoofs\n  // `Symbol.toStringTag = \"Promise\"` is not treated as an async result.\n  return Object.prototype.toString.call(value) === \"[object Promise]\" &&\n    typeof (value as Promise<T>).then === \"function\";\n}\n\ninterface StringMessageLogger {\n  isEnabledFor(level: LogLevel): boolean;\n  log(\n    level: LogLevel,\n    message: string,\n    properties: Record<string, unknown>,\n  ): void;\n}\n\n// Callback-based string-message overloads are intentionally \"fire-and-forget\".\n// When the level is filtered out, we return an already-resolved promise\n// without invoking the callback so async property callbacks remain awaitable.\n// Synchronous callback call sites are expected to ignore the return value.\nfunction logStringMessage(\n  logger: StringMessageLogger,\n  level: LogLevel,\n  message: string,\n  props?: unknown,\n): void | Promise<void> {\n  if (typeof props !== \"function\") {\n    const properties = (props ?? {}) as Record<string, unknown>;\n    logger.log(level, message, properties);\n    return;\n  }\n\n  if (!logger.isEnabledFor(level)) return Promise.resolve();\n\n  const result = (props as LazyPropertiesCallback)();\n  if (isPromiseObject<Record<string, unknown>>(result)) {\n    return Promise.resolve(result).then((resolvedProps) => {\n      logger.log(level, message, resolvedProps);\n    });\n  }\n\n  logger.log(level, message, result);\n}\n\n/**\n * A logger interface.  It provides methods to log messages at different\n * severity levels.\n *\n * ```typescript\n * const logger = getLogger(\"category\");\n * logger.trace `A trace message with ${value}`\n * logger.debug `A debug message with ${value}.`;\n * logger.info `An info message with ${value}.`;\n * logger.warn `A warning message with ${value}.`;\n * logger.error `An error message with ${value}.`;\n * logger.fatal `A fatal error message with ${value}.`;\n * ```\n *\n * Callback-based string-message overloads should be treated as\n * fire-and-forget.  Async callbacks return `Promise<void>`, and when a\n * callback is filtered out because the level is disabled an implementation may\n * still return an already-resolved promise so the async path remains awaitable\n * without invoking the callback.  Call sites should not branch on these\n * return values.\n */\nexport interface Logger {\n  /**\n   * The category of the logger.  It is an array of strings.\n   */\n  readonly category: readonly string[];\n\n  /**\n   * The logger with the supercategory of the current logger.  If the current\n   * logger is the root logger, this is `null`.\n   */\n  readonly parent: Logger | null;\n\n  /**\n   * Get a child logger with the given subcategory.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = logger.getChild(\"sub-category\");\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const subLogger = getLogger([\"category\", \"sub-category\"]);\n   * ```\n   *\n   * @param subcategory The subcategory.\n   * @returns The child logger.\n   */\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger;\n\n  /**\n   * Get a logger with contextual properties.  This is useful for\n   * log multiple messages with the shared set of properties.\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * const ctx = logger.with({ foo: 123, bar: \"abc\" });\n   * ctx.info(\"A message with {foo} and {bar}.\");\n   * ctx.warn(\"Another message with {foo}, {bar}, and {baz}.\", { baz: true });\n   * ```\n   *\n   * The above code is equivalent to:\n   *\n   * ```typescript\n   * const logger = getLogger(\"category\");\n   * logger.info(\"A message with {foo} and {bar}.\", { foo: 123, bar: \"abc\" });\n   * logger.warn(\n   *   \"Another message with {foo}, {bar}, and {baz}.\",\n   *   { foo: 123, bar: \"abc\", baz: true },\n   * );\n   * ```\n   *\n   * @param properties\n   * @returns\n   * @since 0.5.0\n   */\n  with(properties: Record<string, unknown>): Logger;\n\n  /**\n   * Log a trace message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.trace `A trace message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   * @since 0.12.0\n   */\n  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a trace message with properties.\n   *\n   * ```typescript\n   * logger.trace('A trace message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.trace(\n   *   'A trace message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   * @since 0.12.0\n   */\n  trace(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a trace message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.trace(\n   *   'A trace message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  trace(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a trace values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.trace({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.trace('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.trace('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.12.0\n   */\n  trace(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a trace message.  Use this when the message values are expensive\n   * to compute and should only be computed if the message is actually logged.\n   *\n   * ```typescript\n   * logger.trace(l => l`A trace message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   * @since 0.12.0\n   */\n  trace(callback: LogCallback): void;\n\n  /**\n   * Log a debug message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.debug `A debug message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a debug message with properties.\n   *\n   * ```typescript\n   * logger.debug('A debug message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.debug(\n   *   'A debug message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a debug message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.debug(\n   *   'A debug message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  debug(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a debug values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.debug({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.debug('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.debug('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  debug(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a debug message.  Use this when the message values are expensive\n   * to compute and should only be computed if the message is actually logged.\n   *\n   * ```typescript\n   * logger.debug(l => l`A debug message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  debug(callback: LogCallback): void;\n\n  /**\n   * Log an informational message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.info `An info message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an informational message with properties.\n   *\n   * ```typescript\n   * logger.info('An info message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.info(\n   *   'An info message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an informational message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.info(\n   *   'An info message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  info(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log an informational values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.info({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.info('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.info('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  info(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an informational message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.info(l => l`An info message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  info(callback: LogCallback): void;\n\n  /**\n   * Log a warning.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.warn(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warn(error: Error): void;\n\n  /**\n   * Log a warning with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.warn(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  warn(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning with additional properties computed asynchronously.\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  warn(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.warn(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warn(message: string, error: Error): void;\n\n  /**\n   * Log a warning message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.warn `A warning message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a warning message with properties.\n   *\n   * ```typescript\n   * logger.warn('A warning message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.warn(\n   *   'A warning message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.warn(\n   *   'A warning message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  warn(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.warn({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.warn('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.warn('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  warn(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a warning message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.warn(l => l`A warning message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  warn(callback: LogCallback): void;\n\n  /**\n   * Log a warning.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.warning(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warning(error: Error): void;\n\n  /**\n   * Log a warning with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.warning(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  warning(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning with additional properties computed asynchronously.\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  warning(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.warning(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  warning(message: string, error: Error): void;\n\n  /**\n   * Log a warning message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.warning `A warning message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   * @since 0.12.0\n   */\n  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a warning message with properties.\n   *\n   * ```typescript\n   * logger.warning('A warning message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.warning(\n   *   'A warning message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   * @since 0.12.0\n   */\n  warning(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a warning message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.warning(\n   *   'A warning message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  warning(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a warning values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.warning({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.warning('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.warning('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.12.0\n   */\n  warning(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a warning message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.warning(l => l`A warning message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   * @since 0.12.0\n   */\n  warning(callback: LogCallback): void;\n\n  /**\n   * Log an error.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.error(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  error(error: Error): void;\n\n  /**\n   * Log an error with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.error(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.error(\n   *   new Error(\"Oops\"),\n   *   () => ({ requestId: expensiveLookup() })\n   * );\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  error(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an error with additional properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.error(\n   *   new Error(\"Oops\"),\n   *   async () => ({ requestId: await fetchRequestId() })\n   * );\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  error(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log an error message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.error(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  error(message: string, error: Error): void;\n\n  /**\n   * Log an error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.error `An error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log an error message with properties.\n   *\n   * ```typescript\n   * logger.warn('An error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.error(\n   *   'An error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log an error message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.error(\n   *   'An error message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  error(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log an error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.error({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.error('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.error('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  error(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log an error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.error(l => l`An error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  error(callback: LogCallback): void;\n\n  /**\n   * Log a fatal error.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property.\n   *\n   * ```typescript\n   * logger.fatal(new Error(\"Oops\"));\n   * ```\n   *\n   * Note that this uses `{error.message}` as the default message template.\n   * If you want to include the stack trace in text output, include `{error}`\n   * in the message template instead.\n   *\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  fatal(error: Error): void;\n\n  /**\n   * Log a fatal error with additional properties.\n   *\n   * This overload is a shorthand for logging an {@link Error} instance as a\n   * structured property while also adding extra properties.\n   *\n   * ```typescript\n   * logger.fatal(new Error(\"Oops\"), { requestId });\n   * ```\n   *\n   * @param error The error to log.\n   * @param properties Additional properties to log alongside the error.\n   * @since 2.1.0\n   */\n  fatal(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a fatal error with additional properties computed asynchronously.\n   *\n   * @param error The error to log.\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.1.0\n   */\n  fatal(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a fatal error message with an {@link Error}.\n   *\n   * ```typescript\n   * logger.fatal(\"Failed to do something\", new Error(\"Oops\"));\n   * ```\n   *\n   * @param message The message.\n   * @param error The error to log.\n   * @since 2.0.0\n   */\n  fatal(message: string, error: Error): void;\n\n  /**\n   * Log a fatal error message.  Use this as a template string prefix.\n   *\n   * ```typescript\n   * logger.fatal `A fatal error message with ${value}.`;\n   * ```\n   *\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n\n  /**\n   * Log a fatal error message with properties.\n   *\n   * ```typescript\n   * logger.warn('A fatal error message with {value}.', { value });\n   * ```\n   *\n   * If the properties are expensive to compute, you can pass a callback that\n   * returns the properties:\n   *\n   * ```typescript\n   * logger.fatal(\n   *   'A fatal error message with {value}.',\n   *   () => ({ value: expensiveComputation() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a fatal error message with properties computed asynchronously.\n   *\n   * Use this when the properties require async operations to compute:\n   *\n   * ```typescript\n   * await logger.fatal(\n   *   'A fatal error message with {value}.',\n   *   async () => ({ value: await fetchValue() })\n   * );\n   * ```\n   *\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  fatal(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a fatal error values with no message.  This is useful when you\n   * want to log properties without a message, e.g., when you want to log\n   * the context of a request or an operation.\n   *\n   * ```typescript\n   * logger.fatal({ method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * Note that this is a shorthand for:\n   *\n   * ```typescript\n   * logger.fatal('{*}', { method: 'GET', url: '/api/v1/resource' });\n   * ```\n   *\n   * If the properties are expensive to compute, you cannot use this shorthand\n   * and should use the following syntax instead:\n   *\n   * ```typescript\n   * logger.fatal('{*}', () => ({\n   *   method: expensiveMethod(),\n   *   url: expensiveUrl(),\n   * }));\n   * ```\n   *\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   * @since 0.11.0\n   */\n  fatal(properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a fatal error message.  Use this when the message values are\n   * expensive to compute and should only be computed if the message is actually\n   * logged.\n   *\n   * ```typescript\n   * logger.fatal(l => l`A fatal error message with ${expensiveValue()}.`);\n   * ```\n   *\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  fatal(callback: LogCallback): void;\n\n  /**\n   * Emits a log record with custom fields while using this logger's\n   * category.\n   *\n   * This is a low-level API for integration scenarios where you need full\n   * control over the log record, particularly for preserving timestamps\n   * from external systems.\n   *\n   * ```typescript\n   * const logger = getLogger([\"my-app\", \"integration\"]);\n   *\n   * // Emit a log with a custom timestamp\n   * logger.emit({\n   *   timestamp: kafkaLog.originalTimestamp,\n   *   level: \"info\",\n   *   message: [kafkaLog.message],\n   *   rawMessage: kafkaLog.message,\n   *   properties: {\n   *     source: \"kafka\",\n   *     partition: kafkaLog.partition,\n   *     offset: kafkaLog.offset,\n   *   },\n   * });\n   * ```\n   *\n   * @param record Log record without category field (category comes from\n   *               the logger instance)\n   * @since 1.1.0\n   */\n  emit(record: Omit<LogRecord, \"category\">): void;\n\n  /**\n   * Check if a message of the given severity level would be processed by\n   * this logger.\n   *\n   * This is useful for conditionally executing expensive computations\n   * before logging, particularly for async operations where lazy\n   * evaluation callbacks cannot be used:\n   *\n   * ```typescript\n   * if (logger.isEnabledFor(\"debug\")) {\n   *   const result = await expensiveAsync();\n   *   logger.debug(\"Result: {result}\", { result });\n   * }\n   * ```\n   *\n   * @param level The log level to check.\n   * @returns `true` if a message of the given level would be logged,\n   *          `false` otherwise.\n   * @since 2.0.0\n   */\n  isEnabledFor(level: LogLevel): boolean;\n}\n\n/**\n * A logging callback function.  It is used to defer the computation of a\n * message template until it is actually logged.\n * @param prefix The message template prefix.\n * @returns The rendered message array.\n */\nexport type LogCallback = (prefix: LogTemplatePrefix) => unknown[];\n\n/**\n * A logging template prefix function.  It is used to log a message in\n * a {@link LogCallback} function.\n * @param message The message template strings array.\n * @param values The message template values.\n * @returns The rendered message array.\n */\nexport type LogTemplatePrefix = (\n  message: TemplateStringsArray,\n  ...values: unknown[]\n) => unknown[];\n\n/**\n * A function type for logging methods in the {@link Logger} interface.\n * @since 1.0.0\n */\nexport interface LogMethod {\n  /**\n   * Log a message with the given level using a template string.\n   * @param message The message template strings array.\n   * @param values The message template values.\n   */\n  (\n    message: TemplateStringsArray,\n    ...values: readonly unknown[]\n  ): void;\n\n  /**\n   * Log a message with the given level with properties.\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties The values to replace placeholders with.  For lazy\n   *                   evaluation, this can be a callback that returns the\n   *                   properties.\n   */\n  (\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n\n  /**\n   * Log a message with the given level with properties computed asynchronously.\n   * @param message The message template.  Placeholders to be replaced with\n   *                `values` are indicated by keys in curly braces (e.g.,\n   *                `{value}`).\n   * @param properties An async callback that returns the properties.\n   * @returns A promise that resolves when the log is written.\n   * @since 2.0.0\n   */\n  (\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n\n  /**\n   * Log a message with the given level with no message.\n   * @param properties The values to log.  Note that this does not take\n   *                   a callback.\n   */\n  (properties: Record<string, unknown>): void;\n\n  /**\n   * Lazily log a message with the given level.\n   * @param callback A callback that returns the message template prefix.\n   * @throws {TypeError} If no log record was made inside the callback.\n   */\n  (callback: LogCallback): void;\n}\n\n/**\n * Get a logger with the given category.\n *\n * ```typescript\n * const logger = getLogger([\"my-app\"]);\n * ```\n *\n * @param category The category of the logger.  It can be a string or an array\n *                 of strings.  If it is a string, it is equivalent to an array\n *                 with a single element.\n * @returns The logger.\n */\nexport function getLogger(category: string | readonly string[] = []): Logger {\n  return LoggerImpl.getLogger(category);\n}\n\n/**\n * The symbol for the global root logger.\n */\nconst globalRootLoggerSymbol = Symbol.for(\"logtape.rootLogger\");\n\nfunction isMetaLoggerCategory(category: readonly string[]): boolean {\n  return category.length === 2 &&\n    category[0] === \"logtape\" &&\n    category[1] === \"meta\";\n}\n\n/**\n * The global root logger registry.\n */\ninterface GlobalRootLoggerRegistry {\n  [globalRootLoggerSymbol]?: LoggerImpl;\n}\n\n/**\n * A logger implementation.  Do not use this directly; use {@link getLogger}\n * instead.  This class is exported for testing purposes.\n */\nexport class LoggerImpl implements Logger {\n  readonly parent: LoggerImpl | null;\n  readonly children: Record<string, LoggerImpl | WeakRef<LoggerImpl>>;\n  readonly category: readonly string[];\n  readonly sinks: Sink[];\n  parentSinks: \"inherit\" | \"override\" = \"inherit\";\n  readonly filters: Filter[];\n  lowestLevel: LogLevel | null = \"trace\";\n  contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;\n\n  static getLogger(category: string | readonly string[] = []): LoggerImpl {\n    let rootLogger: LoggerImpl | null = globalRootLoggerSymbol in globalThis\n      ? ((globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] ??\n        null)\n      : null;\n    if (rootLogger == null) {\n      rootLogger = new LoggerImpl(null, []);\n      (globalThis as GlobalRootLoggerRegistry)[globalRootLoggerSymbol] =\n        rootLogger;\n    }\n    if (typeof category === \"string\") return rootLogger.getChild(category);\n    if (category.length === 0) return rootLogger;\n    return rootLogger.getChild(category as readonly [string, ...string[]]);\n  }\n\n  private static getNearestExistingLogger(\n    category: readonly string[],\n  ): LoggerImpl {\n    let logger = LoggerImpl.getLogger();\n    for (const name of category) {\n      const childRef = logger.children[name];\n      const child = childRef instanceof LoggerImpl\n        ? childRef\n        : childRef?.deref();\n      if (child == null) break;\n      logger = child;\n    }\n    return logger;\n  }\n\n  private constructor(parent: LoggerImpl | null, category: readonly string[]) {\n    this.parent = parent;\n    this.children = {};\n    this.category = category;\n    this.sinks = [];\n    this.filters = [];\n  }\n\n  getChild(\n    subcategory:\n      | string\n      | readonly [string]\n      | readonly [string, ...(readonly string[])],\n  ): LoggerImpl {\n    const name = typeof subcategory === \"string\" ? subcategory : subcategory[0];\n    const childRef = this.children[name];\n    let child: LoggerImpl | undefined = childRef instanceof LoggerImpl\n      ? childRef\n      : childRef?.deref();\n    if (child == null) {\n      child = new LoggerImpl(this, [...this.category, name]);\n      this.children[name] = \"WeakRef\" in globalThis\n        ? new WeakRef(child)\n        : child;\n    }\n    if (typeof subcategory === \"string\" || subcategory.length === 1) {\n      return child;\n    }\n    return child.getChild(\n      subcategory.slice(1) as [string, ...(readonly string[])],\n    );\n  }\n\n  /**\n   * Reset the logger.  This removes all sinks and filters from the logger.\n   */\n  reset(): void {\n    while (this.sinks.length > 0) this.sinks.shift();\n    this.parentSinks = \"inherit\";\n    while (this.filters.length > 0) this.filters.shift();\n    this.lowestLevel = \"trace\";\n  }\n\n  /**\n   * Reset the logger and all its descendants.  This removes all sinks and\n   * filters from the logger and all its descendants.\n   */\n  resetDescendants(): void {\n    for (const child of Object.values(this.children)) {\n      const logger = child instanceof LoggerImpl ? child : child.deref();\n      if (logger != null) logger.resetDescendants();\n    }\n    this.reset();\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this, { ...properties });\n  }\n\n  filter(record: LogRecord): boolean {\n    for (const filter of this.filters) {\n      if (!filter(record)) return false;\n    }\n    if (this.filters.length < 1) return this.parent?.filter(record) ?? true;\n    return true;\n  }\n\n  *getSinks(level: LogLevel): Iterable<Sink> {\n    if (\n      this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0\n    ) {\n      return;\n    }\n    if (this.parent != null && this.parentSinks === \"inherit\") {\n      for (const sink of this.parent.getSinks(level)) yield sink;\n    }\n    for (const sink of this.sinks) yield sink;\n  }\n\n  isEnabledFor(level: LogLevel): boolean {\n    const categoryPrefix = isMetaLoggerCategory(this.category)\n      ? []\n      : getCategoryPrefix();\n    const dispatcher = categoryPrefix.length > 0\n      ? LoggerImpl.getNearestExistingLogger([\n        ...categoryPrefix,\n        ...this.category,\n      ])\n      : this;\n    return dispatcher.isEnabledForResolved(level);\n  }\n\n  private isEnabledForResolved(level: LogLevel): boolean {\n    if (\n      this.lowestLevel === null || compareLogLevel(level, this.lowestLevel) < 0\n    ) {\n      return false;\n    }\n    for (const _ of this.getSinks(level)) {\n      return true;\n    }\n    return false;\n  }\n\n  emit(record: Omit<LogRecord, \"category\">): void;\n  emit(record: LogRecord, bypassSinks?: Set<Sink>): void;\n  emit(\n    record: Omit<LogRecord, \"category\"> | LogRecord,\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const baseCategory = \"category\" in record\n      ? (record as LogRecord).category\n      : this.category;\n    const categoryPrefix = isMetaLoggerCategory(baseCategory)\n      ? []\n      : getCategoryPrefix();\n    const fullCategory = categoryPrefix.length > 0\n      ? [...categoryPrefix, ...baseCategory]\n      : baseCategory;\n\n    // Create the full record by copying property descriptors from the original\n    // record, which preserves getters without invoking them (unlike spread).\n    const descriptors = Object.getOwnPropertyDescriptors(record) as\n      & PropertyDescriptorMap\n      & { category?: PropertyDescriptor };\n    descriptors.category = {\n      value: fullCategory,\n      enumerable: true,\n      configurable: true,\n    };\n    const fullRecord = Object.defineProperties({}, descriptors) as LogRecord;\n    const dispatcher = categoryPrefix.length > 0\n      ? LoggerImpl.getNearestExistingLogger(fullCategory)\n      : this;\n    dispatcher.emitResolved(fullRecord, bypassSinks);\n  }\n\n  private emitResolved(record: LogRecord, bypassSinks?: Set<Sink>): void {\n    if (\n      this.lowestLevel === null ||\n      compareLogLevel(record.level, this.lowestLevel) < 0 ||\n      !this.filter(record)\n    ) {\n      return;\n    }\n    for (const sink of this.getSinks(record.level)) {\n      if (bypassSinks?.has(sink)) continue;\n      try {\n        sink(record);\n      } catch (error) {\n        const bypassSinks2 = new Set(bypassSinks);\n        bypassSinks2.add(sink);\n        metaLogger.log(\n          \"fatal\",\n          \"Failed to emit a log record to sink {sink}: {error}\",\n          { sink, error, record },\n          bypassSinks2,\n        );\n      }\n    }\n  }\n\n  log(\n    level: LogLevel,\n    rawMessage: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const implicitContext = getImplicitContext();\n    let cachedProps: Record<string, unknown> | undefined = undefined;\n    const record: LogRecord = typeof properties === \"function\"\n      ? {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        get message() {\n          return parseMessageTemplate(rawMessage, this.properties);\n        },\n        rawMessage,\n        get properties() {\n          if (cachedProps == null) {\n            cachedProps = {\n              ...implicitContext,\n              ...properties(),\n            };\n          }\n          return cachedProps;\n        },\n      }\n      : {\n        category: this.category,\n        level,\n        timestamp: Date.now(),\n        message: parseMessageTemplate(rawMessage, {\n          ...implicitContext,\n          ...properties,\n        }),\n        rawMessage,\n        properties: { ...implicitContext, ...properties },\n      };\n    this.emit(record, bypassSinks);\n  }\n\n  logLazily(\n    level: LogLevel,\n    callback: LogCallback,\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext = getImplicitContext();\n    let rawMessage: TemplateStringsArray | undefined = undefined;\n    let msg: unknown[] | undefined = undefined;\n    function realizeMessage(): [unknown[], TemplateStringsArray] {\n      if (msg == null || rawMessage == null) {\n        msg = callback((tpl, ...values) => {\n          rawMessage = tpl;\n          return renderMessage(tpl, values);\n        });\n        if (rawMessage == null) throw new TypeError(\"No log record was made.\");\n      }\n      return [msg, rawMessage];\n    }\n    this.emit({\n      category: this.category,\n      level,\n      get message() {\n        return realizeMessage()[0];\n      },\n      get rawMessage() {\n        return realizeMessage()[1];\n      },\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n    properties: Record<string, unknown> = {},\n  ): void {\n    const implicitContext = getImplicitContext();\n    this.emit({\n      category: this.category,\n      level,\n      message: renderMessage(messageTemplate, values),\n      rawMessage: messageTemplate,\n      timestamp: Date.now(),\n      properties: { ...implicitContext, ...properties },\n    });\n  }\n\n  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  trace(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  trace(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  trace(properties: Record<string, unknown>): void;\n  trace(callback: LogCallback): void;\n  trace(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"trace\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"trace\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"trace\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"trace\", message as TemplateStringsArray, values);\n    }\n  }\n\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  debug(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  debug(properties: Record<string, unknown>): void;\n  debug(callback: LogCallback): void;\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"debug\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  info(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  info(properties: Record<string, unknown>): void;\n  info(callback: LogCallback): void;\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"info\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  private logError(\n    level: \"warning\" | \"error\" | \"fatal\",\n    error: Error,\n    props?: unknown,\n  ): void | Promise<void> {\n    if (typeof props !== \"function\") {\n      this.log(level, \"{error.message}\", {\n        ...(props as Record<string, unknown>),\n        error,\n      });\n      return;\n    }\n\n    if (!this.isEnabledFor(level)) return Promise.resolve();\n\n    const result = (props as () =>\n      | Record<string, unknown>\n      | Promise<Record<string, unknown>>)();\n\n    if (result instanceof Promise) {\n      return result.then((resolved) => {\n        this.log(level, \"{error.message}\", { ...resolved, error });\n      });\n    }\n\n    this.log(level, \"{error.message}\", { ...result, error });\n  }\n\n  warn(error: Error): void;\n  warn(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(message: string, error: Error): void;\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(properties: Record<string, unknown>): void;\n  warn(callback: LogCallback): void;\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warning(error: Error): void;\n  warning(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(message: string, error: Error): void;\n  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warning(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(properties: Record<string, unknown>): void;\n  warning(callback: LogCallback): void;\n  warning(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  error(error: Error): void;\n  error(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(message: string, error: Error): void;\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(properties: Record<string, unknown>): void;\n  error(callback: LogCallback): void;\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"error\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"error\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"error\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(error: Error): void;\n  fatal(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(message: string, error: Error): void;\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(properties: Record<string, unknown>): void;\n  fatal(callback: LogCallback): void;\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"fatal\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"fatal\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"fatal\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * A logger implementation with contextual properties.  Do not use this\n * directly; use {@link Logger.with} instead.  This class is exported\n * for testing purposes.\n */\nexport class LoggerCtx implements Logger {\n  logger: LoggerImpl;\n  properties: Record<string, unknown>;\n\n  constructor(logger: LoggerImpl, properties: Record<string, unknown>) {\n    this.logger = logger;\n    this.properties = properties;\n  }\n\n  get category(): readonly string[] {\n    return this.logger.category;\n  }\n\n  get parent(): Logger | null {\n    return this.logger.parent;\n  }\n\n  getChild(\n    subcategory: string | readonly [string] | readonly [string, ...string[]],\n  ): Logger {\n    return this.logger.getChild(subcategory).with(this.properties);\n  }\n\n  with(properties: Record<string, unknown>): Logger {\n    return new LoggerCtx(this.logger, { ...this.properties, ...properties });\n  }\n\n  log(\n    level: LogLevel,\n    message: string,\n    properties: Record<string, unknown> | (() => Record<string, unknown>),\n    bypassSinks?: Set<Sink>,\n  ): void {\n    const contextProps = this.properties;\n    this.logger.log(\n      level,\n      message,\n      typeof properties === \"function\"\n        ? () =>\n          resolveProperties({\n            ...contextProps,\n            ...properties(),\n          })\n        : () => resolveProperties({ ...contextProps, ...properties }),\n      bypassSinks,\n    );\n  }\n\n  logLazily(level: LogLevel, callback: LogCallback): void {\n    this.logger.logLazily(level, callback, resolveProperties(this.properties));\n  }\n\n  logTemplate(\n    level: LogLevel,\n    messageTemplate: TemplateStringsArray,\n    values: unknown[],\n  ): void {\n    this.logger.logTemplate(\n      level,\n      messageTemplate,\n      values,\n      resolveProperties(this.properties),\n    );\n  }\n\n  emit(record: Omit<LogRecord, \"category\">): void {\n    const recordWithContext = {\n      ...record,\n      properties: resolveProperties({\n        ...this.properties,\n        ...record.properties,\n      }),\n    };\n    this.logger.emit(recordWithContext);\n  }\n\n  isEnabledFor(level: LogLevel): boolean {\n    return this.logger.isEnabledFor(level);\n  }\n\n  trace(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  trace(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  trace(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  trace(properties: Record<string, unknown>): void;\n  trace(callback: LogCallback): void;\n  trace(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"trace\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"trace\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"trace\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"trace\", message as TemplateStringsArray, values);\n    }\n  }\n\n  debug(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  debug(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  debug(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  debug(properties: Record<string, unknown>): void;\n  debug(callback: LogCallback): void;\n  debug(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"debug\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"debug\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"debug\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"debug\", message as TemplateStringsArray, values);\n    }\n  }\n\n  info(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  info(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  info(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  info(properties: Record<string, unknown>): void;\n  info(callback: LogCallback): void;\n  info(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (typeof message === \"string\") {\n      return logStringMessage(this, \"info\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"info\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"info\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"info\", message as TemplateStringsArray, values);\n    }\n  }\n\n  private logError(\n    level: \"warning\" | \"error\" | \"fatal\",\n    error: Error,\n    props?: unknown,\n  ): void | Promise<void> {\n    if (typeof props !== \"function\") {\n      this.log(level, \"{error.message}\", {\n        ...(props as Record<string, unknown>),\n        error,\n      });\n      return;\n    }\n\n    if (!this.isEnabledFor(level)) return Promise.resolve();\n\n    const result = (props as () =>\n      | Record<string, unknown>\n      | Promise<Record<string, unknown>>)();\n\n    if (result instanceof Promise) {\n      return result.then((resolved) => {\n        this.log(level, \"{error.message}\", { ...resolved, error });\n      });\n    }\n\n    this.log(level, \"{error.message}\", { ...result, error });\n  }\n\n  warn(error: Error): void;\n  warn(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(message: string, error: Error): void;\n  warn(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warn(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warn(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warn(properties: Record<string, unknown>): void;\n  warn(callback: LogCallback): void;\n  warn(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  warning(error: Error): void;\n  warning(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(message: string, error: Error): void;\n  warning(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  warning(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  warning(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  warning(properties: Record<string, unknown>): void;\n  warning(callback: LogCallback): void;\n  warning(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"warning\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"warning\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"warning\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"warning\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"warning\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"warning\", message as TemplateStringsArray, values);\n    }\n  }\n\n  error(error: Error): void;\n  error(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(message: string, error: Error): void;\n  error(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  error(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  error(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  error(properties: Record<string, unknown>): void;\n  error(callback: LogCallback): void;\n  error(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"error\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"error\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"error\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"error\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"error\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"error\", message as TemplateStringsArray, values);\n    }\n  }\n\n  fatal(error: Error): void;\n  fatal(\n    error: Error,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    error: Error,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(message: string, error: Error): void;\n  fatal(message: TemplateStringsArray, ...values: readonly unknown[]): void;\n  fatal(\n    message: string,\n    properties?: Record<string, unknown> | (() => Record<string, unknown>),\n  ): void;\n  fatal(\n    message: string,\n    properties: () => Promise<Record<string, unknown>>,\n  ): Promise<void>;\n  fatal(properties: Record<string, unknown>): void;\n  fatal(callback: LogCallback): void;\n  fatal(\n    message:\n      | TemplateStringsArray\n      | string\n      | LogCallback\n      | Record<string, unknown>\n      | Error,\n    ...values: unknown[]\n  ): void | Promise<void> {\n    if (message instanceof Error) {\n      return this.logError(\"fatal\", message, values[0]);\n    } else if (typeof message === \"string\" && values[0] instanceof Error) {\n      this.log(\"fatal\", message, { error: values[0] });\n    } else if (typeof message === \"string\") {\n      return logStringMessage(this, \"fatal\", message, values[0]);\n    } else if (typeof message === \"function\") {\n      this.logLazily(\"fatal\", message);\n    } else if (!Array.isArray(message)) {\n      this.log(\"fatal\", \"{*}\", message as Record<string, unknown>);\n    } else {\n      this.logTemplate(\"fatal\", message as TemplateStringsArray, values);\n    }\n  }\n}\n\n/**\n * The meta logger.  It is a logger with the category `[\"logtape\", \"meta\"]`.\n */\nconst metaLogger = LoggerImpl.getLogger([\"logtape\", \"meta\"]);\n\n/**\n * Check if a property access key contains nested access patterns.\n * @param key The property key to check.\n * @returns True if the key contains nested access patterns.\n */\nfunction isNestedAccess(key: string): boolean {\n  return key.includes(\".\") || key.includes(\"[\") || key.includes(\"?.\");\n}\n\n/**\n * Safely access an own property from an object, blocking prototype pollution.\n *\n * @param obj The object to access the property from.\n * @param key The property key to access.\n * @returns The property value or undefined if not accessible.\n */\nfunction getOwnProperty(obj: unknown, key: string): unknown {\n  // Block dangerous prototype keys\n  if (key === \"__proto__\" || key === \"prototype\" || key === \"constructor\") {\n    return undefined;\n  }\n\n  if ((typeof obj === \"object\" || typeof obj === \"function\") && obj !== null) {\n    return Object.prototype.hasOwnProperty.call(obj, key)\n      ? (obj as Record<string, unknown>)[key]\n      : undefined;\n  }\n\n  return undefined;\n}\n\n/**\n * Result of parsing a single segment from a property path.\n */\ninterface ParseSegmentResult {\n  segment: string | number;\n  nextIndex: number;\n}\n\n/**\n * Parse the next segment from a property path string.\n *\n * @param path The full property path string.\n * @param fromIndex The index to start parsing from.\n * @returns The parsed segment and next index, or null if parsing fails.\n */\nfunction parseNextSegment(\n  path: string,\n  fromIndex: number,\n): ParseSegmentResult | null {\n  const len = path.length;\n  let i = fromIndex;\n\n  if (i >= len) return null;\n\n  let segment: string | number;\n\n  if (path[i] === \"[\") {\n    // Bracket notation: [0] or [\"prop\"]\n    i++;\n    if (i >= len) return null;\n\n    if (path[i] === '\"' || path[i] === \"'\") {\n      // Quoted property name: [\"prop-name\"]\n      const quote = path[i];\n      i++;\n      // Build segment with proper escape handling\n      let segmentStr = \"\";\n      while (i < len && path[i] !== quote) {\n        if (path[i] === \"\\\\\") {\n          i++; // Skip backslash\n          if (i < len) {\n            // Handle escape sequences according to JavaScript spec\n            const escapeChar = path[i];\n            switch (escapeChar) {\n              case \"n\":\n                segmentStr += \"\\n\";\n                break;\n              case \"t\":\n                segmentStr += \"\\t\";\n                break;\n              case \"r\":\n                segmentStr += \"\\r\";\n                break;\n              case \"b\":\n                segmentStr += \"\\b\";\n                break;\n              case \"f\":\n                segmentStr += \"\\f\";\n                break;\n              case \"v\":\n                segmentStr += \"\\v\";\n                break;\n              case \"0\":\n                segmentStr += \"\\0\";\n                break;\n              case \"\\\\\":\n                segmentStr += \"\\\\\";\n                break;\n              case '\"':\n                segmentStr += '\"';\n                break;\n              case \"'\":\n                segmentStr += \"'\";\n                break;\n              case \"u\":\n                // Unicode escape: \\uXXXX\n                if (i + 4 < len) {\n                  const hex = path.slice(i + 1, i + 5);\n                  const codePoint = Number.parseInt(hex, 16);\n                  if (!Number.isNaN(codePoint)) {\n                    segmentStr += String.fromCharCode(codePoint);\n                    i += 4; // Skip the 4 hex digits\n                  } else {\n                    // Invalid unicode escape, keep as-is\n                    segmentStr += escapeChar;\n                  }\n                } else {\n                  // Not enough characters for unicode escape\n                  segmentStr += escapeChar;\n                }\n                break;\n              default:\n                // For any other character after \\, just add it as-is\n                segmentStr += escapeChar;\n            }\n            i++;\n          }\n        } else {\n          segmentStr += path[i];\n          i++;\n        }\n      }\n      if (i >= len) return null;\n      segment = segmentStr;\n      i++; // Skip closing quote\n    } else {\n      // Array index: [0]\n      const startIndex = i;\n      while (\n        i < len && path[i] !== \"]\" && path[i] !== \"'\" && path[i] !== '\"'\n      ) {\n        i++;\n      }\n      if (i >= len) return null;\n      const indexStr = path.slice(startIndex, i);\n      // Empty bracket is invalid\n      if (indexStr.length === 0) return null;\n      const indexNum = Number(indexStr);\n      segment = Number.isNaN(indexNum) ? indexStr : indexNum;\n    }\n\n    // Skip closing bracket\n    while (i < len && path[i] !== \"]\") i++;\n    if (i < len) i++;\n  } else {\n    // Dot notation: prop\n    const startIndex = i;\n    while (\n      i < len && path[i] !== \".\" && path[i] !== \"[\" && path[i] !== \"?\" &&\n      path[i] !== \"]\"\n    ) {\n      i++;\n    }\n    segment = path.slice(startIndex, i);\n    // Empty segment is invalid (e.g., leading dot, double dot, trailing dot)\n    if (segment.length === 0) return null;\n  }\n\n  // Skip dot separator\n  if (i < len && path[i] === \".\") i++;\n\n  return { segment, nextIndex: i };\n}\n\n/**\n * Access a property or index on an object or array.\n *\n * @param obj The object or array to access.\n * @param segment The property key or array index.\n * @returns The accessed value or undefined if not accessible.\n */\nfunction accessProperty(obj: unknown, segment: string | number): unknown {\n  if (typeof segment === \"string\") {\n    return getOwnProperty(obj, segment);\n  }\n\n  // Numeric index for arrays\n  if (Array.isArray(obj) && segment >= 0 && segment < obj.length) {\n    return obj[segment];\n  }\n\n  return undefined;\n}\n\n/**\n * Resolve a nested property path from an object.\n *\n * There are two types of property access patterns:\n * 1. Array/index access: [0] or [\"prop\"]\n * 2. Property access: prop or prop?.next\n *\n * @param obj The object to traverse.\n * @param path The property path (e.g., \"user.name\", \"users[0].email\", \"user['full-name']\").\n * @returns The resolved value or undefined if path doesn't exist.\n */\nfunction resolvePropertyPath(obj: unknown, path: string): unknown {\n  if (obj == null) return undefined;\n\n  // Check for invalid paths\n  if (path.length === 0 || path.endsWith(\".\")) return undefined;\n\n  let current: unknown = obj;\n  let i = 0;\n  const len = path.length;\n\n  while (i < len) {\n    // Handle optional chaining\n    const isOptional = path.slice(i, i + 2) === \"?.\";\n    if (isOptional) {\n      i += 2;\n      if (current == null) return undefined;\n    } else if (current == null) {\n      return undefined;\n    }\n\n    // Parse the next segment\n    const result = parseNextSegment(path, i);\n    if (result === null) return undefined;\n\n    const { segment, nextIndex } = result;\n    i = nextIndex;\n\n    // Access the property/index\n    current = accessProperty(current, segment);\n    if (current === undefined) {\n      return undefined;\n    }\n  }\n\n  return current;\n}\n\n/**\n * Parse a message template into a message template array and a values array.\n *\n * Placeholders to be replaced with `values` are indicated by keys in curly braces\n * (e.g., `{value}`). The system supports both simple property access and nested\n * property access patterns:\n *\n * **Simple property access:**\n * ```ts\n * parseMessageTemplate(\"Hello, {user}!\", { user: \"foo\" })\n * // Returns: [\"Hello, \", \"foo\", \"!\"]\n * ```\n *\n * **Nested property access (dot notation):**\n * ```ts\n * parseMessageTemplate(\"Hello, {user.name}!\", {\n *   user: { name: \"foo\", email: \"foo@example.com\" }\n * })\n * // Returns: [\"Hello, \", \"foo\", \"!\"]\n * ```\n *\n * **Array indexing:**\n * ```ts\n * parseMessageTemplate(\"First: {users[0]}\", {\n *   users: [\"foo\", \"bar\", \"baz\"]\n * })\n * // Returns: [\"First: \", \"foo\", \"\"]\n * ```\n *\n * **Bracket notation for special property names:**\n * ```ts\n * parseMessageTemplate(\"Name: {user[\\\"full-name\\\"]}\", {\n *   user: { \"full-name\": \"foo bar\" }\n * })\n * // Returns: [\"Name: \", \"foo bar\", \"\"]\n * ```\n *\n * **Optional chaining for safe navigation:**\n * ```ts\n * parseMessageTemplate(\"Email: {user?.profile?.email}\", {\n *   user: { name: \"foo\" }\n * })\n * // Returns: [\"Email: \", undefined, \"\"]\n * ```\n *\n * **Wildcard patterns:**\n * - `{*}` - Replaced with the entire properties object\n * - `{ key-with-whitespace }` - Whitespace is trimmed when looking up keys\n *\n * **Escaping:**\n * - `{{` and `}}` are escaped literal braces\n *\n * **Error handling:**\n * - Non-existent paths return `undefined`\n * - Malformed expressions resolve to `undefined` without throwing errors\n * - Out of bounds array access returns `undefined`\n *\n * @param template The message template string containing placeholders.\n * @param properties The values to replace placeholders with.\n * @returns The message template array with values interleaved between text segments.\n */\nexport function parseMessageTemplate(\n  template: string,\n  properties: Record<string, unknown>,\n): readonly unknown[] {\n  const length = template.length;\n  if (length === 0) return [\"\"];\n\n  // Fast path: no placeholders\n  if (!template.includes(\"{\")) return [template];\n\n  const message: unknown[] = [];\n  let startIndex = 0;\n\n  for (let i = 0; i < length; i++) {\n    const char = template[i];\n\n    if (char === \"{\") {\n      const nextChar = i + 1 < length ? template[i + 1] : \"\";\n\n      if (nextChar === \"{\") {\n        // Escaped { character - skip and continue\n        i++; // Skip the next {\n        continue;\n      }\n\n      // Find the closing }\n      const closeIndex = template.indexOf(\"}\", i + 1);\n      if (closeIndex === -1) {\n        // No closing } found, treat as literal text\n        continue;\n      }\n\n      // Add text before placeholder\n      const beforeText = template.slice(startIndex, i);\n      message.push(beforeText.replace(/{{/g, \"{\").replace(/}}/g, \"}\"));\n\n      // Extract and process placeholder key\n      const key = template.slice(i + 1, closeIndex);\n\n      // Resolve property value\n      let prop: unknown;\n\n      // Check for wildcard patterns\n      const trimmedKey = key.trim();\n      if (trimmedKey === \"*\") {\n        // This is a wildcard pattern\n        prop = key in properties\n          ? properties[key]\n          : \"*\" in properties\n          ? properties[\"*\"]\n          : properties;\n      } else {\n        // Regular property lookup with possible whitespace handling\n        if (key !== trimmedKey) {\n          // Key has leading/trailing whitespace\n          prop = key in properties ? properties[key] : properties[trimmedKey];\n        } else {\n          // Key has no leading/trailing whitespace\n          prop = properties[key];\n        }\n\n        // If property not found directly and this looks like nested access, try nested resolution\n        if (prop === undefined && isNestedAccess(trimmedKey)) {\n          prop = resolvePropertyPath(properties, trimmedKey);\n        }\n      }\n\n      message.push(prop);\n      i = closeIndex; // Move to the }\n      startIndex = i + 1;\n    } else if (char === \"}\" && i + 1 < length && template[i + 1] === \"}\") {\n      // Escaped } character - skip\n      i++; // Skip the next }\n    }\n  }\n\n  // Add remaining text\n  const remainingText = template.slice(startIndex);\n  message.push(remainingText.replace(/{{/g, \"{\").replace(/}}/g, \"}\"));\n\n  return message;\n}\n\n/**\n * Render a message template with values.\n * @param template The message template.\n * @param values The message template values.\n * @returns The message template values interleaved between the substitution\n *          values.\n */\nexport function renderMessage(\n  template: TemplateStringsArray,\n  values: readonly unknown[],\n): unknown[] {\n  const args = [];\n  for (let i = 0; i < template.length; i++) {\n    args.push(template[i]);\n    if (i < values.length) args.push(values[i]);\n  }\n  return args;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "2.1.0-dev.522+3619ad7b",
+  "version": "2.1.0-dev.531+0f09947c",
   "description": "Unobtrusive logging library with zero dependencies—library-first design for Deno/Node.js/Bun/browsers/edge",
   "keywords": [
     "logging",