@dbx-tools/shared-core 0.6.69 → 0.6.70

package/lib/src/log.d.ts

@@ -2,17 +2,20 @@
  * Tagged, leveled logging for every runtime - the one logger the whole
  * monorepo shares.
  *
- * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}
- * chosen once at module load. {@link LogLevel} filtering runs through
- * {@link shouldEmit} in the consola reporter or in per-level wrappers on the
- * `console` fallbacks.
+ * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}.
+ * The factory starts as a synchronous console sink so this module never uses
+ * top-level `await` (that left importers with a null namespace mid-load in
+ * browser bundles). A memoized async chain then upgrades to consola when it
+ * is available. {@link LogLevel} filtering runs through {@link shouldEmit} in
+ * the consola reporter or in per-level wrappers on the `console` fallbacks.
  *
  * Sink selection chains two factories with nullish coalescing (first match
  * wins):
  *
  * 1. {@link createConsolaLoggerFactory} when consola resolves and
  *    `LOG_CONSOLA_DISABLED` is not truthy.
- * 2. {@link createConsoleLoggerFactory} everywhere else.
+ * 2. {@link createConsoleLoggerFactory} everywhere else (also the sync
+ *    bootstrap before that promise settles).
  *
  * The console fallback writes formatted lines to `process.stderr` when it is
  * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is
@@ -21,8 +24,8 @@
  * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`
  * tag.
  *
- * Env toggles (read once at init): `LOG_LEVEL`, `LOG_CONSOLA_DISABLED`,
- * `LOG_BUN_CONSOLE_DISABLED`.
+ * Env toggles: `LOG_LEVEL` (read per call), `LOG_CONSOLA_DISABLED` /
+ * `LOG_BUN_CONSOLE_DISABLED` (read once during factory init).
  *
  * Browser-safe: `process` / `Bun` / `window` / `document` are all reached
  * through `globalThis` and guarded, consola loads lazily, and `node:util` is

package/lib/src/log.js

@@ -2,17 +2,20 @@
  * Tagged, leveled logging for every runtime - the one logger the whole
  * monorepo shares.
  *
- * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}
- * chosen once at module load. {@link LogLevel} filtering runs through
- * {@link shouldEmit} in the consola reporter or in per-level wrappers on the
- * `console` fallbacks.
+ * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}.
+ * The factory starts as a synchronous console sink so this module never uses
+ * top-level `await` (that left importers with a null namespace mid-load in
+ * browser bundles). A memoized async chain then upgrades to consola when it
+ * is available. {@link LogLevel} filtering runs through {@link shouldEmit} in
+ * the consola reporter or in per-level wrappers on the `console` fallbacks.
  *
  * Sink selection chains two factories with nullish coalescing (first match
  * wins):
  *
  * 1. {@link createConsolaLoggerFactory} when consola resolves and
  *    `LOG_CONSOLA_DISABLED` is not truthy.
- * 2. {@link createConsoleLoggerFactory} everywhere else.
+ * 2. {@link createConsoleLoggerFactory} everywhere else (also the sync
+ *    bootstrap before that promise settles).
  *
  * The console fallback writes formatted lines to `process.stderr` when it is
  * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is
@@ -21,8 +24,8 @@
  * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`
  * tag.
  *
- * Env toggles (read once at init): `LOG_LEVEL`, `LOG_CONSOLA_DISABLED`,
- * `LOG_BUN_CONSOLE_DISABLED`.
+ * Env toggles: `LOG_LEVEL` (read per call), `LOG_CONSOLA_DISABLED` /
+ * `LOG_BUN_CONSOLE_DISABLED` (read once during factory init).
  *
  * Browser-safe: `process` / `Bun` / `window` / `document` are all reached
  * through `globalThis` and guarded, consola loads lazily, and `node:util` is
@@ -160,6 +163,15 @@ async function createConsoleLoggerFactory(globalProcessStdErr) {
     const utils = globalProcessStdErr === undefined
         ? undefined
         : await import(__rewriteRelativeImportExtension(/* @vite-ignore */ nodeUtil)).catch(() => undefined);
+    return consoleLoggerFactory(globalProcessStdErr, utils);
+}
+/**
+ * The synchronous core of {@link createConsoleLoggerFactory}, split out so the
+ * same emitter also serves as the bootstrap sink before any async factory has
+ * resolved. `utils` is `node:util` when it loaded; without it, object arguments
+ * format through the `JSON.stringify` fallback.
+ */
+function consoleLoggerFactory(globalProcessStdErr, utils) {
     const bunInspect = globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)
         ? globalBun.inspect
         : undefined;
@@ -229,14 +241,43 @@ async function createConsoleLoggerFactory(globalProcessStdErr) {
     return (name) => (name ? factory(name) : defaultFactory());
 }
 /**
- * Module-scoped {@link LoggerFactory}, initialized once via top-level `await`.
- * Delegates to {@link createConsolaLoggerFactory}, then
- * {@link createConsoleLoggerFactory}. Each {@link logger} call invokes the
- * chosen factory with a resolved tag. Env toggles are read only during init.
+ * Preferred factory: consola when it loads, else the full console sink (with
+ * optional `node:util` inspect). Memoized so concurrent / repeat callers share
+ * one in-flight promise and one settled result.
  */
-const createLogger = await (async () => {
+const resolveFactory = memoize(async () => {
     return ((await createConsolaLoggerFactory()) ?? (await createConsoleLoggerFactory(globalProcessStdErr)));
-})();
+});
+/**
+ * Active factory starts as a sync console sink (no `await`, so this module
+ * finishes evaluating immediately) and swaps to {@link resolveFactory}'s
+ * result when that lands. Kick the resolve off at load so consola is usually
+ * ready before the first interesting log line.
+ */
+let activeFactory = consoleLoggerFactory(globalProcessStdErr);
+void resolveFactory().then((factory) => {
+    activeFactory = factory;
+}, () => {
+    // Keep the sync console sink; never leave importers without a factory.
+});
+/**
+ * Build a logger that rebinds when {@link activeFactory} upgrades. Callers that
+ * capture `const log = logger("x")` at module scope still get consola once it
+ * arrives, without every call site waiting on a promise.
+ */
+function createLogger(name) {
+    let bound;
+    const sink = () => {
+        if (bound?.factory !== activeFactory) {
+            bound = { factory: activeFactory, logger: activeFactory(name) };
+        }
+        return bound.logger;
+    };
+    return Object.fromEntries([...LOG_LEVELS, "success", "start"].map((level) => [
+        level,
+        (...args) => sink()[level](...args),
+    ]));
+}
 /**
  * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone
  * in browsers (either part omitted when absent). Applies per-level ANSI color
@@ -366,4 +407,4 @@ export function logger(loggerName) {
     const name = extractLoggerName(loggerName);
     return createLogger(name);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.js","sourceRoot":"","sources":["../../src/log.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tagged, leveled logging for every runtime - the one logger the whole\n * monorepo shares.\n *\n * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}\n * chosen once at module load. {@link LogLevel} filtering runs through\n * {@link shouldEmit} in the consola reporter or in per-level wrappers on the\n * `console` fallbacks.\n *\n * Sink selection chains two factories with nullish coalescing (first match\n * wins):\n *\n * 1. {@link createConsolaLoggerFactory} when consola resolves and\n *    `LOG_CONSOLA_DISABLED` is not truthy.\n * 2. {@link createConsoleLoggerFactory} everywhere else.\n *\n * The console fallback writes formatted lines to `process.stderr` when it is\n * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is\n * unset, otherwise `node:util` `formatWithOptions`), or delegates to global\n * `console.*` when stderr or `node:util` is unavailable. Browser hosts omit\n * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`\n * tag.\n *\n * Env toggles (read once at init): `LOG_LEVEL`, `LOG_CONSOLA_DISABLED`,\n * `LOG_BUN_CONSOLE_DISABLED`.\n *\n * Browser-safe: `process` / `Bun` / `window` / `document` are all reached\n * through `globalThis` and guarded, consola loads lazily, and `node:util` is\n * imported ONLY on a host that has `process.stderr` - never in a browser,\n * where the specifier is unresolvable - so the module works in any runtime.\n * Consola is an optional peer; the module loads fine without it.\n *\n * @module\n */\n\nimport { memoize } from \"./function.ts\";\nimport { type NameLike, toBoolean } from \"./object.ts\";\n\n/** `process`-shaped view off `globalThis`, so no node types are needed. */\ninterface ProcessLike {\n  env?: Record<string, string | undefined>;\n  stderr?: { write?: (chunk: string) => void; isTTY?: unknown };\n}\n\n/** `Bun`-shaped view off `globalThis`, so no `@types/bun` is needed. */\ninterface BunLike {\n  env?: Record<string, string | undefined>;\n  inspect?: (value: unknown, options?: { colors?: boolean; depth?: number }) => string;\n}\n\nconst globalProcess = (globalThis as { process?: ProcessLike }).process;\nconst globalBun = (globalThis as { Bun?: BunLike }).Bun;\n\n/**\n * Node `process.stderr` when writable, else `undefined` (stable for the\n * process). Typed loosely (`any`) because it is handed to consola's\n * `ctx.options.stdout` (a `WriteStream`) and to the console fallback's\n * `.write`, neither of which our structural {@link ProcessLike} shape satisfies\n * nominally.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst globalProcessStdErr: any =\n  globalProcess && typeof globalProcess.stderr?.write === \"function\"\n    ? globalProcess.stderr\n    : undefined;\n\nconst LOG_LEVELS = [\"debug\", \"info\", \"warn\", \"error\"] as const;\nconst LOG_LEVEL_RANK = Object.fromEntries(\n  LOG_LEVELS.map((level, index) => [level, index]),\n) as Record<LogLevel, number>;\nconst LOG_LEVEL_COLORS = Object.fromEntries(\n  LOG_LEVELS.map((level) => {\n    let color = \"\\x1b[90m\"; // gray\n    switch (level) {\n      case \"info\":\n        color = \"\\x1b[34m\"; // blue\n        break;\n      case \"warn\":\n        color = \"\\x1b[33m\"; // yellow\n        break;\n      case \"error\":\n        color = \"\\x1b[31m\"; // red\n        break;\n    }\n    return [level, color];\n  }),\n) as Record<LogLevel, string>;\nconst LOG_LEVEL_COLOR_RESET = \"\\x1b[0m\";\nconst DEFAULT_LEVEL: LogLevel = \"info\";\n\n/**\n * Supported severities, lowest to highest: `debug`, `info`, `warn`, `error`.\n * A call below the active threshold is discarded before any string work or\n * sink I/O.\n *\n * The threshold comes from `process.env.LOG_LEVEL` on every call\n * (case-insensitive, default `info` when unset, empty, or unknown) so test\n * runners and embedders can change verbosity after import without restarting\n * the process.\n */\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\nexport type Logger = {\n  [K in LogLevel]: (...args: any[]) => void;\n} & {\n  /** Success message (consola `success`; falls back to `info`-level output). */\n  success: (...args: any[]) => void;\n  /** Start / in-progress message (consola `start`; falls back to `info`-level output). */\n  start: (...args: any[]) => void;\n};\n\n/** `(name?) => Logger` sink constructor returned by the init-time factory chain. */\ntype LoggerFactory = (name?: string) => Logger;\n\n/**\n * Consola-backed {@link LoggerFactory}, or `undefined` when consola is\n * disabled, fails to import, or throws during setup.\n *\n * Builds one `createConsola` instance (badge off, level `verbose`) whose\n * reporter calls {@link shouldEmit} on `logObj.type` before delegating to\n * consola's default reporters. In Node, when `globalProcessStdErr` is set,\n * recognized {@link LogLevel} types are redirected to stderr for that write.\n * Tags use `withTag` (rendered `[name]`, not merged into args).\n *\n * Memoized: the dynamic `consola` import, env checks, and `createConsola`\n * setup (plus the import/throw fallback) run once; later calls share the one\n * resolved factory (or the one resolved `undefined`). A rejection is evicted\n * by {@link memoize} so a later call retries.\n */\nconst createConsolaLoggerFactory = memoize(async (): Promise<LoggerFactory | undefined> => {\n  const consolaDisabled = toBoolean(globalProcess?.env?.LOG_CONSOLA_DISABLED);\n  if (!consolaDisabled) {\n    try {\n      const { consola, createConsola, LogLevels } = await import(/* @vite-ignore */ \"consola\");\n      const defaultOptions = consola.options;\n      const createConsolaOptions = {\n        ...consola.options,\n        defaults: { badge: false },\n        // `LOG_LEVEL` is enforced in {@link shouldEmit}; keep consola permissive\n        // so a threshold change after import is not blocked by its own filter.\n        level: LogLevels.verbose,\n        reporters: [\n          {\n            log: (logObj, ctx) => {\n              const logLevel = parseLogLevel(logObj.type);\n              if (!shouldEmit(logLevel, true)) return;\n              const ctxStdout = ctx.options.stdout;\n              try {\n                if (globalProcessStdErr !== undefined && logLevel !== undefined) {\n                  ctx.options.stdout = globalProcessStdErr;\n                }\n                defaultOptions.reporters.forEach((reporter) => reporter.log(logObj, ctx));\n              } finally {\n                ctx.options.stdout = ctxStdout;\n              }\n            },\n          },\n        ],\n      } as NonNullable<Parameters<typeof createConsola>[0]>;\n      const consolaLogger = createConsola(createConsolaOptions);\n      return (name?: string) => {\n        return name ? consolaLogger.withTag(name) : consolaLogger;\n      };\n    } catch (error) {\n      // consola is an OPTIONAL peer - not having it installed is the EXPECTED\n      // path (the module degrades to the console fallback), so this is not an\n      // error. Note it only at debug level, and without a stack trace (the\n      // message, not `console.trace`, so a missing optional dep stays quiet).\n      if (isLevelEnabled(\"debug\")) {\n        console.debug(\"consola not available; using console fallback:\", String(error));\n      }\n    }\n  }\n  return undefined;\n});\n\n/**\n * Console {@link LoggerFactory}; always succeeds.\n *\n * When `process.stderr` is available, formats each line and writes only to\n * stderr. Bun `inspect` formats each argument when enabled; otherwise\n * `util.inspect` when `node:util` loads, or a `JSON.stringify` fallback when\n * it does not. When stderr is unavailable (every browser), binds\n * {@link createFormatter} prefixes into global `console.*` calls and skips the\n * `node:util` import entirely.\n */\nasync function createConsoleLoggerFactory(globalProcessStdErr: any): Promise<LoggerFactory> {\n  // Indirect specifier so this browser-safe module doesn't statically pull in\n  // node types: `node:util` is optional (the JSON fallback covers its absence).\n  const nodeUtil = \"node:util\";\n  // Gated, not just caught: the indirect specifier defeats bundler analysis by\n  // design, so a client build emits a literal `import(\"node:util\")` that no\n  // browser can resolve, and the caught rejection still surfaced as a console\n  // error. `utils` only feeds the stderr branch of the emitter below, so no\n  // stderr means the import has nothing to serve and is skipped outright.\n  const utils: { inspect?: any } | undefined =\n    globalProcessStdErr === undefined\n      ? undefined\n      : await import(/* @vite-ignore */ nodeUtil).catch(() => undefined);\n  const bunInspect =\n    globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)\n      ? globalBun.inspect\n      : undefined;\n  const resetColorsPrefix = bunInspect !== undefined;\n\n  const inspect = (arg: any, colors?: boolean) => {\n    if (Array.isArray(arg) || (typeof arg === \"object\" && arg !== null)) {\n      if (bunInspect !== undefined) {\n        return bunInspect(arg, {\n          colors: colors,\n          depth: utils?.inspect?.defaultOptions?.depth ?? undefined,\n        });\n      } else if (utils !== undefined) {\n        return utils.inspect(arg, {\n          ...utils?.inspect?.defaultOptions,\n          colors: false,\n        });\n      } else {\n        const seen = new WeakSet();\n        return JSON.stringify(arg, (_, value) => {\n          if (typeof value === \"object\" && value !== null) {\n            if (seen.has(value)) return \"[Circular]\";\n            seen.add(value);\n          }\n          return value;\n        });\n      }\n    } else {\n      return String(arg);\n    }\n  };\n\n  const factory = (name?: string) => {\n    const prefixFormatter = createFormatter(name, globalProcessStdErr, resetColorsPrefix);\n    const logger = Object.fromEntries(\n      LOG_LEVELS.map((level) => {\n        const { prefix, colors, resetColors } = prefixFormatter(level);\n        const emitter = (...args: any[]) => {\n          if (!shouldEmit(level, true)) return;\n          if (globalProcessStdErr !== undefined) {\n            const messageParts = prefix ? [prefix] : [];\n            messageParts.push(...args.map((arg) => inspect(arg, colors)));\n            if (resetColors) messageParts.push(LOG_LEVEL_COLOR_RESET);\n            globalProcessStdErr.write(messageParts.join(\" \") + \"\\n\");\n          } else {\n            let levelFn = console[level];\n            if (typeof levelFn !== \"function\") {\n              levelFn = console.log;\n            }\n            if (prefix) levelFn = levelFn.bind(console, prefix);\n            levelFn(...args);\n          }\n        };\n        return [level, emitter];\n      }),\n    ) as Logger;\n    // consola sugar the console fallback doesn't have natively - route to info.\n    logger.success = logger.info;\n    logger.start = logger.info;\n    return logger;\n  };\n  const defaultFactory = memoize(factory);\n  return (name?: string) => (name ? factory(name) : defaultFactory());\n}\n\n/**\n * Module-scoped {@link LoggerFactory}, initialized once via top-level `await`.\n * Delegates to {@link createConsolaLoggerFactory}, then\n * {@link createConsoleLoggerFactory}. Each {@link logger} call invokes the\n * chosen factory with a resolved tag. Env toggles are read only during init.\n */\nconst createLogger: LoggerFactory = await (async () => {\n  return (\n    (await createConsolaLoggerFactory()) ?? (await createConsoleLoggerFactory(globalProcessStdErr))\n  );\n})();\n\n/**\n * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone\n * in browsers (either part omitted when absent). Applies per-level ANSI color\n * when `streamSupportsColor` is true for the given stderr stream.\n */\nfunction createFormatter(\n  name: any,\n  stream: any,\n  resetColorsPrefix?: boolean,\n): (level?: LogLevel) => { prefix: string; colors: boolean; resetColors: boolean } {\n  const glob = globalThis as { window?: unknown; document?: unknown };\n  const isBrowser = glob.window !== undefined && glob.document !== undefined;\n  const supportsColor = !isBrowser ? streamSupportsColor(stream) : false;\n  const namePrefix = name ? \"[\" + name + \"]\" : undefined;\n  return (level?: LogLevel) => {\n    const color = supportsColor && level !== undefined ? LOG_LEVEL_COLORS[level] : undefined;\n    let prefix = [!isBrowser && level ? level.toUpperCase() : undefined, namePrefix]\n      .filter(Boolean)\n      .join(\" \");\n    let resetColors = false;\n    if (color) {\n      const applyResetColorsPrefix = resetColorsPrefix || \"info\" === level;\n      if (!applyResetColorsPrefix) resetColors = true;\n      prefix = applyResetColorsPrefix ? color + prefix + LOG_LEVEL_COLOR_RESET : color + prefix;\n    }\n    return { prefix, colors: color ? true : false, resetColors };\n  };\n}\n\n/** True when `stream` is a TTY and the terminal is not `dumb`. */\nfunction streamSupportsColor(stream?: unknown): boolean {\n  if (globalProcess === undefined || typeof stream !== \"object\" || stream === null) return false;\n  const { isTTY } = stream as { isTTY?: unknown };\n  if (isTTY !== true) return false;\n  const term = globalProcess.env?.TERM?.toLowerCase();\n  if (\"dumb\" == term) return false;\n  return true;\n}\n\n/** Parse a raw value as {@link LogLevel} (trimmed, case-insensitive). */\nfunction parseLogLevel(raw: unknown): LogLevel | undefined {\n  if (raw === undefined || raw === null) {\n    return undefined;\n  }\n  let text = typeof raw === \"string\" ? raw : String(raw);\n  for (let i = 0; i < 2; i++) {\n    if (i > 0) {\n      const normalized = text.trim().toLowerCase();\n      if (text === normalized) break;\n      text = normalized;\n    }\n    if (!text) {\n      break;\n    } else if (text in LOG_LEVEL_RANK) {\n      return text as LogLevel;\n    }\n  }\n  return undefined;\n}\n\n/** Active threshold from `process.env.LOG_LEVEL`, default {@link DEFAULT_LEVEL}. */\nfunction activeLevel(): LogLevel {\n  return parseLogLevel(globalProcess?.env?.LOG_LEVEL) ?? DEFAULT_LEVEL;\n}\n\n/**\n * Whether `raw` meets the current `LOG_LEVEL` threshold.\n *\n * Parses `raw` as a {@link LogLevel}; when parsing fails, returns\n * `defaultResult` if supplied, otherwise `false`. Used for consola reporter\n * lines where unknown `logObj.type` values should pass through when\n * `defaultResult` is `true`.\n */\nfunction shouldEmit(raw: unknown, defaultResult?: boolean): boolean {\n  const level = parseLogLevel(raw);\n  if (level === undefined) return defaultResult ?? false;\n  return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[activeLevel()];\n}\n\n/**\n * Whether a call at `level` would be emitted at the current\n * `process.env.LOG_LEVEL` threshold. Use before building expensive debug\n * payloads.\n *\n * @example\n * if (isLevelEnabled(\"debug\")) {\n *   log.debug(\"mounts:resolver\", { contribution: await heavySnapshot() });\n * }\n */\nexport function isLevelEnabled(level: LogLevel): boolean {\n  return shouldEmit(level);\n}\n\nconst LOGGER_NAME_REGEX = /^(?:[a-z][a-z0-9+.-]*:\\/\\/)?.*\\/([^/.]+)(?:\\.[^/]+)?$/i;\n\n/**\n * Derive the tag string from a logger name, plugin, or path. Slash- and\n * URL-shaped strings use the last path segment (extension stripped); plain\n * strings pass through unchanged. Empty or missing names -> `undefined`\n * (untagged sink).\n */\nfunction extractLoggerName(loggerName: NameLike | string | undefined): string | undefined {\n  if (!loggerName) return undefined;\n  if (typeof loggerName === \"string\") {\n    const match = loggerName.match(LOGGER_NAME_REGEX);\n    return match?.[1] ?? loggerName;\n  }\n  return extractLoggerName(loggerName.name);\n}\n\n/**\n * Build a tagged logger for a plugin or module.\n *\n * The tag is `[name]` when `loggerName` is a non-empty string, a\n * {@link NameLike} with `name`, or a file / URL path (the basename without\n * extension is used). Consola applies the tag via `withTag` (render-time).\n * The `console` fallbacks prepend `LEVEL [name]` on Node/Bun hosts or `[name]`\n * alone in browsers via {@link createFormatter}.\n *\n * Calls below `process.env.LOG_LEVEL` are dropped by {@link shouldEmit} before\n * the sink formats or writes the line.\n *\n * @example\n * import { log } from \"@dbx-tools/shared-core\";\n *\n * const logger = log.logger(\"genie/chat\");\n * logger.info(\"starting\");\n * logger.warn(\"missing optional config\", { reason: \"no env var\" });\n */\nexport function logger(loggerName: NameLike | string | undefined): Logger {\n  const name = extractLoggerName(loggerName);\n  return createLogger(name);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.js","sourceRoot":"","sources":["../../src/log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;;;;;;;;;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAiB,SAAS,EAAE,MAAM,aAAa,CAAC;AAcvD,MAAM,aAAa,GAAI,UAAwC,CAAC,OAAO,CAAC;AACxE,MAAM,SAAS,GAAI,UAAgC,CAAC,GAAG,CAAC;AAExD;;;;;;GAMG;AACH,8DAA8D;AAC9D,MAAM,mBAAmB,GACvB,aAAa,IAAI,OAAO,aAAa,CAAC,MAAM,EAAE,KAAK,KAAK,UAAU;IAChE,CAAC,CAAC,aAAa,CAAC,MAAM;IACtB,CAAC,CAAC,SAAS,CAAC;AAEhB,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAU,CAAC;AAC/D,MAAM,cAAc,GAAG,MAAM,CAAC,WAAW,CACvC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CACrB,CAAC;AAC9B,MAAM,gBAAgB,GAAG,MAAM,CAAC,WAAW,CACzC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;IACvB,IAAI,KAAK,GAAG,UAAU,CAAC,CAAC,OAAO;IAC/B,QAAQ,KAAK,EAAE,CAAC;QACd,KAAK,MAAM;YACT,KAAK,GAAG,UAAU,CAAC,CAAC,OAAO;YAC3B,MAAM;QACR,KAAK,MAAM;YACT,KAAK,GAAG,UAAU,CAAC,CAAC,SAAS;YAC7B,MAAM;QACR,KAAK,OAAO;YACV,KAAK,GAAG,UAAU,CAAC,CAAC,MAAM;YAC1B,MAAM;IACV,CAAC;IACD,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AACxB,CAAC,CAAC,CACyB,CAAC;AAC9B,MAAM,qBAAqB,GAAG,SAAS,CAAC;AACxC,MAAM,aAAa,GAAa,MAAM,CAAC;AA0BvC;;;;;;;;;;;;;;GAcG;AACH,MAAM,0BAA0B,GAAG,OAAO,CAAC,KAAK,IAAwC,EAAE;IACxF,MAAM,eAAe,GAAG,SAAS,CAAC,aAAa,EAAE,GAAG,EAAE,oBAAoB,CAAC,CAAC;IAC5E,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,IAAI,CAAC;YACH,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;YACzF,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;YACvC,MAAM,oBAAoB,GAAG;gBAC3B,GAAG,OAAO,CAAC,OAAO;gBAClB,QAAQ,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;gBAC1B,yEAAyE;gBACzE,uEAAuE;gBACvE,KAAK,EAAE,SAAS,CAAC,OAAO;gBACxB,SAAS,EAAE;oBACT;wBACE,GAAG,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;4BACnB,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;4BAC5C,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC;gCAAE,OAAO;4BACxC,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC;4BACrC,IAAI,CAAC;gCACH,IAAI,mBAAmB,KAAK,SAAS,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;oCAChE,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,mBAAmB,CAAC;gCAC3C,CAAC;gCACD,cAAc,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;4BAC5E,CAAC;oCAAS,CAAC;gCACT,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;4BACjC,CAAC;wBACH,CAAC;qBACF;iBACF;aACkD,CAAC;YACtD,MAAM,aAAa,GAAG,aAAa,CAAC,oBAAoB,CAAC,CAAC;YAC1D,OAAO,CAAC,IAAa,EAAE,EAAE;gBACvB,OAAO,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;YAC5D,CAAC,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,wEAAwE;YACxE,wEAAwE;YACxE,qEAAqE;YACrE,wEAAwE;YACxE,IAAI,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC5B,OAAO,CAAC,KAAK,CAAC,gDAAgD,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACjF,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC,CAAC;AAEH;;;;;;;;;GASG;AACH,KAAK,UAAU,0BAA0B,CAAC,mBAAwB;IAChE,4EAA4E;IAC5E,8EAA8E;IAC9E,MAAM,QAAQ,GAAG,WAAW,CAAC;IAC7B,6EAA6E;IAC7E,0EAA0E;IAC1E,4EAA4E;IAC5E,0EAA0E;IAC1E,wEAAwE;IACxE,MAAM,KAAK,GACT,mBAAmB,KAAK,SAAS;QAC/B,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,MAAM,MAAM,kCAAC,kBAAkB,CAAC,QAAQ,EAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACvE,OAAO,oBAAoB,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;GAKG;AACH,SAAS,oBAAoB,CAC3B,mBAAwB,EACxB,KAAqC;IAErC,MAAM,UAAU,GACd,SAAS,KAAK,SAAS,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,wBAAwB,CAAC;QAC5E,CAAC,CAAC,SAAS,CAAC,OAAO;QACnB,CAAC,CAAC,SAAS,CAAC;IAChB,MAAM,iBAAiB,GAAG,UAAU,KAAK,SAAS,CAAC;IAEnD,MAAM,OAAO,GAAG,CAAC,GAAQ,EAAE,MAAgB,EAAE,EAAE;QAC7C,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,CAAC,EAAE,CAAC;YACpE,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;gBAC7B,OAAO,UAAU,CAAC,GAAG,EAAE;oBACrB,MAAM,EAAE,MAAM;oBACd,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,IAAI,SAAS;iBAC1D,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC/B,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE;oBACxB,GAAG,KAAK,EAAE,OAAO,EAAE,cAAc;oBACjC,MAAM,EAAE,KAAK;iBACd,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;gBAC3B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;oBACtC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;wBAChD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;4BAAE,OAAO,YAAY,CAAC;wBACzC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAClB,CAAC;oBACD,OAAO,KAAK,CAAC;gBACf,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;aAAM,CAAC;YACN,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;QACrB,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,CAAC,IAAa,EAAE,EAAE;QAChC,MAAM,eAAe,GAAG,eAAe,CAAC,IAAI,EAAE,mBAAmB,EAAE,iBAAiB,CAAC,CAAC;QACtF,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAC/B,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACvB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;YAC/D,MAAM,OAAO,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE;gBACjC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC;oBAAE,OAAO;gBACrC,IAAI,mBAAmB,KAAK,SAAS,EAAE,CAAC;oBACtC,MAAM,YAAY,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC5C,YAAY,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;oBAC9D,IAAI,WAAW;wBAAE,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;oBAC1D,mBAAmB,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;gBAC3D,CAAC;qBAAM,CAAC;oBACN,IAAI,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;oBAC7B,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;wBAClC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;oBACxB,CAAC;oBACD,IAAI,MAAM;wBAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;oBACpD,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;gBACnB,CAAC;YACH,CAAC,CAAC;YACF,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAC1B,CAAC,CAAC,CACO,CAAC;QACZ,4EAA4E;QAC5E,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;QAC7B,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;QAC3B,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IACF,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,CAAC,IAAa,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC;AACtE,CAAC;AAED;;;;GAIG;AACH,MAAM,cAAc,GAAG,OAAO,CAAC,KAAK,IAA4B,EAAE;IAChE,OAAO,CACL,CAAC,MAAM,0BAA0B,EAAE,CAAC,IAAI,CAAC,MAAM,0BAA0B,CAAC,mBAAmB,CAAC,CAAC,CAChG,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH;;;;;GAKG;AACH,IAAI,aAAa,GAAkB,oBAAoB,CAAC,mBAAmB,CAAC,CAAC;AAC7E,KAAK,cAAc,EAAE,CAAC,IAAI,CACxB,CAAC,OAAO,EAAE,EAAE;IACV,aAAa,GAAG,OAAO,CAAC;AAC1B,CAAC,EACD,GAAG,EAAE;IACH,uEAAuE;AACzE,CAAC,CACF,CAAC;AAEF;;;;GAIG;AACH,SAAS,YAAY,CAAC,IAAa;IACjC,IAAI,KAA6D,CAAC;IAClE,MAAM,IAAI,GAAG,GAAW,EAAE;QACxB,IAAI,KAAK,EAAE,OAAO,KAAK,aAAa,EAAE,CAAC;YACrC,KAAK,GAAG,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;QAClE,CAAC;QACD,OAAO,KAAK,CAAC,MAAM,CAAC;IACtB,CAAC,CAAC;IACF,OAAO,MAAM,CAAC,WAAW,CACvB,CAAC,GAAG,UAAU,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;QACjD,KAAK;QACL,CAAC,GAAG,IAAW,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAqB,CAAC,CAAC,GAAG,IAAI,CAAC;KAC3D,CAAC,CACO,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CACtB,IAAS,EACT,MAAW,EACX,iBAA2B;IAE3B,MAAM,IAAI,GAAG,UAAsD,CAAC;IACpE,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,CAAC;IAC3E,MAAM,aAAa,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACvE,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IACvD,OAAO,CAAC,KAAgB,EAAE,EAAE;QAC1B,MAAM,KAAK,GAAG,aAAa,IAAI,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACzF,IAAI,MAAM,GAAG,CAAC,CAAC,SAAS,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,UAAU,CAAC;aAC7E,MAAM,CAAC,OAAO,CAAC;aACf,IAAI,CAAC,GAAG,CAAC,CAAC;QACb,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,sBAAsB,GAAG,iBAAiB,IAAI,MAAM,KAAK,KAAK,CAAC;YACrE,IAAI,CAAC,sBAAsB;gBAAE,WAAW,GAAG,IAAI,CAAC;YAChD,MAAM,GAAG,sBAAsB,CAAC,CAAC,CAAC,KAAK,GAAG,MAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC;QAC5F,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC;IAC/D,CAAC,CAAC;AACJ,CAAC;AAED,kEAAkE;AAClE,SAAS,mBAAmB,CAAC,MAAgB;IAC3C,IAAI,aAAa,KAAK,SAAS,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC/F,MAAM,EAAE,KAAK,EAAE,GAAG,MAA6B,CAAC;IAChD,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACjC,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IACpD,IAAI,MAAM,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IACjC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,yEAAyE;AACzE,SAAS,aAAa,CAAC,GAAY;IACjC,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;QACtC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,IAAI,GAAG,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACvD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACV,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC7C,IAAI,IAAI,KAAK,UAAU;gBAAE,MAAM;YAC/B,IAAI,GAAG,UAAU,CAAC;QACpB,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM;QACR,CAAC;aAAM,IAAI,IAAI,IAAI,cAAc,EAAE,CAAC;YAClC,OAAO,IAAgB,CAAC;QAC1B,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,oFAAoF;AACpF,SAAS,WAAW;IAClB,OAAO,aAAa,CAAC,aAAa,EAAE,GAAG,EAAE,SAAS,CAAC,IAAI,aAAa,CAAC;AACvE,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,UAAU,CAAC,GAAY,EAAE,aAAuB;IACvD,MAAM,KAAK,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,aAAa,IAAI,KAAK,CAAC;IACvD,OAAO,cAAc,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,KAAe;IAC5C,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;AAC3B,CAAC;AAED,MAAM,iBAAiB,GAAG,wDAAwD,CAAC;AAEnF;;;;;GAKG;AACH,SAAS,iBAAiB,CAAC,UAAyC;IAClE,IAAI,CAAC,UAAU;QAAE,OAAO,SAAS,CAAC;IAClC,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QACnC,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;QAClD,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC;IAClC,CAAC;IACD,OAAO,iBAAiB,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,MAAM,CAAC,UAAyC;IAC9D,MAAM,IAAI,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAC3C,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;AAC5B,CAAC","sourcesContent":["/**\n * Tagged, leveled logging for every runtime - the one logger the whole\n * monorepo shares.\n *\n * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}.\n * The factory starts as a synchronous console sink so this module never uses\n * top-level `await` (that left importers with a null namespace mid-load in\n * browser bundles). A memoized async chain then upgrades to consola when it\n * is available. {@link LogLevel} filtering runs through {@link shouldEmit} in\n * the consola reporter or in per-level wrappers on the `console` fallbacks.\n *\n * Sink selection chains two factories with nullish coalescing (first match\n * wins):\n *\n * 1. {@link createConsolaLoggerFactory} when consola resolves and\n *    `LOG_CONSOLA_DISABLED` is not truthy.\n * 2. {@link createConsoleLoggerFactory} everywhere else (also the sync\n *    bootstrap before that promise settles).\n *\n * The console fallback writes formatted lines to `process.stderr` when it is\n * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is\n * unset, otherwise `node:util` `formatWithOptions`), or delegates to global\n * `console.*` when stderr or `node:util` is unavailable. Browser hosts omit\n * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`\n * tag.\n *\n * Env toggles: `LOG_LEVEL` (read per call), `LOG_CONSOLA_DISABLED` /\n * `LOG_BUN_CONSOLE_DISABLED` (read once during factory init).\n *\n * Browser-safe: `process` / `Bun` / `window` / `document` are all reached\n * through `globalThis` and guarded, consola loads lazily, and `node:util` is\n * imported ONLY on a host that has `process.stderr` - never in a browser,\n * where the specifier is unresolvable - so the module works in any runtime.\n * Consola is an optional peer; the module loads fine without it.\n *\n * @module\n */\n\nimport { memoize } from \"./function.ts\";\nimport { type NameLike, toBoolean } from \"./object.ts\";\n\n/** `process`-shaped view off `globalThis`, so no node types are needed. */\ninterface ProcessLike {\n  env?: Record<string, string | undefined>;\n  stderr?: { write?: (chunk: string) => void; isTTY?: unknown };\n}\n\n/** `Bun`-shaped view off `globalThis`, so no `@types/bun` is needed. */\ninterface BunLike {\n  env?: Record<string, string | undefined>;\n  inspect?: (value: unknown, options?: { colors?: boolean; depth?: number }) => string;\n}\n\nconst globalProcess = (globalThis as { process?: ProcessLike }).process;\nconst globalBun = (globalThis as { Bun?: BunLike }).Bun;\n\n/**\n * Node `process.stderr` when writable, else `undefined` (stable for the\n * process). Typed loosely (`any`) because it is handed to consola's\n * `ctx.options.stdout` (a `WriteStream`) and to the console fallback's\n * `.write`, neither of which our structural {@link ProcessLike} shape satisfies\n * nominally.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst globalProcessStdErr: any =\n  globalProcess && typeof globalProcess.stderr?.write === \"function\"\n    ? globalProcess.stderr\n    : undefined;\n\nconst LOG_LEVELS = [\"debug\", \"info\", \"warn\", \"error\"] as const;\nconst LOG_LEVEL_RANK = Object.fromEntries(\n  LOG_LEVELS.map((level, index) => [level, index]),\n) as Record<LogLevel, number>;\nconst LOG_LEVEL_COLORS = Object.fromEntries(\n  LOG_LEVELS.map((level) => {\n    let color = \"\\x1b[90m\"; // gray\n    switch (level) {\n      case \"info\":\n        color = \"\\x1b[34m\"; // blue\n        break;\n      case \"warn\":\n        color = \"\\x1b[33m\"; // yellow\n        break;\n      case \"error\":\n        color = \"\\x1b[31m\"; // red\n        break;\n    }\n    return [level, color];\n  }),\n) as Record<LogLevel, string>;\nconst LOG_LEVEL_COLOR_RESET = \"\\x1b[0m\";\nconst DEFAULT_LEVEL: LogLevel = \"info\";\n\n/**\n * Supported severities, lowest to highest: `debug`, `info`, `warn`, `error`.\n * A call below the active threshold is discarded before any string work or\n * sink I/O.\n *\n * The threshold comes from `process.env.LOG_LEVEL` on every call\n * (case-insensitive, default `info` when unset, empty, or unknown) so test\n * runners and embedders can change verbosity after import without restarting\n * the process.\n */\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\nexport type Logger = {\n  [K in LogLevel]: (...args: any[]) => void;\n} & {\n  /** Success message (consola `success`; falls back to `info`-level output). */\n  success: (...args: any[]) => void;\n  /** Start / in-progress message (consola `start`; falls back to `info`-level output). */\n  start: (...args: any[]) => void;\n};\n\n/** `(name?) => Logger` sink constructor returned by the init-time factory chain. */\ntype LoggerFactory = (name?: string) => Logger;\n\n/**\n * Consola-backed {@link LoggerFactory}, or `undefined` when consola is\n * disabled, fails to import, or throws during setup.\n *\n * Builds one `createConsola` instance (badge off, level `verbose`) whose\n * reporter calls {@link shouldEmit} on `logObj.type` before delegating to\n * consola's default reporters. In Node, when `globalProcessStdErr` is set,\n * recognized {@link LogLevel} types are redirected to stderr for that write.\n * Tags use `withTag` (rendered `[name]`, not merged into args).\n *\n * Memoized: the dynamic `consola` import, env checks, and `createConsola`\n * setup (plus the import/throw fallback) run once; later calls share the one\n * resolved factory (or the one resolved `undefined`). A rejection is evicted\n * by {@link memoize} so a later call retries.\n */\nconst createConsolaLoggerFactory = memoize(async (): Promise<LoggerFactory | undefined> => {\n  const consolaDisabled = toBoolean(globalProcess?.env?.LOG_CONSOLA_DISABLED);\n  if (!consolaDisabled) {\n    try {\n      const { consola, createConsola, LogLevels } = await import(/* @vite-ignore */ \"consola\");\n      const defaultOptions = consola.options;\n      const createConsolaOptions = {\n        ...consola.options,\n        defaults: { badge: false },\n        // `LOG_LEVEL` is enforced in {@link shouldEmit}; keep consola permissive\n        // so a threshold change after import is not blocked by its own filter.\n        level: LogLevels.verbose,\n        reporters: [\n          {\n            log: (logObj, ctx) => {\n              const logLevel = parseLogLevel(logObj.type);\n              if (!shouldEmit(logLevel, true)) return;\n              const ctxStdout = ctx.options.stdout;\n              try {\n                if (globalProcessStdErr !== undefined && logLevel !== undefined) {\n                  ctx.options.stdout = globalProcessStdErr;\n                }\n                defaultOptions.reporters.forEach((reporter) => reporter.log(logObj, ctx));\n              } finally {\n                ctx.options.stdout = ctxStdout;\n              }\n            },\n          },\n        ],\n      } as NonNullable<Parameters<typeof createConsola>[0]>;\n      const consolaLogger = createConsola(createConsolaOptions);\n      return (name?: string) => {\n        return name ? consolaLogger.withTag(name) : consolaLogger;\n      };\n    } catch (error) {\n      // consola is an OPTIONAL peer - not having it installed is the EXPECTED\n      // path (the module degrades to the console fallback), so this is not an\n      // error. Note it only at debug level, and without a stack trace (the\n      // message, not `console.trace`, so a missing optional dep stays quiet).\n      if (isLevelEnabled(\"debug\")) {\n        console.debug(\"consola not available; using console fallback:\", String(error));\n      }\n    }\n  }\n  return undefined;\n});\n\n/**\n * Console {@link LoggerFactory}; always succeeds.\n *\n * When `process.stderr` is available, formats each line and writes only to\n * stderr. Bun `inspect` formats each argument when enabled; otherwise\n * `util.inspect` when `node:util` loads, or a `JSON.stringify` fallback when\n * it does not. When stderr is unavailable (every browser), binds\n * {@link createFormatter} prefixes into global `console.*` calls and skips the\n * `node:util` import entirely.\n */\nasync function createConsoleLoggerFactory(globalProcessStdErr: any): Promise<LoggerFactory> {\n  // Indirect specifier so this browser-safe module doesn't statically pull in\n  // node types: `node:util` is optional (the JSON fallback covers its absence).\n  const nodeUtil = \"node:util\";\n  // Gated, not just caught: the indirect specifier defeats bundler analysis by\n  // design, so a client build emits a literal `import(\"node:util\")` that no\n  // browser can resolve, and the caught rejection still surfaced as a console\n  // error. `utils` only feeds the stderr branch of the emitter below, so no\n  // stderr means the import has nothing to serve and is skipped outright.\n  const utils: { inspect?: any } | undefined =\n    globalProcessStdErr === undefined\n      ? undefined\n      : await import(/* @vite-ignore */ nodeUtil).catch(() => undefined);\n  return consoleLoggerFactory(globalProcessStdErr, utils);\n}\n\n/**\n * The synchronous core of {@link createConsoleLoggerFactory}, split out so the\n * same emitter also serves as the bootstrap sink before any async factory has\n * resolved. `utils` is `node:util` when it loaded; without it, object arguments\n * format through the `JSON.stringify` fallback.\n */\nfunction consoleLoggerFactory(\n  globalProcessStdErr: any,\n  utils?: { inspect?: any } | undefined,\n): LoggerFactory {\n  const bunInspect =\n    globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)\n      ? globalBun.inspect\n      : undefined;\n  const resetColorsPrefix = bunInspect !== undefined;\n\n  const inspect = (arg: any, colors?: boolean) => {\n    if (Array.isArray(arg) || (typeof arg === \"object\" && arg !== null)) {\n      if (bunInspect !== undefined) {\n        return bunInspect(arg, {\n          colors: colors,\n          depth: utils?.inspect?.defaultOptions?.depth ?? undefined,\n        });\n      } else if (utils !== undefined) {\n        return utils.inspect(arg, {\n          ...utils?.inspect?.defaultOptions,\n          colors: false,\n        });\n      } else {\n        const seen = new WeakSet();\n        return JSON.stringify(arg, (_, value) => {\n          if (typeof value === \"object\" && value !== null) {\n            if (seen.has(value)) return \"[Circular]\";\n            seen.add(value);\n          }\n          return value;\n        });\n      }\n    } else {\n      return String(arg);\n    }\n  };\n\n  const factory = (name?: string) => {\n    const prefixFormatter = createFormatter(name, globalProcessStdErr, resetColorsPrefix);\n    const logger = Object.fromEntries(\n      LOG_LEVELS.map((level) => {\n        const { prefix, colors, resetColors } = prefixFormatter(level);\n        const emitter = (...args: any[]) => {\n          if (!shouldEmit(level, true)) return;\n          if (globalProcessStdErr !== undefined) {\n            const messageParts = prefix ? [prefix] : [];\n            messageParts.push(...args.map((arg) => inspect(arg, colors)));\n            if (resetColors) messageParts.push(LOG_LEVEL_COLOR_RESET);\n            globalProcessStdErr.write(messageParts.join(\" \") + \"\\n\");\n          } else {\n            let levelFn = console[level];\n            if (typeof levelFn !== \"function\") {\n              levelFn = console.log;\n            }\n            if (prefix) levelFn = levelFn.bind(console, prefix);\n            levelFn(...args);\n          }\n        };\n        return [level, emitter];\n      }),\n    ) as Logger;\n    // consola sugar the console fallback doesn't have natively - route to info.\n    logger.success = logger.info;\n    logger.start = logger.info;\n    return logger;\n  };\n  const defaultFactory = memoize(factory);\n  return (name?: string) => (name ? factory(name) : defaultFactory());\n}\n\n/**\n * Preferred factory: consola when it loads, else the full console sink (with\n * optional `node:util` inspect). Memoized so concurrent / repeat callers share\n * one in-flight promise and one settled result.\n */\nconst resolveFactory = memoize(async (): Promise<LoggerFactory> => {\n  return (\n    (await createConsolaLoggerFactory()) ?? (await createConsoleLoggerFactory(globalProcessStdErr))\n  );\n});\n\n/**\n * Active factory starts as a sync console sink (no `await`, so this module\n * finishes evaluating immediately) and swaps to {@link resolveFactory}'s\n * result when that lands. Kick the resolve off at load so consola is usually\n * ready before the first interesting log line.\n */\nlet activeFactory: LoggerFactory = consoleLoggerFactory(globalProcessStdErr);\nvoid resolveFactory().then(\n  (factory) => {\n    activeFactory = factory;\n  },\n  () => {\n    // Keep the sync console sink; never leave importers without a factory.\n  },\n);\n\n/**\n * Build a logger that rebinds when {@link activeFactory} upgrades. Callers that\n * capture `const log = logger(\"x\")` at module scope still get consola once it\n * arrives, without every call site waiting on a promise.\n */\nfunction createLogger(name?: string): Logger {\n  let bound: { factory: LoggerFactory; logger: Logger } | undefined;\n  const sink = (): Logger => {\n    if (bound?.factory !== activeFactory) {\n      bound = { factory: activeFactory, logger: activeFactory(name) };\n    }\n    return bound.logger;\n  };\n  return Object.fromEntries(\n    [...LOG_LEVELS, \"success\", \"start\"].map((level) => [\n      level,\n      (...args: any[]) => sink()[level as keyof Logger](...args),\n    ]),\n  ) as Logger;\n}\n\n/**\n * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone\n * in browsers (either part omitted when absent). Applies per-level ANSI color\n * when `streamSupportsColor` is true for the given stderr stream.\n */\nfunction createFormatter(\n  name: any,\n  stream: any,\n  resetColorsPrefix?: boolean,\n): (level?: LogLevel) => { prefix: string; colors: boolean; resetColors: boolean } {\n  const glob = globalThis as { window?: unknown; document?: unknown };\n  const isBrowser = glob.window !== undefined && glob.document !== undefined;\n  const supportsColor = !isBrowser ? streamSupportsColor(stream) : false;\n  const namePrefix = name ? \"[\" + name + \"]\" : undefined;\n  return (level?: LogLevel) => {\n    const color = supportsColor && level !== undefined ? LOG_LEVEL_COLORS[level] : undefined;\n    let prefix = [!isBrowser && level ? level.toUpperCase() : undefined, namePrefix]\n      .filter(Boolean)\n      .join(\" \");\n    let resetColors = false;\n    if (color) {\n      const applyResetColorsPrefix = resetColorsPrefix || \"info\" === level;\n      if (!applyResetColorsPrefix) resetColors = true;\n      prefix = applyResetColorsPrefix ? color + prefix + LOG_LEVEL_COLOR_RESET : color + prefix;\n    }\n    return { prefix, colors: color ? true : false, resetColors };\n  };\n}\n\n/** True when `stream` is a TTY and the terminal is not `dumb`. */\nfunction streamSupportsColor(stream?: unknown): boolean {\n  if (globalProcess === undefined || typeof stream !== \"object\" || stream === null) return false;\n  const { isTTY } = stream as { isTTY?: unknown };\n  if (isTTY !== true) return false;\n  const term = globalProcess.env?.TERM?.toLowerCase();\n  if (\"dumb\" == term) return false;\n  return true;\n}\n\n/** Parse a raw value as {@link LogLevel} (trimmed, case-insensitive). */\nfunction parseLogLevel(raw: unknown): LogLevel | undefined {\n  if (raw === undefined || raw === null) {\n    return undefined;\n  }\n  let text = typeof raw === \"string\" ? raw : String(raw);\n  for (let i = 0; i < 2; i++) {\n    if (i > 0) {\n      const normalized = text.trim().toLowerCase();\n      if (text === normalized) break;\n      text = normalized;\n    }\n    if (!text) {\n      break;\n    } else if (text in LOG_LEVEL_RANK) {\n      return text as LogLevel;\n    }\n  }\n  return undefined;\n}\n\n/** Active threshold from `process.env.LOG_LEVEL`, default {@link DEFAULT_LEVEL}. */\nfunction activeLevel(): LogLevel {\n  return parseLogLevel(globalProcess?.env?.LOG_LEVEL) ?? DEFAULT_LEVEL;\n}\n\n/**\n * Whether `raw` meets the current `LOG_LEVEL` threshold.\n *\n * Parses `raw` as a {@link LogLevel}; when parsing fails, returns\n * `defaultResult` if supplied, otherwise `false`. Used for consola reporter\n * lines where unknown `logObj.type` values should pass through when\n * `defaultResult` is `true`.\n */\nfunction shouldEmit(raw: unknown, defaultResult?: boolean): boolean {\n  const level = parseLogLevel(raw);\n  if (level === undefined) return defaultResult ?? false;\n  return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[activeLevel()];\n}\n\n/**\n * Whether a call at `level` would be emitted at the current\n * `process.env.LOG_LEVEL` threshold. Use before building expensive debug\n * payloads.\n *\n * @example\n * if (isLevelEnabled(\"debug\")) {\n *   log.debug(\"mounts:resolver\", { contribution: await heavySnapshot() });\n * }\n */\nexport function isLevelEnabled(level: LogLevel): boolean {\n  return shouldEmit(level);\n}\n\nconst LOGGER_NAME_REGEX = /^(?:[a-z][a-z0-9+.-]*:\\/\\/)?.*\\/([^/.]+)(?:\\.[^/]+)?$/i;\n\n/**\n * Derive the tag string from a logger name, plugin, or path. Slash- and\n * URL-shaped strings use the last path segment (extension stripped); plain\n * strings pass through unchanged. Empty or missing names -> `undefined`\n * (untagged sink).\n */\nfunction extractLoggerName(loggerName: NameLike | string | undefined): string | undefined {\n  if (!loggerName) return undefined;\n  if (typeof loggerName === \"string\") {\n    const match = loggerName.match(LOGGER_NAME_REGEX);\n    return match?.[1] ?? loggerName;\n  }\n  return extractLoggerName(loggerName.name);\n}\n\n/**\n * Build a tagged logger for a plugin or module.\n *\n * The tag is `[name]` when `loggerName` is a non-empty string, a\n * {@link NameLike} with `name`, or a file / URL path (the basename without\n * extension is used). Consola applies the tag via `withTag` (render-time).\n * The `console` fallbacks prepend `LEVEL [name]` on Node/Bun hosts or `[name]`\n * alone in browsers via {@link createFormatter}.\n *\n * Calls below `process.env.LOG_LEVEL` are dropped by {@link shouldEmit} before\n * the sink formats or writes the line.\n *\n * @example\n * import { log } from \"@dbx-tools/shared-core\";\n *\n * const logger = log.logger(\"genie/chat\");\n * logger.info(\"starting\");\n * logger.warn(\"missing optional config\", { reason: \"no env var\" });\n */\nexport function logger(loggerName: NameLike | string | undefined): Logger {\n  const name = extractLoggerName(loggerName);\n  return createLogger(name);\n}\n"]}

package/package.json

@@ -43,7 +43,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.69",
+  "version": "0.6.70",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/log.ts

@@ -2,17 +2,20 @@
  * Tagged, leveled logging for every runtime - the one logger the whole
  * monorepo shares.
  *
- * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}
- * chosen once at module load. {@link LogLevel} filtering runs through
- * {@link shouldEmit} in the consola reporter or in per-level wrappers on the
- * `console` fallbacks.
+ * {@link logger} resolves a tagged {@link Logger} via a {@link LoggerFactory}.
+ * The factory starts as a synchronous console sink so this module never uses
+ * top-level `await` (that left importers with a null namespace mid-load in
+ * browser bundles). A memoized async chain then upgrades to consola when it
+ * is available. {@link LogLevel} filtering runs through {@link shouldEmit} in
+ * the consola reporter or in per-level wrappers on the `console` fallbacks.
  *
  * Sink selection chains two factories with nullish coalescing (first match
  * wins):
  *
  * 1. {@link createConsolaLoggerFactory} when consola resolves and
  *    `LOG_CONSOLA_DISABLED` is not truthy.
- * 2. {@link createConsoleLoggerFactory} everywhere else.
+ * 2. {@link createConsoleLoggerFactory} everywhere else (also the sync
+ *    bootstrap before that promise settles).
  *
  * The console fallback writes formatted lines to `process.stderr` when it is
  * available (Bun `inspect` per argument when `LOG_BUN_CONSOLE_DISABLED` is
@@ -21,8 +24,8 @@
  * the `LEVEL` text prefix (devtools show severity) and keep only the `[name]`
  * tag.
  *
- * Env toggles (read once at init): `LOG_LEVEL`, `LOG_CONSOLA_DISABLED`,
- * `LOG_BUN_CONSOLE_DISABLED`.
+ * Env toggles: `LOG_LEVEL` (read per call), `LOG_CONSOLA_DISABLED` /
+ * `LOG_BUN_CONSOLE_DISABLED` (read once during factory init).
  *
  * Browser-safe: `process` / `Bun` / `window` / `document` are all reached
  * through `globalThis` and guarded, consola loads lazily, and `node:util` is
@@ -197,6 +200,19 @@ async function createConsoleLoggerFactory(globalProcessStdErr: any): Promise<Log
     globalProcessStdErr === undefined
       ? undefined
       : await import(/* @vite-ignore */ nodeUtil).catch(() => undefined);
+  return consoleLoggerFactory(globalProcessStdErr, utils);
+}
+
+/**
+ * The synchronous core of {@link createConsoleLoggerFactory}, split out so the
+ * same emitter also serves as the bootstrap sink before any async factory has
+ * resolved. `utils` is `node:util` when it loaded; without it, object arguments
+ * format through the `JSON.stringify` fallback.
+ */
+function consoleLoggerFactory(
+  globalProcessStdErr: any,
+  utils?: { inspect?: any } | undefined,
+): LoggerFactory {
   const bunInspect =
     globalBun !== undefined && !toBoolean(globalBun.env?.LOG_BUN_CONSOLE_DISABLED)
       ? globalBun.inspect
@@ -264,16 +280,52 @@ async function createConsoleLoggerFactory(globalProcessStdErr: any): Promise<Log
 }
 
 /**
- * Module-scoped {@link LoggerFactory}, initialized once via top-level `await`.
- * Delegates to {@link createConsolaLoggerFactory}, then
- * {@link createConsoleLoggerFactory}. Each {@link logger} call invokes the
- * chosen factory with a resolved tag. Env toggles are read only during init.
+ * Preferred factory: consola when it loads, else the full console sink (with
+ * optional `node:util` inspect). Memoized so concurrent / repeat callers share
+ * one in-flight promise and one settled result.
  */
-const createLogger: LoggerFactory = await (async () => {
+const resolveFactory = memoize(async (): Promise<LoggerFactory> => {
   return (
     (await createConsolaLoggerFactory()) ?? (await createConsoleLoggerFactory(globalProcessStdErr))
   );
-})();
+});
+
+/**
+ * Active factory starts as a sync console sink (no `await`, so this module
+ * finishes evaluating immediately) and swaps to {@link resolveFactory}'s
+ * result when that lands. Kick the resolve off at load so consola is usually
+ * ready before the first interesting log line.
+ */
+let activeFactory: LoggerFactory = consoleLoggerFactory(globalProcessStdErr);
+void resolveFactory().then(
+  (factory) => {
+    activeFactory = factory;
+  },
+  () => {
+    // Keep the sync console sink; never leave importers without a factory.
+  },
+);
+
+/**
+ * Build a logger that rebinds when {@link activeFactory} upgrades. Callers that
+ * capture `const log = logger("x")` at module scope still get consola once it
+ * arrives, without every call site waiting on a promise.
+ */
+function createLogger(name?: string): Logger {
+  let bound: { factory: LoggerFactory; logger: Logger } | undefined;
+  const sink = (): Logger => {
+    if (bound?.factory !== activeFactory) {
+      bound = { factory: activeFactory, logger: activeFactory(name) };
+    }
+    return bound.logger;
+  };
+  return Object.fromEntries(
+    [...LOG_LEVELS, "success", "start"].map((level) => [
+      level,
+      (...args: any[]) => sink()[level as keyof Logger](...args),
+    ]),
+  ) as Logger;
+}
 
 /**
  * Build a line prefix of `LEVEL [name]` on Node/Bun hosts, or `[name]` alone